sdl2_ffi 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1fbda9790c93fa1061e680eb19b56d27ef5e9b2e
-  data.tar.gz: 8947768e9c0f8d504f6cb154624cec7a2f220c37
+  metadata.gz: 7b7b0f26850cdb76060ffc915bd52f8979d58374
+  data.tar.gz: 568de3aef8a7ef88a2f381f1cb3eb0d2fdd9fb70
 SHA512:
-  metadata.gz: 8b8f386629bc6ff085e64450ad026b4669ee4251dfe924f6eae89772905b3474f4c0a0bf647f9a22f5ca6024651b655a785aed12e48e647ed0d5b01ddc50e015
-  data.tar.gz: e1afed2d1d6dc466bdaeb9b3a3aac67d93e597972bccdebe0dc692415f4989290638c61594eb0fcfcfe01df4ae045352a9537970df290733f6d12e1abc9ae1c3
+  metadata.gz: d7b43f365d9b052889db92e63437e46a82634f11c6f7ccd13d06b6dd7468fc5766c6dd4817e307655034d72a35b04628c91149ff6c26d309fe9e3df20fd048e1
+  data.tar.gz: 2f64f961c415e03f1b47cbbae7d04cd881b22c0c2e1ae11b527b4b1b912f8e48eef40d99c98caf8208f525d87efb617a101f0f40f8305b8bdd4c2fd3aa38920a

data/Guardfile

@@ -4,12 +4,12 @@
 guard :minitest do
   # with Minitest::Unit
   watch(%r{^test/(.*)\/?test_(.*)\.rb})
-  watch(%r{^lib/(.*/)?([^/]+)\.rb})     { |m| "test/#{m[1]}test_#{m[2]}.rb" }
+  watch(%r{^lib/(.*/)?([^/]+)\.rb})     { |m| "test/unit/#{m[1]}test_#{m[2]}.rb" }
   watch(%r{^test/test_helper\.rb})      { 'test' }
 
   # with Minitest::Spec
   watch(%r{^spec/(.*)_spec\.rb})
-  watch(%r{^lib/(.+)\.rb})         { |m| "spec/#{m[1]}_spec.rb" }
+  watch(%r{^lib/(.+)\.rb})         { |m| "spec/unit/#{m[1]}_spec.rb" }
   watch(%r{^spec/spec_helper\.rb}) { 'spec' }
 
   # Rails 4

data/README.md

@@ -1,6 +1,12 @@
 # sdl2_ffi
 
-This is a simple interface to SDL2 for Ruby using FFI.  This effort has barely started.
+This is a simple interface to SDL2 for Ruby using FFI.  It also supports SDL_image and SDL_ttf.
+Most of the procedural API has been linked with a few large exceptions like SDL_opengl.
+The "Object Oriented" part of this interface has barely started.
+
+# Documentation/API Reference:
+
+The documentation is embedded within the code.  Generate the RDoc 
 
 # How to start:
 
@@ -18,6 +24,8 @@ The SDL2 module is defined and it is where the raw SDL API is loaded and linked.
 
     SDL2.init(SDL2::INIT_EVERYTHING)
     
+
+    
 ### Gotchas:
 
 * Remember that SDL uses the 'SDL_Bool' enum instead of actual ruby Boolean, so instead of 'true' and 'false', you get ':true' and ':false'

data/lib/sdl2.rb

@@ -2,23 +2,105 @@ require 'ffi'
 require 'sdl2/sdl_module'
 require 'active_support/inflector'
 
+# libSDL2's interface
 module SDL2
   extend FFI::Library
+  ffi_lib SDL_MODULE
+
+  [:int, :uint8, :int8, :uint16, :int16, :uint32, :int32, :uint64, :int64, :float, :double].each do |type|
+    typedef :pointer, "p_#{type}".to_sym
+  end
+
+  #Filter Proc, True when arg equals zero
+  TRUE_WHEN_ZERO = Proc.new do |result|
+    result == 0
+  end
+
+  # Filter Proc, True when arg not null?
+  TRUE_WHEN_NOT_NULL = Proc.new do |result|
+    (!result.null?)
+  end
 
-    
   # This converts the SDL Function Prototype name "SDL_XxxYyyyyZzz" to ruby's
   # "xxx_yyyy_zzz" convetion
-  def self.api(func_name, args, type)
+  def self.api(func_name, args, type, options = {})
+
+    options = {
+      :error => false,
+      :filter => TRUE_WHEN_ZERO
+    }.merge(options)
+
     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!"
+
+    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 self.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 self.returns_error(methodName, filter)
+    metaclass.instance_eval do
+      define_method "#{methodName}!".to_sym do |*args|
+        result = self.send(methodName, *args)
+        raise_error_unless filter.call(result)
+        result
+      end
+    end
+  end
+
+  # Generates an alternative version of methodName that will return Ruby's `true`
+  # if the method named returns SDL_true/:true enum value.  The alternative
+  # method has the same name with a question mark ("?") appended, to indicate its
+  # boolean nature.
+  def self.boolean?(methodName)
+    metaclass.instance_eval do
+      define_method("#{methodName}?".to_sym) do |*args|
+        self.send(methodName, *args) == :true
+      end
+    end
+  end
+
+  # Define a four character code as a Uint32
+  #MACRO: SDL_FOURCC(A, B, C, D) \
+  #    ((SDL_static_cast(Uint32, SDL_static_cast(Uint8, (A))) << 0) | \
+  #     (SDL_static_cast(Uint32, SDL_static_cast(Uint8, (B))) << 8) | \
+  #     (SDL_static_cast(Uint32, SDL_static_cast(Uint8, (C))) << 16) | \
+  #     (SDL_static_cast(Uint32, SDL_static_cast(Uint8, (D))) << 24))
+  def self.fourcc(*args)
+    bit_cnt = 0
+    result = 0
+    args.each do |arg|
+      arg = arg.codepoints[0] if arg.kind_of? String
+      result = result | (arg << bit_cnt)
+      bit_cnt += 8
+    end
+    return result
+  end
+
+  # FFI::Struct class with some useful additions.
   class Struct < FFI::Struct
 
+    # Allows creation and use within block, automatically freeing pointer after block.
     def initialize(*args, &block)
       super(*args)
       if block_given?
@@ -27,54 +109,97 @@ module SDL2
         self.class.release(self.pointer)
       end
     end
+
+    # A default release scheme is defined, but should be redefined where appropriate.
+    def self.release(pointer)
+      pointer.free
+    end
+
+    # A human-readable representation of the struct and it's values.
+    def inspect
+      report = "struct #{self.class.to_s}{"
+      report += self.class.members.collect do |field|
+        "#{field}->#{self[field].inspect}"
+      end.join(' ')
+      report += "}"
+    end
+
+    # Compare two structures by class and values.
+    def ==(other)
+      return false unless self.class == other.class
+      self.class.members.each do |field|
+        return false unless self[field] == other[field]
+      end
+      true # return true if we get this far.
+    end
   end
 
+  # FFI::ManagedStruct possibly with useful additions.
   class ManagedStruct < FFI::ManagedStruct
 
+    # Allows create and use the struct within a block.
     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
+  end
 
-  # SDL_Bool
+  # SDL_Bool: SDL's TRUE/FALSE enumeration.
+  # Ruby does not automatically evaluate 0 as false.
   enum :bool, [:false, 0, :true, 1]
 
-  def self.throw_error_unless(condition)
-    throw get_error() unless condition
+  # Raise the current error value as a RuntimeException
+  def self.raise_error
+    raise "SDL Error: #{SDL2.get_error()}"
+  end
+
+  # Conditionally raise an error, unless true
+  def self.raise_error_unless(condition)
+    raise_error unless condition
   end
 
-  def self.throw_error_if(condition)
-    throw get_error() if condition
+  # Conditionally raise an error, unless false
+  def self.raise_error_if(condition)
+    raise_error if condition
+  end
+  
+  class TypedPointer < Struct
+    def self.type(kind)
+      layout :value, kind
+    end
+    
+    def value
+      self[value]
+    end
+    
+    alias_method :deref, :value
   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
+  class FloatPointer < TypedPointer
+    type :float
   end
 
-  class IntStruct < FFI::Struct
-    layout :value, :int
+  # Int-typed pointer
+  class IntStruct < TypedPointer
+    type :int
   end
 
-  class UInt16Struct < FFI::Struct
-    layout :value, :uint16
+  # 
+  class UInt16Struct < TypedPointer
+    type :uint16
   end
 
-  class UInt32Struct < FFI::Struct
-    layout :value, :uint32
+  class UInt32Struct < TypedPointer 
+    type :uint32
   end
 
-  class UInt8Struct < FFI::Struct
-    layout :value, :uint8
+  class UInt8Struct < TypedPointer
+    type :uint8
   end
 
   # TODO: Review if this is the best place to put it.
@@ -87,7 +212,7 @@ module SDL2
     :mod, 0x00000004
   ]
 
-  class BlendModeStruct < FFI::Struct
+  class BlendModeStruct < Struct
     layout :value, :blend_mode
   end
 

data/lib/sdl2/color.rb

@@ -1,12 +1,35 @@
 require 'sdl2'
 
 module SDL2
+
   #SDL_pixels.h:252~258
   class Color < Struct
     layout :r, :uint8,
-      :g, :uint8,
-      :b, :uint8,
-      :a, :uint8
+    :g, :uint8,
+    :b, :uint8,
+    :a, :uint8
+
+    [:r,:g,:b,:a].each do |field|
+      define_method field do
+        self[field]
+      end
+      define_method "#{field}=".to_sym do |value|
+        self[field]=value
+      end
+    end
+
+    def set(r,g,b,a=nil)
+      self.r = r
+      self.g = g
+      self.b = b
+      self.a = a unless a.nil?
+    end
+
+    def copy_from(color)
+      [:r, :g, :b, :a].each do |c|
+        self.send("#{c}=", color.send(c))
+      end
+    end
   end
-  Colour = Color # Because SDL does it  
+  Colour = Color # Because SDL does it
 end

data/lib/sdl2/display.rb

@@ -33,7 +33,7 @@ module SDL2
 
     def self.count!
       total = count
-      SDL2.throw_error_if total < 0
+      SDL2.raise_error_if total < 0
       return total
     end
 
@@ -48,7 +48,7 @@ module SDL2
 
     def closest_display_mode!(wanted)
       found = closest_display_mode(wanted)
-      SDL2.throw_error_if(found.nil?)
+      SDL2.raise_error_if(found.nil?)
       return found
     end
 
@@ -64,7 +64,7 @@ module SDL2
 
     def bounds!
       rect = bounds()
-      SDL2.throw_error_if rect.nil?
+      SDL2.raise_error_if rect.nil?
       return rect
     end
 

data/lib/sdl2/gem_version.rb

@@ -1,4 +1,4 @@
 
 module SDL2
-  GEM_VERSION = "0.0.2"
+  GEM_VERSION = "0.0.3"
 end

data/lib/sdl2/image.rb

@@ -0,0 +1,68 @@
+require 'sdl2'
+require 'sdl2/surface'
+require 'sdl2/image/sdl_image_module'
+require 'active_support/inflector'
+
+module SDL2
+
+  module Image
+
+    extend FFI::Library
+    ffi_lib SDL_IMAGE_MODULE
+
+    def self.api(func_name, args, type)
+      camelCaseName = func_name.to_s.gsub('IMG_', '')
+      methodName = ActiveSupport::Inflector.underscore(camelCaseName).to_sym
+      self.attach_function methodName, func_name, args, type
+      return methodName
+    end
+
+    enum :init_flags, [:JPG, :PNG, :TIF, :WEBP]
+
+    api :IMG_Init, [:init_flags], :int
+    api :IMG_Quit, [], :void
+    api :IMG_LoadTyped_RW, [RWops.by_ref, :int, :string], Surface.auto_ptr
+    api :IMG_Load, [:string], Surface.auto_ptr
+    api :IMG_Load_RW, [RWops.by_ref, :int], Surface.auto_ptr
+
+    api :IMG_isICO, [RWops.by_ref], :int
+    api :IMG_isCUR, [RWops.by_ref], :int
+    api :IMG_isBMP, [RWops.by_ref], :int
+    api :IMG_isGIF, [RWops.by_ref], :int
+    api :IMG_isJPG, [RWops.by_ref], :int
+    api :IMG_isLBM, [RWops.by_ref], :int
+    api :IMG_isPCX, [RWops.by_ref], :int
+    api :IMG_isPNG, [RWops.by_ref], :int
+    api :IMG_isPNM, [RWops.by_ref], :int
+    api :IMG_isTIF, [RWops.by_ref], :int
+    api :IMG_isXCF, [RWops.by_ref], :int
+    api :IMG_isXPM, [RWops.by_ref], :int
+    api :IMG_isXV, [RWops.by_ref], :int
+    api :IMG_isWEBP, [RWops.by_ref], :int
+
+    api :IMG_LoadICO_RW, [RWops.by_ref], Surface.auto_ptr
+    api :IMG_LoadCUR_RW, [RWops.by_ref], Surface.auto_ptr
+    api :IMG_LoadBMP_RW, [RWops.by_ref], Surface.auto_ptr
+    api :IMG_LoadGIF_RW, [RWops.by_ref], Surface.auto_ptr
+    api :IMG_LoadJPG_RW, [RWops.by_ref], Surface.auto_ptr
+    api :IMG_LoadLBM_RW, [RWops.by_ref], Surface.auto_ptr
+    api :IMG_LoadPCX_RW, [RWops.by_ref], Surface.auto_ptr
+    api :IMG_LoadPNG_RW, [RWops.by_ref], Surface.auto_ptr
+    api :IMG_LoadPNM_RW, [RWops.by_ref], Surface.auto_ptr
+    api :IMG_LoadTGA_RW, [RWops.by_ref], Surface.auto_ptr
+    api :IMG_LoadTIF_RW, [RWops.by_ref], Surface.auto_ptr
+    api :IMG_LoadXCF_RW, [RWops.by_ref], Surface.auto_ptr
+    api :IMG_LoadXPM_RW, [RWops.by_ref], Surface.auto_ptr
+    api :IMG_LoadXV_RW, [RWops.by_ref], Surface.auto_ptr
+    api :IMG_LoadWEBP_RW, [RWops.by_ref], Surface.auto_ptr
+    
+    api :IMG_ReadXPMFromArray, [:pointer], Surface.auto_ptr
+      
+    api :IMG_SavePNG, [Surface.by_ref, :string], :int
+    api :IMG_SavePNG_RW, [Surface.by_ref, RWops.by_ref, :int], :int
+
+  end
+
+  IMG = Image # Alias to follow IMG_xxx convention
+
+end

data/lib/sdl2/image/sdl_image_module.rb

@@ -0,0 +1,8 @@
+module SDL2
+  
+  module Image
+    
+    SDL_IMAGE_MODULE = ['libSDL2_image', '/usr/local/lib/libSDL2_image.so']
+    
+  end
+end

data/lib/sdl2/init.rb

@@ -28,16 +28,16 @@ module SDL2
     :everything, INIT_EVERYTHING
   ]
 
-  api :SDL_Init, [:init_flag], :int
+  api :SDL_Init, [:init_flag], :int, {error: true}
 
-  def self.init!(flags)
-    error_code = init(flags)
-    if (error_code != 0)
-      throw get_error()
-    end
-  end
+  #def self.init!(flags)
+  #  error_code = init(flags)
+  #  if (error_code != 0)
+  #    throw get_error()
+  #  end
+  #end
 
-  api :SDL_InitSubSystem, [:init_flag], :int
+  api :SDL_InitSubSystem, [:init_flag], :int, {error: true}
 
   def init_sub_system!(flags)
     error_code = init_sub_system(flags)