SDLRuby 0.3.0 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 808c30b69ff9a14dd61fae1fa5c6812a1be91e6313affb2a46ff136cbffcfeac
-  data.tar.gz: 42794a0310f8329168a8237897d62dddf14cb14922d1db1d631570308708c8da
+  metadata.gz: fb651b451bbc9fc356e5f3a1ecb08d5855a690fa7b0556f7a9da5f0f11f2d6d4
+  data.tar.gz: 9f53754821bf14951f4cd014f1b776d07a5b3807a81ceee937ce96e6f71e148e
 SHA512:
-  metadata.gz: c840b525923d6e083094d5783ad70057f758dbd4be86f1660d16f7873eeb9e12bf5bdfdfb739c0664287eda2bde514926bc8e0fffd25f1822001482b024b3820
-  data.tar.gz: 1bec511a45a3786d35c407d51c66b3e75fb0b339835b2d00e492cce65d73c98873a9433043b8faa43f3ac6117988746c4178c14b7468d68a8873fd99a0d45785
+  metadata.gz: f5cfbf90c23eb97fcec12e34af27a2966e7d5c3fc010186a28ff1ec2c4caaf5a5cefc0ed68863907f9dad417688b1ec9dc61388e4d4723fb199cfcf5b7582553
+  data.tar.gz: b91967cab249f58717362fa4d1241e650d0a38b54ff340167a631a76691a5a17811961fc675a9edfbd0ea8ff2259e4d9c0800c08999cf2273535091f529ce2b4

data/CHANGELOG.md

@@ -1,5 +1,8 @@
 ## [Unreleased]
 
+## [0.3.1] - 2023-09-28
+- Refactored RWOps class.
+
 ## [0.3.0] - 2023-09-19
 - Implemented Mouse Module.
 - Implementation of the Timer Module.

data/lib/SDLRuby/rw/operational.rb

@@ -0,0 +1,116 @@
+module SDLRuby
+  class RW
+    module Operational
+      def close
+        unless closed?
+          err = SDL.SDL_RWclose(to_ptr)
+
+          raise SDLError if err < 0
+        end
+      end
+
+      def closed? = to_ptr.freed?
+
+      def eof?
+        raise SDLError, "closed and freed rw" if closed?
+
+        s = SDL.SDL_RWsize(to_ptr)
+        raise SDLError if s < 0
+
+        t = SDL.SDL_RWtell(to_ptr)
+        raise SDLError if t < 0
+
+        s == t
+      end
+
+      def read(length = nil, buffer = nil)
+        raise SDLError, "closed and freed rw" if closed?
+
+        if length.nil?
+          len = size - tell
+        else
+          len = Integer.try_convert(length)
+          if len.nil?
+            raise TypeError,
+                  "no implicit conversion of #{length.class} into Integer"
+          end
+        end
+
+        if len < 0
+          raise ArgumentError, "negative length #{len} given"
+        end
+
+        if buffer.nil?
+          buffer = ""
+        else
+          buffer = String.try_convert(buffer)
+          if buffer.nil?
+            raise TypeError,
+                  "no implicit conversion of #{buffer.class} into String"
+          end
+        end
+
+        if eof? || len == 0
+          buffer.clear
+          return len == 0 ? buffer : nil
+        end
+
+        bytesize = buffer.bytesize
+        if len == bytesize
+          buffer
+        elsif len > bytesize
+          buffer.gsub!(/\z/nm, "\x00" * (len - bytesize))
+        elsif len < bytesize
+          buffer.gsub!(/[\x00-\xFF]{#{bytesize - len}}\z/nm, "")
+        end
+
+        n = SDL.SDL_RWread(to_ptr, buffer, 1, len)
+        if n < len
+          buffer.gsub!(/[\x00-\xFF]{#{n}}$/nm, "")
+        end
+        raise SDLError if n == 0
+
+        buffer
+      end
+
+      def seek(offset, whence = IO::SEEK_SET)
+        raise SDLError, "closed and freed rw" if closed?
+
+        n = SDL.SDL_RWseek(to_ptr, offset, whence)
+        raise SDLError if n < 0
+        0
+      end
+
+      alias pos= seek
+
+      def size
+        raise SDLError, "closed and freed rw" if closed?
+
+        n = SDL.SDL_RWsize(to_ptr)
+        raise SDLError if n < 0
+        n
+      end
+
+      def tell
+        raise SDLError, "closed and freed rw" if closed?
+
+        n = SDL.SDL_RWtell(to_ptr)
+        raise SDLError if n < 0
+        n
+      end
+
+      alias pos tell
+
+      def write(obj)
+        raise SDLError, "closed and freed rw" if closed?
+
+        ptr = obj.to_s
+        len = ptr.bytesize
+
+        n = SDL.SDL_RWwrite(to_ptr, ptr, 1, len)
+        raise SDLError if n < len
+        n
+      end
+    end
+  end
+end

data/lib/SDLRuby/rw/read_closure.rb

@@ -0,0 +1,28 @@
+module SDLRuby
+  class RW
+    class ReadClosure < Fiddle::Closure
+      include Fiddle
+
+      def initialize(obj)
+        # size_t (*read) (SDL_RWops *context, void *ptr, size_t size, size_t maxnum)
+        #
+        super(TYPE_SIZE_T, [TYPE_VOIDP, TYPE_VOIDP, TYPE_SIZE_T, TYPE_SIZE_T])
+        @obj = obj
+      end
+
+      def call(_, ptr, size, maxnum)
+        len = size * maxnum
+        return 0 if len.zero?
+
+        s = @obj.read(len)
+        return 0 if s.nil? || s.empty? # EOF
+
+        ptr[0, s.size] = s
+        s.size / size
+      rescue => e
+        SDL.last_error_message = e.message
+        0
+      end
+    end
+  end
+end

data/lib/SDLRuby/rw/seek_closure.rb

@@ -0,0 +1,22 @@
+module SDLRuby
+  class RW
+    class SeekClosure < Fiddle::Closure
+      include Fiddle
+
+      def initialize(obj)
+        # Sint64 (*seek) (SDL_RWops *context, Sint64 offset, int whence)
+        #
+        super(TYPE_INT64_T, [TYPE_VOIDP, TYPE_INT64_T, TYPE_INT])
+        @obj = obj
+      end
+
+      def call(_, offset, whence)
+        @obj.seek(offset, whence)
+        @obj.tell
+      rescue => e
+        SDL.last_error_message = e.message
+        -1
+      end
+    end
+  end
+end

data/lib/SDLRuby/rw/size_closure.rb

@@ -0,0 +1,21 @@
+module SDLRuby
+  class RW
+    class SizeClosure < Fiddle::Closure
+      include Fiddle
+
+      def initialize(obj)
+        # Sint64 (*size) (SDL_RWops *context)
+        #
+        super(TYPE_INT64_T, [TYPE_VOIDP])
+        @obj = obj
+      end
+
+      def call(_)
+        @obj.size
+      rescue => e
+        SDL.last_error_message = e.message
+        -1
+      end
+    end
+  end
+end

data/lib/SDLRuby/rw/write_closure.rb

@@ -0,0 +1,21 @@
+module SDLRuby
+  class RW
+    class WriteClosure < Fiddle::Closure
+      include Fiddle
+
+      def initialize(obj)
+        # size_t (*write) (SDL_RWops *context, const void *ptr, size_t size, size_t num)
+        #
+        super(TYPE_SIZE_T, [TYPE_VOIDP, TYPE_VOIDP, TYPE_SIZE_T, TYPE_SIZE_T])
+        @obj = obj
+      end
+
+      def call(_, ptr, size, num)
+        @obj.write(ptr.to_str(size * num)) / size
+      rescue => e
+        SDL.last_error_message = e.message
+        0
+      end
+    end
+  end
+end

data/lib/SDLRuby/rw_ops/mem_close.rb

@@ -0,0 +1,27 @@
+module SDLRuby
+  class RWOps
+    include Fiddle, SDL
+
+    # これはSDL3では不要になります。
+    # SDL3ではメンバーの関数ポインターにNULLを設定できます。
+    # それは”適切な”デフォルトの動作を意味します。
+    #
+    #
+    #
+    # SDL2ではcloseにはC関数ポインターを設定する必要がある。
+    # Rubyのクロージャ―を設定するとGCが動作時に該当のクロージャ―が既に回収されているため
+    # コアダンプする。
+    # また、NULLに設定するとSDL_RWclose関数の呼び出し時にコアダンプする。
+    # ここではSDLをハックしてmem_close関数を割り当てた。
+    # この関数は内部でSDL_FreeRW関数を呼び出すだけである。
+    #
+    # int (*close) (SDL_RWops *context)
+    #
+    MEM_CLOSE = module_eval do
+      ptr = Pointer.malloc(1, RUBY_FREE)
+      rw = SDL.SDL_RWFromMem(ptr, ptr.size)
+      raise SDLError if rw.null?
+      SDL_RWops.new(rw, SDL_FREE_RW)["close"].to_int
+    end
+  end
+end

data/lib/SDLRuby/rw_ops/rw_object.rb

@@ -1,128 +1,34 @@
-module SDLRuby
-  class RWOps
-    class RWObject
-      include Fiddle, SDL
-
-      # size_t (*read) (SDL_RWops *context, void *ptr, size_t size, size_t maxnum)
-      #
-      class ReadClosure < Fiddle::Closure
-        include Fiddle
-
-        def initialize(obj)
-          super(TYPE_SIZE_T, [TYPE_VOIDP, TYPE_VOIDP, TYPE_SIZE_T, TYPE_SIZE_T])
-          @obj = obj
-        end
-
-        def call(_, ptr, size, maxnum)
-          len = size * maxnum
-          return 0 if len.zero?
-
-          s = @obj.read(len)
-          return 0 if s.nil? || s.empty? # EOF
-
-          ptr[0, s.size] = s
-          s.size / size
-        rescue => e
-          SDL.last_error_message = e.full_message
-          0
-        end
-      end
-
-      # Sint64 (*seek) (SDL_RWops *context, Sint64 offset, int whence)
-      #
-      class SeekClosure < Fiddle::Closure
-        include Fiddle
-
-        def initialize(obj)
-          super(TYPE_INT64_T, [TYPE_VOIDP, TYPE_INT64_T, TYPE_INT])
-          @obj = obj
-        end
-
-        def call(_, offset, whence)
-          @obj.seek(offset, whence)
-          @obj.tell
-        rescue => e
-          SDL.last_error_message = e.full_message
-          -1
-        end
-      end
-
-      # Sint64 (*size) (SDL_RWops *context)
-      #
-      class SizeClosure < Fiddle::Closure
-        include Fiddle
-
-        def initialize(obj)
-          super(TYPE_INT64_T, [TYPE_VOIDP])
-          @obj = obj
-        end
-
-        def call(_)
-          @obj.size
-        rescue => e
-          raise e if $DEBUG
-          SDL.last_error_message = e.full_message
-          -1
-        end
-      end
-
-      # size_t (*write) (SDL_RWops *context, const void *ptr, size_t size, size_t num)
-      #
-      class WriteClosure < Fiddle::Closure
-        include Fiddle
-
-        def initialize(obj)
-          super(TYPE_SIZE_T, [TYPE_VOIDP, TYPE_VOIDP, TYPE_SIZE_T, TYPE_SIZE_T])
-          @obj = obj
-        end
-
-        def call(_, ptr, size, num)
-          @obj.write(ptr.to_str(size * num)) / size
-        rescue => e
-          SDL.last_error_message = e.full_message
-          0
-        end
-      end
-
-      # closeにはC関数を設定する必要がある。
-      # クロージャ―を設定するとGCによる回収の際に
-      # 該当のクロージャ―が既に回収されているためコアダンプする。
-      # また、NULLに設定するとSDL_RWclose関数の呼び出し時にコアダンプする。
-      # SDLをハックしてmem_close関数を割り当てた。
-      # この関数は内部でSDL_FreeRW関数を呼び出すだけである。
-      #
-      # int (*close) (SDL_RWops *context)
-      #
-      MEM_CLOSE = module_eval do
-        _ptr = Pointer.malloc(1, RUBY_FREE)
-        rw = SDL.SDL_RWFromMem(_ptr, _ptr.size)
-        raise SDLError if rw.null?
-        st = SDL_RWops.new(rw)
-
-        st.close.freeze
-      end
-
-      # 引数 obj に与えたオブジェクトは SDL から close を呼び出されてもクローズしない。
-      # このインスタンスを単独で扱う場合は使い終わったらclose関数を呼び出す必要がある。
-      # そうしなければポインターは開放されずメモリーリークする。
-      #
-      def initialize(obj)
-        ptr = SDL.SDL_AllocRW
-        raise SDLError if ptr.null?
-
-        # SDLではSDL_RWopsポインターの開放はclose関数から行うように実装されている。
-        # これと同じ仕様とするため、このインスタンスではfreeの設定を行わない。
-        #
-        @st = SDL_RWops.new(ptr)
-
-        @st.close = MEM_CLOSE
-        @st.read = @read = ReadClosure.new(obj)
-        @st.seek = @seek = SeekClosure.new(obj)
-        @st.size = @size = SizeClosure.new(obj)
-        @st.write = @write = WriteClosure.new(obj)
-      end
-
-      def to_ptr = @st.to_ptr
-    end
-  end
-end
+require_relative '../rw/read_closure'
+require_relative '../rw/seek_closure'
+require_relative '../rw/size_closure'
+require_relative '../rw/write_closure'
+require_relative 'mem_close'
+
+module SDLRuby
+  class RWOps
+    class RWObject
+      include Fiddle, SDL
+
+      # 引数objに与えたオブジェクトはSDLからcloseを呼び出されてもクローズしない。
+      # このインスタンスを単独で扱う場合は使い終わったらclose関数を呼び出す必要がある。
+      # そうしなければポインターは開放されずメモリーリークする。
+      #
+      def initialize(obj)
+        ptr = SDL.SDL_AllocRW
+        raise SDLError if ptr.null?
+
+        @st = SDL_RWops.new(ptr)
+
+        # SDLではSDL_RWopsポインターの開放はclose関数ポインターを呼び出して行う仕様となっている。
+        #
+        @st.close = MEM_CLOSE
+        @st.read  = @read  = RW::ReadClosure.new(obj)
+        @st.seek  = @seek  = RW::SeekClosure.new(obj)
+        @st.size  = @size  = RW::SizeClosure.new(obj)
+        @st.write = @write = RW::WriteClosure.new(obj)
+      end
+
+      def to_ptr = @st.to_ptr
+    end
+  end
+end

data/lib/SDLRuby/rw_ops.rb

@@ -1,216 +1,91 @@
-require_relative 'rw_ops/rw_object'
-
-module SDLRuby
-  class RWOps
-    include Fiddle, SDL
-
-    class << self
-      def [](src, autoclose: nil, readonly: nil)
-        case src
-        when RWOps
-          return src
-        when String
-          size = src.bytesize
-          ptr = if readonly
-                  SDL.SDL_RWFromConstMem(src, size)
-                else
-                  SDL.SDL_RWFromMem(src, size)
-                end
-          raise SDLError if ptr.null?
-        when Fiddle::Pointer
-          size = src.size
-          ptr = if readonly
-                  SDL.SDL_RWFromConstMem(src, size)
-                else
-                  SDL.SDL_RWFromMem(src, size)
-                end
-          raise SDLError if ptr.null?
-        else
-          src = RWObject.new(src)
-          ptr = src.to_ptr
-        end
-
-        obj = allocate
-        obj.__send__(:initialize, ptr, src)
-        obj
-      end
-
-      def new(file, mode = "rb")
-        ptr = SDL.SDL_RWFromFile(file, mode)
-        raise SDLError if ptr.null?
-
-        rw = super(ptr)
-
-        if block_given?
-          obj = yield(rw)
-          rw.close
-          obj
-        else
-          rw
-        end
-      end
-
-      alias open new
-    end
-
-    def initialize(ptr, obj = nil)
-      @st = SDL_RWops.new(ptr)
-      @obj = obj
-
-      # ポインターへC実装のfree関数を与えるため、終了時のGC処理でコアダンプしない。
-      #
-      @st.to_ptr.free = @st.close
-
-      # close関数の差し替えをすることで、SDLがcloseを行ってもRuby側に伝達できる。
-      # int (*close) (SDL_RWops *context)
-      #
-      st = @st
-      @st.close = @close = Closure::BlockCaller.new(
-        TYPE_INT, [TYPE_VOIDP]
-      ) do |context|
-        # call_free はclose関数の戻り値が渡されないためcloseの失敗は分からない。
-        st.to_ptr.call_free
-
-        if $DEBUG
-          warn "SDL_RWops(0x#{st.to_i.to_s(16)}) closed."
-        end
-
-        0
-      end
-    end
-
-    def close
-      unless closed?
-        err = SDL.SDL_RWclose(self)
-
-        raise SDLError if err != 0
-      end
-    end
-
-    def closed? = @st.to_ptr.freed?
-
-    def eof?
-      raise IOError, "closed" if closed?
-
-      s = SDL.SDL_RWsize(self)
-      raise SDLError if s < 0
-
-      t = SDL.SDL_RWtell(self)
-      raise SDLError if t < 0
-
-      s == t
-    end
-
-    def read(length = nil, buffer = nil)
-      raise IOError, "closed" if closed?
-
-      len = if length.nil?
-              size - tell
-            else
-              length.to_i
-            end
-
-      if len < 0
-        raise ArgumentError, "length"
-      elsif len > 0 && eof?
-        return nil
-      end
-
-      case buffer
-      when nil
-        return "" if len == 0
-
-        buffer = "\x00" * len
-        buf_size = len
-      when String
-        return buffer.clear if len == 0
-
-        buffer = buffer
-        buf_size = buffer.bytesize
-      when Fiddle::Pointer
-        if len == 0
-          buffer.size = 0
-          return buffer
-        end
-
-        buffer = buffer
-        buf_size = buffer.size
-      else
-        raise TypeError, "buffer"
-      end
-
-      if len > buf_size
-        raise ArgumentError, "length is greater than buffer size."
-      end
-
-      n = SDL.SDL_RWread(self, buffer, 1, len)
-      raise SDLError if n == 0
-
-      if String === buffer
-        buffer.slice!(n, buffer.bytesize)
-      else
-        buffer.size = n
-      end
-
-      buffer
-    end
-
-    def seek(offset, whence = IO::SEEK_SET)
-      raise IOError, "closed" if closed?
-
-      n = SDL.SDL_RWseek(self, offset, whence)
-      raise SDLError if n < 0
-      n
-    end
-
-    alias pos= seek
-
-    def size
-      raise IOError, "closed" if closed?
-
-      n = SDL.SDL_RWsize(self)
-      raise SDLError if n < 0
-      n
-    end
-
-    def tell
-      raise IOError, "closed" if closed?
-
-      n = SDL.SDL_RWtell(self)
-      raise SDLError if n < 0
-      n
-    end
-
-    alias pos tell
-
-    def to_ptr
-      raise SDLError, "released" if closed?
-      @st.to_ptr
-    end
-
-    def type
-      raise SDLError, "released" if closed?
-      @st.type
-    end
-
-    def write(obj)
-      raise IOError, "closed" if closed?
-
-      case obj
-      when String
-        ptr = obj
-        len = obj.bytesize
-      when Fiddle::Pointer
-        ptr = obj
-        len = obj.size
-      else
-        ptr = obj.to_s
-        len = ptr.bytesize
-      end
-
-      n = SDL.SDL_RWwrite(self, ptr, 1, len)
-      raise SDLError if n < len
-      n
-    end
-  end
-end
+require 'stringio'
+require_relative 'rw/operational'
+require_relative 'rw_ops/rw_object'
+
+module SDLRuby
+  class RWOps
+    include Fiddle, RW::Operational, SDL
+
+    class << self
+      def [](obj)
+        return obj if obj.kind_of?(RWOps)
+
+        case obj
+        in Fiddle::Pointer
+          ptr = if obj.frozen?
+                  SDL.SDL_RWFromConstMem(obj, obj.size)
+                else
+                  SDL.SDL_RWFromMem(obj, obj.size)
+                end
+          raise SDLError if ptr.null?
+        in String
+          obj = RWObject.new(StringIO.new(obj))
+          ptr = obj.to_ptr
+        else
+          obj = RWObject.new(obj)
+          ptr = obj.to_ptr
+        end
+
+        rw = allocate
+        rw.__send__(:initialize, ptr, obj)
+        rw
+      end
+
+      def new(file, mode = "rb")
+        path = if file.instance_of?(String)
+                 file
+               elsif file.respond_to?(:to_path)
+                 file.to_path
+               end
+        ptr = SDL.SDL_RWFromFile(path, mode)
+        raise SDLError if ptr.null?
+
+        rw = super(ptr)
+
+        if block_given?
+          begin
+            yield(rw)
+          ensure
+            rw.close
+          end
+        else
+          rw
+        end
+      end
+
+      alias open new
+    end
+
+    def initialize(ptr, obj = nil)
+      @obj = obj
+
+      @st = SDL_RWops.new(ptr)
+
+      # ポインターへC実装のfree関数を与えるため、終了時のGC処理でコアダンプしない。
+      #
+      @st.to_ptr.free = @st["close"]
+
+      # close関数の差し替えをすることで、SDLがcloseを行ってもRuby側に伝達できる。
+      # int (*close) (SDL_RWops *context)
+      #
+      @st["close"] = @close = Closure::BlockCaller.new(TYPE_INT, [TYPE_VOIDP]) do |_|
+        # call_free はclose関数の戻り値が渡されないためcloseの失敗は分からない。
+        to_ptr.call_free
+
+        if $DEBUG
+          warn format("SDL_RWops(0x%016x) closed", to_ptr.to_int)
+        end
+
+        0
+      end
+    end
+
+    def initialize_copy(other)
+      raise SDLError, "closed stream" if closed?
+
+      super
+    end
+
+    def to_ptr = @st.to_ptr
+  end
+end

data/lib/SDLRuby/sdl.rb

@@ -1,218 +1,218 @@
-require "fiddle/import"
-
-module SDLRuby
-  module SDL
-    extend Fiddle::Importer
-
-    dlload "SDL2"
-
-    SDL_DESTROY_RENDERER = import_symbol("SDL_DestroyRenderer").to_int
-    SDL_DESTROY_TEXTURE = import_symbol("SDL_DestroyTexture").to_int
-
-    # SDL_freeはSDL_SetMemoryFunctionsで設定された関数を使用する。
-    # SDL側のメモリーを開放する場合はFiddle::PointerへSDL_FREEを設定してよい。
-    #
-    SDL_FREE = SDL.import_symbol("SDL_free").to_int
-    SDL_FREE_CURSOR = import_symbol("SDL_FreeCursor").to_int
-    SDL_FREE_FORMAT = import_symbol("SDL_FreeFormat").to_int
-    SDL_FREE_PALETTE = import_symbol("SDL_FreePalette").to_int
-    SDL_FREE_RW = import_symbol("SDL_FreeRW").to_int
-    SDL_FREE_SURFACE = import_symbol("SDL_FreeSurface").to_int
-
-    def self.tmp_value(*a, &)
-      raise ArgumentError if a.empty?
-
-      a.map { |ty|
-        st = create_value(ty)
-        st.to_ptr.free = Fiddle::RUBY_FREE
-        st
-      } => vals
-
-      v = vals.one? ? vals.first : vals
-      block_given? ? yield(*v) : v
-    end
-
-    require_relative 'sdl/sdl'
-    require_relative 'sdl_error'
-
-    require_relative 'audio'
-    require_relative 'cursor'
-    require_relative 'display'
-    require_relative 'event'
-    require_relative 'hint'
-    require_relative 'keyboard'
-    require_relative 'mouse'
-    require_relative 'palette'
-    require_relative 'pixel_formatter'
-    require_relative 'rect'
-    require_relative 'renderer'
-    require_relative 'rw_ops'
-    require_relative 'surface'
-    require_relative 'text_input'
-    require_relative 'texture'
-    require_relative 'timer'
-    require_relative 'window'
-
-    class << self
-      # sdl
-      #
-      def init(flags = nil)
-        err = SDL.SDL_Init(flags || SDL_INIT_EVERYTHING)
-        raise SDLError if err < 0
-      end
-
-      # Description:
-      #
-      # This method checks the initialization status of SDL subsystems based on
-      # the provided flags. You can specify the SDL subsystems you want to check
-      # by combining the SDL_INIT_* flags using bitwise OR.
-      #
-      # Parameters:
-      #
-      # flags (optional): An integer or a combination of SDL_INIT_* flags
-      # representing the SDL subsystems to check. Default is nil.
-      #
-      # Return Value:
-      #
-      # If all the specified SDL subsystems in flags are initialized,
-      # the method returns true.
-      # If any of the specified SDL subsystems are not initialized,
-      # it returns false.
-      # If flags is given as nil or 0,
-      # the method returns true if any of the SDL subsystems are initialized.
-      #
-      def init?(flags = nil)
-        if flags && flags != 0
-          SDL.SDL_WasInit(flags) == flags
-        else
-          SDL.SDL_WasInit(0) != 0
-        end
-      end
-
-      def quit = SDL.SDL_Quit
-
-      # clipboard
-      #
-      def clipboard_text
-        ptr = SDL.SDL_GetClipboardText
-        raise SDLError if ptr.null?
-
-        ptr.free = SDL_FREE
-        ptr.to_s.force_encoding("UTF-8")
-      end
-
-      def clipboard_text? = SDL.SDL_HasClipboardText == 1
-
-      def clipboard_text=(s)
-        err = SDL.SDL_SetClipboardText(s.to_s.encode("UTF-8"))
-        raise SDLError if err < 0
-      end
-
-      # cpu info
-      #
-      def cpu_cache_line_size = SDL.SDL_GetCPUCacheLineSize
-
-      def cpu_count = SDL.SDL_GetCPUCount
-
-      def system_ram = SDL.SDL_GetSystemRAM
-
-      # error
-      #
-      def last_error_message = SDL.SDL_GetError.to_s
-
-      def last_error_message=(s)
-        SDL.SDL_SetError(s.to_s.gsub(/%/, "%%"))
-      end
-
-      # filesystem
-      #
-      def base_path
-        ptr = SDL.SDL_GetBasePath
-        raise SDLError if ptr.null?
-
-        ptr.free = SDL_FREE
-        ptr.to_s
-      end
-
-      # locale
-      #
-      def locales
-        ptr = SDL.SDL_GetPreferredLocales
-        return [] if ptr.null?
-
-        ptr.free = SDL_FREE
-        size = SDL_Locale.size
-        (0..).inject([]) do |memo, i|
-          st = SDL_Locale.new(ptr + i * size)
-          break memo if st.language.null?
-          memo << [st.language.to_s,
-                   (c = st.country).null? ? nil : c.to_s]
-        end
-      end
-
-      # message box
-      #
-      def alert(message, title = nil, flags: nil, window: nil)
-        err = SDL.SDL_ShowSimpleMessageBox(flags,
-                                           title.to_s.encode("UTF-8"),
-                                           message.to_s.encode("UTF-8"),
-                                           window)
-        raise SDLError if err < 0
-      end
-
-      def error_alert(message, title = "Error")
-        alert(message, title, flags: SDL_MESSAGEBOX_ERROR)
-      end
-
-      def warn_alert(message, title = "Warning")
-        alert(message, title, flags: SDL_MESSAGEBOX_WARNING)
-      end
-
-      def info_alert(message, title = "Information")
-        alert(message, title, flags: SDL_MESSAGEBOX_INFORMATION)
-      end
-
-      # misc
-      #
-      def open_url(url)
-        raise SDLError if SDL.SDL_OpenURL(url) < 0
-      end
-
-      # platform
-      #
-      def platform = SDL.SDL_GetPlatform.to_s
-
-      # timer
-      #
-      def ticks = Timer.ticks
-
-      # version
-      #
-      def revision = SDL.SDL_GetRevision.to_s
-
-      def version
-        st = SDL_version.malloc(Fiddle::RUBY_FREE)
-        SDL.SDL_GetVersion(st)
-        st.to_a.join(".")
-      end
-
-      # video
-      #
-      def video_driver
-        (ptr = SDL.SDL_GetCurrentVideoDriver).null? ? nil : ptr.to_s
-      end
-
-      def screen_saver=(b)
-        b ? SDL.SDL_EnableScreenSaver : SDL.SDL_DisableScreenSaver
-      end
-
-      def screen_saver? = SDL.SDL_IsScreenSaverEnabled != 0
-
-      def video_drivers
-        SDL.SDL_GetNumVideoDrivers.times.map do |i|
-          (ptr = SDL.SDL_GetVideoDriver(i)).null? ? nil : ptr.to_s
-        end
-      end
-    end
-  end
-end
+require "fiddle/import"
+
+module SDLRuby
+  module SDL
+    extend Fiddle::Importer
+
+    dlload "SDL2"
+
+    SDL_DESTROY_RENDERER = import_symbol("SDL_DestroyRenderer").to_int
+    SDL_DESTROY_TEXTURE  = import_symbol("SDL_DestroyTexture").to_int
+
+    # SDL_freeはSDL_SetMemoryFunctionsで設定された関数を使用する。
+    # SDL側のメモリーを開放する場合はFiddle::PointerへSDL_FREEを設定してよい。
+    #
+    SDL_FREE         = import_symbol("SDL_free").to_int
+    SDL_FREE_CURSOR  = import_symbol("SDL_FreeCursor").to_int
+    SDL_FREE_FORMAT  = import_symbol("SDL_FreeFormat").to_int
+    SDL_FREE_PALETTE = import_symbol("SDL_FreePalette").to_int
+    SDL_FREE_RW      = import_symbol("SDL_FreeRW").to_int
+    SDL_FREE_SURFACE = import_symbol("SDL_FreeSurface").to_int
+
+    def self.tmp_value(*a, &)
+      raise ArgumentError if a.empty?
+
+      a.map { |ty|
+        st = create_value(ty)
+        st.to_ptr.free = Fiddle::RUBY_FREE
+        st
+      } => vals
+
+      v = vals.one? ? vals.first : vals
+      block_given? ? yield(*v) : v
+    end
+
+    require_relative 'sdl/sdl'
+    require_relative 'sdl_error'
+
+    require_relative 'audio'
+    require_relative 'cursor'
+    require_relative 'display'
+    require_relative 'event'
+    require_relative 'hint'
+    require_relative 'keyboard'
+    require_relative 'mouse'
+    require_relative 'palette'
+    require_relative 'pixel_formatter'
+    require_relative 'rect'
+    require_relative 'renderer'
+    require_relative 'rw_ops'
+    require_relative 'surface'
+    require_relative 'text_input'
+    require_relative 'texture'
+    require_relative 'timer'
+    require_relative 'window'
+
+    class << self
+      # sdl
+      #
+      def init(flags = nil)
+        err = SDL.SDL_Init(flags || SDL_INIT_EVERYTHING)
+        raise SDLError if err < 0
+      end
+
+      # Description:
+      #
+      # This method checks the initialization status of SDL subsystems based on
+      # the provided flags. You can specify the SDL subsystems you want to check
+      # by combining the SDL_INIT_* flags using bitwise OR.
+      #
+      # Parameters:
+      #
+      # flags (optional): An integer or a combination of SDL_INIT_* flags
+      # representing the SDL subsystems to check. Default is nil.
+      #
+      # Return Value:
+      #
+      # If all the specified SDL subsystems in flags are initialized,
+      # the method returns true.
+      # If any of the specified SDL subsystems are not initialized,
+      # it returns false.
+      # If flags is given as nil or 0,
+      # the method returns true if any of the SDL subsystems are initialized.
+      #
+      def init?(flags = nil)
+        if flags && flags != 0
+          SDL.SDL_WasInit(flags) == flags
+        else
+          SDL.SDL_WasInit(0) != 0
+        end
+      end
+
+      def quit = SDL.SDL_Quit
+
+      # clipboard
+      #
+      def clipboard_text
+        ptr = SDL.SDL_GetClipboardText
+        raise SDLError if ptr.null?
+
+        ptr.free = SDL_FREE
+        ptr.to_s.force_encoding("UTF-8")
+      end
+
+      def clipboard_text? = SDL.SDL_HasClipboardText == 1
+
+      def clipboard_text=(s)
+        err = SDL.SDL_SetClipboardText(s.to_s.encode("UTF-8"))
+        raise SDLError if err < 0
+      end
+
+      # cpu info
+      #
+      def cpu_cache_line_size = SDL.SDL_GetCPUCacheLineSize
+
+      def cpu_count = SDL.SDL_GetCPUCount
+
+      def system_ram = SDL.SDL_GetSystemRAM
+
+      # error
+      #
+      def last_error_message = SDL.SDL_GetError.to_s
+
+      def last_error_message=(s)
+        SDL.SDL_SetError(s.to_s.gsub(/%/, "%%"))
+      end
+
+      # filesystem
+      #
+      def base_path
+        ptr = SDL.SDL_GetBasePath
+        raise SDLError if ptr.null?
+
+        ptr.free = SDL_FREE
+        ptr.to_s
+      end
+
+      # locale
+      #
+      def locales
+        ptr = SDL.SDL_GetPreferredLocales
+        return [] if ptr.null?
+
+        ptr.free = SDL_FREE
+        size = SDL_Locale.size
+        (0..).inject([]) do |memo, i|
+          st = SDL_Locale.new(ptr + i * size)
+          break memo if st.language.null?
+          memo << [st.language.to_s,
+                   (c = st.country).null? ? nil : c.to_s]
+        end
+      end
+
+      # message box
+      #
+      def alert(message, title = nil, flags: nil, window: nil)
+        err = SDL.SDL_ShowSimpleMessageBox(flags,
+                                           title.to_s.encode("UTF-8"),
+                                           message.to_s.encode("UTF-8"),
+                                           window)
+        raise SDLError if err < 0
+      end
+
+      def error_alert(message, title = "Error")
+        alert(message, title, flags: SDL_MESSAGEBOX_ERROR)
+      end
+
+      def warn_alert(message, title = "Warning")
+        alert(message, title, flags: SDL_MESSAGEBOX_WARNING)
+      end
+
+      def info_alert(message, title = "Information")
+        alert(message, title, flags: SDL_MESSAGEBOX_INFORMATION)
+      end
+
+      # misc
+      #
+      def open_url(url)
+        raise SDLError if SDL.SDL_OpenURL(url) < 0
+      end
+
+      # platform
+      #
+      def platform = SDL.SDL_GetPlatform.to_s
+
+      # timer
+      #
+      def ticks = Timer.ticks
+
+      # version
+      #
+      def revision = SDL.SDL_GetRevision.to_s
+
+      def version
+        st = SDL_version.malloc(Fiddle::RUBY_FREE)
+        SDL.SDL_GetVersion(st)
+        st.to_a.join(".")
+      end
+
+      # video
+      #
+      def video_driver
+        (ptr = SDL.SDL_GetCurrentVideoDriver).null? ? nil : ptr.to_s
+      end
+
+      def screen_saver=(b)
+        b ? SDL.SDL_EnableScreenSaver : SDL.SDL_DisableScreenSaver
+      end
+
+      def screen_saver? = SDL.SDL_IsScreenSaverEnabled != 0
+
+      def video_drivers
+        SDL.SDL_GetNumVideoDrivers.times.map do |i|
+          (ptr = SDL.SDL_GetVideoDriver(i)).null? ? nil : ptr.to_s
+        end
+      end
+    end
+  end
+end

data/lib/SDLRuby/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module SDLRuby
-  VERSION = "0.3.0"
+  VERSION = "0.3.1"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: SDLRuby
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.3.1
 platform: ruby
 authors:
 - shinokaro
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-09-18 00:00:00.000000000 Z
+date: 2023-09-27 00:00:00.000000000 Z
 dependencies: []
 description: SDLRuby is a GEM that allows calling the SDL library from Ruby, enabling
   window creation, image display, audio playback, and more. It easily manages C pointers
@@ -51,7 +51,13 @@ files:
 - lib/SDLRuby/renderer/accessor.rb
 - lib/SDLRuby/renderer/drawer.rb
 - lib/SDLRuby/renderer/renderer_info.rb
+- lib/SDLRuby/rw/operational.rb
+- lib/SDLRuby/rw/read_closure.rb
+- lib/SDLRuby/rw/seek_closure.rb
+- lib/SDLRuby/rw/size_closure.rb
+- lib/SDLRuby/rw/write_closure.rb
 - lib/SDLRuby/rw_ops.rb
+- lib/SDLRuby/rw_ops/mem_close.rb
 - lib/SDLRuby/rw_ops/rw_object.rb
 - lib/SDLRuby/sdl.rb
 - lib/SDLRuby/sdl/include/SDL.h.rb