sgl 0.3.1 → 0.4.0

data/lib/sgl/notuse-objs.rb

@@ -0,0 +1,358 @@
+# Copyright (C) 2004-2007 Kouichirou Eto, All rights reserved.
+# License: Ruby License
+
+  class ObjLib
+    START_CATEGORY = 1
+    START_NUMBER   = 1
+
+    def initialize(c, n)
+      @cat = (c != nil) ? c.to_i : START_CATEGORY
+      @num = (n != nil) ? n.to_i : START_NUMBER
+
+      lines = [HexagonLines.new, PerpendicularLines.new, TangentLines.new, HomingLines.new, RandomFallLines.new,
+	NeonLines.new, RandomCageLines.new, TangeKenzoLines.new, BanShigeruLines.new, CircleLines.new]
+
+      colors = [LayeredCubes.new, ColorCircles.new, ColorfulGrids.new, RotateGrids.new, ColorSquares.new,
+	VerticalFields.new, MovingRects.new, TilingSquares.new, PackedCircles.new, GradationFields.new]
+
+      plants = [Ivies.new, TreeFields.new, Ivies.new, Ivies2.new, Ivies3.new]
+
+      gradations = [MeGrads.new, MeGrads.new]
+
+      #loops = [LoopGrids.new]
+
+      @lib = [[], lines, colors, plants, gradations]
+
+      @lx, @ly = nil, nil #��‘O��potision���Ƃ��Ă���
+      h, s, v = @lib[@cat][@num].background_color
+      @h = NumSpring.new(h, h, 10, 0.7)
+      @s = NumSpring.new(s, s, 10, 0.7)
+      @v = NumSpring.new(v, v, 10, 0.7)
+      Circle.make_list
+
+      change_stage(@cat, @num)
+    end
+
+    def onKeyDown(key)
+      if SDL::Key::K0 <= key && key <= SDL::Key::K9
+	key -= SDL::Key::K0
+	return if @lib[@cat][key] == nil
+	change_stage(@cat, key)
+      elsif SDL::Key::F1 <= key && key <= SDL::Key::F10
+	key -= (SDL::Key::F1-1)
+	return if @lib[key] == nil
+	return if @lib[key][1] == nil
+	change_stage(key, 1)
+      elsif key == SDL::Key::SPACE
+	fadeout
+      end
+    end
+
+    def onMouseDown(x, y)
+      @lib[@cat][@num].onMouseDown(x, y)
+    end
+
+    def onMouseUp(x, y)
+      @lib[@cat][@num].onMouseUp(x, y)
+    end
+
+    def change_stage(cat, num)
+      ocat, onum = @cat, @num
+      olib = @lib[@cat][@num]
+      olib.end_process()
+      @cat, @num = cat, num
+      lib = @lib[@cat][@num]
+      lib.start_process()
+      change_background_color
+      #category���ς��āA����lines����Ȃ���ΑS��fadeout
+      fadeout if ocat != @cat || @cat != 1
+      #fadeout if ocat != @cat || @cat != 1
+      #change_setup if @cat != 1
+    end
+
+    def change_background_color
+      h, s, v = @lib[@cat][@num].background_color
+      @h.moving = @s.moving = @v.moving = true
+      @h.target,@s.target,@v.target = h,s,v
+    end
+
+    def set_background_color
+      @h.move;    @s.move;    @v.move
+      backgroundHSV @h.x, @s.x, @v.x
+    end
+
+    def fadeout
+      @lib.each {|cat|
+	cat.each {|movement|
+	  movement.fadeout
+	}
+      }
+    end
+
+    def display
+      mouse(mouseX, mouseY)
+      render()
+    end
+
+    def mouse(x, y)
+      @lib[@cat][@num].add(x, y, @lx, @ly) unless @lx == nil || @ly == nil
+      @lx,@ly = x,y  #remember last potision
+    end
+
+    def render
+      set_background_color
+      @lib.each_index {|c|
+	cat = @lib[c]
+	cat.each_index {|n|
+	  lib = @lib[c][n]
+	  next if lib == nil
+	  next if ! lib.running
+	  lib.move
+	  lib.render
+	}
+      }
+    end
+  end
+
+  # ����Obj��100�•ۗL����N���X
+  class Objs
+    MAX = 100
+    def initialize(orgclass, max = MAX)
+      @orgclass, @max = orgclass, max
+      @a = []
+      @max.times {|i|
+	@a[i] = @orgclass.dup
+	@a[i].index = i
+	@a[i].enable = false
+      }
+      @cur = 0
+      @running = false
+      @background_color = [66,100,20] # R0,G0,B20�A����
+      @top = height/2
+      @bottom = -@top
+      @right = width/2
+      @left = -@right
+    end
+
+    attr_reader :background_color
+    attr_reader :a, :running, :max, :cur
+
+    def start_process
+      useDepth(false)
+      useCulling(false)
+      useFov(45)
+      @running = true
+    end
+
+    def end_process
+      fadeout
+      @running = false
+    end
+
+    def onMouseDown(x, y)
+    end
+
+    def onMouseUp(x, y)
+    end
+
+    def add(x, y, lx, ly)
+      len = V2.length(x - lx, y - ly)
+      if @a[@cur].enable == true
+	@a[@cur].end_process
+      end
+      @a[@cur].init(self, x, y, lx, ly)
+      @a[@cur].start_process()
+      @a[@cur].enable = false if len < 3
+      @cur += 1
+      @cur = 0 if @max <= @cur
+      @running = true
+      #p [@cur, x, y, lx, ly]
+    end
+
+    def fadeout
+      @a.each {|m|
+	m.fadeout
+      }
+    end
+
+    def move
+      index = @cur
+      @a.each_index {
+	m = @a[index]
+	m.move if m.enable
+	index += 1
+	index = 0 if @max <= index
+      }
+    end
+
+    def render
+      r = false
+      index = @cur
+      @a.each_index {
+	m = @a[index]
+	if m.enable
+	  m.render
+	  r = true
+	end
+	index += 1
+	index = 0 if @max <= index
+      }
+      @running = r
+    end
+  end
+
+  class Obj
+    START_FADEOUT = 20
+
+    def initialize
+      @dx1,@dy1,@dx2,@dy2 = 0,0,0,0
+      @ttl = 0
+      @start_fadeout = START_FADEOUT
+      @enable = true
+      @index = 0
+      @top = height/2
+      @bottom = -@top
+      @right = width/2
+      @left = -@right
+    end
+
+    def init(lib, x1, y1, x2, y2)
+      @lib,@x1,@y1,@x2,@y2 = lib, x1, y1, x2, y2
+      @dx1,@dy1,@dx2,@dy2 = x1, y1, x2, y2 # �����l
+      @cx = (x1+x2)/2
+      @cy = (y1+y2)/2
+      @dcx,@dcy = @cx,@cy
+      @enable = true
+      @ttl = @lib.max
+      @sound = ObjSound.new('wav/start.wav')
+    end
+
+    def start_process
+    end
+
+    def end_process
+    end
+
+    attr_reader :x1, :y1, :dx1, :dy1
+    attr_accessor :enable, :index
+
+    def inspect() sprintf("[%d,%d-%d,%d]",@x1,@y1,@x2,@y2) end
+
+    def length() V2.length(@x1-@x2, @y1-@y2) end
+
+    def move() end
+
+    def fadeout
+      @ttl = @start_fadeout if @start_fadeout < @ttl
+    end
+
+    def render
+      if @ttl <= 0
+	@enable = false
+	return 
+      end
+      @ttl -= 1
+      alpha = 100
+      alpha = @ttl * 100 / @start_fadeout if @ttl < @start_fadeout
+      renderObj(alpha)
+    end
+
+    def renderObj(alpha)
+    end
+
+    def playXY(alpha)
+    end
+
+    def colorline(x1, y1, x2, y2, h, s, v, sa, ea)
+      beginObj(LINES)
+      colorHSV h, s, v, sa
+      vertex x1, y1
+      colorHSV h, s, v, ea
+      vertex x2, y2
+      endObj
+    end
+
+    def randVector(r)
+      rad = deg2rad(rand(360)) #360�x�̂ǂ����������͗����ł���ƁB
+      c = Math.cos(rad) * r
+      s = Math.sin(rad) * r
+      [c, s]
+    end
+  end
+
+  class ObjSound
+    def initialize(file, base=60, span=4)
+      @filename = file
+      @samp = loadSound(file)        #@samp = Sample.new(file)
+      @samp.base = base
+      @count = 0
+      @span = span
+    end
+
+    def inspect
+      "#{@filename} #{@samp.base} #{@span}"
+    end
+
+    def play(note, volume, pan)
+      @count += 1
+      if @span < @count
+	@count = 0
+	#p [self, note, volume, pan]
+	@samp.playNote(note, volume, pan)
+      end
+    end
+  end
+
+  # �O�Տ�
+  class TrailFields < Objs
+    def initialize(orgclass, max=MAX)
+      super(orgclass, max)
+      @a = []
+      @cur_trail = nil
+      onMouseDown(0, 0)
+    end
+
+    attr_reader :a
+
+    def onMouseDown(x, y)
+      @cur_trail = @orgclass.dup
+      @cur_trail.init(self, x, y, x, y)
+      @a << @cur_trail
+      @a.shift if @max < @a.length
+    end
+
+    def onMouseUp(x, y)
+      @cur_trail.start_trail_process
+    end
+
+    def add(x, y, lx, ly)
+      len = V2.length(x - lx, y - ly)
+      if len != 0
+	@cur_trail.add_trail(x, y, lx, ly, len)
+      else
+	onMouseUp(x, y)
+	onMouseDown(x, y)
+      end
+      @running = true
+    end
+
+    def move
+      @a.each {|m|
+	m.move if m.enable
+      }
+    end
+
+    def render
+      r = false
+      @a.each {|m|
+	if m.enable
+	  m.render
+	  r = true
+	end
+      }
+      @running = r
+    end
+  end
+
+  class TrailField < Obj
+  end

data/lib/sgl/opengl-app.rb

@@ -0,0 +1,38 @@
+# Copyright (C) 2004-2007 Kouichirou Eto, All rights reserved.
+# License: Ruby License
+
+require "sdl"
+require "opengl"
+require "sgl/sgl-color"
+require "sgl/opengl-window"
+require "sgl/opengl-color"
+require "sgl/opengl-event"
+require "sgl/opengl-draw"
+require "sgl/sgl-sound"
+
+module SGL
+  class Application
+    def initialize
+      Thread.abort_on_exception = true
+      @options = default_options
+      initialize_window	# opengl-window.rb
+      initialize_color	# sgl-color.rb
+      initialize_event	# opengl-event.rb
+    end
+
+    def default_options
+      {
+	:fullscreen=>nil,
+	:fov=>45,
+	:cursor=>nil,
+	:depth=>false,
+	:culling=>false,
+	:smooth=>false,
+	:delaytime=>1.0/60,
+	:framerate=>nil,
+	:runtime=>nil,
+      }
+    end
+    private :default_options
+  end
+end

data/lib/sgl/opengl-color.rb

@@ -0,0 +1,44 @@
+# Copyright (C) 2004-2007 Kouichirou Eto, All rights reserved.
+# License: Ruby License
+
+module SGL
+  def background(*a)	$__a__.background(*a)	end
+  def backgroundHSV(*a)	$__a__.backgroundHSV(*a)	end
+  def color(*a)		$__a__.color(*a)	end
+  def colorHSV(*a)	$__a__.colorHSV(*a)	end
+
+  class Application
+    def initialize_color
+      @bg_color = @cur_color = nil
+      @rgb = ColorTranslatorRGB.new(100, 100, 100, 100)
+      @hsv = ColorTranslatorHSV.new(100, 100, 100, 100)
+    end
+    private :initialize_color
+
+    attr_reader :cur_color # for test
+
+    def background(x, y = nil, z = nil, a = nil)
+      GL.ClearColor(*@rgb.norm(x, y, z, a))
+      clear
+    end
+
+    def backgroundHSV(x, y = nil, z = nil, a = nil)
+      GL.ClearColor(*@hsv.norm(x, y, z, a))
+      clear
+    end
+
+    def clear
+      GL.Clear(GL::COLOR_BUFFER_BIT | GL::DEPTH_BUFFER_BIT)
+    end
+    private :clear
+
+    def color(x, y = nil, z = nil, a = nil)
+      @cur_color = [x, y, z, a]
+      GL.Color(*@rgb.norm(x, y, z, a))
+    end
+
+    def colorHSV(x, y = nil, z = nil, a = nil)
+      GL.Color(*@hsv.norm(x, y, z, a))
+    end
+  end
+end

data/lib/sgl/opengl-draw.rb

@@ -0,0 +1,260 @@
+# Copyright (C) 2004-2007 Kouichirou Eto, All rights reserved.
+# License: Ruby License
+
+module SGL
+  LINES		= GL::LINES
+  POINTS	= GL::POINTS
+  LINE_STRIP	= GL::LINE_STRIP
+  LINE_LOOP	= GL::LINE_LOOP
+  TRIANGLES	= GL::TRIANGLES
+  TRIANGLE_STRIP = GL::TRIANGLE_STRIP
+  TRIANGLE_FAN	= GL::TRIANGLE_FAN
+  QUADS		= GL::QUADS
+  QUAD_STRIP	= GL::QUAD_STRIP
+  POLYGON	= GL::POLYGON
+
+  # draw
+  def beginObj(*a)	$__a__.beginObj(*a)	end
+  def endObj(*a)	$__a__.endObj(*a)	end
+  def push(*a)		$__a__.push(*a)		end
+  def pop(*a)		$__a__.pop(*a)		end
+  def vertex(*a)	$__a__.vertex(*a)	end
+  def normal(*a)	$__a__.normal(*a)	end
+  def translate(*a)	$__a__.translate(*a)	end
+  def rotateX(*a)	$__a__.rotateX(*a)	end
+  def rotateY(*a)	$__a__.rotateY(*a)	end
+  def rotateZ(*a)	$__a__.rotateZ(*a)	end
+  def scale(*a)		$__a__.scale(*a)	end
+  def point(*a)		$__a__.point(*a)	end
+  def lineWidth(*a)	$__a__.lineWidth(*a)	end
+  def line(*a)		$__a__.line(*a)		end
+  def rect(*a)		$__a__.rect(*a)		end
+  def triangle(*a)	$__a__.triangle(*a)	end
+  def circle(*a)	$__a__.circle(*a)	end
+  def box(*a)		$__a__.box(*a)		end
+  def cube(*a)		$__a__.cube(*a)		end
+
+  class Application
+    LINES	= GL::LINES
+    POINTS	= GL::POINTS
+    LINE_STRIP	= GL::LINE_STRIP
+    LINE_LOOP	= GL::LINE_LOOP
+    TRIANGLES	= GL::TRIANGLES
+    TRIANGLE_STRIP	= GL::TRIANGLE_STRIP
+    TRIANGLE_FAN	= GL::TRIANGLE_FAN
+    QUADS	= GL::QUADS
+    QUAD_STRIP	= GL::QUAD_STRIP
+    POLYGON	= GL::POLYGON
+
+    # draw primitive
+    def beginObj(mode = POLYGON)
+      GL.Begin(mode)
+    end
+
+    def endObj
+      GL.End
+    end
+
+    def push
+      GL.PushMatrix
+    end
+
+    def pop
+      GL.PopMatrix
+    end
+
+    def vertex(a, b = nil, c = nil, d = nil)
+      GL.Vertex(a, b, c, d) if d
+      GL.Vertex(a, b, c) if c
+      GL.Vertex(a, b)
+    end
+
+    def normal(a, b = nil, c = nil)
+      GL.Normal(a, b, c)
+    end
+
+    # matrix manipulation
+    def translate(a, b, c = 0)
+      GL.Translate(a, b, c)
+    end
+
+    def rotateX(a)
+      GL.Rotate(a, 1, 0, 0)
+    end
+
+    def rotateY(a)
+      GL.Rotate(a, 0, 1, 0)
+    end
+
+    def rotateZ(a)
+      GL.Rotate(a, 0, 0, 1)
+    end
+
+    def scale(a)
+      GL.Scale(a, a, a)
+    end
+
+    # simple draw
+    def point(a, b, c = nil)
+      GL.Begin(GL::POINTS)
+      if c
+	GL.Vertex(a, b, c)
+      else
+	GL.Vertex(a, b)
+      end
+      GL.End
+    end
+
+    def lineWidth(w)
+      GL.LineWidth(w)
+    end
+
+    def line(a, b, c, d, e = nil, f = nil)
+      GL.Begin(GL::LINES) 
+      if e && f
+	GL.Vertex(a, b, c) # 3D
+	GL.Vertex(d, e, f)
+      else
+	GL.Vertex(a, b) # 2D
+	GL.Vertex(c, d)
+      end
+      GL.End
+    end
+
+    def rect(a, b, c, d)
+      GL.Rect(a, b, c, d)
+    end
+
+    def triangle(a, b, c, d, e, f)
+      GL.Begin(GL::TRIANGLES)
+      GL.Vertex(a, b)
+      GL.Vertex(c, d)
+      GL.Vertex(e, f)
+      GL.End
+    end
+
+    def circleUnit(style = LINE_LOOP, div = nil)
+      div = 32 if div.nil?
+      e = 2 * Math::PI / div
+      GL.Begin(style)
+      div.times {|i|
+	rad = i * e
+	x = Math.cos(rad)
+	y = Math.sin(rad)
+	GL.Vertex(x, y)
+      }
+      GL.End
+    end
+    private :circleUnit
+
+    def circle(x, y, r, style = LINE_LOOP, div = nil)
+      GL.PushMatrix
+      GL.Translate(x, y, 0)
+      GL.Scale(r, r, r)
+      circleUnit(style, div)
+      GL.PopMatrix
+    end
+
+    def box(x1, y1, z1, x2, y2, z2)
+      box = [
+	[x1, y1, z1], # 0 back left bottom
+	[x2, y1, z1], # 1 back right bottom
+	[x2, y2, z1], # 2 back right top
+	[x1, y2, z1], # 3 back left top
+	[x1, y1, z2], # 4 front left bottom
+	[x2, y1, z2], # 5 front right bottom
+	[x2, y2, z2], # 6 front right top
+	[x1, y2, z2]  # 7 front left top
+      ]
+      GL.Begin(GL::QUADS)
+      GL.Vertex(box[1]) # back
+      GL.Vertex(box[0])
+      GL.Vertex(box[3])
+      GL.Vertex(box[2])
+      GL.Vertex(box[0]) # left
+      GL.Vertex(box[4])
+      GL.Vertex(box[7])
+      GL.Vertex(box[3])
+      GL.Vertex(box[4]) # front
+      GL.Vertex(box[5])
+      GL.Vertex(box[6])
+      GL.Vertex(box[7])
+      GL.Vertex(box[5]) # right
+      GL.Vertex(box[1])
+      GL.Vertex(box[2])
+      GL.Vertex(box[6])
+      GL.Vertex(box[7]) # top
+      GL.Vertex(box[6])
+      GL.Vertex(box[2])
+      GL.Vertex(box[3])
+      GL.Vertex(box[0]) # bottom
+      GL.Vertex(box[1])
+      GL.Vertex(box[5])
+      GL.Vertex(box[4])
+      GL.End
+    end
+
+    def cube(x, y, z, s)
+      s = s / 2
+      box(x - s, y - s, z - s, x + s, y + s, z + s)
+    end
+  end
+
+  # This class is not used for now.
+  class FasterCircle
+    # circle
+    def self.circleUnit(style=LINE_LOOP, div=nil)
+      div = 32 if div == nil
+      e = 2 * Math::PI / div
+      beginObj(style)
+      div.times {|i|
+	rad = i * e
+	x = Math.cos(rad)
+	y = Math.sin(rad)
+	vertex(x, y)
+      }
+      endObj()
+    end
+
+    def self.make_list
+      GL.NewList(1, GL::COMPILE)
+      self.circleUnit(LINE_LOOP, 32)
+      GL.EndList()
+      GL.NewList(2, GL::COMPILE)
+      self.circleUnit(POLYGON, 32)
+      GL.EndList()
+      GL.NewList(3, GL::COMPILE)
+      self.circleUnit(LINE_LOOP, 6)
+      GL.EndList()
+      GL.NewList(4, GL::COMPILE)
+      self.circleUnit(POLYGON, 6)
+      GL.EndList()
+    end
+
+    def self.circleUnitList(style=LINE_LOOP, div=nil)
+      if div == 32
+	if style == LINE_LOOP
+	  GL.CallList(1)
+	elsif style == POLYGON
+	  GL.CallList(2)
+	end
+      elsif div == 6
+	if style == LINE_LOOP
+	  GL.CallList(3)
+	elsif style == POLYGON
+	  GL.CallList(4)
+	end
+      end
+    end
+
+    def self.circle(x, y, r, style=LINE_LOOP, div=nil)
+      push()
+      translate(x, y)
+      scale(r)
+      #circleUnit(style, div)
+      self.circleUnitList(style, div)
+      pop()
+    end
+  end
+
+end