gosu 1.4.6 → 2.0.0.pre6

data/lib/gosu/gl_tex_info.rb

@@ -0,0 +1,33 @@
+module Gosu
+  class GLTexInfo < FFI::ManagedStruct
+    layout :tex_name, :uint32,
+           :left, :double,
+           :right, :double,
+           :top, :double,
+           :bottom, :double
+
+    def tex_name
+      self[:tex_name]
+    end
+
+    def left
+      self[:left]
+    end
+
+    def right
+      self[:right]
+    end
+
+    def top
+      self[:top]
+    end
+
+    def bottom
+      self[:bottom]
+    end
+
+    def self.release(pointer)
+      GosuFFI.Gosu_Image_gl_tex_info_destroy(pointer)
+    end
+  end
+end

data/lib/gosu/gosu.rb

@@ -0,0 +1,210 @@
+module Gosu
+  def self.fps
+    GosuFFI.check_last_error(GosuFFI.Gosu_fps())
+  end
+
+  def self.flush
+    GosuFFI.Gosu_flush()
+    GosuFFI.check_last_error
+  end
+
+  def self.milliseconds
+    GosuFFI.check_last_error(GosuFFI.Gosu_milliseconds())
+  end
+
+  def self.default_font_name
+    GosuFFI.check_last_error(GosuFFI.Gosu_default_font_name())
+  end
+
+  def self.user_languages
+    languages = []
+    callback = proc { |data, string| languages << string if string }
+    GosuFFI.Gosu_user_languages(callback, nil)
+    GosuFFI.check_last_error(languages)
+  end
+
+  def self.gl(z = nil, &block)
+    raise "Block not given!" unless block
+
+    if z
+      # When given a Z position, Gosu.gl will not call its block immediately, but enqueue it for later execution.
+      # To prevent the block from getting GC'd, store it in a global variable which is cleared after Window.draw.
+      $gosu_gl_blocks ||= []
+      $gosu_gl_blocks << block
+
+      GosuFFI.Gosu_gl_z(z, block)
+    else
+      GosuFFI.Gosu_gl(block)
+    end
+
+    GosuFFI.check_last_error
+  end
+
+  def self.render(width, height, retro: false, tileable: false, &block)
+    # TODO: Exception translation from inner block
+    __image = GosuFFI.Gosu_render(width, height, block, GosuFFI.image_flags(retro: retro, tileable: tileable))
+    GosuFFI.check_last_error
+    Gosu::Image.new(__image)
+  end
+
+  def self.record(width, height, &block)
+    # TODO: Exception translation from inner block
+    __image = GosuFFI.Gosu_record(width, height, block)
+    GosuFFI.check_last_error
+    Gosu::Image.new(__image)
+  end
+
+  def self.transform(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, &block)
+    # TODO: Exception translation from inner block
+    GosuFFI.Gosu_transform(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, block)
+    GosuFFI.check_last_error
+  end
+
+  def self.translate(x, y, &block)
+    # TODO: Exception translation from inner block
+    GosuFFI.Gosu_translate(x, y, block)
+    GosuFFI.check_last_error
+  end
+
+  def self.rotate(angle, around_x = 0, around_y = 0, &block)
+    # TODO: Exception translation from inner block
+    GosuFFI.Gosu_rotate(angle, around_x, around_y, block)
+    GosuFFI.check_last_error
+  end
+
+  def self.scale(x, y = x, around_x = 0, around_y = 0, &block)
+    # TODO: Exception translation from inner block
+    GosuFFI.Gosu_scale(x, y, around_x, around_y, block)
+    GosuFFI.check_last_error
+  end
+
+  # Note: On JRuby this seems to get "optimized out" for some reason
+  # For now, call jruby with the `--dev` option
+  def self.clip_to(x, y, width, height, &block)
+    # TODO: Exception translation from inner block
+    GosuFFI.Gosu_clip_to(x, y, width, height, block)
+    GosuFFI.check_last_error
+  end
+
+  def self.button_down?(id)
+    GosuFFI.check_last_error(GosuFFI.Gosu_button_down(id))
+  end
+
+  def self.axis(id)
+    GosuFFI.check_last_error(GosuFFI.Gosu_axis(id))
+  end
+
+  def self.button_id_to_char(id)
+    GosuFFI.check_last_error(GosuFFI.Gosu_button_id_to_char(id))
+  end
+
+  def self.char_to_button_id(id)
+    GosuFFI.check_last_error(GosuFFI.Gosu_button_char_to_id(id))
+  end
+
+  def self.button_name(id)
+    GosuFFI.check_last_error(GosuFFI.Gosu_button_name(id))
+  end
+
+  def self.gamepad_name(id)
+    GosuFFI.check_last_error(GosuFFI.Gosu_gamepad_name(id))
+  end
+
+  def self.clipboard
+    GosuFFI.check_last_error(GosuFFI.Gosu_clipboard())
+  end
+
+  def self.clipboard=(text)
+    GosuFFI.Gosu_set_clipboard(text)
+    GosuFFI.check_last_error
+  end
+
+  def self.draw_line(x1, y1, c1, x2, y2, c2, z = 0, mode = :default)
+    GosuFFI.Gosu_draw_line(x1, y1, GosuFFI.color_to_uint32(c1), x2, y2, GosuFFI.color_to_uint32(c2), z, GosuFFI.blend_mode(mode))
+    GosuFFI.check_last_error
+  end
+
+  def self.draw_triangle(x1, y1, c1, x2, y2, c2, x3, y3, c3, z = 0, mode = :default)
+    GosuFFI.Gosu_draw_triangle(x1, y1, GosuFFI.color_to_uint32(c1), x2, y2, GosuFFI.color_to_uint32(c2),
+                               x3, y3, GosuFFI.color_to_uint32(c3), z, GosuFFI.blend_mode(mode))
+    GosuFFI.check_last_error
+  end
+
+  def self.draw_quad(x1, y1, c1, x2, y2, c2,
+                     x3, y3, c3, x4, y4, c4,
+                     z = 0, mode = :default)
+    GosuFFI.Gosu_draw_quad(x1, y1, GosuFFI.color_to_uint32(c1), x2, y2, GosuFFI.color_to_uint32(c2),
+                           x3, y3, GosuFFI.color_to_uint32(c3), x4, y4, GosuFFI.color_to_uint32(c4),
+                           z, GosuFFI.blend_mode(mode))
+    GosuFFI.check_last_error
+  end
+
+  def self.draw_rect(x, y, width, height, c, z = 0, mode = :default)
+    GosuFFI.Gosu_draw_rect(x, y, width, height, GosuFFI.color_to_uint32(c), z, GosuFFI.blend_mode(mode))
+    GosuFFI.check_last_error
+  end
+
+  def self.offset_x(angle, distance)
+    GosuFFI.check_last_error(GosuFFI.Gosu_offset_x(angle, distance))
+  end
+
+  def self.offset_y(angle, distance)
+    GosuFFI.check_last_error(GosuFFI.Gosu_offset_y(angle, distance))
+  end
+
+  def self.distance(x1, y1, x2, y2)
+    GosuFFI.check_last_error(GosuFFI.Gosu_distance(x1, y1, x2, y2))
+  end
+
+  def self.angle(x1, y1, x2, y2)
+    GosuFFI.check_last_error(GosuFFI.Gosu_angle(x1, y1, x2, y2))
+  end
+
+  def self.angle_diff(angle1, angle2)
+    GosuFFI.check_last_error(GosuFFI.Gosu_angle_diff(angle1, angle2))
+  end
+
+  def self.random(min, max)
+    GosuFFI.check_last_error(GosuFFI.Gosu_random(min, max))
+  end
+
+  def self.available_width(window = nil)
+    if window.nil?
+      GosuFFI.check_last_error(GosuFFI.Gosu_available_width(nil))
+    else
+      raise TypeError, "Instance of Gosu::Window or nil expected, got: #{window.class}" if not window.is_a? Gosu::Window
+      GosuFFI.check_last_error(GosuFFI.Gosu_available_width(window.__pointer))
+    end
+  end
+
+  def self.available_height(window = nil)
+    if window.nil?
+      GosuFFI.check_last_error(GosuFFI.Gosu_available_height(nil))
+    else
+      raise TypeError, "Instance of Gosu::Window or nil expected, got: #{window.class}" if not window.is_a? Gosu::Window
+      GosuFFI.check_last_error(GosuFFI.Gosu_available_height(window.__pointer))
+    end
+  end
+
+  def self.screen_width(window = nil)
+    if window.nil?
+      GosuFFI.check_last_error(GosuFFI.Gosu_screen_width(nil))
+    else
+      raise TypeError, "Instance of Gosu::Window or nil expected, got: #{window.class}" if not window.is_a? Gosu::Window
+      GosuFFI.check_last_error(GosuFFI.Gosu_screen_width(window.__pointer))
+    end
+  end
+
+  def self.screen_height(window = nil)
+    if window.nil?
+      GosuFFI.check_last_error(GosuFFI.Gosu_screen_height(nil))
+    else
+      raise TypeError, "Instance of Gosu::Window or nil expected, got: #{window.class}" if not window.is_a? Gosu::Window
+      GosuFFI.check_last_error(GosuFFI.Gosu_screen_height(window.__pointer))
+    end
+  end
+
+  def self.enable_undocumented_retrofication
+    # TODO: Move implementation from C++ to Ruby.
+  end
+end

data/lib/gosu/image.rb

@@ -0,0 +1,141 @@
+module Gosu
+  class Image
+    BlobHelper = Struct.new(:columns, :rows, :to_blob)
+
+    def self.from_blob(width, height, rgba = "\0\0\0\0" * (width * height), retro: false, tileable: false)
+      self.new(BlobHelper.new(width, height, rgba), retro: retro, tileable: tileable)
+    end
+
+    def self.from_text(markup, line_height, font: Gosu.default_font_name, width: -1, spacing: 0, align: :left,
+                                            bold: false, italic: false, underline: false, retro: false)
+      __image = GosuFFI.Gosu_Image_create_from_text(markup, font, line_height, width, spacing,
+                                                    GosuFFI.font_alignment_flags(align),
+                                                    GosuFFI.font_flags(bold, italic, underline),
+                                                    GosuFFI.image_flags(retro: retro))
+      GosuFFI.check_last_error
+      Gosu::Image.new(__image)
+    end
+
+    def self.from_markup(markup, line_height, font: Gosu.default_font_name, width: -1, spacing: 0, align: :left,
+                                              bold: false, italic: false, underline: false, retro: false)
+      __image = GosuFFI.Gosu_Image_create_from_markup(markup, font, line_height, width, spacing,
+                                                      GosuFFI.font_alignment_flags(align),
+                                                      GosuFFI.font_flags(bold, italic, underline),
+                                                      GosuFFI.image_flags(retro: retro))
+      GosuFFI.check_last_error
+      Gosu::Image.new(__image)
+    end
+
+    def self.load_tiles(filename_or_image, tile_width, tile_height, retro: false, tileable: false)
+      flags = GosuFFI.image_flags(retro: retro, tileable: tileable)
+
+      images = []
+      callback = proc { |data, image| images << Gosu::Image.new(image) }
+
+      if filename_or_image.is_a? String
+        GosuFFI.Gosu_Image_create_from_tiles(filename_or_image, tile_width, tile_height, callback, nil, flags)
+      else
+        if filename_or_image.is_a? Gosu::Image
+          GosuFFI.Gosu_Image_create_tiles_from_image(filename_or_image.__pointer, tile_width, tile_height, callback, nil, flags)
+        else
+          image = Gosu::Image.new(filename_or_image, retro: retro, tileable: tileable)
+          GosuFFI.Gosu_Image_create_tiles_from_image(image.__pointer, tile_width, tile_height, callback, nil, flags)
+        end
+      end
+
+      GosuFFI.check_last_error
+
+      return images
+    end
+
+    def initialize(object, retro: false, tileable: false)
+      if object.is_a? String
+        __image = GosuFFI.Gosu_Image_create(object, GosuFFI.image_flags(retro: retro, tileable: tileable))
+        GosuFFI.check_last_error
+      elsif object.is_a?(FFI::Pointer)
+        __image = object
+      elsif object.respond_to?(:to_blob) &&
+            object.respond_to?(:columns) &&
+            object.respond_to?(:rows)
+        blob_bytes = object.to_blob { self.format = "RGBA"; self.depth = 8 }.bytes
+        FFI::MemoryPointer.new(:uchar, blob_bytes.size) do |blob|
+          blob.write_array_of_type(:uchar, :put_uchar, blob_bytes)
+          __image = GosuFFI.Gosu_Image_create_from_blob(blob, blob_bytes.size, object.columns, object.rows, GosuFFI.image_flags(retro: retro, tileable: tileable))
+          GosuFFI.check_last_error
+        end
+
+        raise "Failed to load image from blob" if __image.null?
+      else
+        raise ArgumentError
+      end
+
+      @managed_pointer = FFI::AutoPointer.new(__image, GosuFFI.method(:Gosu_Image_destroy))
+    end
+
+    def __pointer
+      @managed_pointer
+    end
+
+    def width
+      GosuFFI.check_last_error(GosuFFI.Gosu_Image_width(__pointer))
+    end
+
+    def height
+      GosuFFI.check_last_error(GosuFFI.Gosu_Image_height(__pointer))
+    end
+
+    def draw(x, y, z, scale_x = 1, scale_y = 1, color = Gosu::Color::WHITE, flags = :default)
+      GosuFFI.Gosu_Image_draw(__pointer, x, y, z, scale_x, scale_y, GosuFFI.color_to_uint32(color), GosuFFI.blend_mode(flags))
+      GosuFFI.check_last_error
+    end
+
+    def draw_rot(x, y, z, angle = 0, center_x = 0.5, center_y = 0.5, scale_x = 1, scale_y = 1, color = Gosu::Color::WHITE, flags = :default)
+      GosuFFI.Gosu_Image_draw_rot(__pointer, x, y, z, angle, center_x, center_y, scale_x, scale_y, GosuFFI.color_to_uint32(color), GosuFFI.blend_mode(flags))
+      GosuFFI.check_last_error
+    end
+
+    def draw_as_quad(x1, y1, color1, x2, y2, color2, x3, y3, color3, x4, y4, color4, z = 0, mode = :default)
+      GosuFFI.Gosu_Image_draw_as_quad(x1, y1, GosuFFI.color_to_uint32(color1), x2, y2, GosuFFI.color_to_uint32(color2),
+                                      x3, y3, GosuFFI.color_to_uint32(color3), x4, y4, GosuFFI.color_to_uint32(color4),
+                                      z, GosuFFI.blend_mode(mode))
+      GosuFFI.check_last_error
+    end
+
+    def save(filename)
+      GosuFFI.Gosu_Image_save(__pointer, filename)
+      GosuFFI.check_last_error
+    end
+
+    def to_blob
+      blob = GosuFFI.check_last_error(GosuFFI.Gosu_Image_to_blob(__pointer))
+      blob.read_string(width * height * Gosu::Color::SIZEOF)
+    end
+
+    def subimage(left, top, width, height)
+      __pointer = GosuFFI.Gosu_Image_create_from_subimage(__pointer, left, top, width, height)
+      GosuFFI.check_last_error
+      Gosu::Image.new(__pointer)
+    end
+
+    def insert(image, x, y)
+      image_ = nil
+      if image.is_a?(Gosu::Image)
+        image_ = image.__pointer
+      elsif image.respond_to?(:to_blob) &&
+            image.respond_to?(:rows) &&
+            image.respond_to?(:columns)
+        image_ = Gosu::Image.new(image).__pointer
+      else
+        raise "Unable to insert image!"
+      end
+
+      GosuFFI.Gosu_Image_insert(__pointer, image_, x, y)
+      GosuFFI.check_last_error
+    end
+
+    def gl_tex_info
+      tex_info = GosuFFI.check_last_error(GosuFFI.Gosu_Image_gl_tex_info_create(__pointer))
+      tex_info ? GLTexInfo.new(tex_info) : nil
+    end
+  end
+end

data/lib/gosu/numeric.rb

@@ -0,0 +1,17 @@
+class ::Numeric
+  def degrees_to_radians
+    self * Math::PI / 180.0
+  end
+
+  def radians_to_degrees
+    self * 180.0 / Math::PI
+  end
+
+  def gosu_to_radians
+    (self - 90) * Math::PI / 180.0
+  end
+
+  def radians_to_gosu
+    self * 180.0 / Math::PI + 90
+  end
+end

data/lib/gosu/preview.rb

@@ -1,8 +1,8 @@
 warn "gosu/preview.rb has been removed in Gosu 0.9.0, and Gosu itself \n" +
-  "provides a similar interface to what preview.rb used to offer.\n" +
-  "Notable differences:\n" +
-  "• no global $window variable\n" +
-  "• no global Gosu.mouse_x and Gosu.mouse_y functions\n" +
-  "• Image#initialize et.al. use an options hash now";
+       "provides a similar interface to what preview.rb used to offer.\n" +
+       "Notable differences:\n" +
+       "• no global $window variable\n" +
+       "• no global Gosu.mouse_x and Gosu.mouse_y functions\n" +
+       "• Image#initialize et.al. use an options hash now"
 
-require 'gosu'
+require "gosu"

data/lib/gosu/sample.rb

@@ -0,0 +1,24 @@
+module Gosu
+  class Sample
+    def initialize(filename)
+      __sample = GosuFFI.check_last_error(GosuFFI.Gosu_Sample_create(filename))
+      @memory_pointer = FFI::AutoPointer.new(__sample, GosuFFI.method(:Gosu_Sample_destroy))
+    end
+
+    def __pointer
+      @memory_pointer
+    end
+
+    def play(volume = 1, speed = 1, looping = false)
+      __channel = GosuFFI.Gosu_Sample_play(__pointer, volume, speed, looping)
+      GosuFFI.check_last_error
+      Gosu::Channel.new(__channel)
+    end
+
+    def play_pan(pan = 0, volume = 1, speed = 1, looping = false)
+      __channel = GosuFFI.Gosu_Sample_play_pan(__pointer, pan, volume, speed, looping)
+      GosuFFI.check_last_error
+      Gosu::Channel.new(__channel)
+    end
+  end
+end

data/lib/gosu/song.rb

@@ -0,0 +1,56 @@
+module Gosu
+  class Song
+    def self.current_song
+      ptr = GosuFFI.Gosu_Song_current_song()
+      GosuFFI.check_last_error
+      unless ptr.null?
+        @@current_song
+      else
+        nil
+      end
+    end
+
+    def initialize(filename)
+      __song = GosuFFI.Gosu_Song_create(filename)
+      GosuFFI.check_last_error
+      @memory_pointer = FFI::AutoPointer.new(__song, GosuFFI.method(:Gosu_Song_destroy))
+    end
+
+    def __pointer
+      @memory_pointer
+    end
+
+    def play(looping = false)
+      @@current_song = self
+      GosuFFI.Gosu_Song_play(__pointer, looping)
+      GosuFFI.check_last_error
+    end
+
+    def playing?
+      GosuFFI.check_last_error(GosuFFI.Gosu_Song_playing(__pointer))
+    end
+
+    def pause
+      GosuFFI.Gosu_Song_pause(__pointer)
+      GosuFFI.check_last_error
+    end
+
+    def paused?
+      GosuFFI.check_last_error(GosuFFI.Gosu_Song_paused(__pointer))
+    end
+
+    def stop
+      GosuFFI.Gosu_Song_stop(__pointer)
+      GosuFFI.check_last_error
+    end
+
+    def volume
+      GosuFFI.check_last_error(GosuFFI.Gosu_Song_volume(__pointer))
+    end
+
+    def volume=(double)
+      GosuFFI.Gosu_Song_set_volume(__pointer, double)
+      GosuFFI.check_last_error
+    end
+  end
+end

data/lib/gosu/text_input.rb

@@ -0,0 +1,69 @@
+module Gosu
+  class TextInput
+    def initialize
+      __text_input = GosuFFI.Gosu_TextInput_create()
+      GosuFFI.check_last_error
+      @memory_pointer = FFI::AutoPointer.new(__text_input, GosuFFI.method(:Gosu_TextInput_destroy))
+
+      @__filter_proc = proc { |data, text| protected_filter(text) }
+      GosuFFI.Gosu_TextInput_set_filter(__pointer, @__filter_proc, nil)
+      GosuFFI.check_last_error
+    end
+
+    def __pointer
+      @memory_pointer
+    end
+
+    def text
+      GosuFFI.check_last_error(GosuFFI.Gosu_TextInput_text(__pointer))
+    end
+
+    def text=(string)
+      GosuFFI.Gosu_TextInput_set_text(__pointer, string.to_s)
+      GosuFFI.check_last_error
+    end
+
+    def caret_pos
+      GosuFFI.check_last_error(GosuFFI.Gosu_TextInput_caret_pos(__pointer))
+    end
+
+    def caret_pos=(int)
+      GosuFFI.Gosu_TextInput_set_caret_pos(__pointer, int)
+      GosuFFI.check_last_error
+    end
+
+    def selection_start
+      GosuFFI.check_last_error(GosuFFI.Gosu_TextInput_selection_start(__pointer))
+    end
+
+    def selection_start=(int)
+      GosuFFI.Gosu_TextInput_set_selection_start(__pointer, int)
+      GosuFFI.check_last_error
+    end
+
+    def filter(text)
+      return text
+    end
+
+    def insert_text(text)
+      GosuFFI.Gosu_TextInput_insert_text(__pointer, text)
+      GosuFFI.check_last_error
+    end
+
+    def delete_backward
+      GosuFFI.Gosu_TextInput_delete_backward(__pointer)
+      GosuFFI.check_last_error
+    end
+
+    def delete_forward
+      GosuFFI.Gosu_TextInput_delete_forward(__pointer)
+      GosuFFI.check_last_error
+    end
+
+    # Ensures that filter_result is set on C side before filter callback returns
+    private def protected_filter(text)
+      string = filter(text)
+      GosuFFI.Gosu_TextInput_set_filter_result(__pointer, string)
+    end
+  end
+end