sdl2_ffi 0.0.2

data/lib/sdl2/syswm/msg.rb

@@ -0,0 +1,46 @@
+require 'sdl2'
+
+module SDL2 # SDL_syswm.h
+          
+  module SysWM
+    class Msg < Struct
+      
+      class Win < Struct
+        layout :hwnd, :pointer,
+          :msg, :uint,
+          :wparam, :int16,
+          :lparam, :int32
+      end      
+      
+      
+      class X11 < Struct
+        layout :dummy, :uint32 # TODO: FIXME: NOT YET SUPPORTED!
+      end
+      
+      class DirectFB < Struct
+        layout :event, :uint32 # TODO: FIXME: NOT YET SUPPORTED!
+      end
+      
+      class Cocoa < Struct
+        layout :dummy, :long # SDL2 says 'No Cocoa window events yet'
+      end
+      
+      class UIKit < Struct
+        layout :dummy, :long # SDL2 says 'No UIKit window events yet'
+      end
+      
+      class MsgUnion < FFI::Union
+        layout :win, Win,
+          :x11, X11,
+          :dfb, DirectFB,
+          :cocoa, Cocoa,
+          :uikit, UIKit,
+          :dummy, :int
+      end
+      
+      layout :version, Version,
+        :subsystem, :int,
+        :msg, MsgUnion
+    end
+  end 
+end

data/lib/sdl2/syswm.rb

@@ -0,0 +1,20 @@
+require 'sdl2'
+require 'sdl2/version'
+require 'sdl2/video'
+require 'sdl2/syswm/info'
+require 'sdl2/syswm/msg'
+
+module SDL2 # SDL_syswm.h
+  
+  module SysWM
+    
+  end
+  
+  SYSWM = SysWM # Because I don't care about case.
+  
+  # Line 99~107
+  enum :syswm_type, [:unkown, :window, :x11, :directfb, :cocoa, :uikit]
+  
+  api :SDL_GetWindowWMInfo, [Window.by_ref, SYSWM::Info.by_ref], :bool
+  
+end

data/lib/sdl2/texture.rb

@@ -0,0 +1,9 @@
+require 'sdl2'
+# Stub for now.. need to implement!!!
+module SDL2
+  class Texture < FFI::Struct
+    def self.release(pointer)
+      SDL2.destroy_texture(pointer)
+    end
+  end
+end

data/lib/sdl2/timer.rb

@@ -0,0 +1,17 @@
+require 'sdl2'
+
+module SDL2
+  
+  api :SDL_GetTicks, [], :uint32
+  api :SDL_GetPerformanceCounter, [], :uint64
+  api :SDL_GetPerformanceFrequency, [], :uint64    
+  api :SDL_Delay, [:uint32], :void
+  
+  callback :timer_callback, [:uint32, :pointer], :uint32
+    
+  typedef :int, :timer_id
+  
+  api :SDL_AddTimer, [:uint32, :timer_callback, :pointer], :timer_id
+  api :SDL_RemoveTimer, [:timer_id], :bool  
+  
+end

data/lib/sdl2/touch.rb

@@ -0,0 +1,24 @@
+require 'sdl2'
+require 'sdl2/video'
+
+module SDL2
+  
+  typedef :int64, :touch_id
+  typedef :int64, :finger_id
+  
+  class Finger < Struct
+    layout :id, :finger_id,
+      :x, :float,
+      :y, :float,
+      :pressure, :float
+  end
+  
+  TOUCH_MOUSEID = -1 
+  
+  api :SDL_GetNumTouchDevices, [], :int
+  api :SDL_GetTouchDevice, [:int], :touch_id
+  api :SDL_GetNumTouchFingers, [:touch_id], :int
+  api :SDL_GetTouchFinger, [:touch_id, :int], Finger.by_ref
+  
+  
+end

data/lib/sdl2/version.rb

@@ -0,0 +1,30 @@
+require 'sdl2'
+
+module SDL2  
+  
+  class Version < FFI::Struct
+    layout :major, :uint8,
+      :minor, :uint8,
+      :patch, :uint8
+      
+    def major
+      self[:major]
+    end
+    
+    def minor
+      self[:minor]
+    end
+    
+    def patch
+      self[:patch]
+    end
+    
+    def to_s
+      "SDL v#{major}.#{minor}.#{patch}"
+    end
+  end
+  
+  api :SDL_GetRevision, [], :string
+  api :SDL_GetRevisionNumber, [], :int
+  api :SDL_GetVersion, [Version.by_ref], :void
+end

data/lib/sdl2/video.rb

@@ -0,0 +1,154 @@
+require 'sdl2'
+require 'sdl2/rect'
+require 'sdl2/window'
+require 'sdl2/display'
+require 'sdl2/surface'
+
+#require 'sdl2/renderer'
+#require 'sdl2/texture'
+require 'sdl2/syswm/info'
+
+#
+module SDL2
+  typedef :int, :display_index
+  
+
+  enum :window_flags, [
+    :fullscreen, Window::FULLSCREEN,
+    :opengl, Window::OPENGL,
+    :shown, Window::SHOWN,
+    :hidden, Window::HIDDEN,
+    :borderless, Window::BORDERLESS,
+    :minimized, Window::MINIMIZED,
+    :maximized, Window::MAXIMIZED,
+    :input_grabbed, Window::INPUT_GRABBED,
+    :input_focus, Window::INPUT_FOCUS,
+    :mouse_focus, Window::MOUSE_FOCUS,
+    :fullscreen_desktop, Window::FULLSCREEN_DESKTOP,
+    :foreign, Window::FOREIGN
+  ]
+  # TODO: SDL_video.h lines 113~129
+
+  # line: 134~155
+  enum :window_event_id, [
+    :none,
+    :shown,
+    :hidden,
+    :exposed,
+    :moved,
+    :resized,
+    :size_changed,
+    :minimized,
+    :maximized,
+    :restored,
+    :enter,
+    :leave,
+    :focus_gained,
+    :focus_lost,
+    :close
+  ]
+  # line 160
+  typedef :pointer, :gl_context
+  # lines 165~190
+  enum :gl_attr, [
+    :red_size,
+    :green_size,
+    :blue_size,
+    :alpha_size,
+    :buffer_size,
+    :doublebuffer,
+    :depth_size,
+    :stencil_size,
+    :accum_red_size,
+    :accum_green_size,
+    :accum_blue_size,
+    :accum_alpha_size,
+    :stereo,
+    :multisamplebuffers,
+    :multisamplesamples,
+    :accelerated_visual,
+    :retained_backing,
+    :context_major_version,
+    :context_minor_version,
+    :context_egl,
+    :context_flags,
+    :context_profile_mask,
+    :share_with_current_context
+  ]
+  # lines 192~197
+  enum :gl_profile, [:core, 0x0001, :compatibility, 0x0002, :es, 0x0004]
+  # lines 199~205
+  enum :gl_context_flag, [:debug, 0x0001, :forward_compatible, 0x0002, :robust_access, 0x0004, :reset_isolation, 0x0008]
+
+  # This interface represents SDL_video.h function prototypes, lines 208~
+  api :SDL_GetNumVideoDrivers, [], :int
+  api :SDL_GetVideoDriver, [:int], :string
+  api :SDL_VideoInit, [:string], :int
+  api :SDL_VideoQuit, [], :void
+  api :SDL_GetCurrentVideoDriver, [], :string
+  api :SDL_GetNumVideoDisplays, [], :int
+  api :SDL_GetDisplayName, [:display_index], :string
+  api :SDL_GetDisplayBounds, [:int, Rect.by_ref], :int
+  api :SDL_GetNumDisplayModes, [:int], :int
+  api :SDL_GetDisplayMode, [:int, :int, Display::Mode.by_ref], :int
+  api :SDL_GetDesktopDisplayMode, [:int, Display::Mode.by_ref], :int
+  api :SDL_GetCurrentDisplayMode, [:int, Display::Mode.by_ref], :int
+  api :SDL_GetClosestDisplayMode,  [:display_index, Display::Mode.by_ref, Display::Mode.by_ref], Display::Mode.by_ref
+  api :SDL_GetWindowDisplayIndex, [Window.by_ref], :int
+  api :SDL_SetWindowDisplayMode, [Window.by_ref, :uint32], :int
+  api :SDL_GetWindowDisplayMode, [Window.by_ref, Display::Mode.by_ref], :int
+  api :SDL_GetWindowPixelFormat, [Window.by_ref], :uint32
+  api :SDL_CreateWindow, [:string, :int, :int, :int, :int, :uint32], Window.auto_ptr
+  api :SDL_CreateWindowFrom, [:pointer], Window.auto_ptr
+  api :SDL_GetWindowFromID, [:uint32], Window.by_ref
+  api :SDL_GetWindowID, [Window.by_ref], :uint32
+  api :SDL_GetWindowFlags, [Window.by_ref], :uint32
+  api :SDL_GetWindowTitle, [Window.by_ref], :string
+  api :SDL_SetWindowTitle, [Window.by_ref, :string], :void
+  api :SDL_SetWindowIcon, [Window.by_ref, Surface.by_ref], :void
+  api :SDL_SetWindowData, [Window.by_ref, :string, :pointer], :pointer
+  api :SDL_GetWindowData, [Window.by_ref, :string], :pointer
+  api :SDL_SetWindowPosition, [Window.by_ref, :int, :int], :void
+  api :SDL_GetWindowPosition, [Window.by_ref, IntStruct.by_ref, IntStruct.by_ref], :void
+  api :SDL_SetWindowSize, [Window.by_ref, :int, :int], :void
+  api :SDL_GetWindowSize, [Window.by_ref, IntStruct.by_ref, IntStruct.by_ref], :void
+  api :SDL_SetWindowMaximumSize, [Window.by_ref, :int, :int], :void
+  api :SDL_GetWindowMaximumSize, [Window.by_ref, IntStruct.by_ref, IntStruct.by_ref], :void
+  api :SDL_SetWindowMinimumSize, [Window.by_ref, :int, :int], :void
+  api :SDL_GetWindowMinimumSize, [Window.by_ref, IntStruct.by_ref, IntStruct.by_ref], :void
+  api :SDL_SetWindowBordered, [Window.by_ref, :bool], :void
+  api :SDL_ShowWindow, [Window.by_ref], :void
+  api :SDL_HideWindow, [Window.by_ref], :void
+  api :SDL_RaiseWindow, [Window.by_ref], :void
+  api :SDL_MaximizeWindow, [Window.by_ref], :void
+  api :SDL_MinimizeWindow, [Window.by_ref], :void
+  api :SDL_RestoreWindow, [Window.by_ref], :void
+  api :SDL_SetWindowFullscreen, [Window.by_ref, :uint32], :int
+  api :SDL_GetWindowSurface, [Window.by_ref], Surface.by_ref
+  api :SDL_UpdateWindowSurface, [Window.by_ref], :int
+  api :SDL_UpdateWindowSurfaceRects, [Window.by_ref, Rect.by_ref, :int], :int
+  api :SDL_GetWindowGrab, [Window.by_ref], :bool
+  api :SDL_SetWindowGrab, [Window.by_ref, :bool], :void
+  api :SDL_GetWindowBrightness, [Window.by_ref], :float
+  api :SDL_SetWindowBrightness, [Window.by_ref, :float], :int
+  api :SDL_GetWindowGammaRamp, [Window.by_ref, UInt16Struct.by_ref, UInt16Struct.by_ref, UInt16Struct.by_ref], :int
+  api :SDL_SetWindowGammaRamp, [Window.by_ref, UInt16Struct.by_ref, UInt16Struct.by_ref, UInt16Struct.by_ref], :int
+  api :SDL_DestroyWindow, [Window.by_ref], :void
+  api :SDL_IsScreenSaverEnabled, [], :bool    
+  api :SDL_DisableScreenSaver, [], :void
+  api :SDL_EnableScreenSaver, [], :void    
+  api :SDL_GL_LoadLibrary, [:string], :int
+  api :SDL_GL_GetProcAddress, [:string], :pointer
+  api :SDL_GL_UnloadLibrary, [], :void
+  api :SDL_GL_ExtensionSupported, [:string], :bool
+  api :SDL_GL_SetAttribute, [:gl_attr, IntStruct], :int
+  api :SDL_GL_GetAttribute, [:gl_attr, IntStruct.by_ref], :int  
+  api :SDL_GL_CreateContext, [Window.by_ref], :gl_context  
+  api :SDL_GL_MakeCurrent, [Window.by_ref, :gl_context], :int
+  api :SDL_GL_GetCurrentWindow, [], Window.by_ref
+  api :SDL_GL_GetCurrentContext, [], :gl_context
+  api :SDL_GL_SetSwapInterval, [:int], :int
+  api :SDL_GL_GetSwapInterval, [], :int
+  api :SDL_GL_DeleteContext, [:gl_context], :void
+  api :SDL_GL_SwapWindow, [Window.by_ref], :void
+end

data/lib/sdl2/window.rb

@@ -0,0 +1,259 @@
+require 'sdl2'
+require 'sdl2/error'
+
+#require 'sdl2/video'
+require 'sdl2/surface'
+require 'sdl2/display/mode'
+
+module SDL2
+
+  # System Window
+  # A rectangular area you can blit into.
+  class Window < Struct
+    FULLSCREEN         = 0x00000001
+    OPENGL             = 0x00000002
+    SHOWN              = 0x00000004
+    HIDDEN             = 0x00000008
+    BORDERLESS         = 0x00000010
+    RESIZABLE          = 0x00000020
+    MINIMIZED          = 0x00000040
+    MAXIMIZED          = 0x00000080
+    INPUT_GRABBED      = 0x00000100
+    INPUT_FOCUS        = 0x00000200
+    MOUSE_FOCUS        = 0x00000400
+    FULLSCREEN_DESKTOP = ( FULLSCREEN | 0x00001000 )
+    FOREIGN            = 0x00000800
+
+    layout :magic, :pointer,
+    :id, :uint32,
+    :title, :string,
+    :icon, Surface.by_ref,
+    :x, :int,
+    :y, :int,
+    :w, :int,
+    :h, :int,
+    :min_w, :int,
+    :min_h, :int,
+    :max_w, :int,
+    :max_h, :int,
+    :flags, :uint32,
+    :windowed, Rect,
+    :fullscreen_mode, Display::Mode,
+    :brightness, :float,
+    :gamma, :pointer,
+    :saved_gamma, :pointer,
+    :surface, Surface.by_ref,
+    :surface_valid, :bool,
+    :shaper, :pointer, # TODO: WindowShaper.by_ref,
+    :data, :pointer,
+    :driverdata, :pointer,
+    :prev, Window.by_ref,
+    :next, Window.by_ref
+
+    class Data
+
+      def initialize(for_window)
+        @for_window = for_window
+      end
+
+      def [](name)
+        named(name)
+      end
+
+      def named(name)
+        SDL2.get_window_data(@for_window, name.to_s)
+      end
+
+      def named=(name, value)
+        SDL2.set_window_data(@for_window, name.to_s, value.to_s)
+      end
+    end
+
+    attr_reader :data
+
+    def initialize(*args, &block)
+      super(*args, &block)
+      @data = Data.new(self)
+    end
+
+    def self.create(title ='', x = 0, y = 0, w = 100, h = 100, flags = 0)
+      SDL2.create_window(title, x, y, w, h, flags)
+    end
+
+    def self.create_from(data)
+      create_window_from(data)
+    end
+
+    def self.from_id(id)
+      get_window_from_id(id)
+    end
+
+    def self.create!(*args)
+      creation = create(*args)
+      get_error() if creation.null?
+      return creation
+    end
+
+    def self.create_with_renderer(w, h, flags)
+      window = Window.new
+      renderer = Renderer.new
+      if SDL2.create_window_and_renderer(w,h,flags,window,renderer) == 0
+        [window, renderer]
+      else
+        nil
+      end
+    end
+
+    def self.release(pointer)
+      destroy_window(pointer)
+    end
+
+    def brightness
+      SDL2.get_window_brightness(self)
+    end
+
+    def brightness=(level)
+      SDL2.set_window_brightness(self, level.to_f)
+    end
+
+    def display_mode
+      dm = SDL2::Display::Mode.new
+      if SDL2.get_window_display_mode(self, dm) == 0
+        return dm
+      else
+        dm.pointer.free
+        return nil
+      end
+    end
+
+    def display_index
+      SDL2.get_window_display_index(self)
+    end
+
+    def display
+      Display[display_index]
+    end
+
+    def flags
+      SDL2.get_window_flags(self)
+    end
+
+    def grab?
+      get_window_grab(self) == :true
+    end
+
+    def grab=(value)
+      unless value == :true or value == :false
+        value = value ? :true : :false
+      end
+      set_window_grab(self, value)
+    end
+
+    def id
+      SDL2.get_window_id(self)
+    end
+
+    def pixel_format
+      SDL2.get_window_pixel_format(self)
+    end
+
+    def title
+      SDL2.get_window_title(self)
+    end
+
+    def title=(value)
+      SDL2.set_window_title(self, value)
+    end
+
+    def hide
+      SDL2.hide_window(self)
+    end
+
+    def maximize
+      SDL2.maximize_window(self)
+    end
+
+    def minimize
+      SDL2.minimize_window(self)
+    end
+
+    def raise_above
+      SDL2.raise_window(self)
+    end
+
+    def restore
+      SDL2.restore_window(self)
+    end
+    
+    def show
+      SDL2.show_window(self)
+    end
+
+    def icon=(surface)
+      set_window_icon(self, surface)
+    end
+
+    def update_surface()
+      SDL2.update_window_surface(self)
+    end
+    
+    def update_surface!()      
+      SDL2.throw_error_unless update_surface == 0
+      return 0
+    end
+
+    def current_size()
+      w_struct, h_struct = IntStruct.new, IntStruct.new
+      SDL2::get_window_size(self, w_struct, h_struct)
+      w, h = w_struct[:value], h_struct[:value]
+      [w, h]
+    end
+
+    def current_size=(size)
+      SDL2.set_window_size(self, size[0], size[1])
+    end
+
+    def maximum_size
+      w_struct, h_struct = IntStruct.new, IntStruct.new
+      SDL2::get_window_maximum_size(self, w_struct, h_struct)
+      w, h = w_struct[:value], h_struct[:value]
+      [w, h]
+    end
+
+    def maximum_size=(size)
+      SDL2.set_window_maximum_size(self, size[0], size[1])
+    end
+
+    def minimum_size
+      w_struct, h_struct = IntStruct.new, IntStruct.new
+      SDL2::get_window_minimum_size(self, w_struct, h_struct)
+      w, h = w_struct[:value], h_struct[:value]      
+      [w, h]
+    end
+
+    def minimum_size=(size)
+      SDL2.set_window_minimum_size(self, size[0], size[1])
+    end    
+    
+    def position
+      position = [IntStruct.new, IntStruct.new]
+      SDL2::get_window_position(self, position[0], position[1])
+      x, y = position[0][:value], position[1][:value]
+      position.each{|struct|struct.pointer.free}
+      [x, y]
+    end
+    
+    def position=(location)
+      SDL2::set_window_position(self, location[0],location[1])
+    end
+    
+    def surface
+      SDL2.get_window_surface(self)
+    end
+    
+    def fullscreen=(flags)
+      SDL2.set_window_fullscreen(self, flags)
+    end
+  end
+
+end

data/lib/sdl2.rb

@@ -0,0 +1,99 @@
+require 'ffi'
+require 'sdl2/sdl_module'
+require 'active_support/inflector'
+
+module SDL2
+  extend FFI::Library
+
+    
+  # This converts the SDL Function Prototype name "SDL_XxxYyyyyZzz" to ruby's
+  # "xxx_yyyy_zzz" convetion
+  def self.api(func_name, args, type)
+    camelCaseName = func_name.to_s.gsub('SDL_','')
+    methodName = ActiveSupport::Inflector.underscore(camelCaseName).to_sym
+    print "Linking #{func_name} -> #{methodName}...."
+    self.attach_function methodName, func_name, args, type
+    puts "OK!"
+    return methodName
+  end
+
+  class Struct < FFI::Struct
+
+    def initialize(*args, &block)
+      super(*args)
+      if block_given?
+        throw 'Release must be defined to use block' unless self.class.respond_to?(:release)
+        yield self
+        self.class.release(self.pointer)
+      end
+    end
+  end
+
+  class ManagedStruct < FFI::ManagedStruct
+
+    def initialize(*args, &block)
+      super(*args)
+      if block_given?
+        throw 'Release must be defined to use block' unless self.class.respond_to?(:release)
+        yield self
+        self.class.release(self.pointer)
+      end
+    end
+  end
+
+  # TODO: Review default/hard-coded load paths?
+  ffi_lib SDL_MODULE
+
+  # SDL_Bool
+  enum :bool, [:false, 0, :true, 1]
+
+  def self.throw_error_unless(condition)
+    throw get_error() unless condition
+  end
+
+  def self.throw_error_if(condition)
+    throw get_error() if condition
+  end
+
+  # Simple Type Structures to interface 'typed-pointers'
+  # TODO: Research if this is the best way to handle 'typed-pointers'
+  class FloatStruct < FFI::Struct
+    layout :value, :float
+  end
+
+  class IntStruct < FFI::Struct
+    layout :value, :int
+  end
+
+  class UInt16Struct < FFI::Struct
+    layout :value, :uint16
+  end
+
+  class UInt32Struct < FFI::Struct
+    layout :value, :uint32
+  end
+
+  class UInt8Struct < FFI::Struct
+    layout :value, :uint8
+  end
+
+  # TODO: Review if this is the best place to put it.
+  # BlendMode is defined in a header file that is always included, so I'm
+  # defineing again here.
+  enum :blend_mode, [
+    :none, 0x00000000,
+    :blend, 0x00000001,
+    :add, 0x00000002,
+    :mod, 0x00000004
+  ]
+
+  class BlendModeStruct < FFI::Struct
+    layout :value, :blend_mode
+  end
+
+  typedef :uint32, :pixel_format
+
+  # Simple typedef to represent array sizes.
+  typedef :int, :count
+
+end

data/lib/sdl2_ffi.rb

@@ -0,0 +1,6 @@
+require 'sdl2'
+require 'ffi'
+
+# Alias the module, in case of confusion?
+SDL2_FFI = SDL2 
+Sdl2_Ffi = SDL2

data/sdl2_ffi.gemspec

@@ -0,0 +1,31 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'sdl2/gem_version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'sdl2_ffi'
+  spec.version       = SDL2::GEM_VERSION
+  spec.authors       = ['BadQuanta']
+  spec.email         = ['BadQuanta@Gmail.com']
+  spec.description   = %q{Foreign Function Interface to SDL2 in Ruby }
+  spec.summary       = %q{Object Oriented wrapper for SDL2.  Help me test & debug my interface.}
+  spec.homepage      = 'https://github.com/BadQuanta/sdl2_ffi'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+  
+  spec.add_dependency 'ffi'
+  spec.add_dependency 'yinum'
+  spec.add_dependency 'activesupport'
+
+  spec.add_development_dependency 'bundler', '~> 1.3'
+  spec.add_development_dependency 'minitest', '~> 5.0.7'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'pry'
+  spec.add_development_dependency 'guard'
+  spec.add_development_dependency 'guard-minitest'
+end

data/test/test_helper.rb

@@ -0,0 +1,2 @@
+require 'minitest/autorun'
+