rb_sdl2 0.1.0 → 0.2.0

data/lib/rb_sdl2/mouse/mouse_wheel.rb

@@ -1,53 +1,37 @@
 module RbSDL2
   module Mouse
     class MouseWheel
-      @timestamp = @x = @y = 0
-      @mutex = Mutex.new
-
-      MOUSE_WHEEL_EVENT_WATCH = -> (event, _) {
-        if event.mouse_wheel?
-          a = event[:direction] == ::SDL2::SDL_MOUSEWHEEL_FLIPPED ? -1 : 1
-          @timestamp = event[:timestamp]
-          @x = event[:x] * a
-          @y = event[:y] * a
-        end
-      }
-
-      class << self
-        attr_reader :timestamp, :x, :y
-
-        require_relative '../event'
-
-        def wheel=(bool)
-          @mutex.synchronize do
-            if bool
-              Event.add_watch_callback(MOUSE_WHEEL_EVENT_WATCH)
-            else
-              Event.remove_watch_callback(MOUSE_WHEEL_EVENT_WATCH)
-            end
+      def initialize(window = nil)
+        @wheel_x = @wheel_y = @x = @y = 0
+        window_id = window&.window_id
+        proc = -> (event) do
+          if event.mouse_wheel? && window_id && event[:windowID] == window_id
+            a = event[:direction] == ::SDL::MOUSEWHEEL_FLIPPED ? -1 : 1
+            @x += event[:x] * a
+            @y += event[:y] * a
           end
         end
+        @watch = EventFilter.new(proc)
       end
 
-      require 'singleton'
-      include Singleton
-
-      def initialize
-        @timestamp = @x = @y = 0
+      def update
+        @wheel_x, @wheel_y = @x, @y
+        @x = @y = 0
+        self
       end
 
-      def position = [x, y]
-
-      def update
-        if @timestamp != MouseWheel.timestamp
-          @x, @y, @timestamp = MouseWheel.x, MouseWheel.y, MouseWheel.timestamp
+      def wheel=(bool)
+        if bool
+          EventFilter.define_watch(@watch)
         else
-          @x, @y = 0, 0
+          EventFilter.undefine_watch(@watch)
         end
-        self
+        @wheel_x = @wheel_y = @x = @y = 0
       end
 
-      attr_reader :x, :y
+      def wheel_position = [@wheel_x, @wheel_y]
+
+      attr_reader :wheel_x, :wheel_y, :window_id
     end
   end
 end

data/lib/rb_sdl2/mouse/relative_mouse.rb

@@ -3,8 +3,22 @@ module RbSDL2
     require_relative 'mouse_class'
 
     class RelativeMouse < MouseClass
+      require 'singleton'
+      include Singleton
+
+      @_x = ::FFI::MemoryPointer.new(:int)
+      @_y = ::FFI::MemoryPointer.new(:int)
+
+      class << self
+        def update
+          self.button, self.x, self.y =
+            ::SDL.GetRelativeMouseState(@_x, @_y), @_x.read_int, @_y.read_int
+          self
+        end
+      end
+
       def update
-        self.button = ::SDL2.SDL_GetRelativeMouseState(x_ptr, y_ptr)
+        self.class.update
         self
       end
     end

data/lib/rb_sdl2/palette.rb

@@ -4,9 +4,9 @@ module RbSDL2
 
     class PalettePointer < RefCountPointer
       class << self
-        def release(ptr) = ::SDL2.SDL_FreePalette(ptr)
+        def release(ptr) = ::SDL.FreePalette(ptr)
 
-        def entity_class = ::SDL2::SDL_Palette
+        def entity_class = ::SDL::Palette
       end
     end
 
@@ -18,7 +18,9 @@ module RbSDL2
       end
 
       def new(num_colors)
-        ptr = PalettePointer.new(::SDL2.SDL_AllocPalette(num_colors))
+        # SDL_AllocPalette() のエラーは引数が < 1、または必要なメモリー領域がない場合。
+        # パレットのカラーは作成時に全て [255, 255, 255, 255] で埋められる。
+        ptr = PalettePointer.new(::SDL.AllocPalette(num_colors))
         raise RbSDL2Error if ptr.null?
         super(ptr)
       end
@@ -31,34 +33,36 @@ module RbSDL2
     end
 
     def initialize(ptr)
-      @st = ::SDL2::SDL_Palette.new(ptr)
+      @st = ::SDL::Palette.new(ptr)
     end
 
     def ==(other)
-      other.respond_to?(:to_ptr) && to_ptr == other.to_ptr
+      other.respond_to?(:to_ptr) && other.to_ptr == to_ptr
     end
 
     def [](nth)
       raise ArgumentError if nth < 0 || length <= nth
-      ::SDL2::SDL_Color.new(@st[:colors] + ::SDL2::SDL_Color.size * nth).values
+      ::SDL::Color.new(@st[:colors] + ::SDL::Color.size * nth).values
     end
 
     # color 引数には ３要素以上の配列であること。４要素目以降は無視される。
     # color 引数は内部で splat する。これに対応していれば配列以外のオブジェクトでもよい。
-    # パレットのカラーが描画に使われるときはアルファ値は無視されて不透明(SDL_ALPHA_OPAQUE)として扱わられる。
-    # パレットのカラーは作成時に全て [255, 255, 255, 255] で埋められている。
+    # パレットのカラーが描画に使われるときはアルファ値は無視されて不透明(ALPHA_OPAQUE)として扱う。
     def []=(nth, color)
       raise ArgumentError if nth < 0 || length <= nth
-      c = ::SDL2::SDL_Color.new
+      c = ::SDL::Color.new
       c[:r], c[:g], c[:b] = color
-      err = ::SDL2.SDL_SetPaletteColors(self, c, nth, 1)
+      err = ::SDL.SetPaletteColors(self, c, nth, 1)
       raise RbSDL2Error if err < 0
     end
 
     def each = length.times { |nth| yield(self[nth]) }
 
-    def length = @st[:ncolors]
+    def inspect
+      "#<#{self.class.name} colors=#{length}>"
+    end
 
+    def length = @st[:ncolors]
     alias size length
 
     def to_a = to_enum.to_a

data/lib/rb_sdl2/pixel_format_enum.rb

@@ -1,73 +1,105 @@
 module RbSDL2
   module PixelFormatEnum
-    names = ::SDL2.constants.grep(/\ASDL_PIXELFORMAT_/)
-    values = names.map { |n| ::SDL2.const_get(n) }
-    FORMAT_MAP = names.zip(values).to_h.freeze
-
-    INDEXED_TYPES = [::SDL2::SDL_PIXELTYPE_INDEX1, ::SDL2::SDL_PIXELTYPE_INDEX4,
-                     ::SDL2::SDL_PIXELTYPE_INDEX8].freeze
-
-    PACKED_TYPES = [::SDL2::SDL_PIXELTYPE_PACKED8, ::SDL2::SDL_PIXELTYPE_PACKED16,
-                    ::SDL2::SDL_PIXELTYPE_PACKED32].freeze
-
-    ARRAY_TYPES = [::SDL2::SDL_PIXELTYPE_ARRAYU8, ::SDL2::SDL_PIXELTYPE_ARRAYU16,
-                   ::SDL2::SDL_PIXELTYPE_ARRAYU32, ::SDL2::SDL_PIXELTYPE_ARRAYF16,
-                   ::SDL2::SDL_PIXELTYPE_ARRAYF32].freeze
-
-    PACKED_ORDERS = [::SDL2::SDL_PACKEDORDER_ARGB, ::SDL2::SDL_PACKEDORDER_RGBA,
-                     ::SDL2::SDL_PACKEDORDER_ABGR, ::SDL2::SDL_PACKEDORDER_BGRA].freeze
-
-    ARRAY_ORDERS = [::SDL2::SDL_ARRAYORDER_ARGB, ::SDL2::SDL_ARRAYORDER_RGBA,
-                    ::SDL2::SDL_ARRAYORDER_ABGR, ::SDL2::SDL_ARRAYORDER_BGRA].freeze
+    # SDL の PixelFormatEnum はピクセルフォーマットをビット列にパックしたものである。
+    # ビット操作を通じてピクセルフォーマットを構築、分析できる。
+    # しかし、SDL API は事前に定義されているフォーマット以外を与えるとエラーになる。
+    # ユーザ側で自由なフォーマット定義を行うことはできない。
+    # Ruby 側でフォーマットの詳細を知るため目的に応じたフォーマット集合を作成することにした。
+    # これはコードのメンテナンスを考慮したためである。
+    #
+    # [[sym, num, type, alpha], ...]
+    table = [
+      [:index1lsb, ::SDL::PIXELFORMAT_INDEX1LSB, :indexed, false],
+      [:index1msb, ::SDL::PIXELFORMAT_INDEX1MSB, :indexed, false],
+      [:index4lsb, ::SDL::PIXELFORMAT_INDEX4LSB, :indexed, false],
+      [:index4msb, ::SDL::PIXELFORMAT_INDEX4MSB, :indexed, false],
+      [:index8, ::SDL::PIXELFORMAT_INDEX8, :indexed, false],
+      [:rgb332, ::SDL::PIXELFORMAT_RGB332, :packed, false],
+      [:xrgb4444, ::SDL::PIXELFORMAT_XRGB4444, :packed, false],
+      [:rgb444, ::SDL::PIXELFORMAT_RGB444, :packed, false],
+      [:xbgr4444, ::SDL::PIXELFORMAT_XBGR4444, :packed, false],
+      [:bgr444, ::SDL::PIXELFORMAT_BGR444, :packed, false],
+      [:xrgb1555, ::SDL::PIXELFORMAT_XRGB1555, :packed, false],
+      [:rgb555, ::SDL::PIXELFORMAT_RGB555, :packed, false],
+      [:xbgr1555, ::SDL::PIXELFORMAT_XBGR1555, :packed, false],
+      [:bgr555, ::SDL::PIXELFORMAT_BGR555, :packed, false],
+      [:argb4444, ::SDL::PIXELFORMAT_ARGB4444, :packed, true],
+      [:rgba4444, ::SDL::PIXELFORMAT_RGBA4444, :packed, true],
+      [:abgr4444, ::SDL::PIXELFORMAT_ABGR4444, :packed, true],
+      [:bgra4444, ::SDL::PIXELFORMAT_BGRA4444, :packed, true],
+      [:argb1555, ::SDL::PIXELFORMAT_ARGB1555, :packed, true],
+      [:rgba5551, ::SDL::PIXELFORMAT_RGBA5551, :packed, true],
+      [:abgr1555, ::SDL::PIXELFORMAT_ABGR1555, :packed, true],
+      [:bgra5551, ::SDL::PIXELFORMAT_BGRA5551, :packed, true],
+      [:rgb565, ::SDL::PIXELFORMAT_RGB565, :packed, false],
+      [:bgr565, ::SDL::PIXELFORMAT_BGR565, :packed, false],
+      [:rgb24, ::SDL::PIXELFORMAT_RGB24, :array, false],
+      [:bgr24, ::SDL::PIXELFORMAT_BGR24, :array, false],
+      [:xrgb8888, ::SDL::PIXELFORMAT_XRGB8888, :packed, false],
+      [:rgb888, ::SDL::PIXELFORMAT_RGB888, :packed, false],
+      [:rgbx8888, ::SDL::PIXELFORMAT_RGBX8888, :packed, false],
+      [:xbgr8888, ::SDL::PIXELFORMAT_XBGR8888, :packed, false],
+      [:bgr888, ::SDL::PIXELFORMAT_BGR888, :packed, false],
+      [:bgrx8888, ::SDL::PIXELFORMAT_BGRX8888, :packed, false],
+      [:argb8888, ::SDL::PIXELFORMAT_ARGB8888, :packed, true],
+      [:rgba8888, ::SDL::PIXELFORMAT_RGBA8888, :packed, true],
+      [:abgr8888, ::SDL::PIXELFORMAT_ABGR8888, :packed, true],
+      [:bgra8888, ::SDL::PIXELFORMAT_BGRA8888, :packed, true],
+      [:argb2101010, ::SDL::PIXELFORMAT_ARGB2101010, :packed, true],
+      [:rgba32, ::SDL::PIXELFORMAT_RGBA32, :packed, true],
+      [:argb32, ::SDL::PIXELFORMAT_ARGB32, :packed, true],
+      [:bgra32, ::SDL::PIXELFORMAT_BGRA32, :packed, true],
+      [:abgr32, ::SDL::PIXELFORMAT_ABGR32, :packed, true],
+      [:yv12, ::SDL::PIXELFORMAT_YV12, :fourcc, false],
+      [:iyuv, ::SDL::PIXELFORMAT_IYUV, :fourcc, false],
+      [:yuy2, ::SDL::PIXELFORMAT_YUY2, :fourcc, false],
+      [:uyvy, ::SDL::PIXELFORMAT_UYVY, :fourcc, false],
+      [:yvyu, ::SDL::PIXELFORMAT_YVYU, :fourcc, false],
+      [:nv12, ::SDL::PIXELFORMAT_NV12, :fourcc, false],
+      [:nv21, ::SDL::PIXELFORMAT_NV21, :fourcc, false],
+      [:external_oes, ::SDL::PIXELFORMAT_EXTERNAL_OES, :fourcc, false],
+    ]
+
+    FORMAT_MAP = table.map { |sym, n, _, _| [sym, n] }.to_h.freeze
+
+    INDEXED_TYPES = table.inject([]) { |a, (_, n, type, _)| a << n if type == :indexed; a }.freeze
+
+    WITH_ALPHA = table.inject([]) { |a, (_, n, _, alpha)| a << n if alpha; a }.freeze
 
     class << self
-      def array_type?(num) = !fourcc?(num) && ARRAY_TYPES.include?(to_type(num))
-
-      def fourcc?(num) = (num >> 28) & 0x0F != 1
-
-      def indexed_type?(num) = !fourcc?(num) && INDEXED_TYPES.include?(to_type(num))
-
-      def packed_type?(num) = !fourcc?(num) && PACKED_TYPES.include?(to_type(num))
-
-      def to_fourcc(num)
-        4.times.inject([]) { |n, i| n << (num >> i * 8) % 0x100 }.pack("c4") if fourcc?
+      def to_name(num)
+        ::SDL.GetPixelFormatName(num).read_string.delete_prefix("SDL_PIXELFORMAT_")
       end
 
-      def to_name(num) = ::SDL2.SDL_GetPixelFormatName(num).read_string
-
-      # obj は SDL の SDL_PIXELFORMAT_* 定数のどれか、または定数名でもよい。
-      # 定数名は RGBA32 のような短縮した名前でもよい。"UNKNOWN" も受け取れる（値は 0）。
-      # 該当するフォーマットがない場合は 0 (SDL_PIXELFORMAT_UNKNOWN) を戻す。
-      # SDL はオリジナルのフォーマットを処理しないことに注意。
+      # obj に与えたピクセルフォーマットに応じた整数値を戻す。
       def to_num(obj)
-        name = if Symbol === obj || String === obj
-                 obj.match?(/\ASDL_PIXELFORMAT_/) ? obj : "SDL_PIXELFORMAT_#{obj.upcase}"
-               else
-                 to_name(obj)
-               end
-        FORMAT_MAP[name.to_sym].to_i
-      end
-
-      def to_order(num) = fourcc?(num) ? 0 : (num >> 20) & 0x0F
-
-      def to_type(num) = fourcc?(num) ? 0 : (num >> 24) & 0x0F
-
-      def with_alpha?(num)
-        packed_type?(num) && PACKED_ORDERS.include?(to_order(num)) ||
-          array_type?(num) && ARRAY_ORDERS.include?(to_order(num))
+        case obj
+        when Symbol, String
+          sym = obj.to_sym.downcase
+          if FORMAT_MAP.key?(sym)
+            FORMAT_MAP[sym]
+          else
+            raise ArgumentError, "Invalid format name"
+          end
+        else
+          raise ArgumentError
+        end
       end
     end
 
-    def fourcc = PixelFormatEnum.to_fourcc(format)
+    # FOURCC が無い場合は nil を戻す。
+    def fourcc
+      4.times.inject([]) { |n, i| n << (num >> i * 8) % 0x100 }.pack("c4") if fourcc?
+    end
 
-    def fourcc? = PixelFormatEnum.fourcc?(format)
+    def fourcc? = (format >> 28) & 0x0F != 1
 
-    def format_name = PixelFormatEnum.to_name(format)
+    def format_name = PixelFormatEnum.to_num(format)
 
-    def indexed_color? = PixelFormatEnum.indexed_type?(format)
+    def indexed_color? = PixelFormatEnum::INDEXED_TYPES.include?(format)
 
     def rgb? = !(fourcc? || indexed_color? || rgba?)
 
-    def rgba? = PixelFormatEnum.with_alpha?(format)
+    def rgba? = PixelFormatEnum::WITH_ALPHA.include?(format)
   end
 end

data/lib/rb_sdl2/platform.rb

@@ -1,7 +1,9 @@
 module RbSDL2
   module Platform
     class << self
-      def platform = ::SDL2.SDL_GetPlatform.read_string
+      # プラットフォーム名（動作環境）を文字列で返します。
+      # ここでの動作環境は SDL ライブラリが認識しているものです。
+      def platform = ::SDL.GetPlatform.read_string
     end
   end
 end

data/lib/rb_sdl2/power_info.rb

@@ -1,36 +1,47 @@
 module RbSDL2
-  module PowerInfo
-    @secs_ptr, @pct_ptr = Array.new(2) { ::FFI::MemoryPointer.new(:int) }
+  class PowerInfo
+    def initialize
+      @battery_time = ::FFI::MemoryPointer.new(:int)
+      @battery_percentage = ::FFI::MemoryPointer.new(:int)
+      update
+    end
+
+    # バッテリーの残り容量（パーセント）を戻します。
+    # 残り容量を特定できない, またはバッテリーで動作していない場合 nil を戻します。
+    def battery_percentage = (num = @battery_percentage.read_int) >= 0 ? num : nil
+
+    # バッテリーの残り時間（秒）を戻します。
+    # 残り時間を特定できない、またはバッテリーで動作していない場合は nil を戻します。
+    def battery_time = (num = @battery_time.read_int) >= 0 ? num : nil
 
-    class << self
-      attr_reader :battery_capacity, :battery_time, :state
+    # バッテリーが搭載されているか？
+    def battery? = [::SDL::POWERSTATE_CHARGING,
+                    ::SDL::POWERSTATE_CHARGED,
+                    ::SDL::POWERSTATE_ON_BATTERY].include?(state)
 
-      # バッテリーが搭載されているか？
-      def battery? = on_battery? || battery_charging? || battery_charged?
+    # 電源あり、バッテリー満充電
+    def charged? = ::SDL::POWERSTATE_CHARGED == state
 
-      # 電源あり、バッテリー満充電
-      def battery_charged? = ::SDL2::SDL_POWERSTATE_CHARGED == state
+    # 電源あり、バッテリー充電中
+    def charging? = ::SDL::POWERSTATE_CHARGING == state
 
-      # 電源あり、バッテリー充電中
-      def battery_charging? = ::SDL2::SDL_POWERSTATE_CHARGING == state
+    # 電源あり、バッテリー非搭載（デスクトップパソコンなど）
+    def no_battery? = ::SDL::POWERSTATE_NO_BATTERY == state
 
-      # 電源あり、バッテリー非搭載（デスクトップパソコンなど）
-      def no_battery? = ::SDL2::SDL_POWERSTATE_NO_BATTERY == state
+    # 電源なし、バッテリー使用中
+    def on_battery? = ::SDL::POWERSTATE_ON_BATTERY == state
 
-      # 電源なし、バッテリー使用中
-      def on_battery? = ::SDL2::SDL_POWERSTATE_ON_BATTERY == state
+    # 電源に接続されているか？
+    def plugged_in? = !on_battery?
 
-      # 電源に接続されているか？
-      def plugged_in? = no_battery? || battery_charging? || battery_charged?
+    attr_reader :state
 
-      def update
-        @state = ::SDL2.SDL_GetPowerInfo(@secs_ptr, @pct_ptr)
-        @battery_time, @battery_capacity = @secs_ptr.read_int, @pct_ptr.read_int
-        self
-      end
+    # 電源、バッテリーの情報なし
+    def unknown? = ::SDL::POWERSTATE_UNKNOWN == state
 
-      # 電源、バッテリーの情報なし
-      def unknown? = ::SDL2::SDL_POWERSTATE_UNKNOWN == state
+    def update
+      @state = ::SDL.GetPowerInfo(@battery_time, @battery_percentage)
+      self
     end
   end
 end

data/lib/rb_sdl2/rect.rb

@@ -1,7 +1,13 @@
 module RbSDL2
   class Rect
+    class << self
+      def to_ary(ptr)
+        ::SDL::Rect.new(ptr).values
+      end
+    end
+
     def initialize(x = 0, y = 0, w = 0, h = 0)
-      @st = ::SDL2::SDL_Rect.new
+      @st = ::SDL::Rect.new
       @st[:x], @st[:y], @st[:w], @st[:h] = x, y, w, h
     end
 

data/lib/rb_sdl2/ref_count_pointer.rb

@@ -1,20 +1,35 @@
 module RbSDL2
   class RefCountPointer < ::FFI::AutoPointer
+    # 備考：SDL では参照カウンターを操作する際にロックを行っていない。
+    # SDL_AtomicAdd() を使用した理由はオブジェクトの生成をなるべく行わないようにするため。
     class << self
-      def entity_class
-        raise NotImplementedError
-      end
+      def entity_class = raise NotImplementedError
+
+      def offset_of_refcount = entity_class.offset_of(:refcount)
+
+      def dec_ref(ptr) = ::SDL.SDL_AtomicAdd(ptr + offset_of_refcount, -1)
+
+      def inc_ref(ptr) = ::SDL.SDL_AtomicAdd(ptr + offset_of_refcount, 1)
 
       def to_ptr(ptr)
-        raise ArgumentError, 'Invalid pointer, ptr is NULL' if ptr.null?
-        # refcount の増加を AutoPointer 化する前に成功させる必要がある。
-        # AutoPointer になった後に失敗すると、GC に回収されたとき refcount が実際の参照数より少なくなる。
-        entity_class.new(ptr)[:refcount] += 1
-        new(ptr)
+        obj = new(ptr)
+
+        # ポインターの参照カウントを増加する際に例外が発生すると、
+        # ポインターが GC に回収され refcount が実際の参照数より少なくなる。
+        # 例外を補足してポインターのファイナライザーを解除する。
+        unless ptr.null?
+          begin
+            inc_ref(ptr)
+          rescue => e
+            obj.autorelease = false
+            raise e
+          end
+        end
+
+        obj
       end
     end
 
-    # for debug
-    def refcount = self.class.entity_class.new(self)[:refcount]
+    def refcount = get_int(self.class.offset_of_refcount)
   end
 end

data/lib/rb_sdl2/rw_ops/rw_file.rb

@@ -0,0 +1,19 @@
+module RbSDL2
+  require_relative 'rw_ops_pointer'
+
+  class RWFile < RWOps
+    def initialize(path, mode = "r")
+      @path = path
+      ptr = ::SDL.RWFromFile(SDL.str_to_sdl(path), SDL.str_to_sdl(mode))
+      raise RbSDL2Error if ptr.null?
+      super(RWOpsPointer.new(ptr))
+    end
+
+    def inspect
+      "#<#{self.class.name}:#{path}#{closed? ? " (closed)" : nil}>"
+    end
+
+    attr_reader :path
+    alias to_path path
+  end
+end

data/lib/rb_sdl2/rw_ops/rw_memory.rb

@@ -0,0 +1,18 @@
+module RbSDL2
+  require_relative 'rw_ops_pointer'
+  
+  class RWMemory < RWOps
+    def initialize(obj, readonly: false, size: nil)
+      raise TypeError, "obj is NULL" if obj.nil? || obj.null?
+      size = size || obj.size
+      ptr = readonly ? ::SDL.RWFromConstMem(obj, size) : ::SDL.RWFromMem(obj, size)
+      raise RbSDL2Error if ptr.null?
+      super(RWOpsPointer.new(ptr))
+      @obj = obj
+    end
+
+    def inspect
+      "#<#{self.class.name}:memory#{closed? ? " (closed)" : nil}>"
+    end
+  end
+end

data/lib/rb_sdl2/rw_ops/rw_object.rb

@@ -0,0 +1,126 @@
+module RbSDL2
+  class RWObject < RWOps
+    class CloseCallback < ::FFI::Function
+      def initialize
+        # int (* close) (struct RWops * context);
+        super(:int, [:pointer]) do |context|
+          yield
+          0
+        rescue => e
+          raise e if $DEBUG
+          Error.last_error_message = e.message
+          -1
+        ensure
+          # SDL_RWclose() の仕様により成功、失敗問わずポインターを開放する。
+          ::SDL.FreeRW(context)
+        end
+      end
+    end
+
+    class ReadCallback < ::FFI::Function
+      def initialize
+        # size_t (* read) (struct RWops * context, void *ptr, size_t size, size_t maxnum);
+        super(:size_t, [:pointer, :pointer, :size_t, :size_t]) do |_context, ptr, size, max_num|
+          num = size * max_num
+          str = yield(num)
+          next 0 if str.nil? # EOF
+          len = str.size
+          if len > num # 要求より多い文字数を返している。obj.read が壊れている。
+            raise RbSDL2Error, "The return value of read method is corrupted"
+          end
+          ptr.write_bytes(str, 0, len)
+          len / size
+        rescue => e
+          raise e if $DEBUG
+          Error.last_error_message = e.message
+          0
+        end
+      end
+    end
+
+    class SeekCallback < ::FFI::Function
+      def initialize
+        # Sint64 (* seek) (struct RWops * context, Sint64 offset, int whence);
+        super(:int64, [:pointer, :int64, :int]) do |_context, offset, whence|
+          # SDL_RWseek() の仕様によりシーク後の現在位置を戻す必要がある。
+          yield(offset, whence)
+        rescue => e
+          raise e if $DEBUG
+          Error.last_error_message = e.message
+          -1
+        end
+      end
+    end
+
+    class SizeCallback < ::FFI::Function
+      def initialize
+        # Sint64 (* size) (struct RWops * context);
+        super(:int64, [:pointer]) do |_context|
+          # Ruby ではサイズが不明な IO は size メソッドが無い（NoMethodError）。
+          yield
+        rescue => e
+          raise e if $DEBUG
+          Error.last_error_message = e.message
+          # 不明な時は -1。
+          -1
+        end
+      end
+    end
+
+    class WriteCallback < ::FFI::Function
+      def initialize
+        # size_t (* write) (struct RWops * context, const void *ptr, size_t size, size_t num);
+        super(:size_t, [:pointer, :pointer, :size_t, :size_t]) do |_context, ptr, size, max_num|
+          str = ptr.read_bytes(size * max_num)
+          yield(str) / size
+        rescue => e
+          raise e if $DEBUG
+          Error.last_error_message = e.message
+          0
+        end
+      end
+    end
+
+    require_relative 'rw_ops_pointer'
+
+    # obj 引数には Ruby の IO オブジェクトのように振る舞うオブジェクトを与える。
+    # 期待される振る舞いは close, read, seek, size, tell, write メソッド呼び出しに応答すること。
+    # メソッドが無い場合やメソッドから例外が出た場合は SDL 側にエラー値を戻す。
+    # autoclose 引数に true を与えた場合 close メソッドの呼び出し、GC の回収時に obj 引数に与えたオブジェクトを
+    # クローズする。
+    # C のスコープへ渡す場合、ポインターが利用されている間 RWOps オブジェクトを生存させる必要がある。
+    def initialize(obj)
+      ptr = ::SDL.AllocRW
+      raise RbSDL2Error if ptr.null?
+      super(
+        begin
+          # メンバーの関数ポインターが NULL であってはならない。
+          @st = ::SDL::RWops.new(ptr)
+          # 引数に与えた proc 内で例外が出たときは SDL へ例外メッセージがセットされエラーを表す戻り値が渡される。
+          # デバッグモードの時は Ruby 側へ例外を出す。
+          # close_proc: 引数はなし。戻り値は無視される。RWops ポインタの開放を行う必要はない。
+          # read_proc:  引数に読み出すバイト数。戻り値は文字列。
+          # seek_proc:  引数に offset, whence。IO#seek を参照。戻り値は現在位置（IO#tell）。
+          # size_proc:  引数はなし。戻り値はバイト数。不明な場合は何らかの例外を出す。
+          # write_proc: 引数に書き込む文字列。戻り値は実際に書き込んだバイト数。
+          @st[:close] = @close_callback = CloseCallback.new {} # obj.close しない。autoclose=false
+          @st[:read] = @read_callback = ReadCallback.new { |length| obj.read(length) }
+          @st[:seek] = @seek_callback = SeekCallback.new { |offset, whence| obj.seek(offset, whence); obj.tell }
+          @st[:size] = @size_callback = SizeCallback.new { obj.size }
+          @st[:write] = @write_callback = WriteCallback.new { |str| obj.write(str) }
+          RWOpsPointer.new(ptr)
+        rescue => e
+          ::SDL.FreeRW(ptr)
+          raise e
+        end
+      )
+      @obj = obj
+    end
+
+    def __getobj__ = @obj
+
+    def inspect
+      "#<#{self.class.name}:#{@obj.inspect}#{closed? ? " (closed)" : nil}>"
+    end
+  end
+end