SDLRuby 0.2.1 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 20bdcc86d9ea3a4670b1f0ac86689d0cae12f51417d9ba92cc710be1ecab8614
-  data.tar.gz: 3869b91b982b18fe37c5dc97a4b7e99b9f42e2266b42957fa31632ce79bb3447
+  metadata.gz: fb651b451bbc9fc356e5f3a1ecb08d5855a690fa7b0556f7a9da5f0f11f2d6d4
+  data.tar.gz: 9f53754821bf14951f4cd014f1b776d07a5b3807a81ceee937ce96e6f71e148e
 SHA512:
-  metadata.gz: e0c6372d9db1be4ffaa5ff4af4aba575d74d3c36682da3df5423c30fcde44c6986ebcd1b3c8d8e37a909148308922a98436cfba53ad75fcd91d6e84407d275bf
-  data.tar.gz: fa71f7889d06990aed6fd43d8bd09573ca6900a7d7223ce513d0a47830610cc95f49a0883854d5d4670ccd7a67ca2e72576cf026298ad6bc94b08e70aecd2e6e
+  metadata.gz: f5cfbf90c23eb97fcec12e34af27a2966e7d5c3fc010186a28ff1ec2c4caaf5a5cefc0ed68863907f9dad417688b1ec9dc61388e4d4723fb199cfcf5b7582553
+  data.tar.gz: b91967cab249f58717362fa4d1241e650d0a38b54ff340167a631a76691a5a17811961fc675a9edfbd0ea8ff2259e4d9c0800c08999cf2273535091f529ce2b4

data/CHANGELOG.md

@@ -1,6 +1,15 @@
 ## [Unreleased]
 
-## [0.2.0] - 2023-09-13
+## [0.3.1] - 2023-09-28
+- Refactored RWOps class.
+
+## [0.3.0] - 2023-09-19
+- Implemented Mouse Module.
+- Implementation of the Timer Module.
+- Implemented Keyboard Module.
+- Specification and implementation of SDL.init, SDL.init?, and SDL.quit.
+
+## [0.2.1] - 2023-09-13
 
 - Memory leak fix on event retrieval failure. 
 

data/lib/SDLRuby/keyboard.rb

@@ -3,56 +3,67 @@ module SDLRuby
     module_eval do
       num_keys = SDL.tmp_value("int")
 
-      # SDL_GetKeyboardState() が戻すポインターはSDLがロードされた時点で作成されている。
-      # この関数は SDL_Init() より前に呼ぶことができる。
+      # The SDL_GetKeyboardState function can be called before SDL_Init.
+      #
       ptr = SDL.SDL_GetKeyboardState(num_keys)
 
-      # エラーになるのはnum_keysにNULLを渡したとき。
+      # SDL_GetKeyboardState returns an error when num_keys is NULL.
+      #
       raise SDLError if ptr.null?
 
       ptr.size = num_keys.value
-      @state = ptr
+      @ptr = ptr.freeze
     end
 
     class << self
-      def [](idx)
-        raise IndexError if idx < 0 || @state.size <= idx
-        @state[idx] != 0
-      end
-
-      def any? = to_a.any?
-
-      def clear = SDL.SDL_ResetKeyboard
-
-      # キー名からキーコードを得る
-      def keycode(s) = SDL.GetKeyFromName(s).nonzero?
+      include SDL
 
-      # キーコードからキー名を得る
-      def keycode_name(num)
-        (s = SDL.GetKeyName(num).to_s).empty? ? nil : s
+      # This method specifies the ability to check for a match with
+      # the characters appearing in the 'when' clause of a 'case' statement.
+      #
+      # see also: String#===
+      #
+      def ==(other)
+        case other
+        when Integer
+          0 <= other && other < @ptr.size && @ptr[other] != 0
+        when String, Symbol
+          (idx = scancode(other)) != 0 && @ptr[idx] != 0
+        else
+          super
+        end
       end
 
-      # 修飾キーの状態を得る
-      def mod
-        SDL.SDL_GetModState #=> integer
+      def any?
+        # SDL sets a byte to either 0x00 or 0x01 for each scancode.
+        # It does not fill the byte sequence with 0x80, so this should work.
+        #
+        to_str.sum != 0
       end
 
-      # 修飾キーを設定する
-      def mod=(modstate)
-        SDL.SDL_SetModState(modstate)
+      def clear
+        # SDL_ResetKeyboard should be preceded by initializing SDL events since
+        # it sends SDLK_KEYUP events for pressed keys.
+        #
+        # Calling SDL_ResetKeyboard when the SDL event subsystem is not initialized
+        # results in a core dump.
+        #
+        SDL.SDL_ResetKeyboard if SDL.init?(SDL_INIT_EVENTS)
       end
 
-      # キー名からスキャンコードを得る
-      def scancode(s) = SDL.GetScancodeFromName(s).nonzero?
+      def mod = SDL.SDL_GetModState
 
-      # スキャンコードからキー名を得る
-      def scancode_name(num)
-        (s = SDL.GetScancodeName(num).to_s).empty? ? nil : s
-      end
+      def scancode(s) = SDL.SDL_GetScancodeFromName(s.to_s)
+
+      def scancode_name(num) = SDL.SDL_GetScancodeName(num).to_s
+
+      def size = @ptr.size
+
+      alias length size
 
-      def to_a = to_str.unpack("C*").map(&:nonzero?)
+      def to_a = size.times.select { |i| @ptr[i] != 0 }
 
-      def to_str = @state.to_str
+      def to_str = @ptr.to_str
     end
   end
 end

data/lib/SDLRuby/mouse.rb

@@ -1,52 +1,130 @@
 module SDLRuby
   module Mouse
-    @global_x, @global_y = *SDL.tmp_value("int", "int")
-    @relative_x, @relative_y = *SDL.tmp_value("int", "int")
-    @x, @y = *SDL.tmp_value("int", "int")
-
     class << self
       include SDL
 
-      def to_button_ary(num)
-        [
-          num & SDL_BUTTON_LMASK  != 0,
-          num & SDL_BUTTON_MMASK  != 0,
-          num & SDL_BUTTON_RMASK  != 0,
-          num & SDL_BUTTON_X1MASK != 0,
-          num & SDL_BUTTON_X2MASK != 0
-        ]
-      end
+      def button = button_to_ary(WindowMouse.button)
 
+      # If called without initializing the SDL video subsystem,
+      # even if a mouse is present in the system, it will return an error.
+      #
+      # This method must be called from the main thread.
+      #
       def capture=(b)
         err = SDL.SDL_CaptureMouse(b ? 1 : 0)
         raise SDLError if err < 0
       end
 
+      def global_button = button_to_ary(GlobalMouse.button)
+
+      def global_pos = GlobalMouse.pos
+
+      # If called without initializing the SDL video subsystem,
+      # even if a mouse is present in the system, it will return an error.
+      #
       def global_pos=(xy)
-        err = SDL.SDL_WarpMouseGlobal(*xy)
-        raise SDLError if err < 0
+        GlobalMouse.pos=(xy)
       end
 
-      def global_state = [
-        SDL.SDL_GetGlobalMouseState(@global_x, @global_y),
-        @global_x.value, @global_y.value
-      ]
+      def global_state
+        a = GlobalMouse.state
+        a[0] = button_to_ary(a[0])
+        a
+      end
 
+      def pos = WindowMouse.pos
+
+      def pos=(xy)
+        SDL.SDL_WarpMouseInWindow(nil, *xy)
+      end
+
+      # If called without initializing the SDL video subsystem,
+      # even if a mouse is present in the system, it will return an error.
+      #
       def relative=(b)
         err = SDL.SDL_SetRelativeMouseMode(b ? 1 : 0)
         raise SDLError if err < 0
       end
 
-      def relative? = SDL.SDL_GetRelativeMouseMode == 1
+      def relative? = SDL.SDL_GetRelativeMouseMode != 0
+
+      def relative_pos = RelativeMouse.pos
+
+      def relative_state
+        a = RelativeMouse.state
+        a[0] = button_to_ary(a[0])
+        a
+      end
+
+      def state
+        a = WindowMouse.state
+        a[0] = button_to_ary(a[0])
+        a
+      end
+
+      private
+
+      def button_to_ary(num)
+        [
+          num & SDL_BUTTON_LMASK  != 0,
+          num & SDL_BUTTON_MMASK  != 0,
+          num & SDL_BUTTON_RMASK  != 0,
+          num & SDL_BUTTON_X1MASK != 0,
+          num & SDL_BUTTON_X2MASK != 0,
+        ]
+      end
+    end
+
+    module GlobalMouse
+      @x, @y = SDL.tmp_value("int", "int")
+
+      class << self
+        def button = SDL.SDL_GetGlobalMouseState(nil, nil)
 
-      def relative_state = [
-        SDL.SDL_GetRelativeMouseState(@relative_x, @relative_y),
-        @relative_x.value, @relative_y.value
-      ]
+        def pos
+          SDL.SDL_GetGlobalMouseState(@x, @y)
+          [@x.value, @y.value]
+        end
 
-      def state = [
-        SDL.SDL_GetMouseState(@x, @y), @x.value, @y.value
-      ]
+        def pos=(xy)
+          err = SDL.SDL_WarpMouseGlobal(*xy)
+          raise SDLError if err < 0
+        end
+
+        def state = [SDL.SDL_GetGlobalMouseState(@x, @y), @x.value, @y.value]
+      end
+    end
+
+    module RelativeMouse
+      @x, @y = SDL.tmp_value("int", "int")
+
+      class << self
+        def pos
+          SDL.SDL_GetRelativeMouseState(@x, @y)
+          [@x.value, @y.value]
+        end
+
+        def state = [SDL.SDL_GetRelativeMouseState(@x, @y), @x.value, @y.value]
+      end
+    end
+
+    module WindowMouse
+      @x, @y = SDL.tmp_value("int", "int")
+
+      class << self
+        def button = SDL.SDL_GetMouseState(nil, nil)
+
+        def pos
+          SDL.SDL_GetMouseState(@x, @y)
+          [@x.value, @y.value]
+        end
+
+        def pos=(xy)
+          SDL.SDL_WarpMouseInWindow(nil, *xy)
+        end
+
+        def state = [SDL.SDL_GetMouseState(@x, @y), @x.value, @y.value]
+      end
     end
   end
 end

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