ruby-sdl2 0.1.0

data/sample/test_surface.rb

@@ -0,0 +1,8 @@
+require 'sdl2'
+
+s = SDL2::Surface.load("icon.bmp")
+p s.w
+p s.h
+p s.pitch
+p s.bits_per_pixel
+s2 = SDL2::Surface.from_string(s.pixels, 32, 32, 24)

data/sample/test_ttf.rb

@@ -0,0 +1,77 @@
+require 'sdl2'
+
+SDL2.init(SDL2::INIT_EVERYTHING)
+SDL2::TTF.init
+
+
+window = SDL2::Window.create("testsprite",
+                             SDL2::Window::POS_CENTERED, SDL2::Window::POS_CENTERED,
+                             640, 480, 0)
+renderer = window.create_renderer(-1, 0)
+
+font = SDL2::TTF.open("font.ttf", 40)
+
+def draw_three_types(renderer, font, x, ybase)
+  renderer.copy(renderer.create_texture_from(font.render_solid("Foo", [255, 255, 255])),
+                nil, SDL2::Rect.new(x, ybase, 100, 30))
+
+  renderer.copy(renderer.create_texture_from(font.render_shaded("Foo", [255, 255, 255], [0,0,0])),
+                nil, SDL2::Rect.new(x, ybase+40, 100, 30))
+
+  renderer.copy(renderer.create_texture_from(font.render_blended("Foo", [255, 255, 255])),
+                nil, SDL2::Rect.new(x, ybase+80, 100, 30))
+end
+
+
+p font.style
+p font.outline
+p font.hinting
+p font.kerning
+p font.height
+p font.ascent
+p font.descent
+p font.line_skip
+p font.num_faces
+p font.face_is_fixed_width?
+p font.face_family_name
+p font.face_style_name
+p font.size_text("Foo")
+
+renderer.draw_color = [255,0,0]
+renderer.fill_rect(SDL2::Rect.new(0,0,640,480))
+
+draw_three_types(renderer, font, 20, 50)
+
+font.outline = 1
+draw_three_types(renderer, font, 150, 50)
+
+font.outline = 0
+font.style = SDL2::TTF::STYLE_BOLD
+draw_three_types(renderer, font, 280, 50)
+
+font.style = 0
+font.hinting = SDL2::TTF::HINTING_MONO
+draw_three_types(renderer, font, 410, 50)
+
+font.style = 0
+font.hinting = SDL2::TTF::HINTING_NORMAL
+font.kerning = false
+draw_three_types(renderer, font, 540, 50)
+
+
+loop do
+  while ev = SDL2::Event.poll
+    case ev
+    when SDL2::Event::KeyDown
+      if ev.scancode == SDL2::Key::Scan::ESCAPE
+        exit
+      end
+    when SDL2::Event::Quit
+      exit
+    end
+  end
+
+  renderer.present
+  #GC.start
+  sleep 0.1
+end

data/sample/test_video.rb

@@ -0,0 +1,53 @@
+require "sdl2"
+
+SDL2.init(SDL2::INIT_EVERYTHING)
+
+window = SDL2::Window.create("testsprite",
+                             SDL2::Window::POS_CENTERED, SDL2::Window::POS_CENTERED,
+                             640, 480, 0)
+
+renderer = window.create_renderer(-1,
+                                  SDL2::Renderer::ACCELERATED|SDL2::Renderer::TARGETTEXTURE)
+texture = renderer.load_texture("icon.bmp")
+
+rect = SDL2::Rect.new(48, 128, 32, 32)
+renderer.copy(texture, nil, rect)
+renderer.copy_ex(texture, nil, SDL2::Rect[128, 256, 48, 48], 45, nil,
+                 SDL2::Renderer::FLIP_NONE)
+texture.blend_mode = SDL2::BLENDMODE_ADD
+renderer.copy(texture, nil, SDL2::Rect[128, 294, 48, 48])
+
+texture.blend_mode = SDL2::BLENDMODE_NONE
+texture.color_mod = [128, 128, 255]
+renderer.copy(texture, nil, SDL2::Rect[300, 420, 48, 48])
+
+texture.blend_mode = SDL2::BLENDMODE_NONE
+texture.color_mod = [255, 255, 255]
+
+if renderer.support_render_target?
+  empty_texture = renderer.create_texture(renderer.info.texture_formats.first,
+                                          SDL2::Texture::ACCESS_TARGET, 128, 128)
+  renderer.render_target = empty_texture
+  renderer.draw_color = [255, 0, 255]
+  renderer.draw_line(0, 0, 128, 128)
+  renderer.reset_render_target
+  renderer.copy(empty_texture, SDL2::Rect[0, 0, 128, 128], SDL2::Rect[420, 20, 128, 128])
+end
+
+loop do
+  while ev = SDL2::Event.poll
+    p ev
+    case ev
+    when SDL2::Event::KeyDown
+      if ev.scancode == SDL2::Key::Scan::ESCAPE
+        exit
+      else
+        p ev.scancode
+      end
+    end
+  end
+
+  renderer.present
+  sleep 0.1
+end
+

data/sample/testgl.rb

@@ -0,0 +1,175 @@
+require 'sdl2'
+require 'gl'
+
+include Gl
+
+WINDOW_W = 640
+WINDOW_H = 480
+
+shadedCube = true
+
+SDL2.init(SDL2::INIT_EVERYTHING)
+SDL2::GL.set_attribute(SDL2::GL::RED_SIZE, 8)
+SDL2::GL.set_attribute(SDL2::GL::GREEN_SIZE, 8)
+SDL2::GL.set_attribute(SDL2::GL::BLUE_SIZE, 8)
+SDL2::GL.set_attribute(SDL2::GL::ALPHA_SIZE, 8)
+SDL2::GL.set_attribute(SDL2::GL::DOUBLEBUFFER, 1)
+
+window = SDL2::Window.create("testgl", 0, 0, WINDOW_W, WINDOW_H, SDL2::Window::OPENGL)
+context = SDL2::GL::Context.create(window)
+
+printf("OpenGL version %d.%d\n",
+       SDL2::GL.get_attribute(SDL2::GL::CONTEXT_MAJOR_VERSION),
+       SDL2::GL.get_attribute(SDL2::GL::CONTEXT_MINOR_VERSION))
+
+glViewport( 0, 0, 640, 400 )
+glMatrixMode( GL_PROJECTION )
+glLoadIdentity( )
+
+glMatrixMode( GL_MODELVIEW )
+glLoadIdentity( )
+
+glEnable(GL_DEPTH_TEST)
+
+glDepthFunc(GL_LESS)
+
+glShadeModel(GL_SMOOTH)
+
+color =
+  [[ 1.0,  1.0,  0.0], 
+   [ 1.0,  0.0,  0.0],
+   [ 0.0,  0.0,  0.0],
+   [ 0.0,  1.0,  0.0],
+   [ 0.0,  1.0,  1.0],
+   [ 1.0,  1.0,  1.0],
+   [ 1.0,  0.0,  1.0],
+   [ 0.0,  0.0,  1.0]]
+
+cube =
+  [[ 0.5,  0.5, -0.5], 
+   [ 0.5, -0.5, -0.5],
+   [-0.5, -0.5, -0.5],
+   [-0.5,  0.5, -0.5],
+   [-0.5,  0.5,  0.5],
+   [ 0.5,  0.5,  0.5],
+   [ 0.5, -0.5,  0.5],
+   [-0.5, -0.5,  0.5]]
+
+
+loop do
+
+  while event = SDL2::Event.poll
+    case event
+    when SDL2::Event::Quit, SDL2::Event::KeyDown
+      exit
+    end
+  end
+
+  glClearColor(0.0, 0.0, 0.0, 1.0);
+  glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
+
+
+  glBegin(GL_QUADS) 
+
+  if shadedCube then
+    glColor(color[0])
+    glVertex(cube[0])
+    glColor(color[1])
+    glVertex(cube[1])
+    glColor(color[2])
+    glVertex(cube[2])
+    glColor(color[3])
+    glVertex(cube[3])
+    
+    glColor(color[3])
+    glVertex(cube[3])
+    glColor(color[4])
+    glVertex(cube[4])
+    glColor(color[7])
+    glVertex(cube[7])
+    glColor(color[2])
+    glVertex(cube[2])
+    
+    glColor(color[0])
+    glVertex(cube[0])
+    glColor(color[5])
+    glVertex(cube[5])
+    glColor(color[6])
+    glVertex(cube[6])
+    glColor(color[1])
+    glVertex(cube[1])
+    
+    glColor(color[5])
+    glVertex(cube[5])
+    glColor(color[4])
+    glVertex(cube[4])
+    glColor(color[7])
+    glVertex(cube[7])
+    glColor(color[6])
+    glVertex(cube[6])
+    
+    glColor(color[5])
+    glVertex(cube[5])
+    glColor(color[0])
+    glVertex(cube[0])
+    glColor(color[3])
+    glVertex(cube[3])
+    glColor(color[4])
+    glVertex(cube[4])
+    
+    glColor(color[6])
+    glVertex(cube[6])
+    glColor(color[1])
+    glVertex(cube[1])
+    glColor(color[2])
+    glVertex(cube[2])
+    glColor(color[7])
+    glVertex(cube[7])
+    
+  else
+    glColor(1.0, 0.0, 0.0)
+    glVertex(cube[0])
+    glVertex(cube[1])
+    glVertex(cube[2])
+    glVertex(cube[3])
+    
+    glColor(0.0, 1.0, 0.0)
+    glVertex(cube[3])
+    glVertex(cube[4])
+    glVertex(cube[7])
+    glVertex(cube[2])
+    
+    glColor(0.0, 0.0, 1.0)
+    glVertex(cube[0])
+    glVertex(cube[5])
+    glVertex(cube[6])
+    glVertex(cube[1])
+    
+    glColor(0.0, 1.0, 1.0)
+    glVertex(cube[5])
+    glVertex(cube[4])
+    glVertex(cube[7])
+    glVertex(cube[6])
+    
+    glColor(1.0, 1.0, 0.0)
+    glVertex(cube[5])
+    glVertex(cube[0])
+    glVertex(cube[3])
+    glVertex(cube[4])
+    
+    glColor(1.0, 0.0, 1.0)
+    glVertex(cube[6])
+    glVertex(cube[1])
+    glVertex(cube[2])
+    glVertex(cube[7])
+    
+  end
+
+  glEnd()
+  
+  glMatrixMode(GL_MODELVIEW)
+  glRotate(5.0, 1.0, 1.0, 1.0)
+  
+  window.gl_swap
+
+end

data/sample/testsprite.rb

@@ -0,0 +1,296 @@
+require 'sdl2'
+require 'optparse'
+
+MAX_SPEED = 1
+
+class Integer
+  def bit?(mask)
+    (self & mask) != 0
+  end
+end
+
+class Cycle < Struct.new(:cycle_color, :cycle_alpha, :color, :alpha,
+                         :color_direction, :alpha_direction)
+  def update
+    self.color += self.color_direction
+    if self.color < 0
+      self.color = 0
+      self.color_direction *= -1
+    end
+    if color > 255
+      self.color = 255
+      self.color_direction *= -1
+    end
+    self.alpha += self.alpha_direction
+    if self.alpha < 0
+      self.alpha = 0
+      self.alpha_direction *= -1
+    end
+    if self.alpha > 255
+      self.alpha = 255
+      self.alpha_direction *= -1
+    end
+  end
+end
+                   
+
+class WindowData
+  def initialize(sdl_window, renderer, cycle, blend_mode, use_color_key)
+    @sdl_window = sdl_window
+    @renderer = renderer
+    @cycle = cycle
+    @blend_mode = blend_mode
+    @use_color_key = use_color_key
+  end
+
+  def setup(spritepath, num_sprites)
+    load_sprite(spritepath)
+    @sprite.blend_mode = @blend_mode
+    @sprites = Array.new(num_sprites){
+      Sprite.new(@sdl_window, @renderer, @sprite)
+    }
+  end
+  
+  def load_sprite(fname)
+    bitmap = SDL2::Surface.load(fname)
+    bitmap.color_key = bitmap.pixel(0, 0) if @use_color_key
+    @sprite = @renderer.create_texture_from(bitmap)
+    bitmap.destroy
+  end
+
+  def update
+    @sprites.each(&:update)
+  end
+
+  def draw
+    viewport = @renderer.viewport
+    # Draw a gray background
+    @renderer.draw_color = [0xA0, 0xA0, 0xA0]
+    @renderer.clear
+
+    # Points
+    @renderer.draw_color = [0xff, 0, 0]
+    @renderer.draw_point(0, 0)
+    @renderer.draw_point(viewport.w - 1, 0)
+    @renderer.draw_point(0 ,viewport.h - 1)
+    @renderer.draw_point(viewport.w - 1, viewport.h - 1)
+
+    # Fill rect
+    @renderer.draw_color = [0xff, 0xff, 0xff]
+    @renderer.fill_rect(SDL2::Rect[viewport.w/2 - 50, viewport.h/2 - 50, 100, 100])
+
+    # Draw rect
+    @renderer.draw_color = [0, 0, 0]
+    @renderer.draw_rect(SDL2::Rect[viewport.w/2 - 50, viewport.h/2 - 50, 100, 100])
+    
+    # lines
+    @renderer.draw_color = [0, 0xff, 0]
+    @renderer.draw_line(1, 1, viewport.w - 2, viewport.h - 2)
+    @renderer.draw_line(1, viewport.h - 2, viewport.w - 2, 1)
+
+    @sprite.color_mod = [@cycle.color, 255, @cycle.color] if @cycle.cycle_color
+    @sprite.alpha_mod = @cycle.alpha if @cycle.cycle_alpha
+    
+    @sprites.each(&:draw)
+    @renderer.present
+  end
+  
+  class Sprite
+    def initialize(window, renderer, sprite, max_speed = MAX_SPEED)
+      @renderer = renderer
+      @sprite = sprite
+      window_w, window_h = window.size
+      @position = SDL2::Rect[rand(window_w - sprite.w),
+                             rand(window_h - sprite.h),
+                             sprite.w, sprite.h]
+      @velocity = random_velocity(max_speed)
+    end
+
+    def random_velocity(max_speed)
+      loop do
+        dx = rand(2*max_speed + 1) - max_speed
+        dy = rand(2*max_speed + 1) - max_speed
+        return SDL2::Point[dx, dy] if dx != 0 || dy != 0
+      end
+    end
+
+    def update
+      viewport = @renderer.viewport
+      @position.x += @velocity.x
+      @position.y += @velocity.y
+      unless (0 .. viewport.w - @sprite.w).cover?(@position.x)
+        @velocity.x *= -1
+        @position.x += @velocity.x
+      end
+
+      unless (0 .. viewport.h - @sprite.h).cover?(@position.y)
+        @velocity.y *= -1
+        @position.y += @velocity.y
+      end
+    end
+
+    def draw
+      @renderer.copy(@sprite, nil, @position)
+    end
+  end
+end
+
+class App
+  def initialize
+    @title = "testsprite"
+    @window_flags = 0
+    @icon_path = nil
+    @num_window = 1
+    @window_x = @window_y = SDL2::Window::POS_UNDEFINED
+    @window_w = 640
+    @window_h = 480
+    @spritepath = "icon.bmp"
+    @renderer_flags = 0
+    @num_sprites = 100
+    @blend_mode = SDL2::BLENDMODE_BLEND
+    @cycle = Cycle.new(false, false, rand(255), rand(255), [1,-1].sample, [1,-1].sample)
+    @use_color_key = true
+  end
+
+  def options
+    opts = OptionParser.new("Usage: testsprite [options] [SPRITE]")
+    opts.version = SDL2::VERSION
+    opts.release = nil
+    
+    opts.on("-m", "--mode MODE", "fullscreen|fullscreen-desktop|window"){|mode|
+      case mode
+      when "fullscreen"
+        raise "Only one window is available for fullscreen mode" if @num_window != 1
+        @window_flags |= SDL2::Window::FULLSCREEN
+      when "fullscreen-desktop"
+        raise "Only one window is available for fullscreen-desktop mode" if @num_window != 1
+        @window_flags |= SDL2::Window::FULLSCREEN_DESKTOP
+      when "window"
+        @window_flags &= ~(SDL2::Window::FULLSCREEN|SDL2::Window::FULLSCREEN_DESKTOP)
+      end
+    }
+    
+    opts.on("--windows N", "Number of windows", Integer){|n|
+      if n != 1 and @window_flags.bit?(SDL2::Window::FULLSCREEN|SDL2::Window::FULLSCREEN_DESKTOP)
+        raise "Only one window is available for fullscreen mode"
+      end
+      @num_window = n
+    }
+
+    opts.on("--geometry WxH", "size of the window/screen"){|s|
+      raise "geomtry format error #{s}" unless /\A(\d+)x(\d+)\Z/ =~ s
+      @window_w = Integer($1); @window_h = Integer($2)
+    }
+
+    opts.on("--center", "Window will be centered"){
+      @window_x = @window_y = SDL2::Window::POS_CENTERED
+    }
+
+    opts.on("-t", "--title TITLE", "Window title"){|title| @title = title }
+
+    opts.on("--icon ICON", "Window icon"){|path| @icon_path = path }
+
+    opts.on("--position X,Y", "Position of the window", Array){|x,y|
+      @window_x = Integer(x); @window_y = Integer(y)
+    }
+
+    opts.on("--noframe", "Window is borderless") { @window_flags |= SDL2::Window::BORDERLESS }
+
+    opts.on("--resize", "Window is resizable") { @window_flags |= SDL2::Window::RESIZABLE }
+
+    opts.on("--allow-highdip"){ @window_flags |= SDL2::Window::ALLOW_HIGHDPI }
+
+    opts.on("--blend MODE", "none|blend|add|mod"){|blend_mode|
+      @blend_mode = case blend_mode
+                    when "none"
+                      SDL2::BLENDMODE_NONE
+                    when "blend"
+                      SDL2::BLENDMODE_BLEND
+                    when "add"
+                      SDL2::BLENDMODE_ADD
+                    when "mod"
+                      SDL2::BLENDMODE_MOD
+                    end
+    }
+    
+    opts.on("--cycle-color"){ @cycle.cycle_color = true }
+
+    opts.on("--cycle-alpha"){ @cycle.cycle_alpha = true }
+
+    opts.on("--vsync", "Present is syncronized with the refresh rate") {
+      @renderer_flags |= SDL2::Renderer::PRESENTVSYNC
+    }
+
+    opts.on("--use-color-key (yes|no)", TrueClass){|bool| @use_color_key = bool }
+    opts
+  end
+
+  def run(argv)
+    options.parse!(argv)
+    @spritepath = argv.shift || @spritepath
+    
+    SDL2.init(SDL2::INIT_VIDEO)
+    icon = load_icon
+    @windows = @num_window.times.map do |n|
+      window = SDL2::Window.create("#{@title} #{n}",
+                                   @window_x, @window_y, @window_w, @window_h,
+                                   @window_flags)
+      renderer = window.create_renderer(-1, @renderer_flags)
+      window.icon = icon if icon
+      
+      WindowData.new(window, renderer, @cycle, @blend_mode, @use_color_key)
+    end
+
+    @windows.each{|win| win.setup(@spritepath, @num_sprites) }
+
+    loop do
+      while event = SDL2::Event.poll
+        handle_event(event)
+      end
+      @cycle.update
+      @windows.each {|window| window.update; window.draw }
+      sleep 0.01
+    end
+  end
+
+  def load_icon
+    return nil if @icon_path.nil?
+    SDL2::Surface.load(@icon_path)
+  end
+  
+  def handle_event(event)
+    case event
+    when SDL2::Event::Quit
+      exit
+    when SDL2::Event::KeyDown
+      case event.sym
+      when SDL2::Key::ESCAPE
+        exit
+      when SDL2::Key::RETURN
+        if event.mod.bit?(SDL2::Key::Mod::ALT)
+          if event.window.fullscreen_mode == 0
+            event.window.fullscreen_mode = SDL2::Window::FULLSCREEN_DESKTOP
+          else
+            event.window.fullscreen_mode = 0
+          end
+        end
+      when SDL2::Key::M
+        if event.mod.bit?(SDL2::Key::Mod::CTRL|SDL2::Key::Mod::CAPS)
+          window = event.window
+          if window.flags & SDL2::Window::MAXIMIZED != 0
+            window.restore
+          else
+            window.maximize
+          end
+        end
+      when SDL2::Key::Z
+        if event.mod.bit?(SDL2::Key::Mod::CTRL|SDL2::Key::Mod::CAPS)
+          window = event.window
+          window.minimize if window
+        end
+      end
+    end
+  end
+end
+
+App.new.run(ARGV)