SDLRuby 0.1.0

data/lib/SDLRuby/font.rb

@@ -0,0 +1,227 @@
+require_relative 'ttf'
+
+module SDLRuby
+  class Font
+    include TTF
+
+    class << self
+      def open(file, pt, face: nil, dpi: nil)
+        TTF.init
+
+        if String === file
+          rw = SDL.SDL_RWFromFile(file, "rb")
+          free = 1
+        elsif file.respond_to?(:to_path)
+          rw = SDL.SDL_RWFromFile(file.to_path, "rb")
+          free = 1
+        else
+          rw = RWOps[file]
+          free = 0
+        end
+
+        index = face ? face : 0
+        hdpi, vdpi = *(dpi ? dpi : [0, 0])
+
+        ptr = TTF.TTF_OpenFontIndexDPIRW(rw, free, pt, index, hdpi, vdpi)
+        raise SDLError if ptr.null?
+
+        new(ptr)
+      end
+    end
+
+    def initialize(ptr)
+      ptr.free = TTF_CLOSE_FONT
+      @ptr = ptr
+    end
+
+    def align
+      case TTF.TTF_GetFontWrappedAlign(self)
+      when TTF_WRAPPED_ALIGN_LEFT   then "left"
+      when TTF_WRAPPED_ALIGN_CENTER then "center"
+      when TTF_WRAPPED_ALIGN_RIGHT  then "right"
+      else
+        nil
+      end
+    end
+
+    def align=(s)
+      case s
+      when "left"   then TTF_WRAPPED_ALIGN_LEFT
+      when "center" then TTF_WRAPPED_ALIGN_CENTER
+      when "right"  then TTF_WRAPPED_ALIGN_RIGHT
+      else
+        raise ArgumentError
+      end => align
+
+      TTF.TTF_SetFontWrappedAlign(self, align)
+    end
+
+    def ascent = TTF.TTF_FontAscent(self)
+
+    def descent = TTF.TTF_FontDescent(self)
+
+    def direction=(s)
+      case s
+      when "left"   then TTF_DIRECTION_LTR
+      when "right"  then TTF_DIRECTION_RTL
+      when "top"    then TTF_DIRECTION_TTB
+      when "bottom" then TTF_DIRECTION_BTT
+      else
+        raise ArgumentError
+      end => direction
+
+      err = TTF.TTF_SetFontDirection(self, direction)
+      raise SDLError if err < 0
+    end
+
+    def draw(text, alpha: nil, color: nil, width: nil)
+      t = text.encode("UTF-8")
+      c = SDL_Color.malloc(Fiddle::RUBY_FREE)
+      c.r, c.g, c.b, c.a = color
+      w = width || 0
+
+      if alpha
+        TTF.TTF_RenderUTF8_Blended_Wrapped(self, t, c, w)
+      else
+        TTF.TTF_RenderUTF8_Solid_Wrapped(self, t, c, w)
+      end => ptr
+
+      raise SDLError if ptr.null?
+
+      Surface.new(ptr)
+    end
+
+    def drew_size(text)
+      t = text.encode("UTF-8")
+      w, h = SDL.tmp_value("int", "int")
+      err = TTF.TTF_SizeUTF8(self, t, w, h)
+      raise SDLError if err < 0
+
+      [w.value, h.value]
+    end
+
+    def face_count = TTF.TTF_FontFaces(self)
+
+    def family_name = TTF.TTF_FontFaceFamilyName(self).to_s
+
+    def fixed_width? = TTF.TTF_FontFaceIsFixedWidth(self) == 0
+
+    def glyph?(s)
+      raise ArgumentError if s.empty? || s.size > 1
+
+      uint32 = s[0].encode("UTF-32LE").unpack1("L")
+
+      TTF.TTF_GlyphIsProvided32(self, uint32) != 0
+    end
+
+    def glyph_metrics(s)
+      raise ArgumentError if s.empty? || s.size > 1
+
+      uint32 = s[0].encode("UTF-32LE").unpack1("L")
+
+      minx, maxx, miny, maxy, advance =
+        SDL.tmp_value("int", "int", "int", "int", "int")
+
+      TTF.TTF_GlyphMetrics32(self, uint32, minx, maxx, miny, maxy, advance)
+
+      [minx.value, maxx.value, miny.value, maxy.value, advance.value]
+    end
+
+    def height = TTF.TTF_FontHeight(self)
+
+    alias h height
+
+    def hinting
+      case TTF.TTF_GetFontHinting(self)
+      when TTF_HINTING_NORMAL         then "normal"
+      when TTF_HINTING_LIGHT          then "light"
+      when TTF_HINTING_MONO           then "mono"
+      when TTF_HINTING_NONE           then "none"
+      when TTF_HINTING_LIGHT_SUBPIXEL then "light_subpixel"
+      else
+        nil
+      end
+    end
+
+    def hinting=(s)
+      case s
+      when "normal"         then TTF_HINTING_NORMAL
+      when "light"          then TTF_HINTING_LIGHT
+      when "mono"           then TTF_HINTING_MONO
+      when "none"           then TTF_HINTING_NONE
+      when "light_subpixel" then TTF_HINTING_LIGHT_SUBPIXEL
+      else
+        raise ArgumentError
+      end => hinting
+
+      TTF.TTF_SetFontHinting(self, hinting)
+    end
+
+    def kerning? = TTF.TTF_GetFontKerning(self) == 0
+
+    def kerning=(b)
+      TTF.TTF_SetFontKerning(self, b ? 1 : 0)
+    end
+
+    def line_skip = TTF.TTF_FontLineSkip(self)
+
+    def measure(text, width)
+      t = text.encode("UTF-8")
+      extent, count = SDL.tmp_value("int", "int")
+      err = TTF.TTF_MeasureUTF8(self, t, width, extent, count)
+      raise SDLError if err < 0
+
+      [extent.value, count.value]
+    end
+
+    def outline = TTF.TTF_GetFontOutline(self)
+
+    def outline=(n)
+      TTF.TTF_SetFontOutline(self, n)
+    end
+
+    def pt=(v)
+      err = TTF.TTF_SetFontSize(self, v)
+      raise SDLError if err < 0
+    end
+
+    # see also ISO 15924
+    #
+    def script_name=(four_characters)
+      err = TTF.TTF_SetFontScriptName(self, four_characters)
+      raise SDLError if err < 0
+    end
+
+    def size_pt(pt, hdpi, vdpi)
+      err = TTF.TTF_SetFontSizeDPI(self, pt, hdpi, vdpi)
+      raise SDLError if err < 0
+    end
+
+    def style
+      num = TTF.TTF_GetFontStyle(self)
+
+      a = []
+      a << "normal"    if num & TTF_STYLE_NORMAL != 0
+      a << "bold"      if num & TTF_STYLE_BOLD != 0
+      a << "italic"    if num & TTF_STYLE_ITALIC != 0
+      a << "underline" if num & TTF_STYLE_UNDERLINE != 0
+      a << "strike"    if num & TTF_STYLE_STRIKETHROUGH != 0
+      a
+    end
+
+    def style=(a)
+      num = 0 |
+        (a.include?("normal")    ? TTF_STYLE_NORMAL : 0) |
+        (a.include?("bold")      ? TTF_STYLE_BOLD : 0) |
+        (a.include?("italic")    ? TTF_STYLE_ITALIC : 0) |
+        (a.include?("underline") ? TTF_STYLE_UNDERLINE : 0) |
+        (a.include?("strike")    ? TTF_STYLE_STRIKETHROUGH : 0)
+
+      TTF.TTF_SetFontStyle(self, num)
+    end
+
+    def style_name = TTF.TTF_FontFaceStyleName(self).to_s
+
+    def to_ptr = @ptr
+  end
+end

data/lib/SDLRuby/hint.rb

@@ -0,0 +1,36 @@
+module SDLRuby
+  module Hint
+    class << self
+      include SDL
+
+      def [](name) = SDL.SDL_GetHint(name.to_s).to_s
+
+      # value が nil の場合はヒントの値はNULLに設定される。
+      #
+      def []=(name, value)
+        s = name.to_s
+        if value
+          SDL.SDL_SetHintWithPriority(s, value.to_s, SDL_HINT_OVERRIDE)
+        else
+          SDL.SDL_SetHintWithPriority(s, nil, SDL_HINT_OVERRIDE)
+        end
+      end
+
+      # 全てのヒントを関連付けられた環境変数の値,
+      # または環境変数がない場合はNULLにリセットする.
+      #
+      def clear = SDL.SDL_ResetHints
+
+      def freeze = raise(TypeError, "cannot freeze Hint")
+
+      def include?(name) = SDL.SDL_GetHintBoolean(name.to_s, -1) != -1
+      alias has_key? include?
+      alias member? include?
+      alias key? include?
+
+      # ヒントを環境変数の値にリセットする。
+      #
+      def reset(s) = SDL.SDL_ResetHint(s)
+    end
+  end
+end

data/lib/SDLRuby/image/image.rb

@@ -0,0 +1,23 @@
+module SDLRuby
+  module Image
+    IMG_INIT_JPG    = 0x00000001
+    IMG_INIT_PNG    = 0x00000002
+    IMG_INIT_TIF    = 0x00000004
+    IMG_INIT_WEBP   = 0x00000008
+    IMG_INIT_JXL    = 0x00000010
+    IMG_INIT_AVIF   = 0x00000020
+    typealias "IMG_InitFlags", "int"
+
+    IMG_Animation = struct(
+      [
+        "int w",
+        "int h",
+        "int count",
+        "SDL_Surface **frames",
+        "int *delays"
+      ]
+    )
+
+    IMG_FREE_ANIMATION = import_symbol("IMG_FreeAnimation").to_int
+  end
+end

data/lib/SDLRuby/image/include/SDL_image.h.rb

@@ -0,0 +1,61 @@
+module SDLRuby::Image
+  typealias "IMG_InitFlags", "int"
+  extern "const SDL_version * IMG_Linked_Version(void)"
+  extern "int IMG_Init(int flags)"
+  extern "void IMG_Quit(void)"
+  extern "SDL_Surface * IMG_LoadTyped_RW(SDL_RWops *src, int freesrc, const char *type)"
+  extern "SDL_Surface * IMG_Load(const char *file)"
+  extern "SDL_Surface * IMG_Load_RW(SDL_RWops *src, int freesrc)"
+  extern "SDL_Texture * IMG_LoadTexture(SDL_Renderer *renderer, const char *file)"
+  extern "SDL_Texture * IMG_LoadTexture_RW(SDL_Renderer *renderer, SDL_RWops *src, int freesrc)"
+  extern "SDL_Texture * IMG_LoadTextureTyped_RW(SDL_Renderer *renderer, SDL_RWops *src, int freesrc, const char *type)"
+  extern "int IMG_isAVIF(SDL_RWops *src)"
+  extern "int IMG_isICO(SDL_RWops *src)"
+  extern "int IMG_isCUR(SDL_RWops *src)"
+  extern "int IMG_isBMP(SDL_RWops *src)"
+  extern "int IMG_isGIF(SDL_RWops *src)"
+  extern "int IMG_isJPG(SDL_RWops *src)"
+  extern "int IMG_isJXL(SDL_RWops *src)"
+  extern "int IMG_isLBM(SDL_RWops *src)"
+  extern "int IMG_isPCX(SDL_RWops *src)"
+  extern "int IMG_isPNG(SDL_RWops *src)"
+  extern "int IMG_isPNM(SDL_RWops *src)"
+  extern "int IMG_isSVG(SDL_RWops *src)"
+  extern "int IMG_isQOI(SDL_RWops *src)"
+  extern "int IMG_isTIF(SDL_RWops *src)"
+  extern "int IMG_isXCF(SDL_RWops *src)"
+  extern "int IMG_isXPM(SDL_RWops *src)"
+  extern "int IMG_isXV(SDL_RWops *src)"
+  extern "int IMG_isWEBP(SDL_RWops *src)"
+  extern "SDL_Surface * IMG_LoadAVIF_RW(SDL_RWops *src)"
+  extern "SDL_Surface * IMG_LoadICO_RW(SDL_RWops *src)"
+  extern "SDL_Surface * IMG_LoadCUR_RW(SDL_RWops *src)"
+  extern "SDL_Surface * IMG_LoadBMP_RW(SDL_RWops *src)"
+  extern "SDL_Surface * IMG_LoadGIF_RW(SDL_RWops *src)"
+  extern "SDL_Surface * IMG_LoadJPG_RW(SDL_RWops *src)"
+  extern "SDL_Surface * IMG_LoadJXL_RW(SDL_RWops *src)"
+  extern "SDL_Surface * IMG_LoadLBM_RW(SDL_RWops *src)"
+  extern "SDL_Surface * IMG_LoadPCX_RW(SDL_RWops *src)"
+  extern "SDL_Surface * IMG_LoadPNG_RW(SDL_RWops *src)"
+  extern "SDL_Surface * IMG_LoadPNM_RW(SDL_RWops *src)"
+  extern "SDL_Surface * IMG_LoadSVG_RW(SDL_RWops *src)"
+  extern "SDL_Surface * IMG_LoadQOI_RW(SDL_RWops *src)"
+  extern "SDL_Surface * IMG_LoadTGA_RW(SDL_RWops *src)"
+  extern "SDL_Surface * IMG_LoadTIF_RW(SDL_RWops *src)"
+  extern "SDL_Surface * IMG_LoadXCF_RW(SDL_RWops *src)"
+  extern "SDL_Surface * IMG_LoadXPM_RW(SDL_RWops *src)"
+  extern "SDL_Surface * IMG_LoadXV_RW(SDL_RWops *src)"
+  extern "SDL_Surface * IMG_LoadWEBP_RW(SDL_RWops *src)"
+  extern "SDL_Surface * IMG_LoadSizedSVG_RW(SDL_RWops *src, int width, int height)"
+  extern "SDL_Surface * IMG_ReadXPMFromArray(char **xpm)"
+  extern "SDL_Surface * IMG_ReadXPMFromArrayToRGB888(char **xpm)"
+  extern "int IMG_SavePNG(SDL_Surface *surface, const char *file)"
+  extern "int IMG_SavePNG_RW(SDL_Surface *surface, SDL_RWops *dst, int freedst)"
+  extern "int IMG_SaveJPG(SDL_Surface *surface, const char *file, int quality)"
+  extern "int IMG_SaveJPG_RW(SDL_Surface *surface, SDL_RWops *dst, int freedst, int quality)"
+  extern "IMG_Animation * IMG_LoadAnimation(const char *file)"
+  extern "IMG_Animation * IMG_LoadAnimation_RW(SDL_RWops *src, int freesrc)"
+  extern "IMG_Animation * IMG_LoadAnimationTyped_RW(SDL_RWops *src, int freesrc, const char *type)"
+  extern "void IMG_FreeAnimation(IMG_Animation *anim)"
+  extern "IMG_Animation * IMG_LoadGIFAnimation_RW(SDL_RWops *src)"
+end

data/lib/SDLRuby/image.rb

@@ -0,0 +1,69 @@
+require 'fiddle/import'
+
+module SDLRuby
+  # Supported formats
+  # AVIF, BMP, CUR, GIF, ICO, JPG, JXL, LBM, PCX, PNG, PNM, QOI, SVG, TGA,
+  # TIF, WEBP, XCF, XPM, XV
+  module Image
+    extend Fiddle::Importer
+
+    dlload "SDL2_image"
+
+    require_relative 'image/include/SDL_image.h'
+    require_relative 'image/image'
+
+    class << self
+      def init(flags = nil)
+        num = flags || 0 |
+          IMG_INIT_JPG  | IMG_INIT_PNG | IMG_INIT_TIF |
+          IMG_INIT_WEBP | IMG_INIT_JXL | IMG_INIT_AVIF
+
+        err = Image.IMG_Init(num)
+        raise SDLError if err == 0
+      end
+
+      def load(file, type: nil)
+        if String === file
+          rw = SDL.SDL_RWFromFile(file, "rb")
+          free = 1
+        elsif file.respond_to?(:to_path)
+          rw = SDL.SDL_RWFromFile(file.to_path, "rb")
+          free = 1
+        else
+          rw = RWOps[file]
+          free = 0
+        end
+
+        ptr = Image.IMG_LoadTyped_RW(rw, free, type)
+        raise SDLError if ptr.null?
+
+        Surface.new(ptr)
+      end
+
+      def save(file, surface, type: nil, quality: 85)
+        if String === file
+          rw = SDL.SDL_RWFromFile(file, "wb")
+          free = 1
+        elsif file.respond_to?(:to_path)
+          rw = SDL.SDL_RWFromFile(file.to_path, "wb")
+          free = 1
+        else
+          rw = RWOps[file]
+          free = 0
+        end
+
+        err = if type == "PNG"
+                Image.IMG_SavePNG_RW(surface, rw, free)
+              else
+                Image.IMG_SaveJPG_RW(surface, rw, free, quality)
+              end
+
+        raise SDLError if err != 0
+      end
+
+      def quit = Image.IMG_Quit
+
+      def version = SDL::SDL_version.new(Image.IMG_Linked_Version).to_a.join(".")
+    end
+  end
+end

data/lib/SDLRuby/keyboard.rb

@@ -0,0 +1,58 @@
+module SDLRuby
+  module Keyboard
+    module_eval do
+      num_keys = SDL.tmp_value("int")
+
+      # SDL_GetKeyboardState() が戻すポインターはSDLがロードされた時点で作成されている。
+      # この関数は SDL_Init() より前に呼ぶことができる。
+      ptr = SDL.SDL_GetKeyboardState(num_keys)
+
+      # エラーになるのはnum_keysにNULLを渡したとき。
+      raise SDLError if ptr.null?
+
+      ptr.size = num_keys.value
+      @state = ptr
+    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?
+
+      # キーコードからキー名を得る
+      def keycode_name(num)
+        (s = SDL.GetKeyName(num).to_s).empty? ? nil : s
+      end
+
+      # 修飾キーの状態を得る
+      def mod
+        SDL.SDL_GetModState #=> integer
+      end
+
+      # 修飾キーを設定する
+      def mod=(modstate)
+        SDL.SDL_SetModState(modstate)
+      end
+
+      # キー名からスキャンコードを得る
+      def scancode(s) = SDL.GetScancodeFromName(s).nonzero?
+
+      # スキャンコードからキー名を得る
+      def scancode_name(num)
+        (s = SDL.GetScancodeName(num).to_s).empty? ? nil : s
+      end
+
+      def to_a = to_str.unpack("C*").map(&:nonzero?)
+
+      def to_str = @state.to_str
+    end
+  end
+end

data/lib/SDLRuby/mixer/channel.rb

@@ -0,0 +1,43 @@
+require_relative 'controller'
+
+module SDLRuby
+  module Mixer
+    class Channel
+      include Controller
+
+      def initialize(ch)
+        @ch = ch
+      end
+
+      def __chank_id__ = Mixer.Mix_GetChunk(self).to_i
+
+      def to_int = @ch
+
+      # Effect
+      #
+      # Mix_RegisterEffect - エフェクト関数を登録する
+      # Mix_UnregisterEffect - エフェクト関数を解除する
+      # Mix_UnregisterAllEffects - 全てのエフェクト関数を解除する
+
+      def distance(distance)
+        err = Mixer.Mix_SetDistance(self, distance)
+        raise SDLError if err == 0
+      end
+
+      def panning(left, right)
+        err = Mixer.Mix_SetPanning(self, left, right)
+        raise SDLError if err == 0
+      end
+
+      def position(angle, distance)
+        err = Mixer.Mix_SetPosition(self, angle, distance)
+        raise SDLError if err == 0
+      end
+
+      def reverse_stereo(flip)
+        err = Mixer.Mix_SetReverseStereo(self, flip ? 1 : 0)
+        raise SDLError if err == 0
+      end
+    end
+  end
+end

data/lib/SDLRuby/mixer/chunk.rb

@@ -0,0 +1,49 @@
+module SDLRuby
+  module Mixer
+    class Chunk
+      include Mixer
+
+      class << self
+        def decoders
+          Mixer.Mix_GetNumChunkDecoders.times.map do |idx|
+            ptr = Mixer.Mix_GetChunkDecoder(idx)
+            ptr.null? ? nil : ptr.to_s
+          end
+        end
+
+        def load(file)
+          if String === file
+            rw = SDL.SDL_RWFromFile(file, "rb")
+            free = 1
+          elsif file.respond_to?(:to_path)
+            rw = SDL.SDL_RWFromFile(file.to_path, "rb")
+            free = 1
+          else
+            rw = RWOps[file]
+            free = 0
+          end
+
+          ptr = Mixer.Mix_LoadWAV_RW(rw, free)
+          raise SDLError if ptr.null?
+
+          new(ptr)
+        end
+      end
+
+      def initialize(ptr)
+        ptr.free = MIX_FREE_CHUNK
+        @ptr = ptr
+      end
+
+      def play(...) = Mixer.play(self, ...)
+
+      def volume = Mixer.Mix_VolumeChunk(self, -1)
+
+      def volume=(v)
+        Mixer.Mix_VolumeChunk(self, v)
+      end
+
+      def to_ptr = @ptr
+    end
+  end
+end

data/lib/SDLRuby/mixer/controller.rb

@@ -0,0 +1,44 @@
+module SDLRuby
+  module Mixer
+    module Controller
+      def expire(sec) = Mixer.Mix_ExpireChannel(sec * 1000)
+
+      def fade_out(sec) = Mixer.Mix_FadeOutChannel(-1, sec * 1000)
+
+      def fading? = Mixer.Mix_FadingChanne(self) != MIX_NO_FADING
+
+      def fading_in? = Mixer.Mix_FadingChanne(self) == MIX_FADING_IN
+
+      def fading_out? = Mixer.Mix_FadingChanne(self) == MIX_FADING_OUT
+
+      def halt = Mixer.Mix_HaltChannel(self)
+
+      def pause = Mixer.Mix_Pause(self)
+
+      def paused? = Mixer.Mix_Paused(self).nonzero?
+
+      def play(chunk, fade_in_time: nil, loops: nil, time: nil)
+        l = loops ? loops - 1 : 0
+        t = time ? time * 1000 : -1
+
+        if fade_in_time
+          Mixer.Mix_FadeInChannelTimed(self, chunk, l, fade_in_time * 1000, t)
+        else
+          Mixer.Mix_PlayChannelTimed(self, chunk, l, t)
+        end => err
+
+        raise SDLError if err < 0
+      end
+
+      def playing? = Mixer.Mix_Playing(self).nonzero?
+
+      def resume = Mixer.Mix_Resume(self)
+
+      def volume = Mixer.Mix_Volume(self, -1)
+
+      def volume=(v)
+        Mixer.Mix_Volume(self, v)
+      end
+    end
+  end
+end