SDLRuby 0.1.0

data/lib/SDLRuby/mixer/include/SDL_mixer.h.rb

@@ -0,0 +1,95 @@
+module SDLRuby::Mixer
+  typealias "Mix_Music", "struct _Mix_Music"
+  typealias "MIX_InitFlags", "int"
+  typealias "Mix_Fading", "int"
+  typealias "Mix_MusicType", "int"
+  extern "const SDL_version * Mix_Linked_Version(void)"
+  extern "int Mix_Init(int flags)"
+  extern "void Mix_Quit(void)"
+  extern "int Mix_OpenAudio(int frequency, Uint16 format, int channels, int chunksize)"
+  extern "int Mix_OpenAudioDevice(int frequency, Uint16 format, int channels, int chunksize, const char*device, int allowed_changes)"
+  extern "int Mix_QuerySpec(int *frequency, Uint16 *format, int *channels)"
+  extern "int Mix_AllocateChannels(int numchans)"
+  extern "Mix_Chunk * Mix_LoadWAV_RW(SDL_RWops *src, int freesrc)"
+  extern "Mix_Chunk * Mix_LoadWAV(const char *file)"
+  extern "Mix_Music * Mix_LoadMUS(const char *file)"
+  extern "Mix_Music * Mix_LoadMUS_RW(SDL_RWops *src, int freesrc)"
+  extern "Mix_Music * Mix_LoadMUSType_RW(SDL_RWops *src, Mix_MusicType type, int freesrc)"
+  extern "Mix_Chunk * Mix_QuickLoad_WAV(Uint8 *mem)"
+  extern "Mix_Chunk * Mix_QuickLoad_RAW(Uint8 *mem, Uint32 len)"
+  extern "void Mix_FreeChunk(Mix_Chunk *chunk)"
+  extern "void Mix_FreeMusic(Mix_Music *music)"
+  extern "int Mix_GetNumChunkDecoders(void)"
+  extern "const char * Mix_GetChunkDecoder(int index)"
+  extern "SDL_bool Mix_HasChunkDecoder(const char *name)"
+  extern "int Mix_GetNumMusicDecoders(void)"
+  extern "const char * Mix_GetMusicDecoder(int index)"
+  extern "SDL_bool Mix_HasMusicDecoder(const char *name)"
+  extern "Mix_MusicType Mix_GetMusicType(const Mix_Music *music)"
+  extern "const char * Mix_GetMusicTitle(const Mix_Music *music)"
+  extern "const char * Mix_GetMusicTitleTag(const Mix_Music *music)"
+  extern "const char * Mix_GetMusicArtistTag(const Mix_Music *music)"
+  extern "const char * Mix_GetMusicAlbumTag(const Mix_Music *music)"
+  extern "const char * Mix_GetMusicCopyrightTag(const Mix_Music *music)"
+  extern "void * Mix_GetMusicHookData(void)"
+  extern "int Mix_RegisterEffect(int chan, Mix_EffectFunc_t f, Mix_EffectDone_t d, void *arg)"
+  extern "int Mix_UnregisterEffect(int channel, Mix_EffectFunc_t f)"
+  extern "int Mix_UnregisterAllEffects(int channel)"
+  extern "int Mix_SetPanning(int channel, Uint8 left, Uint8 right)"
+  extern "int Mix_SetPosition(int channel, Sint16 angle, Uint8 distance)"
+  extern "int Mix_SetDistance(int channel, Uint8 distance)"
+  extern "int Mix_SetReverseStereo(int channel, int flip)"
+  extern "int Mix_ReserveChannels(int num)"
+  extern "int Mix_GroupChannel(int which, int tag)"
+  extern "int Mix_GroupChannels(int from, int to, int tag)"
+  extern "int Mix_GroupAvailable(int tag)"
+  extern "int Mix_GroupCount(int tag)"
+  extern "int Mix_GroupOldest(int tag)"
+  extern "int Mix_GroupNewer(int tag)"
+  extern "int Mix_PlayChannel(int channel, Mix_Chunk *chunk, int loops)"
+  extern "int Mix_PlayChannelTimed(int channel, Mix_Chunk *chunk, int loops, int ticks)"
+  extern "int Mix_PlayMusic(Mix_Music *music, int loops)"
+  extern "int Mix_FadeInMusic(Mix_Music *music, int loops, int ms)"
+  extern "int Mix_FadeInMusicPos(Mix_Music *music, int loops, int ms, double position)"
+  extern "int Mix_FadeInChannel(int channel, Mix_Chunk *chunk, int loops, int ms)"
+  extern "int Mix_FadeInChannelTimed(int channel, Mix_Chunk *chunk, int loops, int ms, int ticks)"
+  extern "int Mix_Volume(int channel, int volume)"
+  extern "int Mix_VolumeChunk(Mix_Chunk *chunk, int volume)"
+  extern "int Mix_VolumeMusic(int volume)"
+  extern "int Mix_GetMusicVolume(Mix_Music *music)"
+  extern "int Mix_MasterVolume(int volume)"
+  extern "int Mix_HaltChannel(int channel)"
+  extern "int Mix_HaltGroup(int tag)"
+  extern "int Mix_HaltMusic(void)"
+  extern "int Mix_ExpireChannel(int channel, int ticks)"
+  extern "int Mix_FadeOutChannel(int which, int ms)"
+  extern "int Mix_FadeOutGroup(int tag, int ms)"
+  extern "int Mix_FadeOutMusic(int ms)"
+  extern "Mix_Fading Mix_FadingMusic(void)"
+  extern "Mix_Fading Mix_FadingChannel(int which)"
+  extern "void Mix_Pause(int channel)"
+  extern "void Mix_Resume(int channel)"
+  extern "int Mix_Paused(int channel)"
+  extern "void Mix_PauseMusic(void)"
+  extern "void Mix_ResumeMusic(void)"
+  extern "void Mix_RewindMusic(void)"
+  extern "int Mix_PausedMusic(void)"
+  extern "int Mix_ModMusicJumpToOrder(int order)"
+  extern "int Mix_SetMusicPosition(double position)"
+  extern "double Mix_GetMusicPosition(Mix_Music *music)"
+  extern "double Mix_MusicDuration(Mix_Music *music)"
+  extern "double Mix_GetMusicLoopStartTime(Mix_Music *music)"
+  extern "double Mix_GetMusicLoopEndTime(Mix_Music *music)"
+  extern "double Mix_GetMusicLoopLengthTime(Mix_Music *music)"
+  extern "int Mix_Playing(int channel)"
+  extern "int Mix_PlayingMusic(void)"
+  extern "int Mix_SetMusicCMD(const char *command)"
+  extern "int Mix_SetSynchroValue(int value)"
+  extern "int Mix_GetSynchroValue(void)"
+  extern "int Mix_SetSoundFonts(const char *paths)"
+  extern "const char* Mix_GetSoundFonts(void)"
+  extern "int Mix_SetTimidityCfg(const char *path)"
+  extern "const char* Mix_GetTimidityCfg(void)"
+  extern "Mix_Chunk * Mix_GetChunk(int channel)"
+  extern "void Mix_CloseAudio(void)"
+end

data/lib/SDLRuby/mixer/sdl_mixer.rb

@@ -0,0 +1,60 @@
+module SDLRuby
+  module Mixer
+    typealias "Uint8", "uint8_t"
+    typealias "Uint16", "uint16_t"
+    typealias "Uint32", "uint32_t"
+    typealias "Sint16", "int16_t"
+    typealias "SDL_bool", "int"
+    typealias "Mix_EffectFunc_t", "void*"
+    typealias "Mix_EffectDone_t", "void*"
+
+    require_relative 'include/SDL_mixer.h'
+
+    MIX_INIT_FLAC   = 0x00000001
+    MIX_INIT_MOD    = 0x00000002
+    MIX_INIT_MP3    = 0x00000008
+    MIX_INIT_OGG    = 0x00000010
+    MIX_INIT_MID    = 0x00000020
+    MIX_INIT_OPUS   = 0x00000040
+
+    MIX_CHANNELS = 8
+
+    MIX_DEFAULT_FREQUENCY = 44100
+    #if SDL_BYTEORDER == SDL_LIL_ENDIAN
+    MIX_DEFAULT_FORMAT = AUDIO_S16LSB
+    #else
+    # MIX_DEFAULT_FORMAT = AUDIO_S16MSB
+    #endif
+
+    MIX_DEFAULT_CHANNELS = 2
+    MIX_MAX_VOLUME = SDL_MIX_MAXVOLUME
+
+    Mix_Chunk = struct(
+      [
+        "int allocated",
+        "Uint8 *abuf",
+        "Uint32 alen",
+        "Uint8 volume"
+      ]
+    )
+
+    MIX_NO_FADING = 0
+    MIX_FADING_OUT = 1
+    MIX_FADING_IN = 2
+
+    MUS_NONE = 0
+    MUS_CMD = 1
+    MUS_WAV = 2
+    MUS_MOD = 3
+    MUS_MID = 4
+    MUS_OGG = 5
+    MUS_MP3 = 6
+    MUS_MP3_MAD_UNUSED = 7
+    MUS_FLAC = 8
+    MUS_MODPLUG_UNUSED = 9
+    MUS_OPUS = 10
+
+    MIX_FREE_MUSIC = import_symbol("Mix_FreeMusic").to_int
+    MIX_FREE_CHUNK = import_symbol("Mix_FreeChunk").to_int
+  end
+end

data/lib/SDLRuby/mixer.rb

@@ -0,0 +1,87 @@
+require 'fiddle/import'
+
+module SDLRuby
+  module Mixer
+    include SDL
+    extend Fiddle::Importer
+
+    dlload "SDL2_mixer"
+
+    require_relative 'mixer/sdl_mixer'
+
+    require_relative 'mixer/channel'
+    require_relative 'mixer/chunk'
+    require_relative 'mixer/controller'
+
+    class << self
+      include Controller, SDL
+
+      def close = Mixer.Mix_CloseAudio
+
+      def decoders = Chunk.decoders
+
+      def init(flags = nil)
+        num = flags || 0 |
+          MIX_INIT_FLAC | MIX_INIT_MOD | MIX_INIT_MP3 |
+          MIX_INIT_OGG | MIX_INIT_MID | MIX_INIT_OPUS
+
+        Mixer.Mix_Init(num)
+      end
+
+      def load_chank(...) = Chunk.load(...)
+
+      def master_volume = Mixer.Mix_MasterVolume(-1)
+
+      def master_volume=(v)
+        Mixer.Mix_MasterVolume(v)
+      end
+
+      def open(device = nil,
+               allow_changes: true, channels: 2, chunksize: 2048,
+               format: MIX_DEFAULT_FORMAT, frequency: 48_000)
+
+        err = Mixer.Mix_OpenAudioDevice(
+          frequency, format, channels, chunksize, device,
+          allow_changes ? SDL_AUDIO_ALLOW_ANY_CHANGE : 0
+        )
+        raise SDLError if err < 0
+      end
+
+      def quit = Mixer.Mix_Quit
+
+      def reserve_channels=(num)
+        Mixer.Mix_ReserveChannels(num)
+      end
+
+      def spec
+        fq, ft, ch = SDL.tmp_value("int", "Uint16", "int")
+
+        if Mixer.Mix_QuerySpec(fq, ft, ch) == 1
+          { frequency: fq.value, format: ft.value, channels: ch.value }
+        end
+      end
+
+      def to_int = -1
+
+      def version = SDL_version.new(Mixer.Mix_Linked_Version).to_a.join(".")
+    end
+
+    # Channel manage
+    #
+    @channels = []
+
+    class << self
+      def [](channel)
+        raise IndexError if channel < 0 || channels <= channel
+        @channels[channel] ||= Channel.new(channel)
+      end
+
+      def channels = Mixer.Mix_AllocateChannels(-1)
+
+      def channels=(num)
+        @channels.slice!(num..)
+        Mixer.Mix_AllocateChannels(num)
+      end
+    end
+  end
+end

data/lib/SDLRuby/mouse.rb

@@ -0,0 +1,52 @@
+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 capture=(b)
+        err = SDL.SDL_CaptureMouse(b ? 1 : 0)
+        raise SDLError if err < 0
+      end
+
+      def global_pos=(xy)
+        err = SDL.SDL_WarpMouseGlobal(*xy)
+        raise SDLError if err < 0
+      end
+
+      def global_state = [
+        SDL.SDL_GetGlobalMouseState(@global_x, @global_y),
+        @global_x.value, @global_y.value
+      ]
+
+      def relative=(b)
+        err = SDL.SDL_SetRelativeMouseMode(b ? 1 : 0)
+        raise SDLError if err < 0
+      end
+
+      def relative? = SDL.SDL_GetRelativeMouseMode == 1
+
+      def relative_state = [
+        SDL.SDL_GetRelativeMouseState(@relative_x, @relative_y),
+        @relative_x.value, @relative_y.value
+      ]
+
+      def state = [
+        SDL.SDL_GetMouseState(@x, @y), @x.value, @y.value
+      ]
+    end
+  end
+end

data/lib/SDLRuby/music.rb

@@ -0,0 +1,158 @@
+require_relative 'mixer'
+
+module SDLRuby
+  class Music
+    module Information
+      include Mixer
+
+      def album = Mixer.Mix_GetMusicAlbumTag(self).to_s
+
+      def artist = Mixer.Mix_GetMusicArtistTag(self).to_s
+
+      def copyright = Mixer.Mix_GetMusicCopyrightTag(self).to_s
+
+      def duration = Mixer.Mix_MusicDuration(self)
+
+      def loop_end_time = Mixer.Mix_GetMusicLoopEndTime(self)
+
+      def loop_length_time = Mixer.Mix_GetMusicLoopLengthTime(self)
+
+      def loop_start_time = Mixer.Mix_GetMusicLoopStartTime(self)
+
+      def name = Mixer.Mix_GetMusicTitle(self).to_s
+
+      def pos = Mixer.Mix_GetMusicPosition(self)
+
+      def title = Mixer.Mix_GetMusicTitleTag(self).to_s
+
+      def type
+        case Mixer.Mix_GetMusicType(self)
+        when MUS_NONE then nil
+        when MUS_CMD then "CMD"
+        when MUS_WAV then "WAVE"
+        when MUS_MOD then "MOD"
+        when MUS_MID then "MIDI"
+        when MUS_OGG then "OGG"
+        when MUS_MP3 then "MP3"
+        when MUS_MP3_MAD_UNUSED then "MP3_MAD_UNUSED"
+        when MUS_FLAC then "FLAC"
+        when MUS_MODPLUG_UNUSED then "MODPLUG_UNUSED"
+        when MUS_OPUS then "OPUS"
+        else
+          nil
+        end
+      end
+
+      def volume = Mixer.Mix_GetMusicVolume(self)
+    end
+
+    include Information
+
+    class << self
+      include Information, Mixer
+
+      def decoders
+        Mixer.Mix_GetNumMusicDecoders.times.map do |idx|
+          ptr = Mixer.Mix_GetMusicDecoder(idx)
+          ptr.null? ? nil : ptr.to_s
+        end
+      end
+
+      def fading? = Mixer.Mix_FadingMusic != MIX_NO_FADING
+
+      def fading_in? = Mixer.Mix_FadingMusic == MIX_FADING_IN
+
+      def fading_out? = Mixer.Mix_FadingMusic == MIX_FADING_OUT
+
+      def halt = Mixer.Mix_HaltMusic
+
+      def fade_out(sec) = Mixer.Mix_FadeOutMusic(sec * 1000)
+
+      def load(file, type: MUS_NONE)
+        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_LoadMUSType_RW(rw, type, free)
+        raise SDLError if ptr.null?
+
+        new(ptr)
+      end
+
+      # MOD形成の場合のみ
+      def order=(i)
+        err = Mixer.Mix_ModMusicJumpToOrder(i)
+        raise SDLError if err < 0
+      end
+
+      def playing? = Mixer.Mix_PlayingMusic == 1
+
+      def pause = Mixer.Mix_PauseMusic
+
+      def paused? = Mixer.Mix_PausedMusic == 1
+
+      def pos=(sec)
+        err = Mixer.Mix_SetMusicPosition(sec)
+        raise SDLError if err < 0
+      end
+
+      def resume = Mixer.Mix_ResumeMusic
+
+      def rewind = Mixer.Mix_RewindMusic
+
+      def volume=(v)
+        Mixer.Mix_VolumeMusic(v)
+      end
+
+      private def to_ptr = nil
+
+      # MIDI
+      #
+      def sound_fonts_path
+        ptr = Mixer.Mix_GetSoundFonts
+        ptr.null? ? nil : ptr.to_s
+      end
+
+      # セミコロン区切りで複数のパスを指定できます。
+      def sound_fonts_path=(paths)
+        err = Mixer.Mix_SetSoundFonts(paths)
+        raise SDLError if err == 0
+      end
+
+      def timidity_config_path
+        ptr = Mixer.Mix_GetTimidityCfg
+        ptr.null? ? nil : ptr.to_s
+      end
+
+      def timidity_config_path=(path)
+        err = Mixer.Mix_SetTimidityCfg(path)
+        raise SDLError if err == 0
+      end
+    end
+
+    def initialize(ptr)
+      ptr.free = MIX_FREE_MUSIC
+      @ptr = ptr
+    end
+
+    # loops が 0 の時は1回のみ再生する。それ以外は1も含めて指定した回数を再生する。
+    # fade_in_time はミリ秒で指定する。
+    # non_block はフェードアウト中にブロックせずに即座に新しい音楽を再生する。
+    #
+    def play(loops: 0, fade_in_time: 0, pos: 0, non_block: nil)
+      Music.halt if non_block
+
+      err = Mixer.Mix_FadeInMusicPos(self, loops, fade_in_time * 1000, pos)
+      raise SDLError if err < 0
+    end
+
+    def to_ptr = @ptr
+  end
+end

data/lib/SDLRuby/palette.rb

@@ -0,0 +1,49 @@
+module SDLRuby
+  class Palette
+    include SDL
+    extend Forwardable
+
+    class << self
+      def create(n)
+        ptr = SDL.SDL_AllocPalette(n)
+        raise SDLError if ptr.null?
+        new(ptr)
+      end
+    end
+
+    def initialize(ptr, add_ref: nil)
+      @st = SDL_Palette.new(ptr, SDL_FREE_PALETTE)
+      @st.refcount += 1 if add_ref
+    end
+
+    def_delegator :@st, :ncolors, :size
+    def_delegators :@st, :refcount, :to_ptr, :version
+
+    def ==(other)
+      (other.respond_to?(:to_ptr) && @st.to_ptr == other.to_ptr) ||
+        (Palette === other && other.respond_to?(:to_a) && to_a == other.to_a)
+    end
+
+    def [](n)
+      raise ArgumentError if n < 0 || n >= size
+      SDL_Color.new(@st.colors + SDL_Palette.size * n).to_a
+    end
+
+    def []=(n, obj)
+      c = SDL_Color.malloc(Fiddle::RUBY_FREE)
+      c.r, c.g, c.b, c.a = *obj
+      err = SDL.SDL_SetPaletteColors(self, c, n, 1)
+      raise SDLError if err < 0
+    end
+
+    def each
+      if block_given?
+        size.times { |n| yield(self[n]) }
+      else
+        to_enum
+      end
+    end
+
+    def to_a = each.to_a
+  end
+end

data/lib/SDLRuby/pixel_formatter.rb

@@ -0,0 +1,67 @@
+module SDLRuby
+  module PixelFormatter
+    include SDL
+
+    INDEXED_PIXELFORMATS = [
+      SDL_PIXELFORMAT_INDEX1LSB, SDL_PIXELFORMAT_INDEX1MSB,
+      SDL_PIXELFORMAT_INDEX4LSB, SDL_PIXELFORMAT_INDEX4MSB,
+      SDL_PIXELFORMAT_INDEX8
+    ].freeze
+
+    ALPHA_PIXELFORMATS = [
+      SDL_PIXELFORMAT_ARGB4444, SDL_PIXELFORMAT_RGBA4444,
+      SDL_PIXELFORMAT_ABGR4444, SDL_PIXELFORMAT_BGRA4444,
+      SDL_PIXELFORMAT_ARGB1555, SDL_PIXELFORMAT_RGBA5551,
+      SDL_PIXELFORMAT_ABGR1555, SDL_PIXELFORMAT_BGRA5551,
+      SDL_PIXELFORMAT_ARGB8888, SDL_PIXELFORMAT_RGBA8888,
+      SDL_PIXELFORMAT_ABGR8888, SDL_PIXELFORMAT_BGRA8888,
+      SDL_PIXELFORMAT_ARGB2101010
+    ].freeze
+
+    class << self
+      def alpha?(x) = ALPHA_PIXELFORMATS.include?(x)
+
+      def bits_per_pixel(x) = fourcc?(x) ? nil : x >> 8 & 0xFF
+
+      def bytes_per_pixel(x)
+        if fourcc?(x)
+          x == SDL_PIXELFORMAT_YUY2 ||
+            x == SDL_PIXELFORMAT_UYVY ||
+            x == SDL_PIXELFORMAT_YVYU ? 2 : 1
+        else
+          x >> 0 & 0xFF
+        end
+      end
+
+      def format_name(x) = SDL.SDL_GetPixelFormatName(x).to_s
+
+      def fourcc?(x)
+        if x != 0 && x >> 28 & 0x0F != 1
+          [x].pack("L")
+        end
+      end
+
+      def indexed_color?(x) = INDEXED_PIXELFORMATS.include?(x)
+
+      def rgb_color?(x) = !(fourcc?(x) || indexed_color?(x) || alpha?(x))
+    end
+
+    def alpha? = PixelFormatter.alpha?(format)
+
+    def bits_per_pixel = PixelFormatter.bits_per_pixel(format)
+
+    alias depth bits_per_pixel
+
+    def bytes_per_pixel = PixelFormatter.bytes_per_pixel(format)
+
+    def format_name = PixelFormatter.format_name(format)
+
+    alias pixel_format_name format_name
+
+    def fourcc? = PixelFormatter.fourcc?(format)
+
+    def indexed_color? = PixelFormatter.indexed_color?(format)
+
+    def rgb_color? = PixelFormatter.rgb_color?(format)
+  end
+end

data/lib/SDLRuby/rect.rb

@@ -0,0 +1,11 @@
+module SDLRuby
+  class Rect < SDL::SDL_Rect
+    class << self
+      def [](*rect)
+        st = malloc(Fiddle::RUBY_FREE)
+        st.x, st.y, st.w, st.h = *rect
+        st
+      end
+    end
+  end
+end

data/lib/SDLRuby/renderer/accessor.rb

@@ -0,0 +1,70 @@
+module SDLRuby
+  module Renderer
+    module Accessor
+      def integer_scale? = SDL.SDL_RenderGetIntegerScale(renderer) != 0
+
+      def integer_scale=(b)
+        err = SDL.SDL_RenderSetIntegerScale(renderer, b ? 1 : 0)
+        raise SDLError if err < 0
+      end
+
+      def logical_size
+        w, h = SDL.tmp_value("int", "int")
+        SDL.SDL_RenderGetLogicalSize(renderer, w, h)
+        [w.value, h.value]
+      end
+
+      def logical_size=(wh)
+        err = SDL.SDL_RenderSetLogicalSize(renderer, *wh)
+        raise SDLError if err < 0
+      end
+
+      def output_size
+        x, y = SDL.tmp_value("int", "int")
+        err = SDL.SDL_GetRendererOutputSize(renderer, x, y)
+        raise SDLError if err < 0
+
+        [x.value, y.value]
+      end
+
+      def scale
+        x, y = SDL.tmp_value("float", "float")
+        SDL.SDL_RenderGetScale(renderer, x, y)
+        [x.value, y.value]
+      end
+
+      def scale=(xy)
+        err = SDL.SDL_RenderSetScale(renderer, x, y)
+        raise SDLError if err < 0
+      end
+
+      # ウィンドウ座標から対応する論理座標を戻す。
+      def to_logical_pos(x, y)
+        xp, yp = SDL.tmp_value("float", "float")
+        SDL.SDL_RenderWindowToLogical(renderer, x, y, xp, yp)
+
+        [xp.value, yp.value]
+      end
+
+      # 論理座標から対応するウィンドウの実座標を戻す。
+      #
+      def to_renderer_pos(x, y)
+        xp, yp = SDL.tmp_value("float", "float")
+        SDL.SDL_RenderLogicalToWindow(renderer, x, y, xp, yp)
+
+        [xp.value, yp.value]
+      end
+
+      def viewport
+        r =  Rect[]
+        SDL.SDL_RenderGetViewport(renderer, r)
+        r.to_a
+      end
+
+      def viewport=(rect)
+        err = SDL.SDL_RenderSetViewport(renderer, Rect[*rect])
+        raise SDLError if err < 0
+      end
+    end
+  end
+end