sgl 0.3.1 → 0.4.0

data/lib/sgl/opengl-event.rb

@@ -0,0 +1,325 @@
+# Copyright (C) 2004-2007 Kouichirou Eto, All rights reserved.
+# License: Ruby License
+
+module SGL
+  # callback functions
+  def setup()		end
+  def onMouseDown(x,y)	end
+  def onMouseUp(x,y)	end
+  def onKeyDown(k)	end
+  def onKeyUp(k)	end
+  def display()		end
+
+  # callback functions for fullscreen
+  def onMouseDown0(x,y)	end
+  def display0()	end
+
+  # mainloop
+  def mainloop
+    $__a__.set_setup { setup }
+    $__a__.set_mousedown {|x, y| onMouseDown(x, y) }
+    $__a__.set_mouseup   {|x, y| onMouseUp(x, y) }
+    $__a__.set_keydown   {|k| onKeyDown(k) }
+    $__a__.set_keyup     {|k| onKeyUp(k) }
+    if ! $__a__.check_display0
+      $__a__.set_display0 { display0 }
+      $__a__.set_mousedown0 {|x, y| onMouseDown0(x, y) }
+    end
+    $__a__.set_display { display }
+
+    if ! defined?($__sgl_in_mainloop__)
+      $__sgl_in_mainloop__ = true
+      $__a__.mainloop
+    else
+      # do setup only.
+      $__a__.mainloop_setup
+
+      # for debug
+      # $__a__.mainloop
+    end
+  end
+
+  # novice mode
+  def flip(*a)	$__a__.flip(*a)	end
+  def wait(*a)	$__a__.wait(*a)	end
+  def process(&b)	$__a__.process(&b)	end
+
+  # get status functions
+  def mouseX()	$__a__.mouseX;	end
+  def mouseY()	$__a__.mouseY;	end
+  def mouseDown()	$__a__.mouseDown;	end
+  def key(k)	$__a__.key[k];	end
+  def keynum()	$__a__.keynum;	end
+
+  # get status functions for fullscreen
+  def mouseX0()	$__a__.mouseX0;	end
+  def mouseY0()	$__a__.mouseY0;	end
+
+  # event control
+  def useDelay(*a)	$__a__.useDelay(*a)	end
+  def useFramerate(*a)	$__a__.useFramerate(*a)	end
+  def useRuntime(*a)	$__a__.useRuntime(*a)	end
+
+  class Application
+    def initialize_event
+      @setup_done = nil
+      @display_drawing = nil
+      @block = {}
+
+      # status setting
+      @mouseX, @mouseY = 0, 0
+      @mouseX0, @mouseY0 = 0, 0
+      @mouseDown = 0
+      @keynum = 0
+
+      @starttime = nil
+    end
+    private :initialize_event
+
+    # get status
+    attr_reader :mouseX, :mouseY
+    attr_reader :mouseX0, :mouseY0
+    attr_reader :mouseDown
+    attr_reader :keynum
+
+    # setup
+    def set_setup(&b)
+      return unless block_given?
+      @block[:setup] = Proc.new
+    end
+
+    def setup_pre
+      # do nothing
+    end
+
+    def do_setup
+      setup_pre
+      @block[:setup].call if @block[:setup]
+      setup_post
+    end
+
+    def setup_post
+      @setup_done = true
+    end
+    private :setup_pre, :setup_post
+
+    # display
+    def set_display(&b)
+      return unless block_given?
+      @block[:display] = Proc.new
+    end
+
+    def set_display0(&b)
+      return unless block_given?
+      @block[:display0] = Proc.new
+    end
+
+    def check_display0
+      return ! @block[:display0].nil?
+    end
+
+    def display_pre
+      set_camera_position
+      check_event
+      clear
+    end
+
+    def do_display # callback
+      return if @setup_done.nil?
+#      return if @display_drawing
+      @display_drawing = true
+      display_pre
+      @block[:display].call if @block[:display]
+      display_post
+      @display_drawing = nil
+    end
+
+    def display_post
+      set_fullscreen_camera_position
+      cur_color = @cur_color
+      @block[:display0].call if @block[:display0]
+      color(*cur_color)
+      SDL.GLSwapBuffers
+      #GC.start
+    end
+    private :display_pre, :display_post
+
+    # mouse events
+    def set_mousedown(&b)
+      return unless block_given?
+      @block[:mousedown] = Proc.new
+    end
+
+    def do_mousedown
+      @mouseDown = 1
+      @block[:mousedown].call(@mouseX, @mouseY) if @block[:mousedown]
+      @block[:mousedown0].call(@mouseX0, @mouseY0) if @block[:mousedown0]
+    end
+
+    def set_mouseup(&b)
+      return unless block_given?
+      @block[:mouseup] = Proc.new
+    end
+
+    def do_mouseup
+      @mouseDown = 0
+      @block[:mouseup].call(@mouseX, @mouseY) if @block[:mouseup]
+    end
+
+    # mouse events for fullscreen
+    def set_mousedown0(&b)
+      return unless block_given?
+      @block[:mousedown0] = Proc.new
+    end
+
+    def check_mousedown0
+      return ! @block[:mousedown0].nil?
+    end
+
+    # key events
+    def set_keydown(&b)
+      return unless block_given?
+      @block[:keydown] = Proc.new
+    end
+
+    def keydown_pre(key)
+      exit if key == SDL::Key::ESCAPE
+    end
+    private :keydown_pre
+
+    def do_keydown(key)
+      keydown_pre(key)
+      @block[:keydown].call(key) if @block[:keydown]
+    end
+
+    def set_keyup(&b)
+      return unless block_given?
+      @block[:keyup] = Proc.new
+    end
+
+    def do_keyup(key)
+      @block[:keyup].call(key) if @block[:keyup]
+    end
+
+    def calc_keynum(e)
+      input = e.characters
+      @keynum = input.to_s[0]
+    end
+    private :calc_keynum
+
+    def mainloop_setup
+      do_setup
+    end
+
+    def mainloop
+      mainloop_setup
+      @starttime = Time.now
+      loop {
+	@begintime = Time.now
+	do_display
+	delay
+	return if check_runtime_finished(@starttime)
+      }
+    end
+
+    def delay
+      if @options[:framerate]
+	sec_per_frame = 1.0 / @options[:framerate]
+	diff = sec_per_frame - (Time.now - @begintime)
+	sleep(diff) if 0 < diff
+      else
+	delaytime = @options[:delaytime]
+	sleep(delaytime)
+      end
+    end
+    private :delay
+
+    def check_runtime_finished(starttime)
+      runtime = @options[:runtime]
+      return false if runtime.nil?
+      diff = Time.now - starttime
+      return (runtime && runtime < diff)
+    end
+    private :check_runtime_finished
+
+    # novice mode
+    def flip
+      @starttime = Time.now if @starttime.nil?
+      display_post
+      delay
+      display_pre
+     #exit if check_runtime_finished(@starttime)
+    end
+
+    def wait
+      #SGL.flip if !$__v__.flipped
+      loop {
+	check_event
+	delay
+	return if check_runtime_finished(@starttime)
+      }
+    end
+
+    def process(&b)
+      block = Proc.new
+      @starttime = Time.now
+      loop {
+	check_event
+	block.call
+	#yield
+	delay
+	return if check_runtime_finished(@starttime)
+      }
+    end
+
+    # check event
+    def check_event
+      x, y, l, m, r = SDL::Mouse.state
+      # x pos, y pos, left button, middle button, right button
+      @mouseX, @mouseY = calc_mouse_xy(x, y)
+      @mouseX0, @mouseY0 = calc_fullscreen_mouse_xy(x, y)
+      event = @sdl_event
+      while event.poll != 0
+	case event.type
+	when SDL::Event::MOUSEBUTTONDOWN
+	  do_mousedown
+	when SDL::Event::MOUSEBUTTONUP
+	  do_mouseup
+	when SDL::Event::KEYDOWN
+	  @keynum = event.info[2]
+	  do_keydown(@keynum)
+	when SDL::Event::KEYUP
+	  @keynum = event.info[2]
+	  do_keyup(@keynum)
+	when SDL::Event::QUIT
+	  exit
+	end
+      end
+    end
+
+    def calc_mouse_xy(x, y)
+      if @options[:fullscreen]
+	w, h = @options[:fullscreen]
+	mx = @cameraX - (w / 2) + x
+	my = @cameraY - (h / 2) + (h - y)
+      else
+	mx = @left + x
+	my = @bottom + (@height - y)
+      end
+      return [mx, my]
+    end
+
+    def calc_fullscreen_mouse_xy(x, y)
+      if @options[:fullscreen]
+	w, h = @options[:fullscreen]
+	mx = - (w / 2) + x
+	my = - (h / 2) + (h - y)
+      else
+	mx = @left + x
+	my = @bottom + (@height - y)
+      end
+      return [mx, my]
+    end
+    private :check_event, :calc_mouse_xy, :calc_fullscreen_mouse_xy
+  end
+end

data/lib/sgl/opengl-modules.rb

@@ -0,0 +1,22 @@
+# Copyright (C) 2004-2007 Kouichirou Eto, All rights reserved.
+# License: Ruby License
+
+module SGL
+  # module control
+  def useMidi()		$__a__.useMidi;		end
+  def useMidiIn(*a)	$__a__.useMidiIn(*a)	end
+
+  class Application
+    def useMidi
+      require "sgl/sgl-midi"
+      $__midi__ = SGLMidi.new
+    end
+
+    def useMidiIn(num = -1)
+      require "sgl/sgl-midiin"
+      printMidiDeviceNames
+      openMidiIn(num)
+      startMidiInThread
+    end
+  end
+end

data/lib/sgl/opengl-window.rb

@@ -0,0 +1,224 @@
+# Copyright (C) 2004-2007 Kouichirou Eto, All rights reserved.
+# License: Ruby License
+
+module SGL
+  # window functions
+  def window(*a)	$__a__.window(*a)	end
+  def close_window()	$__a__.close_window;	end
+  def width()	$__a__.width;	end
+  def height()	$__a__.height;	end
+
+  # opengl special functions
+  def useFov(*a)	$__a__.useFov(*a);	end
+  def useDepth(*a)	$__a__.useDepth(*a)	end
+  def useSmooth(*a)	$__a__.useSmooth(*a)	end
+  def useCulling(*a)	$__a__.useCulling(*a)	end
+  def useFullscreen(*a)	$__a__.useFullscreen(*a)	end
+  alias useFullScreen useFullscreen
+  def useCursor(*a)	$__a__.useCursor(*a)	end
+
+  class Application
+    DEFAULT_WINDOW_WIDTH  = 100
+    DEFAULT_WINDOW_HEIGHT = 100
+    DEFAULT_FULLSCREEN_WIDTH  = 1024
+    DEFAULT_FULLSCREEN_HEIGHT = 768
+
+    def initialize_window
+      @width, @height = DEFAULT_WINDOW_WIDTH, DEFAULT_WINDOW_HEIGHT
+      @left, @bottom, @right, @top = 0, 0, @width, @height
+      @cameraX, @cameraY, @cameraZ = 0, 0, 5
+      initialize_sdl
+    end
+
+    def initialize_sdl
+      SDL.init(SDL::INIT_VIDEO)
+      # Setting color size is important for Mac OS X.
+      SDL.setGLAttr(SDL::GL_RED_SIZE, 5)
+      SDL.setGLAttr(SDL::GL_GREEN_SIZE, 5)
+      SDL.setGLAttr(SDL::GL_BLUE_SIZE, 5)
+      SDL.setGLAttr(SDL::GL_DEPTH_SIZE, 16)
+      SDL.setGLAttr(SDL::GL_DOUBLEBUFFER, 1)
+      if !windows?
+	SDL.setVideoMode(640, 400, 16, SDL::OPENGL)
+      end
+      @sdl_event = SDL::Event.new
+    end
+    private :initialize_window, :initialize_sdl
+
+    def windows?
+      r = RUBY_PLATFORM
+      (r.index("cygwin") || r.index("mswin32") || r.index("mingw32")) != nil
+    end
+    private :windows?
+
+    # create window
+    def window(*a)
+      @options.update(a.pop) if a.last.is_a? Hash
+
+      if a.length == 4
+	@left, @bottom, @right, @top = a
+      elsif a.length == 2
+	@right, @top = a
+	@left = @bottom = 0
+      else
+	raise "error"
+      end
+
+      @width, @height = (@right - @left), (@top - @bottom)
+
+      # Do not initialize twice.
+      if ! defined?($__sgl_sdl_window_initialized__)
+        # sdl_window_init
+        mode =  SDL::OPENGL
+        if @options[:fullscreen]
+          mode |= SDL::FULLSCREEN
+          w, h = @options[:fullscreen]
+          SDL.setVideoMode(w, h, 0, mode)
+        else
+          SDL.setVideoMode(@width, @height + 1, 0, mode) # why +1?
+        end
+        GC.start
+        SDL::WM.setCaption("sgl", "sgl")
+        $__sgl_sdl_window_initialized__ = true
+      end
+
+      # setCurosr
+      if @options[:cursor]
+	# You can use only black and white for cursor image.
+	file = @options[:cursor]
+	bmp = SDL::Surface.loadBMP(file) # Create surface from bitmap.
+	SDL::Mouse.setCursor(bmp,		# bitmap
+			     [255, 255, 255],	# white
+			     [  0,   0,   0],	# black
+			     [128, 128, 128],	# transparent
+			     [100, 100, 100],	# inverted
+			     8, 8)		# hot_x, hot_y
+      end
+
+      # gl_init
+      if @options[:fullscreen]
+	set_fullscreen_position
+      else
+	set_window_position
+      end
+      set_camera_position
+      GL.Enable(GL::BLEND)
+      GL.BlendFunc(GL::SRC_ALPHA, GL::ONE_MINUS_SRC_ALPHA)
+      GL.ShadeModel(GL::SMOOTH)
+      useDepth(@options[:depth])
+      useCulling(@options[:culling])
+      useSmooth(@options[:smooth])
+
+      background(0)
+      color(100)
+
+      check_event
+    end
+
+    def close_window
+      # do nothing for now
+    end
+
+    # get window size
+    attr_reader :width, :height
+
+    # world control methods
+    def useFov(f = 45)
+      @options[:fov] = f
+    end
+
+    def useDepth(a = true)
+      @options[:depth] = a
+      @options[:depth] ? GL.Enable(GL::DEPTH_TEST) : GL.Disable(GL::DEPTH_TEST)
+    end
+
+    def useSmooth(a = true)
+      @options[:smooth] = a
+      @options[:smooth] ?
+      GL.Enable(GL::LINE_SMOOTH) : GL.Disable(GL::LINE_SMOOTH)
+    end
+
+    def useCulling(a = true)
+      @options[:culling] = a
+      @options[:culling] ? GL.Enable(GL::CULL_FACE) : GL.Disable(GL::CULL_FACE)
+    end
+
+    def useFullscreen(w=DEFAULT_FULLSCREEN_WIDTH, h=DEFAULT_FULLSCREEN_HEIGHT)
+      if @options[:fullscreen].nil?
+        @options[:fullscreen] = (w.nil? || h.nil?) ? nil : [w, h]
+      end
+    end
+
+    def useCursor(bmpfile)
+      @options[:cursor] = bmpfile
+    end
+
+    def useDelay(sec)
+      @options[:delaytime] = sec
+    end
+
+    def useFramerate(f)
+      @options[:framerate] = f
+    end
+
+    def useRuntime(r)
+      @options[:runtime] = r
+    end
+
+    def runtime=(r)
+      useRuntime(r)
+    end
+
+    def set_window_position
+      @cameraX, @cameraY = ((@left + @right)/2), ((@bottom + @top)/2)
+      fov = @options[:fov]
+      @cameraZ = 1.0 +
+	@height / (2.0 * Math.tan(Math::PI * (fov/2.0) / 180.0))
+      GL.Viewport(0, 0, @width, @height)
+      GL.MatrixMode(GL::PROJECTION)
+      loadIdentity
+      GLU.Perspective(fov, @width/@height.to_f, @cameraZ * 0.1, @cameraZ * 10.0)
+    end
+
+    def set_fullscreen_position
+      cx, cy = ((@left + @right)/2), ((@bottom + @top)/2)
+      @cameraX, @cameraY = cx, cy
+      w, h = @options[:fullscreen]
+      fhw = w / 2 #fullscreen half width
+      fhh = h / 2 #fullscreen half height
+      left   = cx - fhw
+      bottom = cy - fhh
+      right  = cx + fhw
+      top    = cy + fhh
+      GL.Viewport(0, 0, w, h)
+      GL.MatrixMode(GL::PROJECTION)
+      loadIdentity
+      fov = @options[:fov]
+      @cameraZ = 1.0 + h / (2.0 * Math.tan(Math::PI * (fov/2.0) / 180.0));
+      GLU.Perspective(fov, w/h.to_f, @cameraZ * 0.1, @cameraZ * 10.0)
+    end
+    private :set_window_position, :set_fullscreen_position
+
+    def set_camera_position
+      GL.MatrixMode(GL::MODELVIEW)
+      loadIdentity
+      GLU.LookAt(@cameraX, @cameraY, @cameraZ,
+		 @cameraX, @cameraY, 0,
+		 0, 1, 0)
+    end
+
+    def set_fullscreen_camera_position
+      GL.MatrixMode(GL::MODELVIEW)
+      loadIdentity
+      GLU.LookAt(0, 0, @cameraZ,
+		 0, 0, 0,
+		 0, 1, 0)
+    end
+    private :set_camera_position, :set_fullscreen_camera_position
+
+    def loadIdentity
+      GL.LoadIdentity
+    end
+    private :loadIdentity
+  end
+end

data/lib/sgl/opengl.rb

@@ -0,0 +1,7 @@
+# Copyright (C) 2004-2007 Kouichirou Eto, All rights reserved.
+# License: Ruby License
+
+require "sgl/opengl-app"
+
+include SGL
+$__a__ = Application.new

data/lib/sgl/sgl-basic.rb

@@ -0,0 +1,61 @@
+# Copyright (C) 2004-2007 Kouichirou Eto, All rights reserved.
+# License: Ruby License
+
+$LOAD_PATH.unshift '..' if !$LOAD_PATH.include? '..'
+
+module SGL
+  class RingArray < Array
+    alias get []
+
+    def [](nth)
+      nth %= length() if nth < 0 || length() <= nth
+      return get(nth)
+    end
+  end
+
+  class Timer
+    # starttime�b��ɏ��܂��āAendtime�b��ɏI��B
+    def initialize(st, et)
+      # begintime���J�n����
+      @bt = Time.now.to_f
+      @st,@et = @bt+st,@bt+et
+      @now = 0
+      @span = (@et - @st).to_f         #p ['Timer', @bt, @st, @et, @span]
+    end
+
+    def count
+      @now = Time.now.to_f
+    end
+
+    # ���߂�0�ŁA���񂾂�1.0�ɂ����Â��Ă���
+    def ratio
+      count
+      return 0.0 if ! (@st <= @now)
+      return 1.0 if @et <= @now
+      return (@now - @st) / @span
+    end
+
+    def started?() count; @st <= @now end
+    def ended?()   count; @et <= @now end
+  end
+end
+
+if $0 == __FILE__
+  require 'test/unit'
+  $__test_sgl__ = true
+end
+
+if defined?($__test_sgl__) && $__test_sgl__
+  class TestSglBasic < Test::Unit::TestCase #:nodoc:
+    def test_ring_array
+      t = SGL::RingArray.new
+      t[0], t[1], t[2] = 0, 1, 2
+      assert_equal([0, 1, 2, 0, 1, 2, 0, 1],
+		   [t[-3], t[-2], t[-1], t[0], t[1], t[2], t[3], t[4]])
+    end
+
+    def test_timer
+      assert true
+    end
+  end
+end