sdl2_ffi 0.0.6 → 0.0.7

data/spec/lib/sdl2/keyboard_spec.rb

@@ -0,0 +1,22 @@
+require_relative '../../spec_helper'
+
+describe SDL2::Keyboard do
+  before :each do
+    SDL2.init(:VIDEO)
+    @window = SDL2::Window.create()
+    SDL2.pump_events
+  end
+  
+  it 'should return a focused window' do    
+    SDL2::Keyboard.get_focus.should be_a(SDL2::Window)
+  end
+  
+  it 'should return an array of integers' do
+    skip 'TODO: Keyboard#get_state'
+    #binding.pry
+  end
+  
+  after :each do
+    SDL2.quit
+  end
+end

data/spec/lib/sdl2/mouse_spec.rb

@@ -0,0 +1,21 @@
+require_relative '../../spec_helper'
+
+describe SDL2 do
+  it 'should have the SDL_mouse.h API' do
+    [
+      :create_color_cursor!,
+    ].each do |function|
+      SDL2.should respond_to(function)
+    end
+  end
+end
+
+describe SDL2::Cursor do
+  it 'can create color cursors' do
+    skip 'supported yet?' do
+      SDL2::Cursor.should respond_to(:create_color_cursor)
+      finger = SDL2::Image.load(img_path('finger.png'))
+      @cursor = SDL2::Cursor.create_color_cursor(finger,finger.w/2,finger.h/2)
+    end
+  end
+end

data/spec/lib/sdl2/render_spec.rb

@@ -0,0 +1,62 @@
+require_relative '../../spec_helper'
+
+describe SDL2 do
+  it 'should have the renderer api' do
+    [
+      :create_renderer!,      
+      :create_software_renderer!,
+      :create_texture!,
+      :create_texture_from_surface!,
+      :create_window_and_renderer!,
+      :destroy_renderer,
+      :destroy_texture,
+      :get_num_render_drivers!,
+      :get_render_draw_blend_mode!,
+      :get_render_draw_color!,
+      :get_render_driver_info!,
+      :get_render_target,
+      :get_renderer!,
+      :get_renderer_info!,
+      :get_renderer_output_size!,
+      :get_texture_alpha_mod!,
+      :get_texture_color_mod!,
+      :get_texture_blend_mode!,
+      :lock_texture!,
+      :query_texture!,
+      :render_clear!,
+      :render_copy!,
+      :render_copy_ex!,
+      :render_draw_line!,
+      :render_draw_lines!,
+      :render_draw_point!,
+      :render_draw_points!,
+      :render_draw_rect!,
+      :render_draw_rects!,
+      :render_fill_rect!,
+      :render_fill_rects!,
+      :render_get_clip_rect,
+      :render_get_logical_size,
+      :render_get_scale,
+      :render_get_viewport,
+      :render_present,
+      :render_read_pixels!,
+      :render_set_clip_rect!,
+      :render_set_logical_size!,
+      :render_set_scale!,
+      :render_set_viewport!,
+      :render_target_supported?,
+      :set_render_draw_blend_mode!,
+      :set_render_draw_color!,
+      :set_render_target!,
+      :render_set_clip_rect!,
+      :set_texture_alpha_mod!,
+      :set_texture_blend_mode!,
+      :set_texture_color_mod!,
+      :unlock_texture,
+      :update_texture!,
+    ].each do |method| 
+      SDL2.should respond_to(method)
+    end    
+  end
+  
+end

data/spec/lib/sdl2/renderer_spec.rb

@@ -0,0 +1,224 @@
+require_relative '../../spec_helper'
+
+module SDL2
+
+  describe Renderer do
+    before :each do
+      SDL2.init(:VIDEO)
+      @window = SDL2::Window.create()   
+      @renderer = SDL2::Renderer.create(@window)
+    end
+    
+    it 'could have many drivers' do
+      SDL2::Renderer::Drivers.count.should be_a(Integer)
+      SDL2::Renderer::Drivers.count.should >= 0
+    end
+    
+    it 'should have a draw_color' do      
+      @renderer.draw_color.should be_a(SDL2::Color)
+      @renderer.draw_color = SDL2::Color.create(r: 255)
+      @renderer.draw_color.r.should == 255 
+    end
+    
+    it 'should have a draw blend mode' do
+      @renderer.should respond_to(:draw_blend_mode)
+      @renderer.draw_blend_mode= :BLEND
+      @renderer.draw_blend_mode.should == :BLEND
+      @renderer.draw_blend_mode= :NONE
+      @renderer.draw_blend_mode.should == :NONE
+    end
+    
+    it 'should have an info' do
+      @renderer.should respond_to(:info)
+      @renderer.info.should be_a(SDL2::RendererInfo)
+      @renderer.info.should_not be_null     
+    end
+    
+    it 'should have an output size' do
+      @renderer.should respond_to(:output_size)
+      @renderer.output_size.count.should == 2
+      @renderer.output_size.should == @window.current_size
+      @renderer.output_size.each{|val|val.should be_a(Integer)}
+    end
+    
+    it 'should have a target' do
+      @renderer.should respond_to(:target)
+      @renderer.should respond_to(:target=)
+      @renderer.target.should be_nil
+      skip "TODO: SDL Error: glFramebufferTexture2DEXT() failed" #TODO: Investigate SDL Error: glFramebufferTexture2DEXT() failed
+      binding.pry
+      texture = SDL2::Texture.create(@renderer, :RGBA8888, :TARGET, 128, 128)
+      @renderer.target=texture
+      @renderer.target.should == texture
+      @renderer.target=nil
+      @renderer.target.should be_nil
+    end
+    
+    it 'should be able to clear' do
+      @renderer.should respond_to(:clear)
+      @renderer.draw_color = SDL2::Color.create(g: 255)
+      @renderer.clear           
+      SDL2.render_present(@renderer)
+      
+      verify(format: :png){@window.renderer_to_surface}
+    end
+    
+    it 'should be able to create textures from surfaces' do
+      @renderer.should respond_to(:texture_from_surface)
+      sur_hello = @window.surface.convert(SDL2::Image.load!(img_path('hello.bmp')))
+      @renderer.texture_from_surface(sur_hello).should be_a(SDL2::Texture)      
+    end
+    
+    it 'should be able to render textures' do
+      @renderer.should respond_to(:copy)  
+      txt_hello = @renderer.texture_from_surface(@window.surface.convert(SDL2::Image.load!(img_path('hello.bmp'))))
+      @renderer.copy(txt_hello, {w: 200, h: 200}, {x: 100, y: 100, w: 100, h: 100})
+      SDL2.render_present(@renderer)
+      verify(){@window.renderer_to_surface}
+    end
+    
+    it 'should be able to rotate and flip while rendering textures' do
+      @renderer.should respond_to(:copy_ex)
+      txt_hello = @renderer.texture_from_surface(@window.surface.convert(SDL2::Image.load!(img_path('hello.bmp'))))
+      @renderer.copy_ex(txt_hello, nil, nil, 12, {x: 12, y: 12}, :BOTH )
+      verify(){@window.renderer_to_surface}
+    end
+    
+    it 'should be able to draw a single pixel line' do
+      @renderer.should respond_to(:draw_line)
+      @renderer.draw_color = SDL2::Color.create(r: 255,g: 255,b: 255)
+      @renderer.draw_line(100,100,200,200)
+      SDL2.render_present(@renderer)
+      verify(){@window.renderer_to_surface}
+    end
+    
+    it 'should be able to draw a line connecting many points' do
+      @renderer.should respond_to(:draw_lines)
+      points = [[5,5],[1,123],[290,33],[27,222]]
+      @renderer.draw_color = SDL2::Color.create(g: 255)
+      # draw lines expects each point to be specified as an argument,
+      # no limit to the number of points that can be specified at once
+      # that I know of using this method.
+      @renderer.draw_lines(*points)
+      SDL2.render_present(@renderer)
+
+      verify(){@window.renderer_to_surface}
+    end
+    
+    it 'should be able to draw a point' do
+      @renderer.should respond_to(:draw_point)
+      @renderer.draw_color = SDL2::Color.create(r: 255)
+      @renderer.draw_point(160,120)
+      SDL2.render_present(@renderer)
+      verify(){@window.renderer_to_surface}
+    end
+    
+    it 'should be able to draw points' do
+      # You can pass many kinds of points.
+      points = [[88,44],SDL2::Point.cast([128,40]),{x: 300, y: 444}]
+      @renderer.draw_color = SDL2::Color.create(b: 255)
+      @renderer.draw_points(*points)
+      SDL2.render_present(@renderer)
+      verify(){@window.renderer_to_surface}
+    end
+    
+    it 'should be able to draw a single rectangle' do
+      @renderer.should respond_to(:draw_rect)
+      @renderer.draw_color = {r: 255}
+      @renderer.draw_rect([10,10,100,100])
+      @renderer.draw_color = {g: 255}
+      @renderer.draw_rect({x: 40, y: 40, w: 64, h: 128})
+      @renderer.draw_color = {b: 255}
+      @renderer.draw_rect(SDL2::Rect.cast({x: 100, y: 100, w: 128, h: 64}))
+      SDL2.render_present(@renderer)
+      verify(){@window.renderer_to_surface}
+    end
+    
+    
+    it 'should be able to draw many rectangles at once' do
+      @renderer.should respond_to(:draw_rects)
+      # Should be able to handle many kinds of cords.
+      cords = [[10,10,100,100],{x: 40, y: 40, w: 64, h: 128},SDL2::Rect.cast({x: 100, y: 100, w: 128, h: 64})]
+      @renderer.draw_color = {r: 255, g: 255, b: 255}
+      @renderer.draw_rects(*cords)
+      SDL2.render_present(@renderer)
+      verify(){@window.renderer_to_surface}
+    end
+    
+    it 'should be able to draw a single filled rectangle' do
+      @renderer.should respond_to(:fill_rect)
+      rect = {x: 123, y: 132, w: 200, h: 200}
+      @renderer.fill_rect(rect)
+      @renderer.present
+      verify(){@window.renderer_to_surface}
+    end
+    
+    it 'should be able to draw many filled rectangles' do
+      rects = [
+        [21,32,124,200],
+        [64,11,15,66],
+        [222,100,80,100]
+      ]
+      @renderer.fill_rects(*rects)
+      @renderer.present
+      verify(){@window.renderer_to_surface}
+    end
+    
+    it 'should have a clip rect' do
+      @renderer.should respond_to(:clip_rect)
+      @renderer.should respond_to(:clip_rect=)
+      @renderer.clip_rect.should be_a(SDL2::Rect)
+      @renderer.clip_rect.x.should == 0
+      @renderer.clip_rect.y.should == 0
+      @renderer.clip_rect.w.should == 0
+      @renderer.clip_rect.h.should == 0
+      @renderer.clip_rect = {x: 128, y: 128, w: 64, h: 32}
+      
+      @renderer.clip_rect.x.should == 128
+      @renderer.clip_rect.y.should == 128
+      @renderer.clip_rect.w.should == 64
+      @renderer.clip_rect.h.should == 32      
+      @renderer.fill_rect x: 100, y: 100, w: 100, h: 100
+      @renderer.present
+      verify(){@window.renderer_to_surface}
+    end
+    
+    it 'should have a logical size' do
+      @renderer.should respond_to(:logical_size)
+      @renderer.should respond_to(:logical_size=)
+      @renderer.logical_size.should == [0, 0]
+      @renderer.logical_size = [128, 128]
+      @renderer.logical_size.should == [128, 128]
+    end
+    
+    it 'should have a scale' do
+      @renderer.should respond_to(:scale)
+      @renderer.should respond_to(:scale=)
+      @renderer.scale.should == [1.0, 1.0]
+      @renderer.scale = [2.0, 3.0]
+      @renderer.scale.should == [2.0, 3.0]
+    end
+    
+    it 'should have a viewport' do
+      @renderer.should respond_to(:viewport)
+      @renderer.should respond_to(:viewport=)
+      @renderer.viewport.should == SDL2::Rect.cast([0,0,*@window.current_size])
+      @renderer.viewport = {x: 20, y: 20, w: 128, h: 128}
+      @renderer.viewport.x.should == 20
+      @renderer.viewport.y.should == 20
+      @renderer.viewport.w.should == 128
+      @renderer.viewport.h.should == 128
+    end
+    
+    it 'should signal if target rendering is supported' do
+      @renderer.should respond_to(:target_supported?)
+      # TODO: How else should we test this?
+    end    
+    
+    
+    after :each do
+      SDL2.quit
+    end
+
+  end
+end

data/spec/lib/sdl2/sdl2_helper.rb

@@ -0,0 +1,5 @@
+require_relative '../unit_helper.rb'
+
+require 'sdl2'
+
+include SDL2

data/spec/lib/sdl2/texture_spec.rb

@@ -0,0 +1,65 @@
+require_relative '../../spec_helper'
+
+module SDL2
+  
+  describe Texture do
+    
+    before :each do 
+      SDL2.init!(:VIDEO)     
+      @window = SDL2::Window.create()
+      @renderer = SDL2::Renderer.create(@window)
+      @texture = @renderer.texture_from_surface(SDL2::Image.load(img_path('hello.bmp')))
+      #@texture = SDL2::Texture.create(@renderer, :RGBA8888, :STATIC, 64,64)  
+      #@renderer.present    
+      #binding.pry
+      #SDL2::Debug.enable(SDL2::Struct)
+      #SDL2::Debug.enable(SDL2)      
+    end
+    
+    after :each do    
+      #@texture.destroy
+      #@renderer.destroy        
+      SDL2.quit
+    end
+        
+    it 'has an alpha_mod' do
+      @texture.should respond_to(:alpha_mod)
+      @texture.should respond_to(:alpha_mod=) 
+      @texture.alpha_mod.should == 255
+      @texture.alpha_mod = 128
+      @texture.alpha_mod.should == 128
+    end
+    
+    it 'has a blend_mode' do
+      @texture.should respond_to(:blend_mode)
+      @texture.should respond_to(:blend_mode=)
+      @texture.blend_mode.should == :BLEND
+      @texture.blend_mode = SDL2::BLENDMODE::ADD
+      @texture.blend_mode.should == :ADD
+    end
+    
+    it 'has a color_mod' do
+      @texture.should respond_to(:color_mod)
+      @texture.should respond_to(:color_mod=)
+      @texture.color_mod.should == [255,255,255]
+      @texture.color_mod = [32,64,128]
+      @texture.color_mod.should == [32,64,128]
+    end
+    
+    it 'can be locked' do
+      @texture.should respond_to(:lock)
+      @texture.should respond_to(:unlock)
+      skip 'need to mess with streaming textures'
+      @texture.lock
+      @texture.unlock
+    end
+    
+    it 'can be queried' do
+      query = @texture.query
+      query.length.should == 4      
+    end
+    
+    
+  end
+  
+end

data/{test/unit/sdl2/test_video.rb → spec/lib/sdl2/video_spec.rb}

@@ -1,4 +1,4 @@
-require_relative '../../test_helper'
+require_relative '../../spec_helper'
 
 require 'sdl2/init'
 require 'sdl2/video'
@@ -9,15 +9,15 @@ require 'sdl2/video'
 # What the Ruby version of the SDL_video.h API should look like
 #
 VIDEO_API = [
-  :get_num_video_drivers,
+  :get_num_video_drivers!,
   :get_video_driver,
   :video_init,
   :video_quit,
   :get_current_video_driver,
-  :get_num_video_displays,
+  :get_num_video_displays!,
   :get_display_name,
   :get_display_bounds,
-  :get_num_display_modes,
+  :get_num_display_modes!,
   :get_display_mode,
   :get_desktop_display_mode,
   :get_current_display_mode,
@@ -83,88 +83,113 @@ VIDEO_API = [
 ]
 
 describe SDL2 do
-  before do
-    assert(SDL2.init(SDL2::INIT::VIDEO) == 0, 'Video initialized.')
-  end
-
-  after do
-    SDL2.quit()
-  end
-
   it 'has the video API' do
-    assert_equal 70, VIDEO_API.count
+    VIDEO_API.count.should == 70
     VIDEO_API.each do |function|
-      assert_respond_to SDL2, function
+      SDL2.should respond_to(function)
     end
   end
+end
 
-  it 'can manage the screen saver' do
-    SDL2.disable_screen_saver
-    refute SDL2.is_screen_saver_enabled
-    SDL2.enable_screen_saver
-    assert SDL2.is_screen_saver_enabled
+describe SDL2::Video do
+  before do
+    SDL2::Debug.enable(SDL2::Struct)
+    SDL2.init(:VIDEO)
   end
-
-  describe SDL2::Window do
-
+  after do
+    SDL2.quit
   end
-
-  it 'can query OpenGL Extension Support' do
-    skip 'not sure how to write this test right now.'
+  it 'can be initialized and shut down with default drivers' do
+    SDL2::Video.init("x11")
+    SDL2::Video.quit
   end
 
-  it 'can query and set OpenGL Attributes' do
-    skip 'for now.'
+  it 'can initialize each of the video drivers' do
+    skip 'Fails on dummy driver right now for me'
+    SDL2::Video::Drivers.each do |driver|
+      SDL2::Video.init(driver)
+      SDL2::Video.current_driver.should == driver
+      SDL2::Video.quit
+    end
   end
+end
 
-  describe SDL2::Display do
-    it 'can count the displays attached' do
-      sdl_count = SDL2.get_num_video_displays()
-      assert_equal sdl_count, SDL2::Display.count
+describe SDL2::Video::Drivers do
+  before do
+    SDL2.init(:VIDEO)
+  end
+  after do
+    SDL2.quit
+  end
+  it 'can list the video drivers' do
+    SDL2::Video::Drivers.num.should >= 1
+    SDL2::Video::Drivers.each do |driver|
+      driver.should be_a(String)
     end
+  end
 
-    it 'can get the first display' do
-      assert_kind_of SDL2::Display, SDL2::Display.first
-    end
+end
 
-    it 'can get the display bounds' do
-      assert_kind_of SDL2::Rect, SDL2::Display.first.bounds!
-    end
+describe SDL2::ScreenSaver do
+  before do
+    SDL2.init(:VIDEO)
+  end
+  after do
+    SDL2.quit()
+  end
+  before :each do
+    SDL2::Video.init
+  end
+  after :each do
+    SDL2::Video.quit
+  end
+  it 'can manage the screen saver' do
+    SDL2::ScreenSaver.disable
+    SDL2::ScreenSaver.enabled?.should == false
+    SDL2::ScreenSaver.enable
+    SDL2::ScreenSaver.enabled?.should == true
+  end
+end
+
+describe SDL2::Display do
+  before(:each){SDL2.init!(:VIDEO)}
+  after(:each){SDL2.quit}
+  it 'can count the displays attached' do
+    sdl_count = SDL2.get_num_video_displays()
+    SDL2::Display.count.should == sdl_count
+  end
 
-    it 'has many display modes' do
-      assert SDL2::Display.first.modes.count > 0
-      assert_kind_of SDL2::Display::Mode, SDL2::Display.first().modes.first
-    end
+  it 'can get the first display' do
+    SDL2::Display.first.should be_a(SDL2::Display)
+  end
 
+  it 'can get the display bounds' do
+    SDL2::Display.first.bounds!.should be_a(SDL2::Rect)
   end
 
+  it 'has many display modes' do
+    SDL2::Display.first.modes.count.should > 0
+    SDL2::Display.first().modes.first.should be_a(SDL2::Display::Mode)
+  end
   it 'can get the closest display mode' do
     closest_display_mode_found = nil # for now
 
     SDL2::Display::Mode.new do |wanted|
-
       wanted.format = 0 #SDL2::PIXELFORMAT_RGBA8888 #TODO: Import PIXELFORMAT
       # constants?
       wanted.w = 640
       wanted.h = 480
       wanted.refresh_rate = 60
       wanted.driverdata = nil
-
-      closest_display_mode_found = SDL2::Display.first.closest_display_mode!(wanted)
+      closest_display_mode_found = SDL2::Display.first.closest_display_mode(wanted)
     end # This should automatically dispose of the display_mode struct we created
     # as wanted
-    assert_kind_of SDL2::Display::Mode, closest_display_mode_found
+    closest_display_mode_found.should be_a(SDL2::Display::Mode)
 
   end
-  #TODO: Redo GLContext testing
-  #describe SDL2::GLContext do
-  #
-  #    it 'can create gl_context' do
-  #      window = SDL2::Window.create!()
-  #      context = SDL2::GLContext.create!(window)
-  #      assert_kind_of SDL2::GLContext, context
-  #    end
-  #
-  #  end
-
-end
+  
+  it 'can list the current display mode' do
+    SDL2::Display.first.current_display_mode.should be_a(SDL2::Display::Mode)
+    #binding.pry
+  end
+end