ezdraw 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: e511f9b01d78b9b1be53a1138607cc7657f14cc9
+  data.tar.gz: fe32f32026d9e087c3fd7fc9a874b58e47f0fc64
+SHA512:
+  metadata.gz: 9009ac9f82a757744aeedfaf5cea76c80bd14ce6e64eb1831cab282744e2bb29f177bc034f2873101b4a6bb6d8cec4e57c1fda398ef9b6decb4d064574a4949f
+  data.tar.gz: 19619e5c87a3c360023685f95085584d5fc86d8e0b37e9aaae26d1b26deb496ea10ad013fdf8996eb36960e07eb85c9cd807664e7709bbfb3052bc616d5c8745

data/examples/test.rb

@@ -0,0 +1,67 @@
+require 'ezdraw'
+
+#EZDraw.logger.level = Logger::DEBUG
+
+SCRIPT_DIR = File.dirname(__FILE__)
+
+EZDraw.init
+
+win = EZDraw::Window.new(:default, "awesome test window")
+
+win.auto_update = false
+img = EZDraw::Image.new("#{SCRIPT_DIR}/res/star.png")
+y = 0
+while y < win.height
+ x = 0
+ while x < win.height
+  win.image(x, y, img)
+  x += img.width
+ end
+ y += img.height
+end
+win.auto_update = true
+win.image(win.width/2, win.height/2, "#{SCRIPT_DIR}/res/star.png")
+
+win.stroke = EZDraw::Blue
+win.fill = EZDraw::Gray
+win.line(0,0,win.width,win.height)
+win.circle(win.width/2, win.height/2, win.width/3)
+win.rect(10,10,50,50)
+
+win.push_context
+win.stroke = EZDraw::Red
+win.fill = EZDraw::None
+win.circle(100,100,50)
+win.pop_context
+
+win.stroke = EZDraw::Green
+win.line(0,0,win.width/2,win.height)
+win.circle(200,100,50)
+win.line(0,0,win.width,win.height/2)
+win.stroke = EZDraw::Black
+win.push_context
+win.text(0,0,"hello world")
+win.font = EZDraw::Font.new("#{SCRIPT_DIR}/res/opensans.ttf", 80)
+win.stroke = EZDraw::Green
+win.text(0, 20, "hello world")
+win.pop_context
+win.text(0,100,"hello world")
+
+def rnd n
+ Random.rand(n)
+end
+
+100.times {
+ win.stroke = [rnd(0xff),rnd(0xff),rnd(0xff),0xff]
+ win.line(rnd(win.width),rnd(win.height),rnd(win.width),rnd(win.height))
+}
+win.auto_update = false
+100.times {
+ win.stroke = [rnd(0xff),rnd(0xff),rnd(0xff),0xff]
+ win.line(rnd(win.width),rnd(win.height),rnd(win.width),rnd(win.height))
+}
+win.auto_update = true
+EZDraw.waitkey
+
+EZDraw.cleanup
+

data/examples/test_dsl.rb

@@ -0,0 +1,39 @@
+require 'ezdraw'
+
+include EZDraw::DSL
+
+SCRIPT_DIR = File.dirname(__FILE__)
+
+init
+
+draw {
+stroke(Blue)
+(0..width).step(20) {|x| line(x,0,width-x,height) }
+(0..height).step(20) {|y| line(0,y,width,height-y) }
+}
+delay(100)
+
+draw {
+ stroke(Red)
+ (0..width).step(20) {|x| line(x,0,width-x,height) }
+ (0..height).step(20) {|y| line(0,y,width,height-y) }
+}
+delay(100)
+
+img = Image.new("#{SCRIPT_DIR}/res/star.png")
+image(0,0, img)
+delay(100)
+image([0,0,img.width/2,img.height/2], nil, img)
+delay(100)
+image(nil, [0,0,width,height], img)
+
+draw {
+stroke(Brown)
+fill(Yellow)
+circle(width/2,height/2,width/5)
+}
+
+waitkey
+
+cleanup
+

data/examples/trivial.rb

@@ -0,0 +1,14 @@
+require 'ezdraw'
+ 
+include EZDraw::DSL
+
+init
+
+stroke(Red)
+fill(Green)
+text(0,0,"hello world")
+circle(width/2, height/2, width/3)
+
+waitkey
+cleanup
+

data/lib/ezdraw.rb

@@ -0,0 +1,555 @@
+require_relative 'sdl2'
+require 'logger'
+
+module EZDraw
+ White = [0xff, 0xff, 0xff, 0xff].freeze
+ Black = [0x00, 0x00, 0x00, 0xff].freeze
+ Gray  = [0x88, 0x88, 0x88, 0xff].freeze
+
+ Red   = [0xff, 0x00, 0x00, 0xff].freeze
+ Green = [0x00, 0xff, 0x00, 0xff].freeze
+ Blue  = [0x00, 0x00, 0xff, 0xff].freeze
+
+ Yellow  = [0xff, 0xff, 0x00, 0xff].freeze
+ Magenta = [0xff, 0x00, 0xff, 0xff].freeze
+ Cyan    = [0x00, 0xff, 0xff, 0xff].freeze
+
+ Brown   = [0xa5, 0x2a, 0x2a, 0xff].freeze
+
+ None  = [0x00, 0x00, 0x00, 0x00].freeze
+
+ @@logger = Logger.new(STDERR)
+ @@logger.level = Logger::WARN
+ @@logger.progname = "EZDraw"
+ def self.logger
+  @@logger
+ end
+
+ # auto-handles path sep
+ def self.gem_relative_path(path)
+  gem_root = File.expand_path('..', File.dirname(__FILE__))
+  path = File.join(*(path.split("/")))
+  File.join(gem_root, path)
+ end
+ private_class_method :gem_relative_path
+
+ @@inited = false
+
+ def self.init
+  return if inited
+
+  if SDL2.SDL_WasInit(SDL2::SDL_INIT_VIDEO) == 0
+   err = SDL2.SDL_Init(SDL2::SDL_INIT_VIDEO)
+   raise "SDL_Init: ${SDL2.SDL_GetError}" if err != 0
+  end
+
+  Image.init
+  Font.init
+
+  @@inited = true
+
+  # TODO: set font size more dynamically?
+  @@default_font = EZDraw::Font.new(gem_relative_path("res/AnonymousPro-Regular.ttf"), 20)
+  nil
+ end
+
+ def self.default_font
+  requires_init
+  @@default_font
+ end
+
+ def self.inited
+  @@inited == true
+ end
+
+ def self.requires_init
+  raise "EZDraw is not initialized. first call EZDraw.init" if not inited
+ end
+
+ def self.cleanup
+  requires_init
+  Font.cleanup
+  Image.cleanup
+  Window.cleanup
+  SDL2.SDL_Quit
+  @@inited = false
+  nil
+ end
+
+ def self.delay(msec)
+  requires_init
+  SDL2.SDL_Delay(msec)
+  nil
+ end
+
+ # this version eats all events while waiting for a key
+ #def self.waitkey_gluttonous
+  #loop do
+   #ev_p = FFI::MemoryPointer.new SDL2::SDL_Event, 1, false
+   #ev = SDL2::SDL_Event.new ev_p
+   #SDL2.SDL_WaitEvent(ev_p)
+   #break if ev[:type] == SDL2::SDL_KEYDOWN
+  #end
+ #end
+
+ # this version cherry-picks keyboard events from the queue
+ def self.waitkey
+  requires_init
+  ev_p = FFI::MemoryPointer.new SDL2::SDL_Event, 1, false
+  ev = SDL2::SDL_Event.new ev_p
+  #cev = SDL2::SDL_CommonEvent.new ev_p
+
+  loop do
+   nev = SDL2.SDL_PeepEvents(ev_p, 1, SDL2::SDL_GETEVENT, SDL2::SDL_KEYDOWN, SDL2::SDL_KEYUP)
+
+   raise "error: peepevents" if nev < 0
+   if nev == 0
+    SDL2.SDL_PumpEvents
+    delay 1
+    next
+   end
+
+   #EZDraw.logger.debug("0x#{ev[:common][:type].to_s(16)}")
+   if ev[:common][:type] == SDL2::SDL_KEYDOWN
+    return SDL2.SDL_GetKeyName(ev[:key][:keysym][:keycode]).to_s
+   end
+  end
+ end
+
+ class Window
+  @@instances = []
+
+  def initialize(size=:default, title=:default, *opts)
+   EZDraw.requires_init
+
+   if size == :default
+    # TODO: use SDL's GetCurrentDisplayMode and make default proportional (30% ?) the size of screen
+    w = h = 500
+   else
+    w, h = size
+   end
+
+   if title == :default
+    title = $PROGRAM_NAME
+   end
+
+   # TODO: couldn't find an elegant way to put this option in the interface
+   # perhaps kv args? but then how to pass fullscreen?
+   x = y = SDL2::SDL_WINDOWPOS_UNDEFINED
+
+   wflags = 0
+   wflags |= SDL2::SDL_WINDOW_FULLSCREEN if opts.include? :fullscreen
+
+   @win = SDL2.SDL_CreateWindow(title, x, y, w, h, wflags)
+
+   # TODO: add renderer options to interface
+   # eg. :software, :accelerated, :vsync
+   @ren = SDL2.SDL_CreateRenderer(@win, -1, SDL2::SDL_RENDERER_ACCELERATED | SDL2::SDL_RENDERER_TARGETTEXTURE)
+
+   sz = get_window_size
+   rinfo = get_renderer_info
+   @buf = SDL2::SDL_CreateTexture(@ren, rinfo[:texture_formats][0],
+                                  SDL2::SDL_TEXTUREACCESS_TARGET, sz[0], sz[1])
+   SDL2.SDL_SetRenderTarget(@ren, @buf)
+
+   @fill = White
+   @stroke = Black
+   @font = EZDraw::default_font
+   @dc_stack = []
+
+   self.render_draw_color = fill
+   SDL2.SDL_RenderClear(@ren)
+
+   auto_update(true)
+
+   # finalizer
+   @dflag = [false]
+   ObjectSpace.define_finalizer(self, proc {|id|
+    self.class._destroy(@win, @ren, @buf, @dflag)
+   })
+   @@instances << self
+  end
+
+  def self._destroy(win, ren, buf, dflag)
+   if dflag[0]
+    #EZDraw.logger.debug("(already destroyed window #{win})")
+    return
+   end
+   EZDraw.logger.debug("destroy window #{win}")
+
+   SDL2.SDL_DestroyTexture(buf)
+   SDL2.SDL_DestroyRenderer(ren)
+   SDL2.SDL_DestroyWindow(win)
+   dflag[0] = true
+  end
+
+  def close
+   self.class._destroy(@win, @ren, @buf, @dflag)
+  end 
+
+  def self.cleanup
+   EZDraw.requires_init
+   @@instances.each {|win| win.close}
+   @@instances = []
+  end
+
+  # NOTE: these accessors are to circumvent the method/local-variable ambiguity
+  # that results with "stroke = color", and thus needs to be "self.stroke = color"
+  # however...
+  def stroke(color=nil)
+   color ? @stroke=color : @stroke
+  end
+
+  def fill(color=nil)
+   color ? @fill=color : @fill
+  end
+
+  def font(fnt=nil)
+   fnt ? @font=fnt : @font
+  end
+
+  # ...however, traditional foo= writers are also provided
+  attr_writer :fill, :stroke, :font
+
+  def push_context
+   @dc_stack.push([@stroke.clone, @fill.clone, @font, @auto_update])
+  end
+
+  def pop_context
+   raise "dc stack empty" if @dc_stack.length == 0
+   @stroke, @fill, @font, auto_up = @dc_stack.pop
+   auto_update(auto_up)
+  end
+
+  def get_window_size
+   p_w = FFI::MemoryPointer.new :int
+   p_h = FFI::MemoryPointer.new :int
+   SDL2.SDL_GetWindowSize(@win, p_w, p_h)
+   [p_w.get_int(0), p_h.get_int(0)]
+  end
+
+  def width
+   get_window_size[0]
+  end
+
+  def height
+   get_window_size[1]
+  end
+
+  def get_renderer_info
+   p_rinfo = FFI::MemoryPointer.new :uint8, SDL2::SDL_RendererInfo.size, false
+   SDL2::SDL_GetRendererInfo(@ren, p_rinfo)
+   rinfo = SDL2::SDL_RendererInfo.new p_rinfo
+  end
+  private :get_renderer_info
+
+  def render_draw_color
+   pr = FFI::MemoryPointer.new :uint8
+   pg = FFI::MemoryPointer.new :uint8
+   pb = FFI::MemoryPointer.new :uint8
+   pa = FFI::MemoryPointer.new :uint8
+   SDL2::SDL_GetRenderDrawColor(@ren, pr, pg, pb, pa)
+   [pr.get_uint8(0), pg.get_uint8(0), pb.get_uint8(0), pa.get_uint8(0)]
+  end
+  private :render_draw_color
+
+  def render_draw_color=(rgba)
+   SDL2::SDL_SetRenderDrawColor(@ren, rgba[0], rgba[1], rgba[2], rgba[3])
+  end
+  private :render_draw_color=
+
+  def clear
+   self.render_draw_color = fill
+   SDL2.SDL_RenderClear(@ren)
+   need_update
+  end
+
+  def line(x0, y0, x1, y1)
+   SDL2::Gfx.lineRGBA(@ren, x0, y0, x1, y1, stroke[0], stroke[1], stroke[2], stroke[3])
+   need_update
+  end
+
+  def rect(x0, y0, x1, y1)
+   SDL2::Gfx.boxRGBA(@ren, x0, y0, x1, y1, fill[0], fill[1], fill[2], fill[3])
+   SDL2::Gfx.rectangleRGBA(@ren, x0, y0, x1, y1, stroke[0], stroke[1], stroke[2], stroke[3])
+  end
+
+  def circle(x, y, r)
+   SDL2::Gfx.filledCircleRGBA(@ren, x, y, r, fill[0], fill[1], fill[2], fill[3])
+   SDL2::Gfx.circleRGBA(@ren, x, y, r, stroke[0], stroke[1], stroke[2], stroke[3])
+   need_update
+  end
+
+  # x,y => draw location (or...)
+  # x,y => src_rect, dst_rect arrays
+  def text(x, y, text)
+   sfc = @font.render(text, stroke)
+   tex = SDL2.SDL_CreateTextureFromSurface(@ren, sfc)
+
+   w_p = FFI::MemoryPointer.new :int, 1, false
+   h_p = FFI::MemoryPointer.new :int, 1, false
+   err = SDL2.SDL_QueryTexture(tex, nil, nil, w_p, h_p)
+   raise "SDL_QueryTexture: #{SDL2::SDL_GetError}" if err != 0
+
+   r = SDL2::SDL_Rect.new
+   r[:x] = x
+   r[:y] = y
+   r[:w] = w_p.get_int(0)
+   r[:h] = h_p.get_int(0)
+   SDL2.SDL_RenderCopy(@ren, tex, nil, r)
+   need_update
+  end
+
+  def self.parse_rect(r)
+  end
+
+  def image(x, y, img)
+
+   if img.is_a? String
+    img = Image.new(img)
+   end
+
+   sfc = img.instance_exec {self.sfc}
+
+   tex = SDL2.SDL_CreateTextureFromSurface(@ren, sfc)
+   #w_p = FFI::MemoryPointer.new :int, 1, false
+   #h_p = FFI::MemoryPointer.new :int, 1, false
+   #err = SDL2.SDL_QueryTexture(tex, nil, nil, w_p, h_p)
+   #raise "SDL_QueryTexture: #{SDL2::SDL_GetError}" if err != 0
+   #img_w, img_h = w_p.get_int(0), h_p.get_int(0)
+
+   src_r = dst_r = nil 
+ 
+   if x.is_a? Numeric
+    dst_r = SDL2::SDL_Rect.new
+    dst_r[:x], dst_r[:y], dst_r[:w], dst_r[:h] = x, y, img.width, img.height
+   else
+    if x.is_a? Array
+     src_r = SDL2::SDL_Rect.new
+     src_r[:x], src_r[:y], src_r[:w], src_r[:h] = x[0], x[1], img.width, img.height
+     src_r[:w], src_r[:h] = x[2], x[3] if x.length == 4
+    end
+
+    if y.is_a? Array
+     dst_r = SDL2::SDL_Rect.new
+     dst_r[:x], dst_r[:y], dst_r[:w], dst_r[:h] = y[0], y[1], img.width, img.height
+     dst_r[:w], dst_r[:h] = y[2], y[3] if y.length == 4
+    end 
+  end
+
+   SDL2.SDL_RenderCopy(@ren, tex, src_r, dst_r)
+
+   # BUG: cleanup after exception
+   SDL2.SDL_DestroyTexture(tex)
+   need_update
+  end
+
+  def auto_update?
+   @auto_update
+  end
+
+  def auto_update(enable_p)
+   # force an update if enabling auto
+   update if enable_p and not @auto_update
+
+   @auto_update = enable_p
+  end
+
+  def auto_update=(enable_p)
+   auto_update(enable_p)
+  end
+
+  # draw all simultaneously and update at the end
+  # BUG: should nest but doesn't
+  # BUG: if the block meddles with auto_update, the contract fails
+  # perhaps an auto_update override-lock mechanism to fix this?
+  def draw(&block)
+   auto_update(false)
+   block.call
+   auto_update(true)
+  end
+
+  def need_update
+   @need_update = true
+   update if auto_update?
+  end
+
+  def update
+   return if not @need_update
+   SDL2.SDL_SetRenderTarget(@ren, nil)
+   SDL2.SDL_RenderCopy(@ren, @buf, nil, nil)
+   SDL2.SDL_RenderPresent(@ren)
+   SDL2.SDL_SetRenderTarget(@ren, @buf)
+   @need_update = false
+  end
+
+ end
+
+ class Image
+  @@instances = []
+
+  def initialize(img_filename)
+   EZDraw.requires_init
+ 
+   @sfc = SDL2::Image.IMG_Load(img_filename)
+   raise "IMG_Load: #{SDL2::Image.IMG_GetError}" if @sfc.null?
+
+   @dflag = [false] #shared-changable
+   ObjectSpace.define_finalizer(self, proc {|id|
+    self.class._destroy(@sfc, @dflag)
+   })
+   
+   @@instances << self
+  end
+
+  attr_reader :sfc
+
+  def self.init
+   iflags = SDL2::Image::IMG_INIT_JPG |
+	    SDL2::Image::IMG_INIT_PNG |
+	    SDL2::Image::IMG_INIT_TIF
+   oflags = SDL2::Image.IMG_Init(iflags)
+   raise "IMG_Init: #{SDL2::Image.IMG_GetError}" if (oflags & iflags) != iflags
+  end
+
+  def self.cleanup
+   EZDraw.requires_init
+   @@instances.each {|img| img.close}
+   @@instances = []
+   SDL2::Image.IMG_Quit
+  end
+
+  def self._destroy(sfc, dflag)
+   if dflag[0]
+    #EZDraw.logger.debug "(already destroyed image #{sfc})"
+    return
+   end
+   EZDraw.logger.debug "destroy image #{sfc}"
+
+   SDL2.SDL_FreeSurface(sfc)
+   dflag[0] = true
+  end
+
+  def close
+   self.class._destroy(@sfc, @dflag)
+  end
+
+  def width
+   @sfc[:w]
+  end
+
+  def height
+   @sfc[:h]
+  end
+ end
+
+ class Font
+  @@instances = []
+
+  # TODO: better API to distinguish between unsized "typeface" and sized "font"?
+  def initialize(ttf_filename, ptheight)
+   EZDraw.requires_init
+
+   @font = SDL2::Ttf.TTF_OpenFont(ttf_filename, ptheight)
+   raise "TTF_OpenFont: #{SDL2::Ttf.TTF_GetError}" if @font.null? 
+
+   # wrapping in array to make changes shared by all references
+   @destroyed_flag = [false]
+   ObjectSpace.define_finalizer(self, proc {|id|
+    self.class.class._destroy(@font, @destroyed_flag)
+   })
+
+   @@instances << self
+  end
+
+  def self.init
+   if SDL2::Ttf.TTF_WasInit == 0
+    err = SDL2::Ttf.TTF_Init
+    raise "TTF_Init: #{SDL2::Ttf.TTF_GetError}" if err != 0
+   end
+  end
+
+  def self.cleanup
+   EZDraw.requires_init
+
+   # destroy instances explicitly
+   # to prevent finalizers from double-destroying after TTF_Quit
+   @@instances.each {|font| font.close}
+   @@instances = []
+   SDL2::Ttf.TTF_Quit
+  end
+
+  def self._destroy(font, destroyed_flag)
+   if destroyed_flag[0]
+    #EZDraw.logger.debug "(already destroyed font #{font})"
+    return
+   end
+
+   EZDraw.logger.debug "destroy font #{font}"
+   SDL2::Ttf.TTF_CloseFont(font)
+   destroyed_flag[0] = true
+  end
+
+  def close
+   self.class._destroy(@font, @destroyed_flag)
+  end
+
+  def height
+   # BUG: methods should check whether font was destroyed
+   SDL2::Ttf.TTF_FontHeight(@font)
+  end
+
+  def line_pitch
+   SDL2::Ttf.TTF_FontLineSkip(@font)
+  end
+
+
+  attr_reader :font
+
+  def render_utf8(text, color)
+   c = SDL2::SDL_Color.new 
+   c[:r] = color[0]
+   c[:g] = color[1]
+   c[:b] = color[2]
+   c[:a] = color[3]
+   sfc = SDL2::Ttf.TTF_RenderUTF8_Solid(@font, text, c)
+  end
+
+  alias render render_utf8
+ end
+
+ module DSL
+  # BUG: this should be per-including-instance
+  @@win = nil
+
+  def self.included(base)
+   EZDraw.constants.each {|c|
+    EZDraw.logger.debug("#{base}.const_set #{c}")
+    base.const_set c, EZDraw.const_get(c)
+   }
+  end
+
+  def init(*opts)
+   EZDraw.init
+   @@win = EZDraw::Window.new(*opts)
+  end
+
+  def cleanup
+   EZDraw.requires_init
+   @@win = nil
+   EZDraw.cleanup
+  end
+
+  def method_missing(name, *args, &block)
+   delegates = [EZDraw, @@win]
+   delg = delegates.find {|delg_i| delg_i.respond_to?(name)}
+   delg ? delg.public_send(name, *args, &block) : super
+  end
+
+  def const_missing(name)
+   raise "const #{name}"
+  end
+
+ end
+
+end

data/lib/sdl2.rb

@@ -0,0 +1,393 @@
+require 'ffi'
+
+module SDL2
+ module EnumUtil
+  # enum_consts
+  # convenient like FFI's enum
+  # but creates the symbols as normal consts
+  # which I believe is more natural to ruby
+
+  def enum_consts *args
+   pname = nil
+   value = 1
+
+   args.each do |arg|
+
+    if arg.is_a? Symbol
+     if pname
+      #puts "const_set #{pname} = #{value}"
+      const_set(pname, value)
+      pname = nil
+      value += 1
+     end
+     pname = arg
+  
+    elsif arg.is_a? Integer
+     if pname
+      value = arg
+      #puts "const_set #{pname} = #{value}"
+      const_set(pname, value)
+      pname = nil
+      value += 1
+     else
+      raise "unexpected integer without preceeding name"
+     end
+    end
+
+   end # do
+
+   if pname
+    #puts "const_set #{pname} = #{value}"
+    const_set(pname, value)
+   end
+
+  end
+ end
+end
+
+module SDL2
+ extend FFI::Library
+ ffi_lib "libSDL2"
+
+ extend SDL2::EnumUtil
+
+ ## INIT
+ attach_function :SDL_Init, [:uint32], :int
+ attach_function :SDL_Quit, [], :void
+ attach_function :SDL_WasInit, [:uint32], :uint32
+
+ attach_function :SDL_GetError, [], :string
+
+ SDL_INIT_TIMER          = 0x00000001
+ SDL_INIT_AUDIO          = 0x00000010
+ SDL_INIT_VIDEO          = 0x00000020  # SDL_INIT_VIDEO implies SDL_INIT_EVENTS
+ SDL_INIT_JOYSTICK       = 0x00000200  # SDL_INIT_JOYSTICK implies SDL_INIT_EVENTS
+ SDL_INIT_HAPTIC         = 0x00001000
+ SDL_INIT_GAMECONTROLLER = 0x00002000  # SDL_INIT_GAMECONTROLLER implies SDL_INIT_JOYSTICK
+ SDL_INIT_EVENTS         = 0x00004000
+ SDL_INIT_NOPARACHUTE    = 0x00100000  # Don't catch fatal signals
+ SDL_INIT_EVERYTHING     =  SDL_INIT_TIMER | SDL_INIT_AUDIO | SDL_INIT_VIDEO | SDL_INIT_EVENTS | \
+                            SDL_INIT_JOYSTICK | SDL_INIT_HAPTIC | SDL_INIT_GAMECONTROLLER
+
+ 
+ # UTIL
+ attach_function :SDL_Delay, [:uint32], :void
+
+
+ # EVENT
+
+ class SDL_CommonEvent < FFI::Struct
+  layout \
+   :type, :uint32,
+   :timestame, :uint32
+  end
+
+ class SDL_Keysym < FFI::Struct
+  layout \
+   :scancode, :int, #enum
+   :keycode, :int, #enum
+   :mode, :uint16,
+   :unused, :uint32
+ end
+
+ # could all event structs inherit from CommonEvent?
+ class SDL_KeyboardEvent < FFI::Struct
+  layout \
+   :type, :uint32,
+   :timestamp, :uint32,
+   :windowID, :uint32,
+   :state, :uint8,
+   :repeat, :uint8,
+   :keysym, SDL_Keysym
+ end
+
+ class SDL_Event < FFI::Union
+  layout \
+   :common, SDL_CommonEvent,
+   # SDL_CommonEvent common;         /**< Common event data */
+   # SDL_WindowEvent window;         /**< Window event data */
+   :key, SDL_KeyboardEvent,
+   # SDL_TextEditingEvent edit;      /**< Text editing event data */
+   # SDL_TextInputEvent text;        /**< Text input event data */
+   # SDL_MouseMotionEvent motion;    /**< Mouse motion event data */
+   # SDL_MouseButtonEvent button;    /**< Mouse button event data */
+    #SDL_MouseWheelEvent wheel;      /**< Mouse wheel event data */
+    #SDL_JoyAxisEvent jaxis;         /**< Joystick axis event data */
+    #SDL_JoyBallEvent jball;         /**< Joystick ball event data */
+    #SDL_JoyHatEvent jhat;           /**< Joystick hat event data */
+    #SDL_JoyButtonEvent jbutton;     /**< Joystick button event data */
+    #SDL_JoyDeviceEvent jdevice;     /**< Joystick device change event data */
+    #SDL_ControllerAxisEvent caxis;      /**< Game Controller axis event data */
+    #SDL_ControllerButtonEvent cbutton;  /**< Game Controller button event data */
+    #SDL_ControllerDeviceEvent cdevice;  /**< Game Controller device event data */
+    #SDL_QuitEvent quit;             /**< Quit request event data */
+    #SDL_UserEvent user;             /**< Custom event data */
+    #SDL_SysWMEvent syswm;           /**< System dependent window event data */
+    #SDL_TouchFingerEvent tfinger;   /**< Touch finger event data */
+    #SDL_MultiGestureEvent mgesture; /**< Gesture event data */
+    #SDL_DollarGestureEvent dgesture; /**< Gesture event data */
+    #SDL_DropEvent drop;             /**< Drag and drop event data */
+
+   :padding, [:uint8, 56]
+ end
+
+ typedef :pointer, :SDL_Event_out
+ typedef :int, :SDL_eventaction
+ attach_function :SDL_PeepEvents, [:SDL_Event_out, :int, :SDL_eventaction, :uint32, :uint32], :int
+ attach_function :SDL_PollEvent, [:SDL_Event_out], :int
+ attach_function :SDL_WaitEvent, [:SDL_Event_out], :int
+ attach_function :SDL_PumpEvents, [], :void
+
+ #### enum SDL_EventType
+
+ enum_consts \
+  :SDL_FIRSTEVENT,     0,    # Unused (do not remove)
+
+ # Application events
+  :SDL_QUIT,           0x100, # User-requested quit
+
+ # These application events have special meaning on iOS, see README-ios.txt for details
+  :SDL_APP_TERMINATING,         0x101, # The application is being terminated by the OS
+  :SDL_APP_LOWMEMORY,                  # The application is low on memory, free memory if possible.
+  :SDL_APP_WILLENTERBACKGROUND,        # The application is about to enter the background
+  :SDL_APP_DIDENTERBACKGROUND,         # The application did enter the background and may not get CPU for some time
+  :SDL_APP_WILLENTERFOREGROUND,        # The application is about to enter the foreground
+  :SDL_APP_DIDENTERFOREGROUND,         # The application is now interactive
+
+ # Window events
+  :SDL_WINDOWEVENT, 0x200, # Window state change
+  :SDL_SYSWMEVENT,         # System specific event
+
+ # Keyboard events
+  :SDL_KEYDOWN,     0x300, # Key pressed
+  :SDL_KEYUP,              # Key released
+  :SDL_TEXTEDITING,        # Keyboard text editing (composition)
+  :SDL_TEXTINPUT,          # Keyboard text input
+
+ # Mouse events
+  :SDL_MOUSEMOTION,  0x400, # Mouse moved
+  :SDL_MOUSEBUTTONDOWN,     # Mouse button pressed
+  :SDL_MOUSEBUTTONUP,       # Mouse button released
+  :SDL_MOUSEWHEEL,          # Mouse wheel motion
+
+ # Joystick events
+  :SDL_JOYAXISMOTION,   0x600, # Joystick axis motion
+  :SDL_JOYBALLMOTION,          # Joystick trackball motion
+  :SDL_JOYHATMOTION,           # Joystick hat position change
+  :SDL_JOYBUTTONDOWN,          # Joystick button pressed
+  :SDL_JOYBUTTONUP,            # Joystick button released
+  :SDL_JOYDEVICEADDED,         # A new joystick has been inserted into the system
+  :SDL_JOYDEVICEREMOVED,       # An opened joystick has been removed
+
+ # Game controller events
+  :SDL_CONTROLLERAXISMOTION,   0x650, # Game controller axis motion
+  :SDL_CONTROLLERBUTTONDOWN,          # Game controller button pressed
+  :SDL_CONTROLLERBUTTONUP,            # Game controller button released
+  :SDL_CONTROLLERDEVICEADDED,         # A new Game controller has been inserted into the system
+  :SDL_CONTROLLERDEVICEREMOVED,       # An opened Game controller has been removed
+  :SDL_CONTROLLERDEVICEREMAPPED,      # The controller mapping was updated
+
+ # Touch events
+  :SDL_FINGERDOWN,            0x700,
+  :SDL_FINGERUP,
+  :SDL_FINGERMOTION,
+
+  :SDL_DOLLARGESTURE,         0x800,
+  :SDL_DOLLARRECORD,
+  :SDL_MULTIGESTURE,
+
+  :SDL_CLIPBOARDUPDATE,       0x900, # The clipboard changed
+  :SDL_DROPFILE,              0x1000, # The system requests a file open
+  :SDL_RENDER_TARGETS_RESET,  0x2000, # The render targets have been reset
+
+  :SDL_USEREVENT,   0x8000,
+  :SDL_LASTEVENT,   0xFFFF
+ 
+ #### enum SDL_eventaction
+ enum_consts \
+  :SDL_ADDEVENT,    0,
+  :SDL_PEEKEVENT,
+  :SDL_GETEVENT
+
+ # KEYBOARD
+ typedef :int, :SDL_Keycode
+ attach_function :SDL_GetKeyName, [:SDL_Keycode], :string
+
+ # VIDEO
+ typedef :pointer, :SDL_Window
+ typedef :pointer, :SDL_Window_out
+ typedef :pointer, :SDL_Renderer
+ typedef :pointer, :SDL_Renderer_out
+ typedef :pointer, :SDL_Surface
+ typedef :pointer, :SDL_Texture
+ typedef :pointer, :SDL_RendererInfo_out
+ typedef :pointer, :uint32_out
+ typedef :pointer, :uint8_out
+ typedef :pointer, :int_out
+
+ class SDL_RendererInfo < FFI::Struct
+  layout :name, :string,
+         :flags, :uint32,
+         :num_texture_formats, :uint32,
+         :texture_formats, [:uint32, 16],
+         :max_texture_width, :int,
+         :max_texture_height, :int
+ end
+
+ class SDL_Color < FFI::Struct
+  layout \
+   :r, :uint8,
+   :g, :uint8,
+   :b, :uint8,
+   :a, :uint8
+ end
+
+ class SDL_Rect < FFI::Struct
+  layout \
+   :x, :int,
+   :y, :int,
+   :w, :uint,
+   :h, :uint
+ end
+
+ class SDL_Surface < FFI::Struct
+  layout \
+   :flags, :uint32,
+   :format, :pointer,
+   :w, :int,
+   :h, :int,
+   :pitch, :int,
+   :pixels, :pointer,
+   :userdata, :pointer,
+   :_locked, :int,
+   :_lock_data, :pointer,
+   :clip_rect, SDL_Rect,
+   :map, :pointer,
+   :refcount, :int
+ end
+
+
+
+ attach_function :SDL_CreateWindow, [:string, :int,:int, :int,:int, :uint32], :SDL_Window
+ attach_function :SDL_GetWindowSize, [:SDL_Window, :int_out, :int_out], :void
+ attach_function :SDL_DestroyWindow, [:SDL_Window], :void
+
+ attach_function :SDL_CreateRenderer, [:SDL_Window, :int, :uint32], :SDL_Renderer
+ attach_function :SDL_DestroyRenderer, [:SDL_Renderer], :void
+
+ attach_function :SDL_CreateWindowAndRenderer, [:int, :int, :uint32, \
+                                                :SDL_Window_out, :SDL_Renderer_out], :int
+
+ attach_function :SDL_CreateTexture, [:SDL_Renderer, :uint32, :int, :int, :int], :SDL_Texture
+ attach_function :SDL_CreateTextureFromSurface, [:SDL_Renderer, :SDL_Surface], :SDL_Texture
+ attach_function :SDL_QueryTexture, [:SDL_Texture, :uint32_out, :int_out, :int_out, :int_out], :int
+ attach_function :SDL_FreeSurface, [:SDL_Surface], :void
+ attach_function :SDL_DestroyTexture, [:SDL_Texture], :void
+
+ attach_function :SDL_GetRendererInfo, [:SDL_Renderer, :SDL_RendererInfo_out], :int
+ attach_function :SDL_RenderCopy, [:SDL_Renderer, :SDL_Texture, SDL_Rect, SDL_Rect], :int
+ attach_function :SDL_RenderClear, [:SDL_Renderer], :int
+ attach_function :SDL_RenderPresent, [:SDL_Renderer], :void
+ attach_function :SDL_SetRenderTarget, [:SDL_Renderer, :SDL_Texture], :int
+
+ attach_function :SDL_GetRenderDrawColor, [:SDL_Renderer, :uint8_out,:uint8_out,:uint8_out,:uint8_out], :int
+ attach_function :SDL_SetRenderDrawColor, [:SDL_Renderer, :uint8,:uint8,:uint8,:uint8], :int
+
+ SDL_WINDOWPOS_UNDEFINED  = 0x1FFF0000
+ SDL_WINDOWPOS_CENTERED   = 0x2FFF0000
+
+ SDL_WINDOW_FULLSCREEN    = 0x00000001         # fullscreen window 
+ SDL_WINDOW_OPENGL        = 0x00000002             # window usable with OpenGL context 
+ SDL_WINDOW_SHOWN         = 0x00000004              # window is visible 
+ SDL_WINDOW_HIDDEN        = 0x00000008             # window is not visible 
+ SDL_WINDOW_BORDERLESS    = 0x00000010         # no window decoration 
+ SDL_WINDOW_RESIZABLE     = 0x00000020          # window can be resized 
+ SDL_WINDOW_MINIMIZED     = 0x00000040          # window is minimized 
+ SDL_WINDOW_MAXIMIZED     = 0x00000080          # window is maximized 
+ SDL_WINDOW_INPUT_GRABBED = 0x00000100      # window has grabbed input focus 
+ SDL_WINDOW_INPUT_FOCUS   = 0x00000200        # window has input focus 
+ SDL_WINDOW_MOUSE_FOCUS   = 0x00000400        # window has mouse focus 
+ SDL_WINDOW_FULLSCREEN_DESKTOP = SDL_WINDOW_FULLSCREEN | 0x00001000
+ SDL_WINDOW_FOREIGN       = 0x00000800        # window not created by SDL 
+ SDL_WINDOW_ALLOW_HIGHDPI = 0x00002000        # window should be created in high-DPI mode if supported 
+
+ SDL_RENDERER_SOFTWARE     = 0x00000001,     # The renderer is a software fallback
+ SDL_RENDERER_ACCELERATED  = 0x00000002,     # The renderer uses hardware acceleration
+ SDL_RENDERER_PRESENTVSYNC = 0x00000004,     # Present is synchronized with the refresh rate
+ SDL_RENDERER_TARGETTEXTURE = 0x00000008     # The renderer supports rendering to texture
+
+ enum_consts \
+ :SDL_TEXTUREACCESS_STATIC,     0, # Changes rarely, not lockable
+ :SDL_TEXTUREACCESS_STREAMING,     # Changes frequently, lockable
+ :SDL_TEXTUREACCESS_TARGET        # Texture can be used as a render target
+end
+
+module SDL2
+ module Gfx 
+  extend FFI::Library
+  ffi_lib "libSDL2_gfx"
+  attach_function :lineRGBA, [:pointer, :int16,:int16,:int16,:int16, :uint8,:uint8,:uint8,:uint8], :int
+  attach_function :rectangleRGBA, [:pointer, :int16,:int16,:int16,:int16, :uint8,:uint8,:uint8,:uint8], :int
+  attach_function :boxRGBA,       [:pointer, :int16,:int16,:int16,:int16, :uint8,:uint8,:uint8,:uint8], :int
+  attach_function :circleRGBA,       [:pointer, :int16,:int16,:int16, :uint8,:uint8,:uint8,:uint8], :int
+  attach_function :filledCircleRGBA, [:pointer, :int16,:int16,:int16, :uint8,:uint8,:uint8,:uint8], :int
+ end
+end
+
+module SDL2
+ module Image
+  extend FFI::Library
+  ffi_lib "libSDL2_image"
+
+  extend SDL2::EnumUtil
+
+  typedef :pointer, :SDL_Surface
+
+  attach_function :IMG_Init, [:int], :int
+  attach_function :IMG_Quit, [], :void
+  attach_function :IMG_Load, [:string], SDL2::SDL_Surface.by_ref
+
+  def self.IMG_GetError
+   SDL2.SDL_GetError
+  end
+  
+  enum_consts \
+   :IMG_INIT_JPG,  0x00000001,
+   :IMG_INIT_PNG,  0x00000002,
+   :IMG_INIT_TIF,  0x00000004,
+   :IMG_INIT_WEBP, 0x00000008
+ end
+end
+
+module SDL2
+ module Ttf
+  extend FFI::Library
+  ffi_lib "libSDL2_ttf"
+
+  attach_function :TTF_Init, [], :int
+  attach_function :TTF_WasInit, [], :int
+  attach_function :TTF_Quit, [], :void
+
+  def self.TTF_GetError
+   SDL2.SDL_GetError
+  end
+
+  typedef :pointer, :TTF_Font
+  attach_function :TTF_OpenFont, [:string, :int], :TTF_Font
+  attach_function :TTF_CloseFont, [:TTF_Font], :void
+
+  typedef :pointer, :SDL_Surface
+  typedef :pointer, :int_out
+  attach_function :TTF_RenderText_Solid, [:TTF_Font, :string, SDL_Color.by_value], :SDL_Surface
+  attach_function :TTF_SizeText, [:TTF_Font, :string, :int_out, :int_out], :int
+
+  attach_function :TTF_RenderUTF8_Solid, [:TTF_Font, :string, SDL_Color.by_value], :SDL_Surface
+  attach_function :TTF_SizeUTF8, [:TTF_Font, :string, :int_out, :int_out], :int
+
+  attach_function :TTF_FontHeight, [:TTF_Font], :int
+  attach_function :TTF_FontLineSkip, [:TTF_Font], :int
+  attach_function :TTF_FontAscent, [:TTF_Font], :int
+  attach_function :TTF_FontDescent, [:TTF_Font], :int
+ end
+end
+

data/res/LICENSE

@@ -0,0 +1,93 @@
+Copyright (c) 2009, Mark Simonson (http://www.ms-studio.com, mark@marksimonson.com),
+with Reserved Font Name Anonymous Pro.
+This Font Software is licensed under the SIL Open Font License, Version 1.1.
+This license is copied below, and is also available with a FAQ at:
+http://scripts.sil.org/OFL
+
+
+-----------------------------------------------------------
+SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
+-----------------------------------------------------------
+
+PREAMBLE
+The goals of the Open Font License (OFL) are to stimulate worldwide
+development of collaborative font projects, to support the font creation
+efforts of academic and linguistic communities, and to provide a free and
+open framework in which fonts may be shared and improved in partnership
+with others.
+
+The OFL allows the licensed fonts to be used, studied, modified and
+redistributed freely as long as they are not sold by themselves. The
+fonts, including any derivative works, can be bundled, embedded, 
+redistributed and/or sold with any software provided that any reserved
+names are not used by derivative works. The fonts and derivatives,
+however, cannot be released under any other type of license. The
+requirement for fonts to remain under this license does not apply
+to any document created using the fonts or their derivatives.
+
+DEFINITIONS
+"Font Software" refers to the set of files released by the Copyright
+Holder(s) under this license and clearly marked as such. This may
+include source files, build scripts and documentation.
+
+"Reserved Font Name" refers to any names specified as such after the
+copyright statement(s).
+
+"Original Version" refers to the collection of Font Software components as
+distributed by the Copyright Holder(s).
+
+"Modified Version" refers to any derivative made by adding to, deleting,
+or substituting -- in part or in whole -- any of the components of the
+Original Version, by changing formats or by porting the Font Software to a
+new environment.
+
+"Author" refers to any designer, engineer, programmer, technical
+writer or other person who contributed to the Font Software.
+
+PERMISSION & CONDITIONS
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of the Font Software, to use, study, copy, merge, embed, modify,
+redistribute, and sell modified and unmodified copies of the Font
+Software, subject to the following conditions:
+
+1) Neither the Font Software nor any of its individual components,
+in Original or Modified Versions, may be sold by itself.
+
+2) Original or Modified Versions of the Font Software may be bundled,
+redistributed and/or sold with any software, provided that each copy
+contains the above copyright notice and this license. These can be
+included either as stand-alone text files, human-readable headers or
+in the appropriate machine-readable metadata fields within text or
+binary files as long as those fields can be easily viewed by the user.
+
+3) No Modified Version of the Font Software may use the Reserved Font
+Name(s) unless explicit written permission is granted by the corresponding
+Copyright Holder. This restriction only applies to the primary font name as
+presented to the users.
+
+4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
+Software shall not be used to promote, endorse or advertise any
+Modified Version, except to acknowledge the contribution(s) of the
+Copyright Holder(s) and the Author(s) or with their explicit written
+permission.
+
+5) The Font Software, modified or unmodified, in part or in whole,
+must be distributed entirely under this license, and must not be
+distributed under any other license. The requirement for fonts to
+remain under this license does not apply to any document created
+using the Font Software.
+
+TERMINATION
+This license becomes null and void if any of the above conditions are
+not met.
+
+DISCLAIMER
+THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
+OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
+COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
+DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
+OTHER DEALINGS IN THE FONT SOFTWARE.

metadata

@@ -0,0 +1,51 @@
+--- !ruby/object:Gem::Specification
+name: ezdraw
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Devin Landes
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-05-01 00:00:00.000000000 Z
+dependencies: []
+description: 
+email: devinlandes@users.noreply.github.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/ezdraw.rb
+- lib/sdl2.rb
+- res/AnonymousPro-Regular.ttf
+- res/Glossy_3d_blue_star_scratched.png
+- res/LICENSE
+- examples/test.rb
+- examples/test_dsl.rb
+- examples/trivial.rb
+homepage: https://github.com/devinlandes/ruby-ezdraw
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.14
+signing_key: 
+specification_version: 4
+summary: Simple Processing-esq Drawing API
+test_files: []