sdl2_ffi 0.0.3 → 0.0.4

data/lib/sdl2/library.rb

@@ -0,0 +1,96 @@
+require 'ffi'
+
+module SDL2
+
+  # Extensions to FFI::Library
+  module Library
+
+    # This converts the SDL Function Prototype name "SDL_XxxYyyyyZzz" to ruby's
+    # "xxx_yyyy_zzz" convetion
+    def api(func_name, args, type, options = {})
+
+      options = {
+        :error => false,
+        :filter => type == :bool ? TRUE_WHEN_TRUE : TRUE_WHEN_ZERO
+      }.merge(options)
+
+      # TODO: Review ugly hack:
+      remove_part = case self.to_s
+      when "SDL2"
+        "SDL_"
+      when "SDL2::Image"
+        "IMG_"
+      when "SDL2::TTF"
+        "TTF_"
+      else
+        $stderr.puts("Library#api does not know how to handle module: #{self.to_s}")
+        /[A-Z][A-Z|0-9]*_/
+      end
+
+      camelCaseName = func_name.to_s.gsub(remove_part,'')
+      methodName = ActiveSupport::Inflector.underscore(camelCaseName).to_sym
+
+      attach_function methodName, func_name, args, type
+
+      if options[:error]
+        returns_error(methodName, options[:filter])
+      end
+
+      if type == :bool
+        boolean?(methodName)
+      end
+
+      return methodName
+    end
+
+    # Returns the 'singleton class' so we can define class-level methods on the
+    # fly.
+    # There may be a better place to put this.
+    def metaclass
+
+      class << self; self; end
+    end
+
+    # Generates an alternative version of methodName that will raise a SDL Error
+    # when the return value fails the filter test.  The alternative version has
+    # the same name, but with an exclamation mark ("!") at the end, indicating the
+    # danger.
+    def returns_error(methodName, filter)
+      metaclass.instance_eval do
+        define_method "#{methodName}!".to_sym do |*args|
+          result = send(methodName, *args)
+          raise_error_unless filter.call(result)
+          result
+        end
+      end
+    end
+
+    # Generates an alternative ? version for methodName.
+    def boolean?(methodName, filter = nil)
+      metaclass.instance_eval do
+        if filter.nil?
+          alias_method "#{methodName}?".to_sym, methodName
+        else
+          define_method("#{methodName}?".to_sym) do |*args|
+            filter.call(send(methodName, *args))
+          end
+        end
+      end
+    end
+
+    # Raise the current error value as a RuntimeException
+    def raise_error
+      raise "SDL Error: #{SDL2.get_error()}"
+    end
+
+    # Conditionally raise an error, unless true
+    def raise_error_unless(condition)
+      raise_error unless condition
+    end
+
+    # Conditionally raise an error, unless false
+    def raise_error_if(condition)
+      raise_error if condition
+    end
+  end
+end

data/lib/sdl2/mouse.rb

@@ -1,5 +1,5 @@
 require 'sdl2'
-require 'yinum'
+
 
 module SDL2
 
@@ -32,22 +32,27 @@ module SDL2
     def self.button(num)
       1 << (num-1)
     end
-
-    Button = Enum.new(:MOUSE_BUTTONS, {
-      :LEFT => 1,
-      :MIDDLE => 2,
-      :RIGHT => 3,
-      :X1 => 4,
-      :X2 => 5
-    })
-
-    ButtonMask = Enum.new(:MOUSE_BUTTON_MASK, {
-      :LEFT => button(Button.LEFT),
-      :MIDDLE => button(Button.MIDDLE),
-      :RIGHT => button(Button.RIGHT),
-      :X1 => button(Button.X1),
-      :X2 => button(Button.X2)
-    })
+    
+    module BUTTON
+      include EnumerableConstants
+      LEFT = next_const_value
+      MIDDLE  = next_const_value
+      RIGHT  = next_const_value
+      X1  = next_const_value
+      X2  = next_const_value
+    end
+    
+    module BUTTONMASK
+      def self.for_enum button_enum 
+        1 << (button_enum-1)
+      end
+      include EnumerableConstants
+      LEFT = for_enum(BUTTON::LEFT)
+      MIDDLE = for_enum(BUTTON::MIDDLE)
+      RIGHT = for_enum(BUTTON::RIGHT)
+      X1 = for_enum(BUTTON::X1)
+      X2 = for_enum(BUTTON::X2)
+    end
 
   end
 

data/lib/sdl2/pixel_format.rb

@@ -110,7 +110,8 @@ module SDL2
       ptr.each(&:free)
       return result
     end
-
+    
+    
   end
 
 end

data/lib/sdl2/pixels.rb

@@ -1,81 +1,97 @@
 require 'sdl2/error'
 require 'sdl2/color'
 require 'sdl2/pixel_format'
-require 'yinum'
 
 # SDL_pixels.h API
 module SDL2
   ALPHA_OPAQUE = 255
   ALPHA_TRANSPARENT = 0
 
-  PIXELTYPE = Enum.new :PIXELTYPE, {
-    UNKNOWN: 0,
-    INDEX1: 1,
-    INDEX4: 2,
-    INDEX8: 3,
-    PACKED8: 4,
-    PACKED16: 5,
-    PACKED32: 6,
-    ARRAYU8: 7,
-    ARRAYU16: 8,
-    ARRAYU32: 9,
-    ARRAYF16: 10,
-    ARRAYF32: 11
-  }
-  enum :pixeltype, PIXELTYPE.by_name
+  # Predefined pixel types.
+  module PIXELTYPE
+    include EnumerableConstants
+    UNKNOWN = next_const_value
+    INDEX1 = next_const_value
+    INDEX4 = next_const_value
+    INDEX8 = next_const_value
+    PACKED8 = next_const_value
+    PACKED16 = next_const_value
+    PACKED32 = next_const_value
+    ARRAYU8 = next_const_value
+    ARRAYU16 = next_const_value
+    ARRAYU32 = next_const_value
+    ARRAYF16 = next_const_value
+    ARRAYF32 = next_const_value
+  end
+  enum :pixeltype, PIXELTYPE.flatten_consts
+
+  # Bitmap pixel order, high bit -> low bit
+  module BITMAPORDER
+    include EnumerableConstants
+    NONE =  next_const_value
+    N4321 = next_const_value
+    N1234 = next_const_value
+  end
 
-  BITMAPORDER = Enum.new :BITMAPORDER, {
-    NONE: 0,
-    _4321: 1,
-    _1234: 2
-  }
-  enum :bitmaporder, BITMAPORDER.by_name
+  enum :bitmaporder, BITMAPORDER.flatten_consts
+
+  # Packed component order, high bit -> low bit
+  module PACKEDORDER
+    include EnumerableConstants
+    NONE = next_const_value
+    XRGB = next_const_value
+    RGBX = next_const_value
+    ARGB = next_const_value
+    RGBA = next_const_value
+    XBGR = next_const_value
+    BGRX = next_const_value
+    ABGR = next_const_value
+    BGRA = next_const_value
+  end
 
-  PACKEDORDER = Enum.new :PACKEDORDER, {
-    NONE: 0,
-    XRGB: 1,
-    RGBX: 2,
-    ARGB: 3,
-    RGBA: 4,
-    XBGR: 5,
-    BGRX: 6,
-    ABGR: 7,
-    BGRA: 8
-  }
-  enum :packedorder, PACKEDORDER.by_name
+  enum :packedorder, PACKEDORDER.flatten_consts
+
+  # Array component order, low byte -> hight byte
+  module ARRAYORDER
+    include EnumerableConstants
+    NONE = next_const_value
+    RGB = next_const_value
+    RGBA = next_const_value
+    ARGB = next_const_value
+    BGR = next_const_value
+    BGRA = next_const_value
+    ABGR = next_const_value
+  end
 
-  ARRAYORDER = Enum.new :ARRAYORDER, {
-    NONE: 0,
-    RGB: 1,
-    RGBA: 2,
-    ARGB: 3,
-    BGR: 4,
-    BGRA: 5,
-    ABGR: 6
-  }
-  enum :arrayorder, ARRAYORDER.by_name
+  enum :arrayorder, ARRAYORDER.flatten_consts
+
+  # Packed component layout
+  module PACKEDLAYOUT
+    include EnumerableConstants
+    NONE = next_const_value
+    N332 = next_const_value
+    N4444 = next_const_value
+    N1555 = next_const_value
+    N5551 = next_const_value
+    N565 = next_const_value
+    N8888 = next_const_value
+    N2101010 = next_const_value
+    N1010102 = next_const_value
+  end
 
-  PACKEDLAYOUT = Enum.new :PACKEDLAYOUT, {
-    NONE: 0,
-    _332: 1,
-    _4444: 2,
-    _1555: 3,
-    _5551: 4,
-    _565: 5,
-    _8888: 6,
-    _2101010: 7,
-    _1010102: 8
-  }
-  enum :packedlayout, PACKEDLAYOUT.by_name
+  enum :packedlayout, PACKEDLAYOUT.flatten_consts
 
   #MACRO: SDL_DEFINE_PIXELFOURCC(A, B, C, D) SDL_FOURCC(A, B, C, D)
-  def self.define_pixelfourcc(a,b,c,d); SDL2.fourcc(a,b,c,d); end
+  def self.define_pixelfourcc(a,b,c,d)
+    SDL2.fourcc(a,b,c,d);
+  end
 
   #MACRO: SDL_DEFINE_PIXELFORMAT(type, order, layout, bits, bytes) \
   #    ((1 << 28) | ((type) << 24) | ((order) << 20) | ((layout) << 16) | \
   #     ((bits) << 8) | ((bytes) << 0))
   def self.define_pixelformat(type, order, layout, bits, bytes)
-    ((1 << 28) | ((type) << 24) | ((order) << 20) | ((layout) << 16) | ((bits) << 8) | ((bytes) << 0))
+    ((1 << 28) | ((type) << 24) | ((order) << 20) | ((layout) << 16) | 
+     ((bits) << 8) | ((bytes) << 0))
   end
 
   #MACRO: SDL_PIXELFLAG(X)    (((X) >> 28) & 0x0F)
@@ -137,109 +153,46 @@ module SDL2
     ((format) && (pixelflag(format) != 1))
   end
 
-  PIXELFORMAT = Enum.new(:PIXELFORMAT, {
-    UNKNOWN: 0,
-    INDEX1LSB:
-    define_pixelformat(PIXELTYPE.INDEX1, BITMAPORDER._4321, 0,
-    1, 0),
-    INDEX1MSB:
-    define_pixelformat(PIXELTYPE.INDEX1, BITMAPORDER._1234, 0,
-    1, 0),
-    INDEX4LSB:
-    define_pixelformat(PIXELTYPE.INDEX4, BITMAPORDER._4321, 0,
-    4, 0),
-    INDEX4MSB:
-    define_pixelformat(PIXELTYPE.INDEX4, BITMAPORDER._1234, 0,
-    4, 0),
-    INDEX8:
-    define_pixelformat(PIXELTYPE.INDEX8, 0, 0, 8, 1),
-    RGB332:
-    define_pixelformat(PIXELTYPE.PACKED8, PACKEDORDER.XRGB,
-    PACKEDLAYOUT._332, 8, 1),
-    RGB444:
-    define_pixelformat(PIXELTYPE.PACKED16, PACKEDORDER.XRGB,
-    PACKEDLAYOUT._4444, 12, 2),
-    RGB555:
-    define_pixelformat(PIXELTYPE.PACKED16, PACKEDORDER.XRGB,
-    PACKEDLAYOUT._1555, 15, 2),
-    BGR555:
-    define_pixelformat(PIXELTYPE.PACKED16, PACKEDORDER.XBGR,
-    PACKEDLAYOUT._1555, 15, 2),
-    ARGB4444:
-    define_pixelformat(PIXELTYPE.PACKED16, PACKEDORDER.ARGB,
-    PACKEDLAYOUT._4444, 16, 2),
-    RGBA4444:
-    define_pixelformat(PIXELTYPE.PACKED16, PACKEDORDER.RGBA,
-    PACKEDLAYOUT._4444, 16, 2),
-    ABGR4444:
-    define_pixelformat(PIXELTYPE.PACKED16, PACKEDORDER.ABGR,
-    PACKEDLAYOUT._4444, 16, 2),
-    BGRA4444:
-    define_pixelformat(PIXELTYPE.PACKED16, PACKEDORDER.BGRA,
-    PACKEDLAYOUT._4444, 16, 2),
-    ARGB1555:
-    define_pixelformat(PIXELTYPE.PACKED16, PACKEDORDER.ARGB,
-    PACKEDLAYOUT._1555, 16, 2),
-    RGBA5551:
-    define_pixelformat(PIXELTYPE.PACKED16, PACKEDORDER.RGBA,
-    PACKEDLAYOUT._5551, 16, 2),
-    ABGR1555:
-    define_pixelformat(PIXELTYPE.PACKED16, PACKEDORDER.ABGR,
-    PACKEDLAYOUT._1555, 16, 2),
-    BGRA5551:
-    define_pixelformat(PIXELTYPE.PACKED16, PACKEDORDER.BGRA,
-    PACKEDLAYOUT._5551, 16, 2),
-    RGB565:
-    define_pixelformat(PIXELTYPE.PACKED16, PACKEDORDER.XRGB,
-    PACKEDLAYOUT._565, 16, 2),
-    BGR565:
-    define_pixelformat(PIXELTYPE.PACKED16, PACKEDORDER.XBGR,
-    PACKEDLAYOUT._565, 16, 2),
-    RGB24:
-    define_pixelformat(PIXELTYPE.ARRAYU8, ARRAYORDER.RGB, 0,
-    24, 3),
-    BGR24:
-    define_pixelformat(PIXELTYPE.ARRAYU8, ARRAYORDER.BGR, 0,
-    24, 3),
-    RGB888:
-    define_pixelformat(PIXELTYPE.PACKED32, PACKEDORDER.XRGB,
-    PACKEDLAYOUT._8888, 24, 4),
-    RGBX8888:
-    define_pixelformat(PIXELTYPE.PACKED32, PACKEDORDER.RGBX,
-    PACKEDLAYOUT._8888, 24, 4),
-    BGR888:
-    define_pixelformat(PIXELTYPE.PACKED32, PACKEDORDER.XBGR,
-    PACKEDLAYOUT._8888, 24, 4),
-    BGRX8888:
-    define_pixelformat(PIXELTYPE.PACKED32, PACKEDORDER.BGRX,
-    PACKEDLAYOUT._8888, 24, 4),
-    ARGB8888:
-    define_pixelformat(PIXELTYPE.PACKED32, PACKEDORDER.ARGB,
-    PACKEDLAYOUT._8888, 32, 4),
-    RGBA8888:
-    define_pixelformat(PIXELTYPE.PACKED32, PACKEDORDER.RGBA,
-    PACKEDLAYOUT._8888, 32, 4),
-    ABGR8888:
-    define_pixelformat(PIXELTYPE.PACKED32, PACKEDORDER.ABGR,
-    PACKEDLAYOUT._8888, 32, 4),
-    BGRA8888:
-    define_pixelformat(PIXELTYPE.PACKED32, PACKEDORDER.BGRA,
-    PACKEDLAYOUT._8888, 32, 4),
-    ARGB2101010:
-    define_pixelformat(PIXELTYPE.PACKED32, PACKEDORDER.ARGB,
-    PACKEDLAYOUT._2101010, 32, 4),
-
-    YV12:
-    define_pixelfourcc('Y', 'V', '1', '2'),
-    IYUV:
-    define_pixelfourcc('I', 'Y', 'U', 'V'),
-    YUY2:
-    define_pixelfourcc('Y', 'U', 'Y', '2'),
-    UYVY:
-    define_pixelfourcc('U', 'Y', 'V', 'Y'),
-    YVYU:
-    define_pixelfourcc('Y', 'V', 'Y', 'U')
-  })
+  module PIXELFORMAT
+    include EnumerableConstants
+    UNKNOWN =  0
+    INDEX1LSB =     SDL2.define_pixelformat(PIXELTYPE::INDEX1, BITMAPORDER::N4321, 0,    1, 0)
+    INDEX1MSB =     SDL2.define_pixelformat(PIXELTYPE::INDEX1, BITMAPORDER::N1234, 0,    1, 0)
+    INDEX4LSB =     SDL2.define_pixelformat(PIXELTYPE::INDEX4, BITMAPORDER::N4321, 0,    4, 0)
+    INDEX4MSB =     SDL2.define_pixelformat(PIXELTYPE::INDEX4, BITMAPORDER::N1234, 0,    4, 0)
+    INDEX8 =        SDL2.define_pixelformat(PIXELTYPE::INDEX8, 0, 0, 8, 1)
+    RGB332 =        SDL2.define_pixelformat(PIXELTYPE::PACKED8, PACKEDORDER::XRGB,    PACKEDLAYOUT::N332, 8, 1)
+    RGB444 =        SDL2.define_pixelformat(PIXELTYPE::PACKED16, PACKEDORDER::XRGB,    PACKEDLAYOUT::N4444, 12, 2)
+    RGB555 =        SDL2.define_pixelformat(PIXELTYPE::PACKED16, PACKEDORDER::XRGB,    PACKEDLAYOUT::N1555, 15, 2)
+    BGR555 =        SDL2.define_pixelformat(PIXELTYPE::PACKED16, PACKEDORDER::XBGR,    PACKEDLAYOUT::N1555, 15, 2)
+    ARGB4444 =      SDL2.define_pixelformat(PIXELTYPE::PACKED16, PACKEDORDER::ARGB,    PACKEDLAYOUT::N4444, 16, 2)
+    RGBA4444 =      SDL2.define_pixelformat(PIXELTYPE::PACKED16, PACKEDORDER::RGBA,    PACKEDLAYOUT::N4444, 16, 2)
+    ABGR4444 =      SDL2.define_pixelformat(PIXELTYPE::PACKED16, PACKEDORDER::ABGR,    PACKEDLAYOUT::N4444, 16, 2)
+    BGRA4444 =      SDL2.define_pixelformat(PIXELTYPE::PACKED16, PACKEDORDER::BGRA,    PACKEDLAYOUT::N4444, 16, 2)
+    ARGB1555 =      SDL2.define_pixelformat(PIXELTYPE::PACKED16, PACKEDORDER::ARGB,    PACKEDLAYOUT::N1555, 16, 2)
+    RGBA5551 =      SDL2.define_pixelformat(PIXELTYPE::PACKED16, PACKEDORDER::RGBA,    PACKEDLAYOUT::N5551, 16, 2)
+    ABGR1555 =      SDL2.define_pixelformat(PIXELTYPE::PACKED16, PACKEDORDER::ABGR,    PACKEDLAYOUT::N1555, 16, 2)
+    BGRA5551 =      SDL2.define_pixelformat(PIXELTYPE::PACKED16, PACKEDORDER::BGRA,    PACKEDLAYOUT::N5551, 16, 2)
+    RGB565 =        SDL2.define_pixelformat(PIXELTYPE::PACKED16, PACKEDORDER::XRGB,    PACKEDLAYOUT::N565, 16, 2)
+    BGR565 =        SDL2.define_pixelformat(PIXELTYPE::PACKED16, PACKEDORDER::XBGR,    PACKEDLAYOUT::N565, 16, 2)
+    RGB24 =         SDL2.define_pixelformat(PIXELTYPE::ARRAYU8,  ARRAYORDER::RGB, 0,    24, 3)
+    BGR24 =         SDL2.define_pixelformat(PIXELTYPE::ARRAYU8,  ARRAYORDER::BGR, 0,    24, 3)
+    RGB888 =        SDL2.define_pixelformat(PIXELTYPE::PACKED32, PACKEDORDER::XRGB,    PACKEDLAYOUT::N8888, 24, 4)
+    RGBX8888 =      SDL2.define_pixelformat(PIXELTYPE::PACKED32, PACKEDORDER::RGBX,    PACKEDLAYOUT::N8888, 24, 4)
+    BGR888 =        SDL2.define_pixelformat(PIXELTYPE::PACKED32, PACKEDORDER::XBGR,    PACKEDLAYOUT::N8888, 24, 4)
+    BGRX8888 =      SDL2.define_pixelformat(PIXELTYPE::PACKED32, PACKEDORDER::BGRX,    PACKEDLAYOUT::N8888, 24, 4)
+    ARGB8888 =      SDL2.define_pixelformat(PIXELTYPE::PACKED32, PACKEDORDER::ARGB,    PACKEDLAYOUT::N8888, 32, 4)
+    RGBA8888 =      SDL2.define_pixelformat(PIXELTYPE::PACKED32, PACKEDORDER::RGBA,    PACKEDLAYOUT::N8888, 32, 4)
+    ABGR8888 =      SDL2.define_pixelformat(PIXELTYPE::PACKED32, PACKEDORDER::ABGR,    PACKEDLAYOUT::N8888, 32, 4)
+    BGRA8888 =      SDL2.define_pixelformat(PIXELTYPE::PACKED32, PACKEDORDER::BGRA,    PACKEDLAYOUT::N8888, 32, 4)
+    ARGB2101010 =   SDL2.define_pixelformat(PIXELTYPE::PACKED32, PACKEDORDER::ARGB,    PACKEDLAYOUT::N2101010, 32, 4)
+
+    YV12 =          SDL2.define_pixelfourcc('Y', 'V', '1', '2')
+    IYUV =          SDL2.define_pixelfourcc('I', 'Y', 'U', 'V')
+    YUY2 =          SDL2.define_pixelfourcc('Y', 'U', 'Y', '2')
+    UYVY =          SDL2.define_pixelfourcc('U', 'Y', 'V', 'Y')
+    YVYU =          SDL2.define_pixelfourcc('Y', 'V', 'Y', 'U')
+  end
 
   api :SDL_GetPixelFormatName, [:pixel_format], :string
   api :SDL_PixelFormatEnumToMasks, [:pixel_format, IntStruct.by_ref, UInt32Struct.by_ref, UInt32Struct.by_ref,UInt32Struct.by_ref,UInt32Struct.by_ref,], :bool