hybridgroup-ruby-sdl-ffi 0.4.1

data/lib/ruby-sdl-ffi/sdl/core.rb

@@ -0,0 +1,129 @@
+#--
+#
+# This file is one part of:
+#
+# Ruby-SDL-FFI - Ruby-FFI bindings to SDL
+#
+# Copyright (c) 2009 John Croisant
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+# IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+# CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+# SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#
+#++
+
+
+module SDL
+
+  # Aliases for integer-like types
+  ENUM        = :int            # :nodoc:
+  BOOL        = :int            # :nodoc:
+  GLATTR      = :int            # :nodoc:
+
+
+  LIL_ENDIAN  = 1234
+  BIG_ENDIAN  = 4321
+
+
+
+  # SDL.h
+
+  class Version < NiceFFI::Struct
+    layout( :major, :uint8,
+            :minor, :uint8,
+            :patch, :uint8 )
+  end
+
+  sdl_func  :Linked_Version, [], Version.typed_pointer
+
+
+  INIT_TIMER       = 0x00000001
+  INIT_AUDIO       = 0x00000010
+  INIT_VIDEO       = 0x00000020
+  INIT_CDROM       = 0x00000100
+  INIT_JOYSTICK    = 0x00000200
+  INIT_NOPARACHUTE = 0x00100000
+  INIT_EVENTTHREAD = 0x01000000
+  INIT_EVERYTHING  = 0x0000FFFF
+
+  sdl_func  :Init,          [ :uint32 ], :int
+  sdl_func  :InitSubSystem, [ :uint32 ], :int
+  sdl_func  :QuitSubSystem, [ :uint32 ], :void
+  sdl_func  :WasInit,       [ :uint32 ], :uint32
+  sdl_func  :Quit,          [         ], :void
+
+
+
+  # SDL_active.h
+
+  APPMOUSEFOCUS = 0x01
+  APPINPUTFOCUS = 0x02
+  APPACTIVE     = 0x04
+
+  sdl_func  :GetAppState, [  ], :uint8
+
+
+
+  # SDL_cpuinfo.h
+
+  sdl_func  :HasRDTSC,    [  ], SDL::BOOL
+  sdl_func  :HasMMX,      [  ], SDL::BOOL
+  sdl_func  :HasMMXExt,   [  ], SDL::BOOL
+  sdl_func  :Has3DNow,    [  ], SDL::BOOL
+  sdl_func  :Has3DNowExt, [  ], SDL::BOOL
+  sdl_func  :HasSSE,      [  ], SDL::BOOL
+  sdl_func  :HasSSE2,     [  ], SDL::BOOL
+  sdl_func  :HasAltiVec,  [  ], SDL::BOOL
+
+
+
+  # SDL_error.h
+
+  sdl_func  :SetError,   [ :string, :varargs  ], :void
+  sdl_func  :GetError,   [ ], :string
+  sdl_func  :ClearError, [ ], :void
+
+  ENOMEM      = 0
+  EFREAD      = 1
+  EFWRITE     = 2
+  EFSEEK      = 3
+  UNSUPPORTED = 4
+  LASTERROR   = 5
+
+  sdl_func  :Error, [ SDL::ENUM ], :void
+
+
+
+  # SDL_loadso.h
+
+  sdl_func  :LoadObject,   [ :string           ], :pointer
+  sdl_func  :LoadFunction, [ :pointer, :string ], :pointer
+  sdl_func  :UnloadObject, [ :pointer          ], :void
+
+
+
+  # SDL_thread.h
+
+  sdl_func  :CreateThread, [ callback([:pointer], :int), :pointer ], :pointer
+
+  sdl_func  :ThreadID,    [                    ], :uint32
+  sdl_func  :GetThreadID, [ :pointer           ], :uint32
+  sdl_func  :WaitThread,  [ :pointer, :pointer ], :void
+  sdl_func  :KillThread,  [ :pointer           ], :void
+
+end

data/lib/ruby-sdl-ffi/sdl/event.rb

@@ -0,0 +1,375 @@
+#--
+#
+# This file is one part of:
+#
+# Ruby-SDL-FFI - Ruby-FFI bindings to SDL
+#
+# Copyright (c) 2009 John Croisant
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+# IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+# CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+# SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#
+#++
+
+
+module SDL
+
+  RELEASED        = 0
+  PRESSED         = 1
+
+  NOEVENT         = 0
+  ACTIVEEVENT     = 1
+  KEYDOWN         = 2
+  KEYUP           = 3
+  MOUSEMOTION     = 4
+  MOUSEBUTTONDOWN = 5
+  MOUSEBUTTONUP   = 6
+  JOYAXISMOTION   = 7
+  JOYBALLMOTION   = 8
+  JOYHATMOTION    = 9
+  JOYBUTTONDOWN   = 10
+  JOYBUTTONUP     = 11
+  QUIT            = 12
+  SYSWMEVENT      = 13
+  EVENT_RESERVEDA = 14
+  EVENT_RESERVEDB = 15
+  VIDEORESIZE     = 16
+  VIDEOEXPOSE     = 17
+  EVENT_RESERVED2 = 18
+  EVENT_RESERVED3 = 19
+  EVENT_RESERVED4 = 20
+  EVENT_RESERVED5 = 21
+  EVENT_RESERVED6 = 22
+  EVENT_RESERVED7 = 23
+  USEREVENT       = 24
+  NUMEVENTS       = 32
+
+
+  ACTIVEEVENTMASK     = (1 << (ACTIVEEVENT))
+  JOYAXISMOTIONMASK   = (1 << (JOYAXISMOTION))
+  JOYEVENTMASK        = (1 << (JOYAXISMOTION)) | \
+                        (1 << (JOYBALLMOTION)) | \
+                        (1 << (JOYHATMOTION))  | \
+                        (1 << (JOYBUTTONDOWN)) | \
+                        (1 << (JOYBUTTONUP))
+  JOYBALLMOTIONMASK   = (1 << (JOYBALLMOTION))
+  JOYBUTTONDOWNMASK   = (1 << (JOYBUTTONDOWN))
+  JOYBUTTONUPMASK     = (1 << (JOYBUTTONUP))
+  JOYHATMOTIONMASK    = (1 << (JOYHATMOTION))
+  KEYDOWNMASK         = (1 << (KEYDOWN))
+  KEYEVENTMASK        = (1 << (KEYDOWN))|(1 << (KEYUP))
+  KEYUPMASK           = (1 << (KEYUP))
+  MOUSEBUTTONDOWNMASK = (1 << (MOUSEBUTTONDOWN))
+  MOUSEBUTTONUPMASK   = (1 << (MOUSEBUTTONUP))
+  MOUSEMOTIONMASK     = (1 << (MOUSEMOTION))
+  MOUSEEVENTMASK      = (1 << (MOUSEMOTION)) | \
+                        (1 << (MOUSEBUTTONDOWN)) | \
+                        (1 << (MOUSEBUTTONUP))
+  QUITMASK            = (1 << (QUIT))
+  SYSWMEVENTMASK      = (1 << (SYSWMEVENT))
+  VIDEOEXPOSEMASK     = (1 << (VIDEOEXPOSE))
+  VIDEORESIZEMASK     = (1 << (VIDEORESIZE))
+  ALLEVENTS           = 0xFFFFFFFF
+
+
+
+  class ActiveEvent < NiceFFI::Struct
+    layout( :type,  :uint8,
+            :gain,  :uint8,
+            :state, :uint8 )
+  end
+
+
+  class KeyboardEvent < NiceFFI::Struct
+    layout( :type,   :uint8,
+            :which,  :uint8,
+            :state,  :uint8,
+            :keysym, SDL::Keysym )
+  end
+
+
+  class MouseMotionEvent < NiceFFI::Struct
+    layout( :type,  :uint8,
+            :which, :uint8,
+            :state, :uint8,
+            :x,     :uint16,
+            :y,     :uint16,
+            :xrel,  :int16,
+            :yrel,  :int16 )
+  end
+
+
+  class MouseButtonEvent < NiceFFI::Struct
+    layout( :type,   :uint8,
+            :which,  :uint8,
+            :button, :uint8,
+            :state,  :uint8,
+            :x,      :uint16,
+            :y,      :uint16 )
+  end
+
+
+  class JoyAxisEvent < NiceFFI::Struct
+    layout( :type,  :uint8,
+            :which, :uint8,
+            :axis,  :uint8,
+            :value, :int16 )
+  end
+
+
+  class JoyBallEvent < NiceFFI::Struct
+    layout( :type,  :uint8,
+            :which, :uint8,
+            :ball,  :uint8,
+            :xrel,  :int16,
+            :yrel,  :int16 )
+  end
+
+
+  class JoyHatEvent < NiceFFI::Struct
+    layout( :type,  :uint8,
+            :which, :uint8,
+            :hat,   :uint8,
+            :value, :uint8 )
+  end
+
+
+  class JoyButtonEvent < NiceFFI::Struct
+    layout( :type,   :uint8,
+            :which,  :uint8,
+            :button, :uint8,
+            :state,  :uint8 )
+  end
+
+
+  class ResizeEvent < NiceFFI::Struct
+    layout( :type, :uint8,
+            :w,    :int,
+            :h,    :int )
+  end
+
+
+  class ExposeEvent < NiceFFI::Struct
+    layout( :type, :uint8 )
+  end
+
+
+  class QuitEvent < NiceFFI::Struct
+    layout( :type, :uint8 )
+  end
+
+
+  class UserEvent < NiceFFI::Struct
+    layout( :type,  :uint8,
+            :code,  :int,
+            :data1, :pointer,
+            :data2, :pointer )
+  end
+
+
+  class SysWMEvent < NiceFFI::Struct
+    layout( :type, :uint8,
+            :msg,  :pointer )
+  end
+
+
+  class Event < FFI::Union
+    layout( :type,    :uint8,
+            :active,  SDL::ActiveEvent,
+            :key,     SDL::KeyboardEvent,
+            :motion,  SDL::MouseMotionEvent,
+            :button,  SDL::MouseButtonEvent,
+            :jaxis,   SDL::JoyAxisEvent,
+            :jball,   SDL::JoyBallEvent,
+            :jhat,    SDL::JoyHatEvent,
+            :jbutton, SDL::JoyButtonEvent,
+            :resize,  SDL::ResizeEvent,
+            :expose,  SDL::ExposeEvent,
+            :quit,    SDL::QuitEvent,
+            :user,    SDL::UserEvent,
+            :syswm,   SDL::SysWMEvent )
+
+
+    # Creates a generic Event containing a specific event.
+    # You usually don't need to do this, because you can pass
+    # specific events directly to SDL::SDL_PushEvent.
+    # 
+    def self.wrap( event )
+      self.new( event.pointer )
+    end
+
+
+    # Extracts a specific event class from a generic Event.
+    def unwrap
+      case self[:type]
+      when ACTIVEEVENT;       ActiveEvent.new(self.pointer)
+      when KEYDOWN, KEYUP;    KeyboardEvent.new(self.pointer)
+      when MOUSEMOTION;       MouseMotionEvent.new(self.pointer)
+
+      when MOUSEBUTTONDOWN, MOUSEBUTTONUP;
+                              MouseButtonEvent.new(self.pointer)
+
+      when JOYAXISMOTION;     JoyAxisEvent.new(self.pointer)
+      when JOYBALLMOTION;     JoyBallEvent.new(self.pointer)
+      when JOYHATMOTION;      JoyHatEvent.new(self.pointer)
+
+      when JOYBUTTONDOWN, JOYBUTTONUP;
+                              JoyButtonEvent.new(self.pointer)
+
+      when QUIT;              QuitEvent.new( self.pointer )
+      when SYSWMEVENT;        SysWMEvent.new( self.pointer )
+      when VIDEORESIZE;       ResizeEvent.new( self.pointer )
+      when VIDEOEXPOSE;       ExposeEvent.new( self.pointer )
+      when USEREVENT;         UserEvent.new( self.pointer )
+
+      else; raise TypeError, "Invalid event #{self.inspect}"
+      end
+    end
+
+    def inspect
+      super.gsub(">", " :type=#{self[:type]}>")
+    end
+
+  end
+
+
+  sdl_func  :PumpEvents, [  ], :void
+
+
+  ADDEVENT  = 0
+  PEEKEVENT = 1
+  GETEVENT  = 2
+
+  func  :__SDL_PeepEvents, "SDL_PeepEvents",
+        [ :pointer, :int, SDL::ENUM, :uint32 ], :int
+
+
+  # Behavior varies depending on action.
+  # 
+  # PEEKEVENT or GETEVENT:
+  #   events is the max number of events to retrieve.
+  #   Returns an array of Events, or nil if there was an error.
+  #   GETEVENT removes them from the queue, PEEKEVENT leaves them.
+  # 
+  # ADDEVENT:
+  #   events is an array of Events (or specific event instances)
+  #   to append to the queue.
+  #   Returns the number of events added, or -1 if there was an error.
+  # 
+  def self.PeepEvents( events, action, mask )
+    # PeepEvents is very versatile, so we break it up into
+    # different actions...
+
+    case action
+
+    # Append the given events to the queue, return number added.
+    when ADDEVENT
+      numevents = events.size
+      mp = FFI::Buffer.new( SDL::Event, numevents )
+
+      # Dump the events into the Buffer as raw, hardcore bytes
+      events.each_with_index do |ev, i|
+        mp[i].put_bytes( 0, ev.pointer.get_bytes(0, ev.size) )
+      end
+
+      return __SDL_PeepEvents( mp, numevents, action, mask )
+      
+    # Peek or Get the first N events and return them in an array.
+    # Peek does not remove them from the queue, but Get does.
+    when PEEKEVENT, GETEVENT
+      numevents = events.to_i
+      mp = FFI::Buffer.new( SDL::Event, numevents )
+      n = __SDL_PeepEvents( mp, numevents, action, mask )
+
+      # Something went wrong
+      return nil if( n == -1 )
+
+      events = []
+      n.times do |i|
+        events << Event.new( mp[i] ).unwrap
+      end
+
+      return events
+    end
+  end
+
+
+  func  :__SDL_PollEvent, "SDL_PollEvent", [ :pointer ], :int
+
+  def self.PollEvent()
+    mp = FFI::Buffer.new( SDL::Event, 1 )
+    n = __SDL_PollEvent( mp )
+    if n == 0
+      nil
+    else
+      Event.new(mp).unwrap
+    end
+  end
+
+
+  func  :__SDL_WaitEvent, "SDL_WaitEvent", [ :pointer ], :int
+
+  def self.WaitEvent()
+    mp = FFI::Buffer.new( SDL::Event, 1 )
+    n = __SDL_WaitEvent( mp )
+    if n == 0
+      nil
+    else
+      Event.new(mp).unwrap
+    end
+  end
+
+
+  sdl_func  :PushEvent, [ :buffer_in ], :int
+
+
+
+  callback(:eventfilter_cb, [ :pointer ], :int)
+
+  func  :__SDL_SetEventFilter, "SDL_SetEventFilter",
+        [ :eventfilter_cb ], :void
+
+  def self.SetEventFilter( &block )
+    if( block_given? )
+      proc = Proc.new { |ev| 
+        result = block.call( Event.new(ev).unwrap )
+        case result
+        when true;        1
+        when false, nil;  0
+        else;             result
+        end
+      }
+      __SDL_SetEventFilter( proc )
+    else
+      __SDL_SetEventFilter( nil )
+    end
+  end
+
+
+  #sdl_func  :GetEventFilter, [ ], :eventfilter_cb
+
+
+  QUERY   = -1
+  IGNORE  = 0
+  DISABLE = 0
+  ENABLE  = 1
+
+  sdl_func  :EventState, [ :uint8, :int ], :uint8
+
+end

data/lib/ruby-sdl-ffi/sdl/joystick.rb

@@ -0,0 +1,73 @@
+#--
+#
+# This file is one part of:
+#
+# Ruby-SDL-FFI - Ruby-FFI bindings to SDL
+#
+# Copyright (c) 2009 John Croisant
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+# IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+# CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+# SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#
+#++
+
+
+module SDL
+
+  class Joystick < NiceFFI::OpaqueStruct
+    #--
+    # SDL_Joystick struct (in C) has a hidden layout.
+    #++
+  end
+
+
+  sdl_func  :NumJoysticks,       [                ], :int
+  sdl_func  :JoystickName,       [ :int           ], :string
+  sdl_func  :JoystickOpen,       [ :int           ], Joystick.typed_pointer
+  sdl_func  :JoystickOpened,     [ :int           ], :int
+  sdl_func  :JoystickIndex,      [ :pointer       ], :int
+
+  sdl_func  :JoystickNumAxes,    [ :pointer       ], :int
+  sdl_func  :JoystickNumBalls,   [ :pointer       ], :int
+  sdl_func  :JoystickNumHats,    [ :pointer       ], :int
+  sdl_func  :JoystickNumButtons, [ :pointer       ], :int
+
+  sdl_func  :JoystickUpdate,     [                ], :void
+  sdl_func  :JoystickEventState, [ :int           ], :int
+  sdl_func  :JoystickGetAxis,    [ :pointer, :int ], :int16
+
+
+  HAT_CENTERED  = 0x00
+  HAT_UP        = 0x01
+  HAT_RIGHT     = 0x02
+  HAT_DOWN      = 0x04
+  HAT_LEFT      = 0x08
+  HAT_RIGHTUP   = (HAT_RIGHT|HAT_UP)
+  HAT_RIGHTDOWN = (HAT_RIGHT|HAT_DOWN)
+  HAT_LEFTUP    = (HAT_LEFT |HAT_UP)
+  HAT_LEFTDOWN  = (HAT_LEFT |HAT_DOWN)
+
+
+  sdl_func  :JoystickGetHat,    [ :pointer, :int                     ], :uint8
+  sdl_func  :JoystickGetBall,   [ :pointer, :int, :pointer, :pointer ], :int
+  sdl_func  :JoystickGetButton, [ :pointer, :int                     ], :uint8
+
+  sdl_func  :JoystickClose, [ :pointer ], :void
+
+end

data/lib/ruby-sdl-ffi/sdl/keyboard.rb

@@ -0,0 +1,76 @@
+#--
+#
+# This file is one part of:
+#
+# Ruby-SDL-FFI - Ruby-FFI bindings to SDL
+#
+# Copyright (c) 2009 John Croisant
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+# IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+# CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+# SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#
+#++
+
+
+module SDL
+
+  class Keysym < NiceFFI::Struct
+    layout( :scancode, :uint8,
+            :sym,      SDL::ENUM,
+            :mod,      SDL::ENUM,
+            :unicode,  :uint16 )
+  end
+
+  ALL_HOTKEYS = 0xFFFFFFFF
+
+
+  sdl_func  :EnableUNICODE, [ :int ], :int
+
+
+  DEFAULT_REPEAT_DELAY    = 500
+  DEFAULT_REPEAT_INTERVAL = 30
+
+  sdl_func  :EnableKeyRepeat, [ :int, :int ], :int
+
+
+  func  :__SDL_GetKeyRepeat, "SDL_GetKeyRepeat",
+        [ :buffer_out, :buffer_out ], :void
+
+  def self.GetKeyRepeat()
+    delay = FFI::Buffer.new( :int )
+    interval = FFI::Buffer.new( :int )
+    __SDL_GetKeyRepeat( delay, interval )
+    return [delay.get_int(0), interval.get_int(0)]
+  end
+
+
+  func  :__SDL_GetKeyState, "SDL_GetKeyState", [ :buffer_out ], :pointer
+
+  def self.GetKeyState()
+    numkeys = FFI::Buffer.new( :int )
+    keys = __SDL_GetKeyState( numkeys )
+    return keys.get_array_of_uint8( 0, numkeys.get_int(0) )
+  end
+
+
+  sdl_func  :GetModState, [           ], SDL::ENUM
+  sdl_func  :SetModState, [ SDL::ENUM ], :void
+  sdl_func  :GetKeyName,  [ SDL::ENUM ], :string
+
+end