sdl2_ffi 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 1fbda9790c93fa1061e680eb19b56d27ef5e9b2e
+  data.tar.gz: 8947768e9c0f8d504f6cb154624cec7a2f220c37
+SHA512:
+  metadata.gz: 8b8f386629bc6ff085e64450ad026b4669ee4251dfe924f6eae89772905b3474f4c0a0bf647f9a22f5ca6024651b655a785aed12e48e647ed0d5b01ddc50e015
+  data.tar.gz: e1afed2d1d6dc466bdaeb9b3a3aac67d93e597972bccdebe0dc692415f4989290638c61594eb0fcfcfe01df4ae045352a9537970df290733f6d12e1abc9ae1c3

data/.gitignore

@@ -0,0 +1,20 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+.project
+.buildpath
+*~

data/.ruby-gemset

@@ -0,0 +1 @@
+sdl2_ffi

data/.ruby-version

@@ -0,0 +1 @@
+ruby-2.0.0-p247

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in sdl2_ffi.gemspec
+gemspec

data/Guardfile

@@ -0,0 +1,33 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+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{^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{^spec/spec_helper\.rb}) { 'spec' }
+
+  # Rails 4
+  # watch(%r{^test/test_helper\.rb}) { 'test' }
+  # watch(%r{^test/.+_test\.rb})
+  # watch(%r{^app/(.+)\.rb})                               { |m| "test/#{m[1]}_test.rb" }
+  # watch(%r{^app/controllers/application_controller\.rb}) { 'test/controllers' }
+  # watch(%r{^app/controllers/(.+)_controller\.rb})        { |m| "test/integration/#{m[1]}_test.rb" }
+  # watch(%r{^app/views/(.+)_mailer/.+})                   { |m| "test/mailers/#{m[1]}_mailer_test.rb" }
+  # watch(%r{^lib/(.+)\.rb})                               { |m| "test/lib/#{m[1]}_test.rb" }
+
+  # Rails 3.2
+  # watch(%r{^app/controllers/(.*)\.rb}) { |m| "test/controllers/#{m[1]}_test.rb" }
+  # watch(%r{^app/helpers/(.*)\.rb})     { |m| "test/helpers/#{m[1]}_test.rb" }
+  # watch(%r{^app/models/(.*)\.rb})      { |m| "test/unit/#{m[1]}_test.rb" }
+
+  # Rails
+  # watch(%r{^app/controllers/(.*)\.rb}) { |m| "test/functional/#{m[1]}_test.rb" }
+  # watch(%r{^app/helpers/(.*)\.rb})     { |m| "test/helpers/#{m[1]}_test.rb" }
+  # watch(%r{^app/models/(.*)\.rb})      { |m| "test/unit/#{m[1]}_test.rb" }
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 BadQuanta
+
+MIT License
+
+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.

data/README.md

@@ -0,0 +1,83 @@
+# sdl2_ffi
+
+This is a simple interface to SDL2 for Ruby using FFI.  This effort has barely started.
+
+# How to start:
+
+The GEM is organized to the same structure as the SDL header files.  Where in C/C++ you would need to:
+
+    include 'SDL.h'
+    include 'SDL_video.h'
+    
+with this rubygem, you would instead:
+
+    require 'sdl2'
+    require 'sdl2/video'
+    
+The SDL2 module is defined and it is where the raw SDL API is loaded and linked.  The Raw API can be called like so:
+
+    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'
+  * Whenever SDL returns an SDL_Bool in the RAW API, I will always endevour to ensure there is a xxx? equivalent helper that converts the response to Ruby Booleans.
+
+## Updates
+
+### Imported APIs
+
+I'm working my way through the SDL API header files.  I am attempting to make this GEM as modular as the SDL header files themselves so that the developer can load only the enum, typedefs and link to only the functionality needed.
+
+## Dependencies
+
+* Obviously, ruby
+* SDL2 Runtime (Development files are not needed.)
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'sdl2_ffi'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install sdl2_ffi
+    
+## Testing
+
+Minitests are being written to validate functionality. Not SDL's functionality, but that the GEM has been linked properly and that the Object Oriented wrapper functions as intended.
+
+Run the tests with rake:
+
+    $ rake test
+    
+Verbose options are nice:
+
+    $ rake test TESTOPTS="--verbose"
+    
+### I need your help!
+
+I'm just starting to implement the Object Oriented Wrapper.  I'll need help identifying mistakes, especially in memory management.  Bug-reports submitted with tests will be looked at before bug-reports without tests, as a way to encourage tests being written.
+
+Thanks for reading this!
+
+## Usage
+
+The interface is intended to be modular and follows (roughly) SDL's header files.
+
+## Contributing
+
+libSDL 2.0 is licensed under the 'zlib license', listed as compatible with the GNU GPL by [the gnu foundation](http://www.gnu.org/licenses/license-list.html).  The 'sdl_ffi' GEM is licensed under the MIT License.  Both encourage distribution and modification.  Please let me know about your work and I'll link it where appropriate. 
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+
+I specifically need help writing the minitest code.  

data/Rakefile

@@ -0,0 +1,7 @@
+require "bundler/gem_tasks"
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.pattern = 'test/**/test*.rb'
+  t.verbose = true
+end

data/bin/coderay

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+#
+# This file was generated by Bundler.
+#
+# The application 'coderay' is installed as part of a gem, and
+# this file is here to facilitate running it.
+#
+
+require 'pathname'
+ENV['BUNDLE_GEMFILE'] ||= File.expand_path("../../Gemfile",
+  Pathname.new(__FILE__).realpath)
+
+require 'rubygems'
+require 'bundler/setup'
+
+load Gem.bin_path('sdl2_ffi', 'coderay')

data/bin/guard

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+#
+# This file was generated by Bundler.
+#
+# The application 'guard' is installed as part of a gem, and
+# this file is here to facilitate running it.
+#
+
+require 'pathname'
+ENV['BUNDLE_GEMFILE'] ||= File.expand_path("../../Gemfile",
+  Pathname.new(__FILE__).realpath)
+
+require 'rubygems'
+require 'bundler/setup'
+
+load Gem.bin_path('sdl2_ffi', 'guard')

data/bin/pry

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+#
+# This file was generated by Bundler.
+#
+# The application 'pry' is installed as part of a gem, and
+# this file is here to facilitate running it.
+#
+
+require 'pathname'
+ENV['BUNDLE_GEMFILE'] ||= File.expand_path("../../Gemfile",
+  Pathname.new(__FILE__).realpath)
+
+require 'rubygems'
+require 'bundler/setup'
+
+load Gem.bin_path('sdl2_ffi', 'pry')

data/bin/rake

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+#
+# This file was generated by Bundler.
+#
+# The application 'rake' is installed as part of a gem, and
+# this file is here to facilitate running it.
+#
+
+require 'pathname'
+ENV['BUNDLE_GEMFILE'] ||= File.expand_path("../../Gemfile",
+  Pathname.new(__FILE__).realpath)
+
+require 'rubygems'
+require 'bundler/setup'
+
+load Gem.bin_path('sdl2_ffi', 'rake')

data/bin/thor

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+#
+# This file was generated by Bundler.
+#
+# The application 'thor' is installed as part of a gem, and
+# this file is here to facilitate running it.
+#
+
+require 'pathname'
+ENV['BUNDLE_GEMFILE'] ||= File.expand_path("../../Gemfile",
+  Pathname.new(__FILE__).realpath)
+
+require 'rubygems'
+require 'bundler/setup'
+
+load Gem.bin_path('sdl2_ffi', 'thor')

data/lib/sdl2/assert.rb

@@ -0,0 +1,7 @@
+
+require 'sdl2'
+
+# Stub for SDL_assert.h, Unsure if we should translate or borrow existing functionality.
+# TODO: Review for future implementation
+module SDL2
+end

data/lib/sdl2/audio.rb

@@ -0,0 +1,139 @@
+require 'sdl2'
+require 'yinum'
+
+module SDL2
+
+  typedef :uint16, :audio_format
+
+  module Audio
+    Mask = Enum.new(:AudioMask, {
+      BITSIZE: (0xFF),
+      DATATYPE: (1<<8),
+      ENDIAN: (1<<12),
+      SIGNED: (1<<15)
+    })
+
+    def self.bitsize(x)
+      x & Mask.BITSIZE
+    end
+
+    def self.is_float?(x)
+      (x & Mask.DATATYPE) != 0
+    end
+
+    def self.is_big_endian?(x)
+      x & mask.ENDIAN
+    end
+
+    def self.is_signed?(x)
+      x & mask.SIGNED
+    end
+
+    def self.is_int?(x)
+      !is_float?(x)
+    end
+
+    def self.is_little_endian?(x)
+      !is_big_endian?(x)
+    end
+
+    def self.is_unsigned?(x)
+      !is_signed?(x)
+    end
+
+    
+    U8 = 0x0008
+    S8 = 0x8008
+    U16LSB = 0x0010
+    S16LSB = 0x8010
+    U16MSB = 0x1010
+    S16MSB = 0x9010
+    U16 = U16LSB
+    S16 = S16LSB
+    S32LSB = 0x8020
+    S32MSB = 0x9020
+    S32 = S32LSB
+    F32LSB = 0x8120
+    F32MSB = 0x9120
+    F32= F32LSB
+
+    ALLOW_FREQUENCY_CHANGE    =0x00000001
+    ALLOW_FORMAT_CHANGE       =0x00000002
+    ALLOW_CHANNELS_CHANGE     =0x00000004
+    ALLOW_ANY_CHANGE          =(ALLOW_FREQUENCY_CHANGE|ALLOW_FORMAT_CHANGE|ALLOW_CHANNELS_CHANGE)
+
+    
+
+    class Spec < Struct
+      layout :freq, :int,
+      :format, :uint16,
+      :channels, :uint8,
+      :silence, :uint8,
+      :samples, :uint16,
+      :padding, :uint16,
+      :size, :uint32,
+      :callback, :pointer, #:audio_callback,
+      :userdata, :pointer
+    end  
+
+    class CVT < Struct
+      layout :needed, :int,
+      :src_format, :uint16,
+      :dst_format, :uint16,
+      :rate_incr, :double,
+      :buf, :pointer,
+      :len, :int,
+      :len_cvt, :int,
+      :len_mult, :int,
+      :len_ratio, :double,
+      :filters, [:pointer, 10], # :audio_filter callback
+      :filter_index, :int
+    end
+
+  end#module Audio
+  
+  callback :audio_callback, [:pointer, :pointer, :int], :void
+  callback :audio_filter, [Audio::CVT.by_ref, :audio_format], :void
+
+  api :SDL_GetNumAudioDrivers, [], :int
+  api :SDL_GetAudioDriver, [:int], :string
+  api :SDL_AudioInit, [:string], :int
+  api :SDL_AudioQuit, [], :void
+  api :SDL_GetCurrentAudioDriver, [], :string
+  api :SDL_OpenAudio, [Audio::Spec.by_ref, Audio::Spec.by_ref], :int
+
+  typedef :uint32, :audio_device_id
+
+  api :SDL_GetNumAudioDevices, [:int], :int
+  api :SDL_GetAudioDeviceName, [:int, :int], :string
+  api :SDL_OpenAudioDevice, [:string, :int, Audio::Spec.by_ref, Audio::Spec.by_ref, :int], :audio_device_id
+
+  enum :audio_status, [:STOPPED, 0, :PLAYING, :PAUSED]
+
+  api :SDL_GetAudioStatus, [], :audio_status
+  api :SDL_PauseAudio, [:int], :void
+  api :SDL_PauseAudioDevice, [:audio_device_id, :int], :void
+  api :SDL_LoadWAV_RW, [RWops.by_ref, :int, Audio::Spec.by_ref, :pointer, :pointer], Audio::Spec.by_ref
+
+  def self.load_wav(file, spec, audio_buf, audio_len)
+    load_wav_rw(rw_from_file)
+  end
+  
+  api :SDL_FreeWAV, [:pointer], :void
+  api :SDL_BuildAudioCVT, [Audio::CVT.by_ref, :audio_format, :uint8, :int, :audio_format, :uint8, :int], :int
+  api :SDL_ConvertAudio, [Audio::CVT.by_ref], :int
+  
+  MIX_MAXVOLUME = 128
+  
+  api :SDL_MixAudio, [:pointer, :pointer, :uint32, :int], :void
+  api :SDL_MixAudioFormat, [:pointer, :pointer, :audio_format, :uint32, :int], :void
+  api :SDL_LockAudio, [], :void
+  api :SDL_LockAudioDevice, [:audio_device_id], :void
+  api :SDL_UnlockAudio, [], :void
+  api :SDL_UnlockAudioDevice, [:audio_device_id], :void
+    
+  api :SDL_CloseAudio, [], :void
+  api :SDL_CloseAudioDevice, [:audio_device_id], :void
+  
+
+end

data/lib/sdl2/clipboard.rb

@@ -0,0 +1,27 @@
+require 'sdl2'
+
+module SDL2
+
+  module Clipboard
+
+    def self.has
+      SDL2.has_clipboard_text()
+    end
+
+    def self.has?
+      SDL2.has_clipboard_text == :true
+    end
+
+    def self.get
+      SDL2.get_clipboard_text()
+    end
+
+    def self.set(text)
+      SDL2.set_clipboard_text(text.to_s)
+    end
+  end
+
+  api :SDL_SetClipboardText, [:string], :int
+  api :SDL_GetClipboardText, [], :string
+  api :SDL_HasClipboardText, [], :bool
+end

data/lib/sdl2/color.rb

@@ -0,0 +1,12 @@
+require 'sdl2'
+
+module SDL2
+  #SDL_pixels.h:252~258
+  class Color < Struct
+    layout :r, :uint8,
+      :g, :uint8,
+      :b, :uint8,
+      :a, :uint8
+  end
+  Colour = Color # Because SDL does it  
+end

data/lib/sdl2/cpuinfo.rb

@@ -0,0 +1,18 @@
+require 'sdl2'
+
+module SDL2
+  
+  CACHELINE_SIZE = 128
+  
+  api :SDL_GetCPUCount, [], :int
+  api :SDL_GetCPUCacheLineSize, [], :int
+  api :SDL_HasRDTSC, [], :bool
+  api :SDL_HasAltiVec, [], :bool
+  api :SDL_Has3DNow, [], :bool
+  api :SDL_HasSSE, [], :bool
+  api :SDL_HasSSE2, [], :bool
+  api :SDL_HasSSE3, [], :bool
+  api :SDL_HasSSE41, [], :bool
+  api :SDL_HasSSE42, [], :bool
+  
+end

data/lib/sdl2/display/mode.rb

@@ -0,0 +1,53 @@
+require 'sdl2'
+
+module SDL2
+  
+  class Display
+    # Converted from 'SDL_video.h':53
+    class Mode < Struct
+      layout :format, :uint32,
+        :w, :int,
+        :h, :int,
+        :refresh_rate, :int,
+        :driverdata, :pointer
+        
+      def self.release(pointer)
+        pointer.free # TODO: Is there a better way of doing this?
+      end
+        
+      def self.current(display_index)
+        dm = DisplayMode.new      
+        get_current_display_mode(display_index, dm)
+        return dm
+      end
+      
+      def self.current!(display_index)
+        get_current_display_mode!(display_index)
+      end
+      
+      
+      def format=(value)
+        self[:format] = value
+      end
+      
+      def w=(value)
+        self[:w] = value
+      end
+      
+      def h=(value)
+        self[:h] = value
+      end
+      
+      def refresh_rate=(value)
+        self[:refresh_rate] = value
+      end
+      
+      def driverdata=(value)
+        self[:driverdata] = value
+      end
+      
+    end
+  end
+  
+  
+end

data/lib/sdl2/display/modes.rb

@@ -0,0 +1,36 @@
+require 'sdl2'
+
+module SDL2
+
+  class Display
+    
+    class Modes
+      # TODO: Consider converting this into some kind of enumerator?
+      def initialize(for_display)
+        @for_display = for_display
+      end
+
+      def count
+        SDL2.get_num_display_modes(@for_display.id)
+      end
+
+      # TODO: Probably leaks memory.. WeakRef cache?
+      def [](index)
+        if (idx = index.to_i) < count
+          dm_buffer = SDL2::Display::Mode.new
+          if SDL2.get_display_mode(@for_display.id, idx, dm_buffer) == 0
+            return dm_buffer
+          else
+            dm_buffer.pointer.free
+          end
+        else
+          return nil
+        end
+      end
+
+      def first
+        self[0]
+      end
+    end
+  end
+end

data/lib/sdl2/display.rb

@@ -0,0 +1,74 @@
+require 'sdl2'
+require 'sdl2/display/modes'
+require 'sdl2/display/mode'
+
+module SDL2
+
+  # Abstract representation of what SDL calls a "Display"
+  class Display
+
+    attr_reader :id   
+       
+    def initialize(display_id)
+      @id = display_id.to_i # It should be an integer.
+      
+    end
+
+        
+    def modes
+      @modes ||= Modes.new(self)
+    end
+
+    def self.[](display_id)
+      if (idx = display_id.to_i) < count
+        return Display.new(display_id)
+      else
+        return nil
+      end
+    end
+
+    def self.count
+      SDL2.get_num_video_displays()
+    end
+
+    def self.count!
+      total = count
+      SDL2.throw_error_if total < 0
+      return total
+    end
+
+    def self.first
+      self[0]
+    end
+
+    def closest_display_mode(wanted)
+      closest = SDL2::Display::Mode.new # Make a new structure.
+      return SDL2.get_closest_display_mode(@id, wanted, closest)
+    end
+
+    def closest_display_mode!(wanted)
+      found = closest_display_mode(wanted)
+      SDL2.throw_error_if(found.nil?)
+      return found
+    end
+
+    def bounds
+      rect = SDL2::Rect.new
+      if SDL2.get_display_bounds(@id, rect) == 0
+        return rect
+      else
+        rect.pointer.free
+        return nil
+      end
+    end
+
+    def bounds!
+      rect = bounds()
+      SDL2.throw_error_if rect.nil?
+      return rect
+    end
+
+  end
+
+end
+

data/lib/sdl2/error.rb

@@ -0,0 +1,9 @@
+require 'sdl2'
+
+module SDL2
+
+  api :SDL_ClearError, [], :void
+  api :SDL_GetError, [], :string
+  api :SDL_SetError, [:string, :varargs], :int
+    
+end