roglew 0.1.0

data/lib/roglew/native/glx.rb

@@ -0,0 +1,8 @@
+module Roglew
+  module GLX
+    extend FFI::Library
+    #ffi_library '?'
+
+    #TODO
+  end
+end

data/lib/roglew/native/kernel32.rb

@@ -0,0 +1,9 @@
+module Roglew
+	module Kernel32
+		extend ::FFI::Library
+		ffi_lib 'kernel32'
+		ffi_convention :stdcall
+
+		attach_function :GetLastError, [], :uint
+	end
+end

data/lib/roglew/native/native_object.rb

@@ -0,0 +1,11 @@
+module Roglew
+  module NativeObject
+    def get_function(function_name, parameters, return_type)
+      ptr = WGL.GetProcAddress(function_name.to_s) #TODO platforms
+      return nil if ptr.null?
+      return_type = GL.find_type(return_type) || return_type
+      parameters = parameters.map { |p| GL.find_type(p) || p }
+      FFI::Function.new(return_type, parameters, ptr, convention: :stdcall)
+    end
+  end
+end

data/lib/roglew/native/wgl.rb

@@ -0,0 +1,138 @@
+module Roglew
+  module WGL
+    include GL::Native
+    extend NativeObject
+
+    ENCODING = 'W'
+
+    class RECT < FFI::Struct
+      layout :left,   :long,
+             :top,    :long,
+             :right,  :long,
+             :bottom, :long
+    end
+
+    class POINTFLOAT < FFI::Struct
+      layout :x, :float,
+             :y, :float
+    end
+
+    class GLYPHMETRICSFLOAT < FFI::Struct
+      layout :gmfBlackBoxX,     :float,
+             :gmfBlackBoxY,     :float,
+             :gmfptGlyphOrigin, POINTFLOAT,
+             :gmfCellIncX,      :float,
+             :gmfCellIncY,      :float
+    end
+
+    class LAYERPLANEDESCRIPTOR < FFI::Struct
+      layout :nSize,           :ushort,
+             :nVersion,        :ushort,
+             :dwFlags,         :uint,
+             :iPixelType,      :uchar,
+             :cColorBits,      :uchar,
+             :cRedBits,        :uchar,
+             :cRedShift,       :uchar,
+             :cGreenBits,      :uchar,
+             :cGreenShift,     :uchar,
+             :cBlueBits,       :uchar,
+             :cBlueShift,      :uchar,
+             :cAlphaBits,      :uchar,
+             :cAlphaShift,     :uchar,
+             :cAccumBits,      :uchar,
+             :cAccumRedBits,   :uchar,
+             :cAccumGreenBits, :uchar,
+             :cAccumBlueBits,  :uchar,
+             :cAccumAlphaBits, :uchar,
+             :cDepthBits,      :uchar,
+             :cStencilBits,    :uchar,
+             :cAuxBuffers,     :uchar,
+             :iLayerType,      :uchar,
+             :bReserved,       :uchar,
+             :crTransparent,   :uint
+    end
+
+    class PIXELFORMATDESCRIPTOR < FFI::Struct
+      layout :nSize,           :ushort,
+             :nVersion,        :ushort,
+             :iPixelType,      :uchar,
+             :dwFlags,         :uint,
+             :cColorBits,      :uchar,
+             :cRedBits,        :uchar,
+             :cRedShift,       :uchar,
+             :cGreenBits,      :uchar,
+             :cGreenShift,     :uchar,
+             :cBlueBits,       :uchar,
+             :cBlueShift,      :uchar,
+             :cAlphaBits,      :uchar,
+             :cAlphaShift,     :uchar,
+             :cAccumBits,      :uchar,
+             :cAccumRedBits,   :uchar,
+             :cAccumGreenBits, :uchar,
+             :cAccumBlueBits,  :uchar,
+             :cAccumAlphaBits, :uchar,
+             :cDepthBits,      :uchar,
+             :cStencilBits,    :uchar,
+             :cAuxBuffers,     :uchar,
+             :iLayerType,      :uchar,
+             :bReserved,       :uchar,
+             :dwLayerMask,     :uint,
+             :dwVisibleMask,   :uint,
+             :dwDamageMask,    :uint
+    end
+
+    [
+      #HGLRC WINAPI wglCreateContext(HDC hdc)
+      [ :CreateContext, [:pointer], :pointer ],
+
+      #HGLRC wglCreateLayerContext(HDC hdc, int iLayerPlane)
+      [ :CreateLayerContext, [:pointer, :int], :pointer ],
+
+      #BOOL wglCopyContext(HGLRC hglrcSrc, HGLRC hglrcDst, UINT mask)
+      [ :CopyContext, [:pointer, :pointer, :uint], :bool ],
+
+      #BOOL wglDeleteContext(HGLRC hglrc)
+      [ :DeleteContext, [:pointer], :bool ],
+
+      #BOOL wglDescribeLayerPlane(HDC hdc, int iPixelFormat, int iLayerPlane, UINT nBytes, LPLAYERPLANEDESCRIPTOR plpd)
+      [ :DescribeLayerPlane, [:pointer, :int, :int, :uint, LAYERPLANEDESCRIPTOR.ptr], :bool ],
+
+      #HGLRC wglGetCurrentContext()
+      [ :GetCurrentContext, [], :pointer ],
+
+      #HDC wglGetCurrentDC()
+      [ :GetCurrentDC, [], :pointer ],
+
+      #int wglGetLayerPaletteEntries(HDC hdc, int iLayerPlane, int iStart, int cEntries, COLORREF *pcr)
+      [ :GetLayerPaletteEntries, [:pointer, :int, :int, :int, :pointer], :int ],
+
+      #PROC wglGetProcAddress(LPCSTR lpszProc)
+      [ :GetProcAddress, [:string], :pointer ],
+
+      #BOOL wglMakeCurrent(HDC hdc, HGLRC hglrc)
+      [ :MakeCurrent, [:pointer, :pointer], :bool ],
+
+      #BOOL wglRealizeLayerPalette(HDC hdc, int iLayerPlane, BOOL bRealize)
+      [ :RealizeLayerPalette, [:pointer, :int, :bool], :bool ],
+
+      #int wglSetLayerPaletteEntries(HDC hdc, int iLayerPlane, int iStart, int cEntries, const COLORREF *pcr)
+      [ :SetLayerPaletteEntries, [:pointer, :int, :int, :int, :pointer], :int ],
+
+      #BOOL wglShareLists(HGLRC hglrc1, HGLRC hglrc2)
+      [ :ShareLists, [:pointer, :pointer], :bool ],
+
+      #BOOL wglSwapLayerBuffers(HDC hdc, UINT fuPlanes)
+      [ :SwapLayerBuffers, [:pointer, :uint], :bool ],
+
+      #BOOL wglUseFontBitmaps(HDC hdc, DWORD first, DWORD count, DWORD listBase)
+      [ :UseFontBitmaps, "wglUseFontBitmaps#{ENCODING}", [:pointer, :uint, :uint, :uint], :bool ],
+
+      #BOOL wglUseFontOutlines(HDC hdc, DWORD first, DWORD count, DWORD listBase, FLOAT deviation, FLOAT extrusion, int format, LPGLYPHMETRICSFLOAT lpgmf)
+      [ :UseFontOutlines, "wglUseFontOutlines#{ENCODING}", [:pointer, :uint, :uint, :uint, :float, :float, :int, GLYPHMETRICSFLOAT.ptr], :bool ]
+    ].each do |args|
+      args[1, 0] = "wgl#{args[0]}" if args.length == 3
+      attach_function *args
+      RenderContext.class_eval "def wgl#{args[0]}(*args) WGL.#{args[0]}(*args) end"
+    end
+  end
+end

data/lib/roglew/native/win32ffi.rb

@@ -0,0 +1,27 @@
+module Roglew
+	module Win32FFI
+		def self.included(base)
+      {
+        :ATOM        => :uint,
+        :BYTE        => :uchar,
+        :DWORD       => :uint32,
+        :HANDLE      => :pointer,
+        :HCURSOR     => :pointer,
+        :HDC         => :pointer,
+        :HFONT       => :pointer,
+        :HGLRC       => :pointer,
+        :HICON       => :pointer,
+        :HINSTANCE   => :pointer,
+        :HMENU       => :pointer,
+        :HMODULE     => :pointer,
+        :HWND        => :pointer,
+        :LPARAM      => :long,
+        :LPRECT      => :pointer,
+        :LPVOID      => :pointer,
+        :LRESULT     => :long,
+        :WORD        => :uint16,
+        :WPARAM      => :ulong,
+      }.each{ |k,v| base.typedef(v, k) }
+		end
+	end
+end

data/lib/roglew/render_context.rb

@@ -0,0 +1,229 @@
+module Roglew
+  class RenderContext
+    include Roglew::Contextual(nil)
+    include GLObject
+
+    @registered_extensions = {}
+
+    #if version not passed, builds context with latest version
+    def initialize(hdc, version = nil)
+      @hdc = hdc
+
+      initialize_pixel_format
+
+      @hrc, old_hrc = wglCreateContext(@hdc), nil
+
+      bind do
+        #check version
+        max_version = glGetString(GL::VERSION).split('.', 2).map!(&:to_i)
+
+        #if max OpelGL version is less than requested, give error
+        raise ArgumentError, "unsupported version #{version.join('.')}" if version && (max_version <=> version < 0)
+
+        @version = version || max_version
+        @loaded_extensions = Set.new
+        core_extension_list.each { |ext| load_extension(ext) }
+
+        old_hrc, @hrc = @hrc, upgrade_context if @version[0] > 2
+
+        (gl_extension_list + platform_extension_list).each { |ext| load_extension(ext) }
+      end
+
+      @attribs = Set[GL::DITHER, GL::MULTISAMPLE]
+
+      wglDeleteContext(old_hrc) if old_hrc
+
+      self.class.finalize(self, @hrc)
+    end
+
+    def self.finalize(obj, hrc)
+      ObjectSpace.define_finalizer(obj, proc do
+        WGL.DeleteContext(hrc) #assumes that context was unbound
+      end)
+    end
+
+    def load_extension(ext)
+      ext = ext.to_sym
+      @loaded_extensions << ext
+
+      unless Object.const_defined?(ext)
+        reg = self.class.instance_variable_get(:@registered_extensions)
+        filename = reg[ext] || File.expand_path("../extensions/#{ext}.rb", __FILE__)
+        require filename if File.exists?(filename)
+      end
+
+      return unless Object.const_defined?(ext)
+      mod = Object.const_get(ext)
+      return unless mod.const_defined?(:RenderContext)
+      mod = mod::RenderContext
+
+      singleton_class.send(:include, mod) if mod
+    end
+
+    def bind(&block)
+      wglMakeCurrent(@hdc, @hrc)
+      if block_given?
+        ergo &block
+        unbind
+      end
+      self
+    end
+
+    def unbind
+      wglMakeCurrent(nil, nil)
+    end
+
+    def version; @version.dup end
+
+    def loaded_extensions; @loaded_extensions.dup end
+
+    def supports?(extension); !!@loaded_extensions[extension] end
+
+    def create_texture2d(*args)
+      Texture2d.new(self, *args)
+    end
+
+    def_object :Textures
+
+    def begin(mode, &block)
+      glBegin(mode)
+      return unless block_given?
+      ergo &block
+      glEnd
+    end
+
+    %w'points lines line_strip line_loop triangles triangle_strip triangle_fan quads quad_strip polygon'.each do |v|
+      class_eval("def #{v}(&block) self.begin(GL::#{v.upcase}, &block) end")
+    end
+
+    def clear(*flags)
+      glClear(flags.reduce(&:|))
+    end
+
+    def disable(*caps)
+      caps = Set[*caps] & @attribs
+      caps.each do |cap|
+        glDisable(cap)
+        @attribs.delete(cap)
+      end
+      return unless block_given?
+      yield
+      enable(caps)
+    end
+
+    def enable(*caps)
+      caps = Set[*caps] - @attribs
+      caps.each { |cap| glEnable(cap) }
+      @attribs.merge(caps)
+      return unless block_given?
+      yield
+      disable(*caps)
+    end
+
+    def get_errors
+      errors = []
+      while (error = glGetError) != 0
+        errors << GL::ERROR[error] || error
+      end
+      errors
+    end
+
+    def get_integers(pname, count = 1)
+      p = FFI::MemoryPointer.new(:int, count)
+      glGetIntegerv(pname, p)
+      result = p.read_array_of_int(count)
+      count == 1 ? result[0] : result
+    end
+
+    def swap_buffers
+      Gdi32.SwapBuffers(@hdc)
+    end
+
+    def tex_parameter(target, pname, *params)
+      params.flatten!
+      type = params.all? { |param| param.is_a? Integer } ? 'int' : 'float'
+      ptr = FFI::MemoryPointer.new(type.to_sym, params.length)
+      ptr.send("write_array_of_#{type}", params)
+      send("glTexParameter#{type[0]}v", target, pname, ptr)
+    end
+
+    def self.register_extensions(extensions)
+      extensions = Hash[extensions.map { |k, v| [k.to_sym, v] }]
+      @registered_extensions.merge!(extensions)
+      nil
+    end
+
+    def self.unregister_extensions(*extensions)
+      extensions.map! { |e| e.to_sym }.each { |e| @registered_extensions.delete(e) }
+      nil
+    end
+
+    #------
+    private
+
+    def initialize_pixel_format
+      pfd = Gdi32::PIXELFORMATDESCRIPTOR.new
+      pfd.dwFlags = [:DOUBLEBUFFER, :SUPPORT_OPENGL, :DRAW_TO_WINDOW]
+      pfd.cColorBits = 24
+      pfd.cAlphaBits = 8
+      pfd.cDepthBits = 32
+
+      pxfmt = Gdi32.ChoosePixelFormat(@hdc, pfd)
+      raise InvalidPixelFormatError,
+            "(ChoosePixelFormat) GetLastError returned #{Kernel32.GetLastError}" if pxfmt == 0
+
+      #Can't use DescribePixelFormat. Blows up remote desktop
+      #
+      #max_pfd = Gdi32.DescribePixelFormat(@hdc, pxfmt, Gdi32::PIXELFORMATDESCRIPTOR.size, pfd)
+      #puts "#\t" + Gdi32::PIXELFORMATDESCRIPTOR.members.select { |x| x != :nSize }.join("\t")
+      #max_pfd.times do |i|
+      #	pfd2 = Gdi32::PIXELFORMATDESCRIPTOR.new
+      #	Gdi32.DescribePixelFormat(@hdc, i+1, Gdi32::PIXELFORMATDESCRIPTOR.size, pfd2)
+      #	puts "#{i + 1}\t" + Gdi32::PIXELFORMATDESCRIPTOR.
+      #      members.select { |x| x != :nSize }.map { |x| pfd2.send(x).inspect }.join("\t")
+      #end
+
+      raise InvalidPixelFormatError,
+            "(SetPixelFormat) GetLastError returned #{Kernel32.GetLastError}" unless Gdi32.SetPixelFormat(@hdc, pxfmt, pfd)
+    end
+
+    def upgrade_context
+      load_extension(:WGL_ARB_create_context)
+
+      raise 'undefined function wglCreateContextAttribsARB' unless respond_to?(:wglCreateContextAttribsARB)
+
+      attribs = [WGL::CONTEXT_MAJOR_VERSION_ARB, @version[0],
+                 WGL::CONTEXT_MINOR_VERSION_ARB, @version[1],
+                 WGL::CONTEXT_FLAGS_ARB,         WGL::CONTEXT_FORWARD_COMPATIBLE_BIT_ARB,
+                 0]
+      ptr_attribs = FFI::MemoryPointer.new(:int, attribs.length)
+      ptr_attribs.write_array_of_int(attribs)
+
+      wglCreateContextAttribsARB(@hdc, nil, ptr_attribs)
+    end
+
+    def core_extension_list
+      Dir["#{File.expand_path('../extensions', __FILE__)}/GL_VERSION_*.rb"].
+        map! { |f| File.basename(f, '.rb') }.
+        select! { |f| (f.gsub('GL_VERSION_', '').split('_', 2).map!(&:to_i) <=> @version) <= 0 }
+    end
+
+    def gl_extension_list
+      if @version[0] < 3
+        glGetString(GL::EXTENSIONS).split
+      else
+        get_integers(GL::NUM_EXTENSIONS).times.map { |i| glGetStringi(GL::EXTENSIONS, i) }
+      end.map!(&:to_sym)
+    end
+
+    def platform_extension_list
+      if (func = WGL.get_function(:wglGetExtensionsStringARB, [:pointer], :string))
+        func.(@hdc)
+      elsif (func = WGL.get_function(:wglGetExtensionsStringEXT, [], :string))
+        func.()
+      else
+        ''
+      end.split.map!(&:to_sym)
+    end
+  end
+end

data/lib/roglew/render_handle.rb

@@ -0,0 +1,64 @@
+module Roglew
+  class RenderHandle
+    def initialize(hdc)
+      @hdc = hdc
+      init_pixel_format()
+      @hrc = GL.create_context(@hdc)
+
+      @context_class = Class.new(RenderContext)
+    end
+
+    def bind(deferred = nil)
+      deferred = [deferred, self.deferred?, self.class.deferred?].compact.first
+
+      ctx = @context_class.new(self, deferred)
+      GL.make_current(@hdc, @hrc) unless deferred
+      return ctx unless block_given?
+      ctx.ergo &block
+      if deferred then ctx.apply else self.class.unbind end
+
+      self
+    end
+
+    def self.unbind
+      GL.make_current(nil, nil)
+    end
+
+    def new_texture2d(*args)
+      Texture2d.new(self, *args)
+    end
+
+    def load_extensions(*names)
+
+    end
+
+    private
+    def self.init_pixel_format
+      pfd = Gdi32::PIXELFORMATDESCRIPTOR.new
+      pfd.dwFlags = [:DOUBLEBUFFER, :SUPPORT_OPENGL, :DRAW_TO_WINDOW]
+      pfd.cColorBits = 24
+      pfd.cAlphaBits = 8
+      pfd.cDepthBits = 32
+
+      pxfmt = Gdi32.choose_pixel_format(@hdc, pfd)
+      raise InvalidPixelFormatError,
+            "(ChoosePixelFormat) GetLastError returned #{Kernel32.last_error}" if pxfmt == 0
+
+      #Can't use DescribePixelFormat. Blows up remote desktop
+      #
+      #max_pfd = Gdi32.describe_pixel_format(@hdc, pxfmt, Gdi32::PIXELFORMATDESCRIPTOR.size, pfd)
+      #puts "#\t" + Gdi32::PIXELFORMATDESCRIPTOR.members.select { |x| x != :nSize }.join("\t")
+      #max_pfd.times do |i|
+      #	pfd2 = Gdi32::PIXELFORMATDESCRIPTOR.new
+      #	Gdi32.describe_pixel_format(@hdc, i+1, Gdi32::PIXELFORMATDESCRIPTOR.size, pfd2)
+      #	puts "#{i + 1}\t" + Gdi32::PIXELFORMATDESCRIPTOR.
+      #      members.select { |x| x != :nSize }.map { |x| pfd2.send(x).inspect }.join("\t")
+      #end
+
+      unless Gdi32.set_pixel_format(@hdc, pxfmt, pfd)
+        raise InvalidPixelFormatError,
+              "(SetPixelFormat) GetLastError returned #{Kernel32.last_error}"
+      end
+    end
+  end
+end

data/lib/roglew/texture2d.rb

@@ -0,0 +1,23 @@
+module Roglew
+  class Texture2d
+    include Roglew::Contextual(TextureContext)
+
+    attr_reader :context, :id
+
+    def initialize(context)
+      @context = context.bind { |c| @id = c.gen_textures }
+      self.class.finalize(self, @context, @id)
+    end
+
+    def self.finalize(obj, ctx, id)
+      ObjectSpace.define_finalizer(obj, proc do
+        puts "releasing texture #{id}"
+        ctx.glDeleteTextures(id)
+      end)
+    end
+
+    def bind(deferred = nil, &block)
+      create_binding(deferred, GL::TEXTURE_2D, &block)
+    end
+  end
+end

data/lib/roglew/texture_context.rb

@@ -0,0 +1,46 @@
+module Roglew
+  class TextureContext
+    include Roglew::BaseContext(:texture)
+
+    def initialize(texture, deferred, target, &block)
+      @target = target
+      super(texture, deferred, &block)
+    end
+
+    {
+      :min_filter   => :TEXTURE_MIN_FILTER,
+      :mag_filter   => :TEXTURE_MAG_FILTER,
+      :min_lod      => :TEXTURE_MIN_LOD,
+      :max_lod      => :TEXTURE_MAX_LOD,
+      :base_level   => :TEXTURE_BASE_LEVEL,
+      :max_level    => :TEXTURE_MAX_LEVEL,
+      :wrap_s       => :TEXTURE_WRAP_S,
+      :wrap_t       => :TEXTURE_WRAP_T,
+      :wrap_r       => :TEXTURE_WRAP_R,
+      :priority     => :TEXTURE_PRIORITY,
+      :compare_mode => :TEXTURE_COMPARE_MODE,
+      :compare_func => :TEXTURE_COMPARE_FUNC,
+      :depth_mode   => :DEPTH_TEXTURE_MODE,
+      :mipmap       => :GENERATE_MIPMAP
+    }.each do |name, cnst|
+      class_eval "def #{name}=(v) make_call(:tex_parameter, @target, GL::#{cnst}, v) end"
+    end
+
+    def border_color(r, g, b, a)
+      make_call(:tex_parameter, @target, GL::TEXTURE_BORDER_COLOR, r, g, b, a)
+    end
+
+    def tex_image_2d(width, height, border, internalFormat, format, type, data)
+      make_call(:glTexImage2D, @target, 0, internalFormat, width, height, border, format, type, data)
+    end
+
+    private
+    def bind
+      context.glBindTexture(@target, texture.id)
+    end
+
+    def unbind
+      context.glBindTexture(@target, 0)
+    end
+  end
+end

data/lib/roglew.rb

@@ -0,0 +1,32 @@
+#Raw Glue - the Ruby OpenGL and Extensions Wrapper
+
+module Roglew
+  VERSION = '0.1.0'
+end
+
+#external dependencies
+%w'
+  set
+  ffi
+  facets/kernel/ergo
+  facets/module/module_load
+  facets/string/camelcase
+  facets/string/snakecase
+'.each { |f| require f }
+
+#internal files
+%w'
+  contexts/base
+  contexts/deferred
+  contexts/immediate
+  ext/ffi_struct_ext
+  errors
+  native/kernel32
+  native/gdi32
+  contextual
+  gl_extension
+  gl_object
+  native/native_object
+  native/gl
+  render_context
+'.each { |f| require "roglew/#{f}" }