rb_sdl2 0.1.0

data/lib/rb_sdl2/surface/pixel_format.rb

@@ -0,0 +1,89 @@
+module RbSDL2
+  class Surface
+    class PixelFormat
+      require_relative '../ref_count_pointer'
+
+      class PixelFormatPointer < RefCountPointer
+        class << self
+          def release(ptr) = ::SDL2.SDL_FreeFormat(ptr)
+
+          def entity_class = ::SDL2::SDL_PixelFormat
+        end
+      end
+
+      class << self
+        require_relative '../pixel_format_enum'
+
+        def new(format)
+          ptr = PixelFormatPointer.new(::SDL2::SDL_AllocFormat(PixelFormatEnum.to_num(format)))
+          raise RbSDL2Error if ptr.null?
+          super(ptr)
+        end
+
+        def to_ptr(ptr)
+          obj = allocate
+          obj.__send__(:initialize, PixelFormatPointer.to_ptr(ptr))
+          obj
+        end
+      end
+
+      def initialize(ptr)
+        @st = ::SDL2::SDL_PixelFormat.new(ptr)
+      end
+
+      def ==(other)
+        other.respond_to?(:to_ptr) && to_ptr == other.to_ptr
+      end
+
+      def alpha_mask? = @st[:Amask] > 0
+
+      def bits_per_pixel = @st[:BitsPerPixel]
+      alias bpp bits_per_pixel
+
+      def bytes_per_pixel = @st[:BytesPerPixel]
+
+      def format = @st[:format]
+
+      require_relative '../pixel_format_enum'
+      include PixelFormatEnum
+
+      # indexed format のときはパレット番号を戻す。
+      def pack_color(color)
+        r, g, b, a = color
+        if alpha_mask?
+          ::SDL2.SDL_MapRGBA(self, r, g, b, a || ::SDL2::SDL_ALPHA_OPAQUE)
+        else
+          ::SDL2.SDL_MapRGB(self, r, g, b)
+        end
+      end
+
+      require_relative '../palette'
+
+      def palette
+        # パレットは参照カウンターで生存の保証がある。
+        # Ruby 側がパレットを保持している限り同一アドレスに違うパレットが作成されることはない。
+        # SDL では PixelFormat の palette メンバーは（行儀よく SDL_SetPixelFormatPalette を使う場合は）
+        # 後から NULL に書き換わることはない。
+        (ptr = @st[:palette]) == @palette&.to_ptr ? @palette : @palette = Palette.to_ptr(ptr)
+      end
+
+      def palette=(pal)
+        err = ::SDL2.SDL_SetPixelFormatPalette(self, pal)
+        raise RbSDL2Error if err < 0
+        @palette = nil
+      end
+
+      def to_ptr = @st.to_ptr
+
+      # indexed format のときはパレット番号を引数へ与える。
+      def unpack_color(pixel)
+        if alpha_mask?
+          ::SDL2.SDL_GetRGBA(pixel, self, *Array.new(4) { ::FFI::MemoryPointer.new(:uint8) })
+        else
+          ::SDL2.SDL_GetRGB(pixel, self, *Array.new(3) { ::FFI::MemoryPointer.new(:uint8) })
+        end
+        color.map(&:read_uint8)
+      end
+    end
+  end
+end

data/lib/rb_sdl2/surface.rb

@@ -0,0 +1,244 @@
+module RbSDL2
+  class Surface
+    require_relative 'ref_count_pointer'
+
+    class SurfacePointer < RefCountPointer
+      class << self
+        def release(ptr)
+          # 備考：SDL では参照カウンターを操作する際にロックを行っていない。
+          #
+          # SDL_Surface ポインターの参照カウンターの扱いでは SDL_DONTFREE フラグを考慮する必要がある。
+          # SDL_DONTFREE フラグが設定されていると SDL_FreeSurface を呼び出しても参照カウントが減少しない。
+          # SDL_DONTFREE フラグの状態に関わらず Ruby 側ではポインターを正しく扱えるので参照カウントを増減する。
+          # 備考：Window から SDL_Surface ポインターを取り出す際にこのフラグが設定されている。
+          st = entity_class.new(ptr)
+          if st[:flags] & ::SDL2::SDL_DONTFREE != 0
+            st[:refcount] -= 1
+            # SDL_DONTFREE が設定されているので参照カウントの値によらず SDL_FreeSurface を呼び出さない。
+            # スレッドでの競合によりポインターを開放されない可能性（＝メモリーリーク）はある。
+            # 具体的にはこのセクションを実行中に SDL_EventPump が実行され、ウィンドウのリサイズ・イベントが発生
+            # したときに起きる。この競合が起きないようにアプリケーションを実装する必要がある。
+          else
+            ::SDL2.SDL_FreeSurface(ptr)
+          end
+        end
+
+        def entity_class = ::SDL2::SDL_Surface
+      end
+    end
+
+    require_relative 'pixel_format_enum'
+
+    class << self
+      # 変換ができない場合はエラーを発生させる。
+      # 変換先がインデックスカラー（INDEX8）の時は期待する変換は行われない。
+      def convert(surface, new_format)
+        ptr = SurfacePointer.new(
+          ::SDL2.SDL_ConvertSurfaceFormat(surface, PixelFormatEnum.to_num(new_format), 0))
+        raise RbSDL2Error if ptr.null?
+        obj = allocate
+        obj.__send__(:initialize, ptr)
+        obj
+      end
+
+      require_relative 'rw_ops'
+
+      def load(file) = RWOps.new(file, "rb") { |rw| load_rw(rw) }
+
+      # load_rw は与えられたオブジェクトをオートクローズしません。
+      def load_rw(rw)
+        ptr = SurfacePointer.new(::SDL2.SDL_LoadBMP_RW(rw, 0))
+        raise RbSDL2Error if ptr.null?
+        obj = allocate
+        obj.__send__(:initialize, ptr)
+        obj
+      end
+
+      def new(w, h, format)
+        ptr = SurfacePointer.new(
+          ::SDL2.SDL_CreateRGBSurfaceWithFormat(0, w, h, 0, PixelFormatEnum.to_num(format)))
+        raise RbSDL2Error if ptr.null?
+        super(ptr)
+      end
+
+      def to_ptr(ptr)
+        obj = allocate
+        obj.__send__(:initialize, SurfacePointer.to_ptr(ptr))
+        obj
+      end
+
+      def yuv_conversion_mode_name
+        case ::SDL2.SDL_GetYUVConversionMode
+        when ::SDL2::SDL_YUV_CONVERSION_JPEG then "JPEG"
+        when ::SDL2::SDL_YUV_CONVERSION_BT601 then "BT601"
+        when ::SDL2::SDL_YUV_CONVERSION_BT709 then "BT709"
+        when ::SDL2::SDL_YUV_CONVERSION_AUTOMATIC then "AUTOMATIC"
+        else ""
+        end
+      end
+
+      def yuv_conversion_mode=(mode)
+        ::SDL2.SDL_SetYUVConversionMode(mode)
+      end
+    end
+
+    def initialize(ptr)
+      @st = ::SDL2::SDL_Surface.new(ptr)
+    end
+
+    def ==(other)
+      other.respond_to?(:to_ptr) && to_ptr == other.to_ptr
+    end
+
+    def alpha_mod
+      alpha = ::FFI::MemoryPointer.new(:uint8)
+      num = ::SDL2.SDL_GetSurfaceAlphaMod(self, alpha)
+      raise RbSDL2Error if num < 0
+      alpha.read_uint8
+    end
+
+    def alpha_mod=(alpha)
+      num = ::SDL2.SDL_SetSurfaceAlphaMod(self, alpha)
+      raise RbSDL2Error if num < 0
+    end
+
+    def blend_mode
+      blend = ::FFI::MemoryPointer.new(:int)
+      err = ::SDL2.SDL_GetSurfaceBlendMode(self, blend)
+      raise RbSDL2Error if err < 0
+      blend.read_int
+    end
+
+    require_relative 'surface/blend_mode'
+    include BlendMode
+
+    def blend_mode_name = BlendMode.to_name(blend_mode)
+
+    def blend_mode=(blend)
+      err = ::SDL2.SDL_SetSurfaceBlendMode(self, BlendMode.to_num(blend))
+      raise RbSDL2Error if err < 0
+    end
+
+    def blit(other, from: nil, to: nil, scale: false)
+      from &&= Rect.new(*from)
+      to &&= Rect.new(*to)
+      err = if scale
+              ::SDL2.SDL_UpperBlitScaled(other, from, self, to)
+            else
+              ::SDL2.SDL_UpperBlit(other, from, self, to)
+            end
+      raise RbSDL2Error if err < 0
+    end
+
+    def bounds = [0, 0, w, h]
+
+    def bytesize = pitch * height
+
+    def clip
+      rect = Rect.new
+      ::SDL2.SDL_GetClipRect(self, rect)
+      rect.to_a
+    end
+
+    # nil の場合はサーフェィス全域がクリップになる。
+    def clip=(rect)
+      rect &&= Rect.new(*rect)
+      bool = ::SDL2.SDL_SetClipRect(self, rect)
+      raise "out of bounds" if bool == ::SDL2::SDL_FALSE
+    end
+
+    def clear(color = [0, 0, 0, 0]) = fill(bounds, color)
+
+    def color_key
+      return unless color_key?
+      key = ::FFI::MemoryPointer.new(:uint32)
+      err = ::SDL2.SDL_GetColorKey(self, key)
+      return RbSDL2Error if err < 0
+      pixel_format.unpack_color(key.read_uint32)
+    end
+
+    def color_key=(color)
+      err = if color
+              ::SDL2.SDL_SetColorKey(self, ::SDL2::SDL_TRUE, pixel_format.pack_color(color))
+            else
+              ::SDL2.SDL_SetColorKey(self, ::SDL2::SDL_FALSE, 0)
+            end
+      raise RbSDL2Error if err < 0
+    end
+
+    def color_key? = ::SDL2.SDL_HasColorKey(self) == ::SDL2::SDL_TRUE
+
+    def color_mod
+      rgb = Array.new(3) { ::FFI::MemoryPointer.new(:uint8) }
+      err = ::SDL2.SDL_GetSurfaceColorMod(self, *rgb)
+      raise RbSDL2Error if err < 0
+      rgb.map(&:read_uint8)
+    end
+
+    def color_mod=(color)
+      r, g, b = color
+      err = ::SDL2.SDL_SetSurfaceColorMod(self, r, g, b)
+      raise RbSDL2Error if err < 0
+    end
+
+    def convert(new_format = format) = Surface.convert(self, new_format)
+
+    def fill(rect = clip, color = [0, 0, 0, 0])
+      err = ::SDL2.SDL_FillRect(self, Rect.new(*rect), pixel_format.pack_color(color))
+      raise RbSDL2Error if err < 0
+    end
+
+    def height = @st[:h]
+
+    alias h height
+
+    def pitch = @st[:pitch]
+
+    require_relative 'surface/pixel_format'
+
+    def pixel_format
+      # SDL_Surface の format メンバーは読み取り専用である。作成時の値が不変であることを前提としている。
+      @pixel_format ||= PixelFormat.to_ptr(@st[:format])
+    end
+
+    require 'forwardable'
+    extend Forwardable
+    def_delegators :pixel_format, *%i(bits_per_pixel bpp format palette palette=)
+
+    require_relative 'pixel_format_enum'
+    include PixelFormatEnum
+
+    def rle=(bool)
+      err = ::SDL2.SDL_SetSurfaceRLE(self, bool ? 1 : 0)
+      raise RbSDL2Error if err < 0
+    end
+
+    def rle? = ::SDL2.SDL_HasSurfaceRLE(self) == ::SDL2::SDL_TRUE
+
+    require_relative 'rw_ops'
+
+    def save(file) = RWOps.new(file, "wb") { |rw| save_rw(rw); nil }
+
+    # save_rw は与えられたオブジェクトをオートクローズしません。
+    def save_rw(rw)
+      err = ::SDL2.SDL_SaveBMP_RW(rw, 0)
+      raise RbSDL2Error if err < 0
+      rw
+    end
+
+    def size = [width, height]
+
+    def synchronize
+      ::SDL2.SDL_LockSurface(self)
+      yield(self)
+    ensure
+      ::SDL2.SDL_UnlockSurface(self)
+    end
+
+    def to_ptr = @st.to_ptr
+
+    def width = @st[:w]
+
+    alias w width
+  end
+end

data/lib/rb_sdl2/text_input.rb

@@ -0,0 +1,15 @@
+module RbSDL2
+  module TextInput
+    class << self
+      def active? = ::SDL2.SDL_IsTextInputActive == ::SDL2::SDL_TRUE
+
+      def bounds=(rect)
+        ::SDL2.SDL_SetTextInputRect(Rect.new(*rect))
+      end
+
+      def start = ::SDL2.SDL_StartTextInput
+
+      def stop = ::SDL2.SDL_StopTextInput
+    end
+  end
+end

data/lib/rb_sdl2/timer.rb

@@ -0,0 +1,22 @@
+module RbSDL2
+  module Timer
+    class << self
+      def delay(ms)
+        raise ArgumentError if ms < 0
+        ::SDL2.SDL_Delay(ms)
+      end
+
+      def performance_frequency = ::SDL2.SDL_GetPerformanceFrequency
+
+      def performance_count = ::SDL2.SDL_GetPerformanceCounter
+
+      def realtime
+        t = performance_count
+        yield
+        (performance_count - t).fdiv(performance_frequency)
+      end
+
+      def ticks = ::SDL2.SDL_GetTicks
+    end
+  end
+end

data/lib/rb_sdl2/version.rb

@@ -0,0 +1,13 @@
+module RbSDL2
+  module Version
+    class << self
+      def revision = ::SDL2.SDL_GetRevision.read_string
+
+      def version
+        st = ::SDL2::SDL_version.new
+        ::SDL2.SDL_GetVersion(st)
+        "#{st[:major]}.#{st[:minor]}.#{st[:patch]}"
+      end
+    end
+  end
+end

data/lib/rb_sdl2/video.rb

@@ -0,0 +1,25 @@
+module RbSDL2
+  module Video
+    class << self
+      def init(driver = nil)
+        raise RbSDL2Error if ::SDL2.SDL_VideoInit(driver) < 0
+      end
+
+      def current
+        ptr = ::SDL2.SDL_GetCurrentVideoDriver
+        raise RbSDL2Error if ptr.null?
+        ptr.read_string
+      end
+
+      def drivers
+        ::SDL2.SDL_GetNumVideoDrivers.times.map do |num|
+          ptr = ::SDL2.SDL_GetVideoDriver(num)
+          raise RbSDL2Error if ptr.null?
+          ptr.read_string
+        end
+      end
+
+      def quit = ::SDL2.SDL_VideoQuit
+    end
+  end
+end

data/lib/rb_sdl2/window/dialog.rb

@@ -0,0 +1,19 @@
+module RbSDL2
+  class Window
+    module Dialog
+      require_relative '../message_box'
+
+      def alert(message, **opts) = MessageBox.alert(message, self, **opts)
+
+      def confirm(message, **opts) = MessageBox.confirm(message, self, **opts)
+
+      def dialog(message, **opts) = MessageBox.dialog(message, self, **opts)
+
+      def error_alert(message, **opts) = MessageBox.error(message, self, **opts)
+
+      def info_alert(message, **opts) = MessageBox.info(message, self, **opts)
+
+      def warn_alert(message, **opts) = MessageBox.warn(message, self, **opts)
+    end
+  end
+end

data/lib/rb_sdl2/window/display.rb

@@ -0,0 +1,85 @@
+module RbSDL2
+  class Window
+    module Display
+      # Brightness はウィンドウ単体ではなくウインドウの中心があるディスプレイの輝度の取得、変更を行う。
+      # 対象となるディスプレイの取得は Window＃display メソッドを呼び出す。
+      def brightness = ::SDL2.SDL_GetWindowBrightness(self)
+
+      def brightness=(float)
+        err = ::SDL2.SDL_SetWindowBrightness(self, float)
+        raise RbSDL2Error if err < 0
+      end
+
+      require_relative '../display'
+
+      def display = Display.new(display_index)
+
+      def display_index
+        index = ::SDL2.SDL_GetWindowDisplayIndex(to_ptr)
+        raise RbSDL2Error if index < 0
+        index
+      end
+
+      require_relative '../display_mode'
+      def fullscreen_display_mode
+        obj = DisplayMode.new
+        err = ::SDL2.SDL_GetWindowDisplayMode(self, obj)
+        raise RbSDL2Error if err < 0
+        obj
+      end
+
+      def fullscreen_display_mode=(display_mode)
+        err = ::SDL2.SDL_SetWindowDisplayMode(self, display_mode)
+        raise RbSDL2Error if err < 0
+      end
+
+      class GammaRamp
+        class << self
+          def [](*a)
+            raise ArgumentError if a.length != 256
+            ptr = ::FFI::MemoryPointer.new(:uint16, 256).write_array_of_uint16(a)
+            obj = allocate
+            obj.__send__(:initialize, ptr)
+            obj
+          end
+
+          def new(gamma)
+            ptr = ::FFI::MemoryPointer.new(:uint16, 256)
+            ::SDL2.SDL_CalculateGammaRamp(gamma, ptr)
+            super(ptr)
+          end
+        end
+
+        def initialize(ptr)
+          @ptr = ptr
+        end
+
+        def to_ptr = @ptr
+
+        def to_a = @ptr.read_array_of_uint16(256)
+        alias to_ary to_a
+      end
+
+      # [r_gamma, g_gamma, b_gamma] | gamma
+      def gamma=(rgb)
+        r, g, b = *rgb
+        self.gamma_ramp = (!g && !b ? [r, r, r] : [r, g, b]).map { |f| GammaRamp.new(f) }
+      end
+
+      def gamma_ramp
+        rgb = Array.new(3) { GammaRamp.new }
+        err = ::SDL2.SDL_GetWindowGammaRamp(self, *rgb)
+        raise RbSDL2Error if err < 0
+        rgb.map(&:to_a)
+      end
+
+      # r_g_b: [[r,...],[g,...],[b,...]]
+      # 画面全体に影響を与える。OSからリセットされることもある。
+      # アプリケーションが終了しても永続的に影響をあたえる。ユーザにとって望ましくないだろう。
+      def gamma_ramp=(r_g_b)
+        err = ::SDL2.SDL_SetWindowGammaRamp(self, *r_g_b.map { |a| GammaRamp[*a] })
+        raise RbSDL2Error if err < 0
+      end
+    end
+  end
+end

data/lib/rb_sdl2/window/grab.rb

@@ -0,0 +1,23 @@
+module RbSDL2
+  class Window
+    module Grab
+      def grab=(bool)
+        ::SDL2.SDL_SetWindowGrab(self, bool ? ::SDL2::SDL_TRUE : ::SDL2::SDL_FALSE)
+      end
+
+      def grabbed? = ::SDL2.SDL_GetWindowGrab(self) == ::SDL2::SDL_TRUE
+
+      def grabbed_keyboard? = ::SDL2.SDL_GetWindowKeyboardGrab(self) == ::SDL2::SDL_TRUE
+
+      def grabbed_mouse? = ::SDL2.SDL_GetWindowMouseGrab(self) == ::SDL2::SDL_TRUE
+
+      def keyboard_grab=(bool)
+        ::SDL2.SDL_SetWindowKeyboardGrab(self, bool ? ::SDL2::SDL_TRUE : ::SDL2::SDL_FALSE)
+      end
+
+      def mouse_grab=(bool)
+        ::SDL2.SDL_SetWindowMouseGrab(self, bool ? ::SDL2::SDL_TRUE : ::SDL2::SDL_FALSE)
+      end
+    end
+  end
+end

data/lib/rb_sdl2/window/hit_test.rb

@@ -0,0 +1,52 @@
+module RbSDL2
+  class Window
+    class HitTest < ::FFI::Function
+      @callbacks = {}
+      @mutex = Mutex.new
+
+      class << self
+        def callback_set(window, obj, userdata = nil)
+          func = if Proc === obj
+                   new(&obj)
+                 else
+                   obj
+                 end
+          @mutex.synchronize do
+            err = ::SDL2.SDL_SetWindowHitTest(window, func, userdata)
+            raise RbSDL2Error if err < 0
+            id = window.id
+            if obj
+              @callbacks[id] = [func, userdata]
+            else
+              @callbacks.delete(id)
+            end
+          end
+          [obj, userdata]
+        end
+      end
+
+      HIT_TEST_RESULT = Hash.new(::SDL2::SDL_HITTEST_NORMAL).merge!(
+        :normal => ::SDL2::SDL_HITTEST_NORMAL,
+        :draggable => ::SDL2::SDL_HITTEST_DRAGGABLE,
+        :top_left => ::SDL2::SDL_HITTEST_RESIZE_TOPLEFT,
+        :top => ::SDL2::SDL_HITTEST_RESIZE_TOP,
+        :top_right => ::SDL2::SDL_HITTEST_RESIZE_TOPRIGHT,
+        :resize_right => ::SDL2::SDL_HITTEST_RESIZE_RIGHT,
+        :bottom_right => ::SDL2::SDL_HITTEST_RESIZE_BOTTOMRIGHT,
+        :bottom => ::SDL2::SDL_HITTEST_RESIZE_BOTTOM,
+        :bottom_left => ::SDL2::SDL_HITTEST_RESIZE_BOTTOMLEFT,
+        :resize_left => ::SDL2::SDL_HITTEST_RESIZE_LEFT,
+      ).freeze
+
+      def initialize(&block)
+        # typedef SDL_HitTestResult (*SDL_HitTest)(SDL_Window *win,
+        #                                          const SDL_Point *area, void *data);
+        super(:int, [:pointer, :pointer, :pointer]) do |win, area, _data|
+          # コールバック実行終了を OS が待つようなので、与えらえた window ポインターは有効なものとしてよいだろう。
+          # area には SDL_Point のアドレスが入る。SDL_Point は x, y の２つの int 型メンバーである。
+          HIT_TEST_RESULT[yield(Window.to_ptr(win), ::SDL2::SDL_Point.new(area).values)]
+        end
+      end
+    end
+  end
+end

data/lib/rb_sdl2/window/position.rb

@@ -0,0 +1,38 @@
+module RbSDL2
+  class Window
+    module Position
+      def position
+        x_y = Array.new(2) { ::FFI::MemoryPointer.new(:int) }
+        ::SDL2.SDL_GetWindowPosition(self, *x_y)
+        x_y.map(&:read_int)
+      end
+
+      def position=(x_y)
+        wx, wy = x_y
+        wx ||= ::SDL2::SDL_WINDOWPOS_CENTERED_MASK
+        wy ||= ::SDL2::SDL_WINDOWPOS_CENTERED_MASK
+        ::SDL2.SDL_SetWindowPosition(self, wx, wy)
+      end
+
+      def x
+        ptr = ::FFI::MemoryPointer.new(:int)
+        ::SDL2.SDL_GetWindowPosition(self, ptr, nil)
+        ptr.read_int
+      end
+
+      def x=(num)
+        self.position = [num, y]
+      end
+
+      def y
+        ptr = ::FFI::MemoryPointer.new(:int)
+        ::SDL2.SDL_GetWindowPosition(self, nil, ptr)
+        ptr.read_int
+      end
+
+      def y=(num)
+        self.position = [x, num]
+      end
+    end
+  end
+end