SDLRuby 0.1.0

data/lib/SDLRuby/window/display_info.rb

@@ -0,0 +1,48 @@
+module SDLRuby
+  class Window
+    module DisplayInfo
+      include SDL
+
+      def display_brightness = SDL.SDL_GetWindowBrightness(self)
+
+      def display_icc_profile
+        size = SDL.tmp_value("size_t")
+        ptr = SDL.SDL_GetWindowICCProfile(self, size)
+        raise SDLError if ptr.null?
+
+        ptr.free = SDL_FREE
+        ptr.to_str(size.value)
+      end
+
+      def display_index
+        num = SDL.SDL_GetWindowDisplayIndex(self)
+        raise SDLError if num < 0
+
+        num
+      end
+
+      def display_gamma_ramp
+        rgb = Array.new(3) { Fiddle::Pointer.malloc(2 * 256, Fiddle::RUBY_FREE) }
+        err = SDL.SDL_GetWindowGammaRamp(self, *rgb)
+        raise SDLError if err < 0
+
+        rgb.map { |ptr| ptr.to_str.unpack("S*") }
+      end
+
+      def display_orientation = Display.orientation(display_index)
+
+      def fullscreen_display_mode
+        mode = DisplayMode.new
+        err = SDL.SDL_GetWindowDisplayMode(self, mode)
+        raise SDLError if err < 0
+
+        mode
+      end
+
+      def fullscreen_display_mode=(mode)
+        err = SDL.SDL_SetWindowDisplayMode(self, mode)
+        raise SDLError if err < 0
+      end
+    end
+  end
+end

data/lib/SDLRuby/window/flag.rb

@@ -0,0 +1,42 @@
+module SDLRuby
+  class Window
+    module Flag
+      class << self
+        def to_i(allow_highdpi: nil, always_on_top: nil, borderless: nil,
+                 foreign: nil, fullscreen: nil, fullscreen_desktop: nil,
+                 hidden: nil, input_focus: nil, input_grabbed: nil,
+                 keyboard_grabbed: nil, maximized: nil, metal: nil,
+                 minimized: nil, mouse_capture: nil, mouse_focus: nil,
+                 mouse_grabbed: nil, opengl: nil, popup_menu: nil,
+                 resizable: nil, shown: nil, skip_taskbar: nil, tooltip: nil,
+                 utility: nil, vulkan: nil, **)
+          0 |
+            (allow_highdpi ? SDL_WINDOW_ALLOW_HIGHDPI : 0) |
+            (always_on_top ? SDL_WINDOW_ALWAYS_ON_TOP : 0) |
+            (borderless ? SDL_WINDOW_BORDERLESS : 0) |
+            (foreign ? SDL_WINDOW_FOREIGN : 0) |
+            (fullscreen ? SDL_WINDOW_FULLSCREEN : 0) |
+            (fullscreen_desktop ? SDL_WINDOW_FULLSCREEN_DESKTOP : 0) |
+            (hidden ? SDL_WINDOW_HIDDEN : 0) |
+            (input_focus ? SDL_WINDOW_INPUT_FOCUS : 0) |
+            (input_grabbed ? SDL_WINDOW_INPUT_GRABBED : 0) |
+            (keyboard_grabbed ? SDL_WINDOW_KEYBOARD_GRABBED : 0) |
+            (maximized ? SDL_WINDOW_MAXIMIZED : 0) |
+            (metal ? SDL_WINDOW_METAL : 0) |
+            (minimized ? SDL_WINDOW_MINIMIZED : 0) |
+            (mouse_capture ? SDL_WINDOW_MOUSE_CAPTURE : 0) |
+            (mouse_focus ? SDL_WINDOW_MOUSE_FOCUS : 0) |
+            (mouse_grabbed ? SDL_WINDOW_MOUSE_GRABBED : 0) |
+            (opengl ? SDL_WINDOW_OPENGL : 0) |
+            (popup_menu ? SDL_WINDOW_POPUP_MENU : 0) |
+            (resizable ? SDL_WINDOW_RESIZABLE : 0) |
+            (shown ? SDL_WINDOW_SHOWN : 0) |
+            (skip_taskbar ? SDL_WINDOW_SKIP_TASKBAR : 0) |
+            (tooltip ? SDL_WINDOW_TOOLTIP : 0) |
+            (utility ? SDL_WINDOW_UTILITY : 0) |
+            (vulkan ? SDL_WINDOW_VULKAN : 0)
+        end
+      end
+    end
+  end
+end

data/lib/SDLRuby/window/hit_tester.rb

@@ -0,0 +1,61 @@
+module SDLRuby
+  class Window
+    module HitTester
+
+      module Remover
+        def destroy
+          Window.set_hit_test_proc(self, nil)
+          super
+        end
+      end
+
+      class << self
+        private def included(klass) = klass.prepend(Remover)
+      end
+
+      # SDL_HitTestResult SDL_HitTest(SDL_Window* win, const SDL_Point* area, void* data)
+      #
+      class HitTestClosure < Fiddle::Closure
+        include Fiddle, SDL
+
+        def initialize(obj)
+          super(TYPE_INT, [TYPE_VOIDP, TYPE_VOIDP, TYPE_VOIDP])
+          @obj = obj
+        end
+
+        def call(_win, area, _data) = @obj.call(*SDL_Point.new(area)).to_i
+      end
+
+      @hit_tests = {}
+
+      class << self
+        def get_hit_test_proc(window)
+          id = window.to_int
+          @hit_tests[id].last
+        end
+
+        def set_hit_test_proc(window, obj)
+          func = obj ? HitTestClosure.new(obj) : nil
+          err = SDL.SDL_SetWindowHitTest(window, func, nil)
+          raise SDLError if err < 0
+
+          id = window.to_int
+
+          if obj
+            @hit_tests[id] = [func, obj]
+          else
+            @hit_tests.delete(id)
+          end
+        end
+      end
+
+      def hit_test_proc = HitTester.get_hit_test_proc(self)
+
+      # objはcallメソッドを持つオブジェクトであること。
+      #
+      def hit_test_proc=(obj)
+        HitTester.set_hit_test_proc(self, obj)
+      end
+    end
+  end
+end

data/lib/SDLRuby/window/input.rb

@@ -0,0 +1,68 @@
+module SDLRuby
+  class Window
+    class << self
+      # 該当するウィンドウがない場合はnilを戻す。
+      #
+      def grabbed
+        ptr = SDL.SDL_GetGrabbedWindow
+        return if ptr.null?
+
+        new(ptr)
+      end
+
+      # 該当するウィンドウがない場合はnilを戻す。
+      #
+      def keyboard_focused
+        ptr = SDL.SDL_GetKeyboardFocus
+        return if ptr.null?
+
+        new(ptr)
+      end
+
+      # 該当するウィンドウがない場合はnilを戻す。
+      #
+      def mouse_focused
+        ptr = SDL.SDL_GetMouseFocus
+        return if ptr.null?
+
+        new(ptr)
+      end
+    end
+
+    module Input
+      def grab = SDL.SDL_GetWindowGrab(self) != 0
+
+      def grab=(b)
+        SDL.SDL_SetWindowGrab(sef, b ? 1 : 0)
+      end
+
+      def keyboard_grabbed? = SDL.SDL_GetWindowKeyboardGrab(self) != 0
+
+      def keyboard_grab=(b)
+        SDL.SDL_SetWindowKeyboardGrab(self, b ? 1 : 0)
+      end
+
+      def mouse_clip
+        ptr = SDL.SDL_GetWindowMouseRect(self)
+        return if ptr.null?
+
+        SDL_Rect.new(ptr).to_a
+      end
+
+      def mouse_clip=(rect)
+        err = SDL.SDL_SetWindowMouseRect(self, Rect[*rect])
+        raise SDLError if err < 0
+      end
+
+      def mouse_pos=(xy)
+        SDL.SDL_WarpMouseInWindow(self, *xy)
+      end
+
+      def mouse_grabbed? = SDL.SDL_GetWindowMouseGrab(self) != 0
+
+      def mouse_grab=(b)
+        SDL.SDL_SetWindowMouseGrab(self, b ? 1 : 0)
+      end
+    end
+  end
+end

data/lib/SDLRuby/window/shaper.rb

@@ -0,0 +1,68 @@
+module SDLRuby
+  class Window
+    module Shaper
+      def shape(shape, cutoff = nil)
+        st = SDL_WindowShapeMode.malloc(Fiddle::RUBY_FREE)
+
+        case cutoff
+        when nil
+          st.mode = ShapeModeDefault
+        when Integer
+          st.mode = cutoff >= 0 ? ShapeModeBinarizeAlpha : ShapeModeReverseBinarizeAlpha
+          st.parameters.binarizationCutoff = cutoff.abs
+        when Array
+          st.mode = ShapeModeColorKey
+          st.parameters.colorKey.tap { |c| c.r, c.g, c.b, c.a = *cutoff }
+        else
+          raise ArgumentError
+        end
+
+        case SDL.SDL_SetWindowShape(self, shape, st)
+        when 0
+          return
+        when SDL_NONSHAPEABLE_WINDOW
+          raise SDLError, "SDL_NONSHAPEABLE_WINDOW"
+        when SDL_INVALID_SHAPE_ARGUMENT
+          if shape.size != size
+            raise SDLError, "the size of window and the size of surface do not match."
+          elsif !shape.alpha?
+            raise SDLError, "the color key is not specified in the surface without alpha channel."
+          else
+            raise SDLError, "SDL_INVALID_SHAPE_ARGUMENT"
+          end
+        else
+          raise SDLError
+        end
+      end
+
+      def cutoff
+        st = SDL_WindowShapeMode.malloc(Fiddle::RUBY_FREE)
+
+        case SDL.SDL_GetShapedWindowMode(self, st)
+        when 0
+          cutoff = case st.mode
+                   when ShapeModeDefault
+                     nil
+                   when ShapeModeBinarizeAlpha
+                     st.parameters.binarizationCutoff
+                   when ShapeModeReverseBinarizeAlpha
+                     -st.parameters.binarizationCutoff
+                   when ShapeModeColorKey
+                     st.parameters.colorKey.to_a[0..2]
+                   else
+                     nil
+                   end
+          return cutoff
+        when SDL_NONSHAPEABLE_WINDOW
+          raise SDLError, "SDL_NONSHAPEABLE_WINDOW"
+        when SDL_WINDOW_LACKS_SHAPE
+          raise SDLError, "SDL_WINDOW_LACKS_SHAPE"
+        else
+          raise SDLError
+        end
+      end
+
+      def shaped? = SDL.SDL_IsShapedWindow(self) == 1
+    end
+  end
+end

data/lib/SDLRuby/window/surfacer.rb

@@ -0,0 +1,37 @@
+module SDLRuby
+  class Window
+    module Surfacer
+      include SDL
+
+      def destroy_surface
+        err = SDL.SDL_DestroyWindowSurface(self)
+        raise SDLError if err < 0
+      end
+
+      def surface
+        ptr = SDL.SDL_GetWindowSurface(self)
+        raise SDLError if ptr.null?
+
+        # ウィンドウからのサーフェスにはSDL_DONTFREEフラグが設定されている。
+        # このためにSDL_FreeSurfaceではリファレンスカウンターを減じる事ができない。
+        # これはRubyのGC管理では問題になる（メモリーリークする）。
+        # そのためSDL_DONTFREEフラグを解除する！
+        #
+        st = SDL_Surface.new(ptr)
+        st.flags &= ~SDL_DONTFREE
+
+        Surface.new(ptr, add_ref: true)
+      end
+
+      # ウィンドウのサーフェスがvalidかどうか確認していない。
+      # リサイズなどで壊れていてもtrueを戻す。
+      #
+      def surface? = SDL.SDL_HasWindowSurface(self) == 1
+
+      def update_surface
+        err = SDL.SDL_UpdateWindowSurface(self)
+        raise SDLError if err < 0
+      end
+    end
+  end
+end

data/lib/SDLRuby/window/window_renderer.rb

@@ -0,0 +1,31 @@
+module SDLRuby
+  class Window
+    module WindowRenderer
+      def init_renderer(name = nil, flags = nil,
+                        accelerated: nil, software: nil, vsync: nil)
+
+        idx = if name
+                i = Renderer.drivers.index(name)
+                raise ArgumentError unless i
+                i
+              else
+                -1
+              end
+        num = flags || 0 |
+          (accelerated ? SDL_RENDERER_ACCELERATED : 0) |
+          (software ? SDL_RENDERER_SOFTWARE : 0) |
+          (vsync ? SDL_RENDERER_PRESENTVSYNC : 0)
+        ptr = SDL.SDL_CreateRenderer(self, idx, num)
+        raise SDLError if ptr.null?
+      end
+
+      private def renderer
+        ptr = SDL.SDL_GetRenderer(self)
+        raise SDLError if ptr.null?
+        ptr
+      end
+
+      def destroy_renderer = SDL.SDL_DestroyRenderer(SDL.SDL_GetRenderer(self))
+    end
+  end
+end

data/lib/SDLRuby/window.rb

@@ -0,0 +1,90 @@
+require_relative 'display'
+require_relative 'pixel_formatter'
+require_relative 'window/accessor'
+require_relative 'window/controller'
+require_relative 'window/display_info'
+require_relative 'window/flag'
+require_relative 'window/hit_tester'
+require_relative 'window/input'
+require_relative 'window/shaper'
+require_relative 'window/surfacer'
+require_relative 'window/window_renderer'
+
+module SDLRuby
+  class Window
+    include Accessor, Controller, DisplayInfo, HitTester, Input,
+            PixelFormatter, Renderer, SDL, Shaper, Surfacer, WindowRenderer
+
+    class << self
+      include SDL
+
+      # 該当するウィンドウがない場合はnilを戻す。
+      #
+      def [](obj)
+        id = obj.to_int
+        ptr = SDL.SDL_GetWindowFromID(id)
+        return nil if ptr.null?
+
+        new(ptr)
+      end
+
+      def _from(ptr)
+        ptr = SDL.SDL_CreateWindowFrom(ptr)
+        raise SDLError if ptr.null?
+
+        new(ptr)
+      end
+
+      def create(title, x = nil, y = nil, w = 640, h = 480, flags = nil,
+                 shaped: nil, **opts)
+
+        _title = title.encode("UTF-8")
+        _x = x ? x : SDL_WINDOWPOS_UNDEFINED
+        _y = y ? y : SDL_WINDOWPOS_UNDEFINED
+        _flags = flags || Flag.to_i(**opts)
+        ptr = if shaped
+                SDL.SDL_CreateShapedWindow(_title, _x, _y, w, h, _flags)
+              else
+                SDL.SDL_CreateWindow(_title, _x, _y, w, h, _flags)
+              end
+        raise SDLError if ptr.null?
+
+        new(ptr)
+      end
+    end
+
+    attr_reader :id
+
+    def initialize(ptr)
+      id = SDL.SDL_GetWindowID(ptr)
+      raise SDLError if id == 0
+
+      @id = id
+    end
+
+    def ==(other) = other.respond_to?(:to_ptr) && to_ptr == other.to_ptr
+
+    def destroy = SDL.SDL_DestroyWindow(self)
+
+    def flags = SDL.SDL_GetWindowFlags(self)
+
+    def flash(op)
+      _op = op ? SDL_FLASH_UNTIL_FOCUSED : SDL_FLASH_CANCEL
+      err = SDL.SDL_FlashWindow(self, _op)
+      raise SDLError if err < 0
+    end
+
+    def focus! = SDL.SDL_RaiseWindow(self)
+
+    def format = SDL.SDL_GetWindowPixelFormat(self)
+
+    alias to_int id
+    alias to_i id
+
+    def to_ptr
+      ptr = SDL.SDL_GetWindowFromID(@id)
+      raise SDLError if ptr.null?
+      ptr
+    end
+  end
+end

data/lib/SDLRuby.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+require_relative 'SDLRuby/version'
+require_relative 'SDLRuby/sdl'
+
+# Extended libraries
+#
+require_relative 'SDLRuby/font'
+require_relative 'SDLRuby/image'
+require_relative 'SDLRuby/mixer'
+require_relative 'SDLRuby/music'
+
+module SDLRuby
+  class Error < StandardError; end
+end

data/sig/SDLRuby/event.rbs

@@ -0,0 +1,104 @@
+module SDLRuby
+  type event_type_symbols = (
+      :adevice | :button | :caxis | :cbutton | :cdevice | :common | :csensor |
+        :ctouchpad | :dgesture | :display | :drop | :edit | :editExt | :jaxis |
+        :jball | :jbattery | :jbutton | :jdevice | :jhat | :key | :mgesture |
+        :motion | :quit | :sensor | :syswm | :text | :tfinger | :user |
+        :wheel | :window
+     )
+
+  class Event
+    @st: untyped
+
+    def self.clear: -> void
+
+    def self.count: -> Integer
+
+    def self.disable: (untyped) -> void
+
+    def self.enable: (untyped) -> void
+
+    def self.flash: -> void
+
+    def self.get: -> Event
+
+    def self.poll: (Event) -> Event
+
+    def self.pump: -> nil
+
+    alias self.update self.pump
+
+    def self.quit?: -> bool
+
+    def initialize: -> void
+
+    attr_reader entity: any
+
+    def to_ptr: -> untyped
+
+    def to_sym: -> (event_type_symbols)
+
+    def update: -> self
+
+    module Accessor
+      include SDL
+
+      self.@modules: Hash[Symbol, Module]
+      self.@_ptr: untyped
+
+      def self.[]: (event_type_symbols) -> Module
+
+      private
+
+      def char_ary_to_str: (untyped) -> String
+      def char_ptr_to_str: (untyped) -> String
+
+      public
+
+      def capture?: -> bool
+      def pressed?: -> bool
+      def file: -> String
+      def text: -> String
+      def keysym: -> untyped
+      def msg: -> untyped
+      def data1: -> untyped
+      def data2: -> untyped
+    end
+
+    module Type
+      QUIT_EVENT: Range[Integer]
+      DISPLAY_EVENT: Range[Integer]
+      WINDOW_EVENT: Range[Integer]
+      SYSWM_EVENT: Range[Integer]
+      KEY_EVENT: Range[Integer]
+      EDIT_EVENT: Range[Integer]
+      TEXT_EVENT: Range[Integer]
+      EDIT_EXT_EVENT: Range[Integer]
+      MOTION_EVENT: Range[Integer]
+      BUTTON_EVENT: Range[Integer]
+      WHEEL_EVENT: Range[Integer]
+      JAXIS_EVENT: Range[Integer]
+      JBALL_EVENT: Range[Integer]
+      JHAT_EVENT: Range[Integer]
+      JBUTTON_EVENT: Range[Integer]
+      JDEVICE_EVENT: Range[Integer]
+      JBATTERY_EVENT: Range[Integer]
+      CAXIS_EVENT: Range[Integer]
+      CBUTTON_EVENT: Range[Integer]
+      CDEVICE_EVENT: Range[Integer]
+      CTOUCHPAD_EVENT: Range[Integer]
+      CSENSOR_EVENT: Range[Integer]
+      TFINGER_EVENT: Range[Integer]
+      DGESTURE_EVENT: Range[Integer]
+      MGESTURE_EVENT: Range[Integer]
+      DROP_EVENT: Range[Integer]
+      ADEVICE_EVENT: Range[Integer]
+      SENSOR_EVENT: Range[Integer]
+      USER_EVENT: Range[Integer]
+
+      include SDL
+
+      def self.to_sym: (Integer) -> (event_type_symbols)
+    end
+  end
+end

data/sig/SDLRuby/pixel_formmater.rbs

@@ -0,0 +1,24 @@
+module SDLRuby
+  module PixelFormatter
+    INDEXED_PIXELFORMATS: [untyped, untyped, untyped, untyped, untyped]
+    ALPHA_PIXELFORMATS: [untyped, untyped, untyped, untyped, untyped, untyped, untyped, untyped, untyped, untyped, untyped, untyped, untyped]
+    include SDL
+
+    def self.alpha?: (untyped x) -> bool
+    def self.bits_per_pixel: (untyped x) -> Integer?
+    def self.bytes_per_pixel: (untyped x) -> Integer
+    def self.format_name: (untyped x) -> String
+    def self.fourcc?: (untyped x) -> String?
+    def self.indexed_color?: (untyped x) -> bool
+    def self.rgb_color?: (untyped x) -> bool
+    def alpha?: -> bool
+    def bits_per_pixel: -> Integer?
+    alias depth bits_per_pixel
+    def bytes_per_pixel: -> Integer
+    def format_name: -> String
+    alias pixel_format_name format_name
+    def fourcc?: -> String?
+    def indexed_color?: -> bool
+    def rgb_color?: -> bool
+  end
+end

data/sig/SDLRuby/rect.rbs

@@ -0,0 +1,5 @@
+module SDLRuby
+  class Rect
+    def self.[]: (*any) -> self
+  end
+end