rubysdl 1.3.0

data/lib/sdl.rb

@@ -0,0 +1,271 @@
+#
+# Ruby/SDL   Ruby extension library for SDL
+#  Copyright (C) 2001-2007 Ohbayashi Ippei
+# 
+# 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 'sdl.so'
+require 'forwardable'
+
+if !defined?(block_given?) then
+  alias block_given? iterator?
+end
+
+module SDL
+  
+  VERSION = "1.3.0"
+
+  class PixelFormat
+
+    extend Forwardable
+    
+    def initialize(surface)
+      @surface = surface
+    end
+
+    def_delegators( :@surface, :mapRGB, :mapRGBA, :getRGB, :getRGBA, :bpp,
+		    :colorkey, :alpha )
+  end
+
+  class Surface
+    def put(surface,x,y)
+      SDL::blitSurface(surface,0,0,surface.w,surface.h,self,x,y)
+    end
+
+    def format
+      return PixelFormat.new(self)
+    end
+
+    if method_defined?(:rotateScaledSurface) then
+      def rotateSurface(angle,bgcolor)
+	rotateScaledSurface(angle,1.0,bgcolor)
+      end
+    end
+
+    def copyRect(x,y,w,h)
+      flagbase=SDL::SWSURFACE|SDL::HWSURFACE|SDL::SRCCOLORKEY|SDL::SRCALPHA
+      alpha_flag = self.flags & (SDL::SRCCOLORKEY|SDL::RLEACCEL)
+      self.setAlpha(0,self.alpha)
+      begin
+        new_surface=Surface.new(flagbase&self.flags,w,h,self)
+      ensure
+        self.setAlpha(alpha_flag,self.alpha)
+      end
+      SDL.blitSurface(self,x,y,w,h,new_surface,0,0)
+      new_surface.setColorKey(self.flags & (SDL::SRCCOLORKEY|SDL::RLEACCEL),
+                              self.colorkey )
+      new_surface.setAlpha(self.flags & (SDL::SRCALPHA|SDL::RLEACCEL),
+                           self.alpha )
+      return new_surface
+    end
+    
+    def self.blit(src, srcX, srcY, srcW, srcH, dst, dstX, dstY)
+      SDL.blitSurface(src, srcX, srcY, srcW, srcH, dst, dstX, dstY)
+    end
+    
+    def self.new(*args)
+      case args.size
+      when 4
+        create(*args)
+      when 8
+        createWithFormat(*args)
+      else
+        raise ArgumentError,"must be SDL::Surface.new(flags,w,h,surface) or SDL::Surface.new(flags,w,h,depth,Rmask,Gmask,Bmask,Amask)"
+      end
+    end
+  end
+
+  class Screen
+    def self.open(*args); SDL.setVideoMode(*args) end
+  end
+  
+  def color2int(color,format)
+    case color
+    when Integer
+      return color
+    when Array
+      return format.mapRGB(*color)
+    else
+      raise Error,'first argument must be Integer or Array'
+    end
+  end
+  module_function :color2int
+    
+  module Mouse
+    module_function
+
+    def setCursor(bitmap,white,black,transparent,inverted,hot_x=0,hot_y=0)
+      if bitmap.w % 8 != 0 then
+	raise SDL::Error,"width of cursor must be muliple of 8"
+      end
+
+      white=SDL.color2int(white,bitmap.format)
+      black=SDL.color2int(black,bitmap.format)
+      transparent=SDL.color2int(transparent,bitmap.format)
+      inverted=SDL.color2int(inverted,bitmap.format)
+      
+      data=[]
+      mask=[]
+
+      i=-1
+      for y in 0..(bitmap.h-1)
+	for x in 0..(bitmap.w-1)
+	  if x%8 != 0 then
+	    data[i] <<= 1
+	    mask[i] <<= 1
+	  else
+	    i+=1
+	    data[i]=mask[i]=0
+	  end
+	  
+	  case bitmap.getPixel(x,y)
+	  when white
+	    mask[i] |= 0x01
+	  when black
+	    data[i] |= 0x01
+	    mask[i] |= 0x01
+	  when transparent
+	    # do nothing 
+	  when inverted
+	    data[i] |= 0x01
+	  end
+
+	end
+      end
+
+      setCursor_imp data.pack('C*'),mask.pack('C*'),bitmap.w,bitmap.h,hot_x,hot_y
+    end
+    
+  end # of module Mouse
+
+  class CD
+    def in_drive?
+      status > 0
+    end
+  end
+  
+  module_function
+
+  if defined?(rotateXYScaled) then
+    def rotateScaled(src,dst,x,y,angle,scale)
+      rotateXYScaled(src,dst,x,y,angle,scale,scale)
+    end
+    def rotate(src,dst,x,y,angle)
+      rotateXYScaled(src,dst,x,y,angle,1,1)
+    end
+
+    def rotateBlit(src,dst,x,y,angle)
+      rotateScaledBlit(src,dst,x,y,angle,1)
+    end
+
+    def autoLock?
+      autoLock
+    end
+    
+    def autoLockON
+      self.autoLock = true
+    end
+    def autoLockOFF
+      self.autoLock =false
+    end
+  end
+
+  if defined?(transform) then
+    def transformBlit(src,dst,angle,xscale,yscale,px,py,qx,qy,flags)
+      transformed = src.transformSurface( src.colorkey, angle,
+					 xscale, yscale, flags )
+      transformed.setColorKey( src.flags & (SDL::SRCCOLORKEY|SDL::RLEACCEL),
+			      src.colorkey )
+      transformed.setAlpha( src.flags & (SDL::SRCALPHA|SDL::RLEACCEL),
+			    src.alpha )
+      rad = Math::PI*angle/180.0
+      x = px - src.w/2.0 ; y = py - src.h/2.0
+      x *= xscale ; y *= yscale
+      dst_x = x*Math.cos(rad)-y*Math.sin(rad) 
+      dst_y = x*Math.sin(rad)+y*Math.cos(rad) 
+      dst_x += transformed.w/2
+      dst_y += transformed.h/2
+      blitSurface( transformed, 0, 0, 0, 0, dst, qx-dst_x, qy-dst_y )
+    end      
+  end
+
+  Rect = Struct.new( :x, :y, :w, :h )
+  
+  def convertRect(rect)
+    case rect
+    when NilClass
+      return Rect.new( 0, 0, 0, 0 )
+    when Array
+      return Rect.new( rect[0], rect[1], rect[2], rect[3] )
+    else
+      return rect
+    end
+  end
+  
+  def blitSurface2(src,srcRect,dst,dstRect)
+    srcR = convertRect(srcRect)
+    dstR = convertRect(dstRect)
+    blitSurface( src, srcR.x, srcR.y, srcR.w, srcR.h , dst, dstR.x, dstR.y )
+  end
+  
+  if defined?(Mixer)
+    class << Mixer
+      alias open_imp open
+      private :open_imp
+      def open(frequency=Mixer::DEFAULT_FREQUENCY,format=Mixer::DEFAULT_FORMAT,
+	       cannels=Mixer::DEFAULT_CHANNELS,chunksize=4096)
+	open_imp(frequency,format,cannels,chunksize)
+      end
+    end
+  end
+
+  if defined?(MPEG)
+    class MPEG
+      alias info_imp info
+      private :info_imp
+      def info(*arg)
+	case arg.size
+	when 0
+	  result = SDL::MPEG::Info.new
+	  info_imp(result)
+	  result
+	when 1
+	  info_imp(arg[0])
+	  arg[0]
+	end
+      end
+    end
+  end
+  
+end
+
+if defined?(GL) then
+  class << GL
+    alias Begin_imp Begin
+    private :Begin_imp
+    def Begin(mode)
+      if block_given? then
+	begin
+	  Begin_imp(mode)
+	  yield
+	ensure
+	  End()
+	end
+      else
+	Begin_imp(mode)
+      end
+    end
+  end
+end
+
+require 'rubysdl_aliases.rb'

data/rubysdl.h

@@ -0,0 +1,109 @@
+/*
+  Ruby/SDL   Ruby extension library for SDL
+
+  Copyright (C) 2001-2007 Ohbayashi Ippei
+  
+  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
+  */
+
+#include <SDL.h>
+#include <ruby.h>
+#include <stdio.h>
+#ifndef UINT2NUM
+#define UINT2NUM(v) INT2NUM(v)
+#endif
+
+#ifdef DEF_GLOBAL
+#define GLOBAL
+#else
+#define GLOBAL extern
+#endif
+
+#ifdef StringValuePtr
+#define GETCSTR(v) StringValuePtr(v)
+#else
+#define GETCSTR(v) STR2CSTR(v)
+#endif
+
+GLOBAL VALUE mSDL;
+GLOBAL VALUE eSDLError;
+GLOBAL VALUE cVideoInfo;
+GLOBAL VALUE cSurface;
+GLOBAL VALUE cScreen;
+GLOBAL VALUE cEvent;
+GLOBAL VALUE mKey;
+GLOBAL VALUE mMixer;
+GLOBAL VALUE cWave;
+GLOBAL VALUE cMusic;
+GLOBAL VALUE mWM;
+GLOBAL VALUE mMouse;
+GLOBAL VALUE cTTF;
+GLOBAL VALUE cJoystick;
+GLOBAL VALUE cCD;
+GLOBAL VALUE cMPEG;
+GLOBAL VALUE cMPEGInfo;
+GLOBAL VALUE mSDLSKK;
+GLOBAL VALUE cContext;
+GLOBAL VALUE cDictionary;
+GLOBAL VALUE cRomKanaRuleTable;
+GLOBAL VALUE cKeybind;
+
+#ifdef HAVE_SGE
+GLOBAL VALUE cCollisionMap;
+GLOBAL VALUE cBMFont;
+#endif /* ifdef HAVE_SGE */
+
+#ifdef DEF_EVENT2
+GLOBAL VALUE cEvent2;
+GLOBAL VALUE cActiveEvent;
+GLOBAL VALUE cKeyDownEvent;
+GLOBAL VALUE cKeyUpEvent;
+GLOBAL VALUE cMouseMotionEvent;
+GLOBAL VALUE cMouseButtonDownEvent;
+GLOBAL VALUE cMouseButtonUpEvent;
+GLOBAL VALUE cJoyAxisEvent;
+GLOBAL VALUE cJoyBallEvent;
+GLOBAL VALUE cJoyHatEvent;
+GLOBAL VALUE cJoyButtonUpEvent;
+GLOBAL VALUE cJoyButtonDownEvent;
+GLOBAL VALUE cQuitEvent;
+GLOBAL VALUE cSysWMEvent;
+GLOBAL VALUE cVideoResizeEvent;
+GLOBAL VALUE cVideoExposeEvent;
+#endif
+
+#define SetRect(Rect,X,Y,W,H) \
+do{ \
+  Rect.x=NUM2INT(X); \
+  Rect.y=NUM2INT(Y); \
+  Rect.w=NUM2INT(W); \
+  Rect.h=NUM2INT(H); \
+}while(0) \
+
+#define BOOL(x) (x)?Qtrue:Qfalse
+
+#ifndef SDL_VERSION_ATLEAST
+#define SDL_COMPILEDVERSION SDL_VERSIONNUM(SDL_MAJOR_VERSION, SDL_MINOR_VERSION, SDL_PATCHLEVEL)
+     
+#define SDL_VERSION_ATLEAST(X, Y, Z) (SDL_COMPILEDVERSION >= SDL_VERSIONNUM(X, Y, Z))
+     
+#endif
+
+Uint32 VALUE2COLOR(VALUE color,SDL_PixelFormat *format);
+void rubysdl_putPixel(SDL_Surface *surface, Sint16 x, Sint16 y, Uint32 color);
+Uint32 rubysdl_getPixel(SDL_Surface *surface, Sint16 x, Sint16 y);
+void sdl_freeSurface(SDL_Surface* surface);
+int rubysdl_is_quit(void);
+SDL_RWops* rubysdl_RWops_from_ruby_obj(VALUE obj);

data/rubysdl_cdrom.c

@@ -0,0 +1,176 @@
+/*
+  Ruby/SDL   Ruby extension library for SDL
+
+  Copyright (C) 2001-2007 Ohbayashi Ippei
+  
+  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
+  */
+#include "rubysdl.h"
+
+static VALUE sdl_cd_numDrive(VALUE class)
+{
+  return INT2FIX(SDL_CDNumDrives());
+}
+static VALUE sdl_cd_name(VALUE class,VALUE drive)
+{
+  return rb_str_new2(SDL_CDName(NUM2INT(drive)));
+}
+static VALUE sdl_cd_open(VALUE class,VALUE drive)
+{
+  SDL_CD *cd;
+  cd=SDL_CDOpen(NUM2INT(drive));
+  if(cd==NULL)
+    rb_raise(eSDLError,"Couldn't open drive %d: %s",
+	     NUM2INT(drive),SDL_GetError());
+  return Data_Wrap_Struct(class,0,SDL_CDClose,cd);
+}
+static VALUE sdl_cd_status(VALUE obj)
+{
+  SDL_CD *cd;
+  Data_Get_Struct(obj,SDL_CD,cd);
+  return INT2FIX(SDL_CDStatus(cd));
+}
+static VALUE sdl_cd_play(VALUE obj,VALUE start,VALUE length)
+{
+  SDL_CD *cd;
+  Data_Get_Struct(obj,SDL_CD,cd);
+  if( SDL_CDPlay(cd,NUM2INT(start),NUM2INT(length))==-1 )
+    rb_raise(eSDLError,"Couldn't play cd :%s",SDL_GetError() );
+  return Qnil;
+}
+static VALUE sdl_cd_playTracks(VALUE obj,VALUE start_track,VALUE start_frame,
+			       VALUE ntracks,VALUE nframes)
+{
+  SDL_CD *cd;
+  Data_Get_Struct(obj,SDL_CD,cd);
+  if( SDL_CDPlayTracks(cd,NUM2INT(start_track),NUM2INT(start_frame),
+		       NUM2INT(ntracks),NUM2INT(nframes))==-1 )
+    rb_raise(eSDLError,"Couldn't play cd :%s",SDL_GetError() );
+  return Qnil;
+}
+static VALUE sdl_cd_pause(VALUE obj)
+{
+  SDL_CD *cd;
+  Data_Get_Struct(obj,SDL_CD,cd);
+  if( SDL_CDPause(cd)==-1 )
+    rb_raise(eSDLError,"cd pause failed :%s",SDL_GetError());
+  return Qnil;
+}
+static VALUE sdl_cd_resume(VALUE obj)
+{
+  SDL_CD *cd;
+  Data_Get_Struct(obj,SDL_CD,cd);
+  if( SDL_CDResume(cd)==-1 )
+    rb_raise(eSDLError,"cd resume failed :%s",SDL_GetError());
+  return Qnil;
+}
+static VALUE sdl_cd_stop(VALUE obj)
+{
+  SDL_CD *cd;
+  Data_Get_Struct(obj,SDL_CD,cd);
+  if( SDL_CDStop(cd)==-1 )
+    rb_raise(eSDLError,"cd pause failed :%s",SDL_GetError());
+  return Qnil;
+}
+static VALUE sdl_cd_eject(VALUE obj)
+{
+  SDL_CD *cd;
+  Data_Get_Struct(obj,SDL_CD,cd);
+  if( SDL_CDEject(cd)==-1 )
+    rb_raise(eSDLError,"cd eject failed :%s",SDL_GetError());
+  return Qnil;
+}
+
+static VALUE sdl_cd_numTracks(VALUE obj)
+{
+  SDL_CD *cd;
+  Data_Get_Struct(obj,SDL_CD,cd);
+  return INT2NUM(cd->numtracks);
+}
+static VALUE sdl_cd_currentTrack(VALUE obj)
+{
+  SDL_CD *cd;
+  Data_Get_Struct(obj,SDL_CD,cd);
+  return INT2NUM(cd->cur_track);
+}
+static VALUE sdl_cd_currentFrame(VALUE obj)
+{
+  SDL_CD *cd;
+  Data_Get_Struct(obj,SDL_CD,cd);
+  return INT2NUM(cd->cur_frame);
+}
+static VALUE sdl_cd_trackType(VALUE obj,VALUE track)
+{
+  SDL_CD *cd;
+  int index=NUM2INT(track);
+  Data_Get_Struct(obj,SDL_CD,cd);
+  return INT2FIX(cd->track[index].type);
+}
+static VALUE sdl_cd_trackLength(VALUE obj,VALUE track)
+{
+  SDL_CD *cd;
+  int index=NUM2INT(track);
+  Data_Get_Struct(obj,SDL_CD,cd);
+  return INT2FIX(cd->track[index].length);
+}
+
+static VALUE sdl_cd_framesToMSF(VALUE class, VALUE frames)
+{
+  int m, s, f;
+  FRAMES_TO_MSF(NUM2INT(frames), &m, &s, &f);
+  return rb_ary_new3(3, INT2FIX(m), INT2FIX(s), INT2FIX(f));
+}
+static VALUE sdl_cd_MSFToFrames(VALUE class, VALUE m, VALUE s, VALUE f)
+{
+  return INT2FIX(MSF_TO_FRAMES(NUM2INT(m),NUM2INT(s),NUM2INT(f)));
+}
+
+static void defineConstForCDROM()
+{
+  rb_define_const(cCD,"TRAYEMPTY",INT2NUM(CD_TRAYEMPTY));
+  rb_define_const(cCD,"STOPPED",INT2NUM(CD_STOPPED));
+  rb_define_const(cCD,"PLAYING",INT2NUM(CD_PLAYING));
+  rb_define_const(cCD,"PAUSED",INT2NUM(CD_PAUSED));
+  rb_define_const(cCD,"ERROR",INT2NUM(CD_ERROR));
+  
+  rb_define_const(cCD,"AUDIO_TRACK",UINT2NUM(SDL_AUDIO_TRACK));
+  rb_define_const(cCD,"DATA_TRACK",UINT2NUM(SDL_DATA_TRACK));
+
+  rb_define_const(cCD,"FPS", UINT2NUM(CD_FPS));
+}
+void init_cdrom()
+{
+  cCD=rb_define_class_under(mSDL,"CD",rb_cObject);
+  rb_define_singleton_method(cCD,"numDrive",sdl_cd_numDrive,0);
+  rb_define_singleton_method(cCD,"indexName",sdl_cd_name,1);
+  rb_define_singleton_method(cCD,"open",sdl_cd_open,1);
+  rb_define_singleton_method(cCD,"framesToMSF",sdl_cd_framesToMSF,1);
+  rb_define_singleton_method(cCD,"MSFToFrames",sdl_cd_MSFToFrames,3);
+  rb_define_method(cCD,"status",sdl_cd_status,0);
+  rb_define_method(cCD,"play",sdl_cd_play,2);
+  rb_define_method(cCD,"playTracks",sdl_cd_playTracks,4);
+  rb_define_method(cCD,"pause",sdl_cd_pause,0);
+  rb_define_method(cCD,"resume",sdl_cd_resume,0);
+  rb_define_method(cCD,"stop",sdl_cd_stop,0);
+  rb_define_method(cCD,"eject",sdl_cd_eject,0);
+
+  rb_define_method(cCD,"numTracks",sdl_cd_numTracks,0);
+  rb_define_method(cCD,"currentTrack",sdl_cd_currentTrack,0);
+  rb_define_method(cCD,"currentFrame",sdl_cd_currentFrame,0);
+  rb_define_method(cCD,"trackType",sdl_cd_trackType,1);
+  rb_define_method(cCD,"trackLength",sdl_cd_trackLength,1);
+  
+  defineConstForCDROM();
+}