rubygame 2.5.3 → 2.6.0

data/lib/rubygame/gl.rb

@@ -0,0 +1,107 @@
+#--
+#	Rubygame -- Ruby code and bindings to SDL to facilitate game creation
+#	Copyright (C) 2004-2009  John Croisant
+#
+#	This library is free software; you can redistribute it and/or
+#	modify it under the terms of the GNU Lesser General Public
+#	License as published by the Free Software Foundation; either
+#	version 2.1 of the License, or (at your option) any later version.
+#
+#	This library is distributed in the hope that it will be useful,
+#	but WITHOUT ANY WARRANTY; without even the implied warranty of
+#	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+#	Lesser General Public License for more details.
+#
+#	You should have received a copy of the GNU Lesser General Public
+#	License along with this library; if not, write to the Free Software
+#	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+#++
+
+
+
+# The GL module provides an interface to SDL's OpenGL-related functions,
+# allowing a Rubygame application to create hardware-accelerated 3D graphics
+# with OpenGL.
+#
+# Please note that Rubygame itself does not provide an interface to OpenGL
+# functions -- only functions which allow Rubygame to work together with
+# OpenGL. You will need to use another library, for example
+# ruby-opengl[http://ruby-opengl.rubyforge.org/],
+# to actually create graphics with OpenGL.
+#
+# Users who wish to use Rubygame Surfaces as textures in OpenGL should
+# see also the Surface#pixels method.
+#
+module Rubygame::GL
+
+
+  # Return the value of the the SDL/OpenGL attribute identified by +attrib+,
+  # which should be one of the constants defined in the Rubygame::GL module.
+  # See #set_attrib for a list of attribute constants.
+  #
+  # This method is useful after using #set_attrib and calling Screen#set_mode,
+  # to make sure the attribute is the expected value.
+  #
+  def self.get_attrib( attrib )
+    result = SDL.GL_GetAttribute(attrib)
+    if( result.nil? )
+      raise Rubygame::SDLError, "GL get attribute failed: #{SDL.GetError()}"
+    end
+  end
+
+
+
+  # Set the SDL/OpenGL attribute +attrib+ to +value+. This should be called
+  # *before* you call Screen#set_mode with the OPENGL flag. You may wish to
+  # use #get_attrib after calling Screen#set_mode to confirm that the attribute
+  # is set to the desired value.
+  #
+  # The full list of SDL/OpenGL attribute identifier constants (located under
+  # the Rubygame::GL module) is as follows:
+  #
+  # RED_SIZE::         Size of framebuffer red component, in bits.
+  # GREEN_SIZE::       Size of framebuffer green component, in bits.
+  # BLUE_SIZE::        Size of framebuffer blue component, in bits.
+  # ALPHA_SIZE::       Size of framebuffer alpha (opacity) component, in bits.
+  # BUFFER_SIZE::      Size of framebuffer, in bits.
+  # DOUBLEBUFFER::     Enable or disable double-buffering.
+  # DEPTH_SIZE::       Size of depth buffer, in bits.
+  # STENCIL_SIZE::     Size of stencil buffer, in bits.
+  # ACCUM_RED_SIZE::   Size of accumulation buffer red component, in bits.
+  # ACCUM_GREEN_SIZE:: Size of accumulation buffer green component, in bits.
+  # ACCUM_BLUE_SIZE::  Size of accumulation buffer blue component, in bits.
+  # ACCUM_ALPHA_SIZE:: Size of accumulation buffer alpha component, in bits.
+  #
+  def self.set_attrib( attrib, value )
+    result = SDL.GL_SetAttribute( attrib, value )
+    if( result == -1 )
+      raise Rubygame::SDLError, "GL set attribute failed: #{SDL.GetError()}"
+    end
+  end
+
+
+
+  # Swap the back and front buffers, for double-buffered OpenGL displays.
+  # Should be safe to use (albeit with no effect) on single-buffered OpenGL
+  # displays.
+  #
+  def self.swap_buffers
+    SDL.GL_SwapBuffers()
+  end
+
+
+  RED_SIZE         = SDL::GL_RED_SIZE
+  GREEN_SIZE       = SDL::GL_GREEN_SIZE
+  BLUE_SIZE        = SDL::GL_BLUE_SIZE
+  ALPHA_SIZE       = SDL::GL_ALPHA_SIZE
+  BUFFER_SIZE      = SDL::GL_BUFFER_SIZE
+  DOUBLEBUFFER     = SDL::GL_DOUBLEBUFFER
+  DEPTH_SIZE       = SDL::GL_DEPTH_SIZE
+  STENCIL_SIZE     = SDL::GL_STENCIL_SIZE
+  ACCUM_RED_SIZE   = SDL::GL_ACCUM_RED_SIZE
+  ACCUM_GREEN_SIZE = SDL::GL_ACCUM_GREEN_SIZE
+  ACCUM_BLUE_SIZE  = SDL::GL_ACCUM_BLUE_SIZE
+  ACCUM_ALPHA_SIZE = SDL::GL_ACCUM_ALPHA_SIZE
+
+
+end

data/lib/rubygame/image.rb

@@ -0,0 +1,140 @@
+#--
+#	Rubygame -- Ruby code and bindings to SDL to facilitate game creation
+#	Copyright (C) 2004-2009  John Croisant
+#
+#	This library is free software; you can redistribute it and/or
+#	modify it under the terms of the GNU Lesser General Public
+#	License as published by the Free Software Foundation; either
+#	version 2.1 of the License, or (at your option) any later version.
+#
+#	This library is distributed in the hope that it will be useful,
+#	but WITHOUT ANY WARRANTY; without even the implied warranty of
+#	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+#	Lesser General Public License for more details.
+#
+#	You should have received a copy of the GNU Lesser General Public
+#	License along with this library; if not, write to the Free Software
+#	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+#++
+
+
+
+require "ruby-sdl-ffi/image"
+
+Rubygame::VERSIONS[:sdl_image] = SDL::Image.Linked_Version().to_ary
+
+
+class Rubygame::Surface
+
+  class << self
+
+    # Searches each directory in Surface.autoload_dirs for a file with
+    # the given filename. If it finds that file, loads it and returns
+    # a Surface instance. If it doesn't find the file, returns nil.
+    #
+    # See Rubygame::NamedResource for more information about this
+    # functionality.
+    #
+    def autoload( name )
+      path = find_file( name )
+
+      if( path )
+        return load( path )
+      else
+        return nil
+      end
+    end
+
+
+    # *IMPORTANT*: this method only exists if SDL_image is available!
+    # Your code should check "defined?(Rubygame::Surface.load) != nil"
+    # to see if you can use this method, or be prepared to rescue from
+    # NameError.
+    # 
+    # Load an image file from the disk to a Surface. If the image has an alpha
+    # channel (e.g. PNG with transparency), the Surface will as well. If the
+    # image cannot be loaded (for example if the image format is unsupported),
+    # will raise SDLError.
+    #
+    # This method takes this argument:
+    # filename:: a string containing the relative or absolute path to the
+    #            image file. The file must have the proper file extension,
+    #            as it is used to determine image format.
+    #
+    # These formats may be supported, but some may not be available on a
+    # particular system.
+    # BMP:: "Windows Bitmap" format.
+    # GIF:: "Graphics Interchange Format."
+    # JPG:: "Independent JPEG Group" format.
+    # LBM:: "Linear Bitmap" format (?)
+    # PCX:: "PC Paintbrush" format
+    # PNG:: "Portable Network Graphics" format.
+    # PNM:: "Portable Any Map" format. (i.e., PPM, PGM, or PBM)
+    # TGA:: "Truevision TARGA" format.
+    # TIF:: "Tagged Image File Format"
+    # XCF:: "eXperimental Computing Facility" (GIMP native format).
+    # XPM:: "XPixMap" format.
+    # 
+    def load( filename )
+      surf = SDL::Image.Load( filename )
+
+      if( surf.pointer.null? )
+        raise( Rubygame::SDLError, "Couldn't load image \"%s\": %s"%\
+               [filename, SDL.GetError()] )
+      end
+
+      return self.new(surf)
+    end
+
+
+    # Deprecated. Use Surface.load instead!
+    def load_image( filename )
+      Rubygame.deprecated( "Rubygame::Surface.load_image", "3.0" )
+      load( filename )
+    end
+
+
+    # *IMPORTANT*: this method only exists if SDL_image is available!
+    # Your code should check
+    # "defined?(Rubygame::Surface.load_from_string) != nil" to see if
+    # you can use this method, or be prepared to rescue from
+    # NameError.
+    # 
+    # Load an image file from memory (in the form of the given data)
+    # to a Surface. If the image has an alpha channel (e.g. PNG with
+    # transparency), the Surface will as well. If the image cannot be
+    # loaded (for example if the image format is unsupported), will
+    # raise SDLError.
+    # 
+    # This method takes these arguments:
+    # data:: a string containing the data for the image, such as
+    #        IO::read would return.
+    # type:: The type of file that the image is (i.e. 'TGA'). Case is
+    #        not important. If absent, the library will try to
+    #        automatically detect the type.
+    # 
+    # See Surface.load for a list of possible supported file types.
+    # 
+    def load_from_string( data, type=nil )
+      raw = FFI::Buffer.new(:char, data.length)
+      raw.put_bytes(0, data)
+
+      rw = SDL.RWFromMem( raw, data.length )
+
+      surf = if type
+               SDL::Image.LoadTyped_RW(rw, 1, type)
+             else
+               SDL::Image.Load_RW(rw, 1)
+             end
+      
+      if surf.pointer.null?
+        raise( Rubygame::SDLError,
+               "Couldn't load image from string: #{SDL.GetError()}" )
+      end
+
+      return new(surf)
+    end
+
+  end
+
+end

data/lib/rubygame/joystick.rb

@@ -0,0 +1,184 @@
+#--
+#	Rubygame -- Ruby code and bindings to SDL to facilitate game creation
+#	Copyright (C) 2004-2009  John Croisant
+#
+#	This library is free software; you can redistribute it and/or
+#	modify it under the terms of the GNU Lesser General Public
+#	License as published by the Free Software Foundation; either
+#	version 2.1 of the License, or (at your option) any later version.
+#
+#	This library is distributed in the hope that it will be useful,
+#	but WITHOUT ANY WARRANTY; without even the implied warranty of
+#	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+#	Lesser General Public License for more details.
+#
+#	You should have received a copy of the GNU Lesser General Public
+#	License along with this library; if not, write to the Free Software
+#	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+#++
+
+
+
+# The Joystick class interfaces with joysticks, gamepads, and other
+# similar hardware devices used to play games. Each joystick may
+# have zero or more #axes, #balls, #hats, and/or #buttons.
+#
+# After a Joystick object is successfully created, events for that
+# Joystick will begin appearing on the EventQueue when a button is
+# pressed or released, a control stick is moved, etc.
+#
+# You can use Joystick.activate_all to start receiving events for
+# all joysticks (equivalent to creating them all individually with
+# Joystick.new). You can use Joystick.deactivate_all to stop
+# receiving events for all joysticks.
+#
+# As of Rubygame 2.4, these are the current, "new-style" Joystick
+# event classes:
+#
+# * Events::JoystickAxisMoved
+# * Events::JoystickButtonPressed
+# * Events::JoystickButtonReleased
+# * Events::JoystickBallMoved
+# * Events::JoystickHatMoved
+#
+# These old Joystick-related events are deprecated and will be
+# removed in Rubygame 3.0:
+#
+# * JoyAxisEvent
+# * JoyBallEvent
+# * JoyHatEvent
+# * JoyDownEvent
+# * JoyUpEvent
+#
+# For more information about "new-style" events, see
+# EventQueue.enable_new_style_events.
+#
+class Rubygame::Joystick
+
+
+  # Returns the total number of joysticks detected on the system.
+  def self.num_joysticks
+    SDL.NumJoysticks()
+  end
+
+
+  # Returns the name of Nth joystick on the system. The name is
+  # implementation-dependent. See also #name.
+  #
+  def self.get_name( index )
+    SDL.JoystickName( index )
+  end
+
+
+  # Activate all joysticks on the system, equivalent to calling
+  # Joystick.new for every joystick available. This will allow
+  # joystick-related events to be sent to the EventQueue for all
+  # joysticks.
+  #
+  # Returns::   Array of zero or more Joysticks.
+  # May raise:: SDLError, if the joystick system could not be
+  #             initialized.
+  #
+  def self.activate_all
+    # Initialize if it isn't already.
+    if( SDL.WasInit(SDL::INIT_JOYSTICK) == 0 )
+      if( SDL.Init(SDL::INIT_JOYSTICK) != 0 )
+        raise Rubygame::SDLError, "Could not initialize SDL joysticks."
+      end
+    end
+
+    # Collect Joystick instances in an Array
+    joysticks = []
+
+    num_joysticks.times do |i|
+      joysticks << new( i )
+    end
+
+    return joysticks
+  end
+
+
+  # Deactivate all joysticks on the system. This will stop all
+  # joystick-related events from being sent to the EventQueue.
+  #
+  def self.deactivate_all
+    # Return right away if it isn't active
+    return if( SDL.WasInit(SDL::INIT_JOYSTICK) == 0 )
+
+    num_joysticks.times do |i|
+      joy = SDL.JoystickOpen(i)
+      unless( joy.pointer.nil? )
+        SDL.JoystickClose( joy )
+      end
+    end
+
+    return nil
+  end
+
+
+  # Create and initialize an interface to the Nth joystick on the
+  # system. Raises SDLError if the joystick could not be opened.
+  #
+  def initialize( index )
+    @struct = SDL.JoystickOpen( index )
+    if( @struct.pointer.null? )
+      raise( Rubygame::SDLError, "Could not open joystick %d: %s"%
+             [index, SDL.GetError()] )
+    end
+  end
+
+
+  # Returns the index number of the Joystick, i.e. the identifier
+  # number of the joystick that this interface controls. This is the
+  # same number that was given to Joystick.new.
+  #
+  def index
+    SDL.JoystickIndex( @struct )
+  end
+
+
+  # Returns a String containing the name of the Joystick. The name is
+  # implementation-dependent. See also Joystick.get_name.
+  #
+  def name
+    SDL.JoystickName( self.index )
+  end
+
+
+  # Returns the number of axes (singular: axis) featured on the
+  # Joystick. Each control stick generally has two axes (X and Y),
+  # although there are other types of controls which are represented
+  # as one or more axes.
+  #
+  def axes
+    SDL.JoystickNumAxes( @struct )
+  end
+
+
+  # Returns the number of trackballs featured on the Joystick. A
+  # trackball is usually a small sphere which can be rotated in-place
+  # in any direction, registering relative movement along two axes.
+  #
+  def balls
+    SDL.JoystickNumBalls( @struct )
+  end
+
+
+  # Returns the number of hats featured on the Joystick. A hat is a
+  # switch which can be pushed in one of several directions, or
+  # centered.
+  #
+  def hats
+    SDL.JoystickNumHats( @struct )
+  end
+
+
+  # Returns the number of buttons featured on the Joystick. A button
+  # can be in one of two states: neutral, or pushed.
+  #
+  def buttons
+    SDL.JoystickNumButtons( @struct )
+  end
+
+
+end

data/lib/rubygame/main.rb

@@ -0,0 +1,82 @@
+#--
+#	Rubygame -- Ruby code and bindings to SDL to facilitate game creation
+#	Copyright (C) 2004-2009  John Croisant
+#
+#	This library is free software; you can redistribute it and/or
+#	modify it under the terms of the GNU Lesser General Public
+#	License as published by the Free Software Foundation; either
+#	version 2.1 of the License, or (at your option) any later version.
+#
+#	This library is distributed in the hope that it will be useful,
+#	but WITHOUT ANY WARRANTY; without even the implied warranty of
+#	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+#	Lesser General Public License for more details.
+#
+#	You should have received a copy of the GNU Lesser General Public
+#	License along with this library; if not, write to the Free Software
+#	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+#++
+
+
+
+require "ruby-sdl-ffi/sdl"
+
+
+module Rubygame
+
+  VERSIONS = {
+    :rubygame => [2, 5, 3],
+    :sdl      => SDL.Linked_Version().to_ary
+  }
+
+
+  # Initialize Rubygame. This should be called soon after you
+  # +require+ Rubygame, so that everything will work properly.
+  #
+  def self.init
+    if( SDL.Init(SDL::INIT_EVERYTHING) == 0 )
+      SDL.EnableUNICODE(1)
+    else
+      raise Rubygame::SDLError, "Could not initialize SDL: #{SDL.GetError()}"
+    end
+  end
+
+
+  # Quit Rubygame. This should be used before your program terminates,
+  # especially if you have been using a fullscreen Screen! (Otherwise,
+  # the desktop resolution might not revert to its previous setting on
+  # some platforms, and your users will be frustrated and confused!)
+  #
+  def self.quit
+    SDL.Quit
+  end
+
+
+
+  # Indicates that an SDL function failed.
+  class SDLError < RuntimeError
+  end
+
+
+
+  SWSURFACE   = SDL::SWSURFACE
+  HWSURFACE   = SDL::HWSURFACE
+  ASYNCBLIT   = SDL::ASYNCBLIT
+  ANYFORMAT   = SDL::ANYFORMAT
+  HWPALETTE   = SDL::HWPALETTE
+  HWACCEL     = SDL::HWACCEL
+  SRCCOLORKEY = SDL::SRCCOLORKEY
+  RLEACCELOK  = SDL::RLEACCELOK
+  RLEACCEL    = SDL::RLEACCEL
+  SRCALPHA    = SDL::SRCALPHA
+  PREALLOC    = SDL::PREALLOC
+
+  DOUBLEBUF   = SDL::DOUBLEBUF
+  FULLSCREEN  = SDL::FULLSCREEN
+  OPENGL      = SDL::OPENGL
+  OPENGLBLIT  = SDL::OPENGLBLIT
+  RESIZABLE   = SDL::RESIZABLE
+  NOFRAME     = SDL::NOFRAME
+
+
+end