green_shoes 0.129.0

data/lib/ext/bloops/songs/bloopsaphone_theme_song_by_why.rb

@@ -0,0 +1,31 @@
+
+  # the bloops o' phone
+  b = Bloops.new
+  b.tempo = 320
+
+  # melodious
+  s1 = b.sound Bloops::SQUARE
+  s1.punch = 0.5
+  s1.sustain = 0.4
+  s1.decay = 0.2
+  s1.arp = 0.4
+  s1.aspeed = 0.6
+  s1.repeat = 0.6
+  s1.phase = 0.2
+  s1.psweep = 0.2
+  
+  # beats
+  s2 = b.sound Bloops::NOISE
+  s2.punch = 0.5
+  s2.sustain = 0.2
+  s2.decay = 0.4
+  s2.slide = -0.4
+  s2.phase = 0.2
+  s2.psweep = 0.2
+
+  # the tracks
+  b.tune s1, "f#5 c6 e4 b6 g5 d6 4  f#5 e5 c5 b6 c6 d6 4 "
+  b.tune s2, "4   c6 4  b5 4  4  e4 4   c6 4  b5 4  4  e4"
+  
+  b.play
+  

data/lib/ext/bloops/songs/feepogram.rb

@@ -0,0 +1,67 @@
+# downloaded from http://github.com/aanand/feepogram
+class Feepogram
+  attr_reader :bloops, :length
+
+  def initialize(bloops, &block)
+    @bloops = bloops
+    @length = 0
+
+    @sounds        = {}
+    @tracks        = {}
+    @track_lengths = {}
+
+    instance_eval(&block)
+  end
+
+  def metaclass
+    class << self; self; end
+  end
+
+  def metaclass_eval(&block)
+    metaclass.class_eval(&block)
+  end
+
+  def sound(name, base, &block)
+    name = name.to_sym
+
+    sound = bloops.sound(base)
+
+    @sounds[name]        = sound
+    @tracks[name]        = ""
+    @track_lengths[name] = 0
+
+    block.call(sound)
+
+    instance_variable_set("@#{name}", sound)
+
+    metaclass_eval do
+      define_method(name) do |notes|
+        dub(name, notes)
+      end
+    end
+  end
+
+  def phrase(&block)
+    instance_eval(&block)
+    @length += 32
+  end
+
+  def dub sound_name, notes
+    catchup = @length - @track_lengths[sound_name]
+
+    @tracks[sound_name] << ("4 " * catchup)
+    @tracks[sound_name] << notes
+    @track_lengths[sound_name] = length+32
+  end
+
+  def play
+    @tracks.each do |sound_name, notes|
+      bloops.tune @sounds[sound_name], notes
+
+      #puts "#{sound_name}: #{notes.gsub(/\s+/, ' ')}"
+    end
+
+    bloops.play
+    sleep 1 while !bloops.stopped?
+  end
+end

data/lib/ext/bloops/songs/simpsons_theme_song_by_why.rb

@@ -0,0 +1,14 @@
+
+  b = Bloops.new
+  b.tempo = 180
+  
+  
+  sound = b.sound Bloops::SQUARE
+  sound.volume = 0.4
+  sound.sustain = 0.3
+  sound.attack = 0.1
+  sound.decay = 0.3
+  
+  b.tune sound, "32 + C E F# 8:A G E C - 8:A 8:F# 8:F# 8:F# 2:G"
+  
+  b.play

data/lib/ext/chipmunk.rb

@@ -0,0 +1,34 @@
+require_relative 'chipmunk/chipmunk'
+
+module ChipMunk
+  def cp_space
+    @space = CP::Space.new
+    @space.damping = 0.8
+    @space.gravity = vec2 0, 25
+    @space
+  end
+
+  def cp_oval l, t, r, opts = {}
+    b = CP::Body.new 1,1
+    b.p = vec2 l, t
+    @space.add_body b
+    @space.add_shape CP::Shape::Circle.new(b, r, vec2(0, 0))
+      
+    opts = opts.merge({left: l-r-1, top: t-r-1, width: 2*r+2, height: 2*r+2, body: b, inflate: r-2})
+    oval opts
+  end
+  
+  def cp_line x0, y0, x1, y1, opts = {}
+    opts[:strokewidth] = 5 unless opts[:strokewidth]
+    sb = CP::Body.new 1.0/0.0, 1.0/0.0
+    seg = CP::Shape::Segment.new sb, vec2(x0, y0), vec2(x1, y1), opts[:strokewidth]
+    @space.add_shape seg
+    line x0, y0, x1, y1, opts
+  end
+end
+
+Shoes::ShapeBase.class_eval do
+  def cp_move
+    move args[:body].p.x.to_i - args[:inflate], args[:body].p.y.to_i - args[:inflate]
+  end
+end

data/lib/ext/projector.rb

@@ -0,0 +1 @@
+require_relative 'projector/projector'

data/lib/ext/projector/matrix3d.rb

@@ -0,0 +1,73 @@
+# Author:: MIZUTANI Tociyuki <tociyuki@gmail.com>
+# Copyright: Copyright 2010 by MIZUTANI Tociyuki
+# License:: GNU General Public License Version 2
+
+require 'matrix'
+
+module Matrix3d
+  def identity() Matrix.identity(4) end
+
+  def frustum(left, right, bottom, top, znear, zfar)
+    x = 2.0 * znear / (right - left)
+    y = 2.0 * znear / (top - bottom)
+    a = (right + left) / (right - left)
+    b = (top + bottom) / (top - bottom)
+    c = -(zfar + znear) / (zfar - znear)
+    d = -2.0 * zfar * znear / (zfar - znear)
+    Matrix[
+        [x,   0.0, a,    0.0],
+        [0.0, y,   b,    0.0],
+        [0.0, 0.0, c,    d],
+        [0.0, 0.0, -1.0, 0.0]
+    ]
+  end
+
+  def perspective(fov, aspect, znear, zfar)
+    yhi = znear * Math.tan(fov * Math::PI / 360.0)
+    ylo = -yhi
+    xlo = ylo * aspect
+    xhi = yhi * aspect
+    frustum(xlo, xhi, ylo, yhi, znear, zfar)
+  end
+
+  def translate(v)
+    v.size >= 3 or raise 'vector size >= 3.'
+    Matrix[
+      [1.0, 0.0, 0.0, v[0]],
+      [0.0, 1.0, 0.0, v[1]],
+      [0.0, 0.0, 1.0, v[2]],
+      [0.0, 0.0, 0.0, 1.0]
+    ]
+  end
+
+  def scale(v)
+    v.size >= 3 or raise 'vector size >= 3.'
+    Matrix[
+      [v[0], 0.0, 0.0, 0.0],
+      [0.0, v[1], 0.0, 0.0],
+      [0.0, 0.0, v[2], 0.0],
+      [0.0, 0.0, 0.0, 1.0]
+    ]
+  end
+
+  def rotate(theta, axis)
+    axis.size >= 3 or raise 'axis vector size >= 3.'
+    theta = Math::PI / 180.0 * theta
+    axis = Vector[axis[0], axis[1], axis[2]]
+    axis_r = axis.r
+    axis_r > axis_r * Float::EPSILON or raise 'r must not be zero vector.'
+    x = axis[0] / axis_r
+    y = axis[1] / axis_r
+    z = axis[2] / axis_r
+    s = Math.sin(theta)
+    c = Math.cos(theta)
+    cc = 1.0 - c
+    Matrix[
+      [cc * x * x + c,     cc * y * x - s * z, cc * z * x + s * y, 0.0],
+      [cc * x * y + s * z, cc * y * y + c,     cc * z * y - s * x, 0.0],
+      [cc * x * z - s * y, cc * y * z + s * x, cc * z * z + c,     0.0],
+      [0.0, 0.0, 0.0, 1.0]
+    ]
+  end
+  module_function :identity, :frustum, :perspective, :translate, :scale, :rotate
+end

data/lib/ext/projector/projector.rb

@@ -0,0 +1,306 @@
+#!/usr/bin/env ruby
+# -*- encoding: UTF-8 -*-
+# Author:: MIZUTANI Tociyuki <tociyuki@gmail.com>
+# Copyright: Copyright 2010 by MIZUTANI Tociyuki
+# License:: GNU General Public License Version 2
+#
+#     wget -O akatsukiface.png http://img.f.hatena.ne.jp/images/fotolife/t/tociyuki/20101219/20101219152034_original.png
+#     ruby akatsuki-papermodel.rb
+
+#require 'gtk2'
+require_relative 'matrix3d'
+require 'observer'
+
+module AkatsukiFace
+  # JAXA PLANET-C Akatsuki paper craft
+  #   http://www.jaxa.jp/countdown/f17/special/craft_j.html
+
+  #IMG_SOURCE = 'akatsukiface.png'
+
+  # body size: 1040mm 1450mm 1400mm
+  SCALE = Vector[1040.0/1450.0, 1.0, 1400.0/1450.0, 1.0]
+  FACES = [
+    {
+      'label' => 'loof',
+      'angle' => -90.0, 'axis' => Vector[1.0, 0.0, 0.0, 1.0],
+      'texture' => [0.00, 0.00, 0.25, 0.50], # left, top, width, height
+    },
+    {
+      'label' => 'front',
+      'angle' => 0.0, 'axis' => Vector[0.0, 1.0, 0.0, 1.0],
+      'texture' => [0.00, 0.50, 0.25, 0.50],
+    },
+    {
+      'label' => 'floor',
+      'angle' => +90.0, 'axis' => Vector[1.0, 0.0, 0.0, 1.0],
+      'texture' => [0.25, 0.00, 0.25, 0.50],
+    },
+    {
+      'label' => 'right',
+      'angle' => +90.0, 'axis' => Vector[0.0, 1.0, 0.0, 1.0],
+      'texture' => [0.25, 0.50, 0.25, 0.50],
+    },
+    {
+      'label' => 'back',
+      'angle' => +180.0, 'axis' => Vector[0.0, 1.0, 0.0, 1.0],
+      'texture' => [0.50, 0.50, 0.25, 0.50],
+    },
+    {
+      'label' => 'left',
+      'angle' => +270.0, 'axis' => Vector[0.0, 1.0, 0.0, 1.0],
+      'texture' => [0.75, 0.50, 0.25, 0.50],
+    },
+  ]
+
+  # divide MESH x MESH rectangles per a FACE
+  MESH = 2
+
+  # the modeling unit: right-hand 3d object coordinates
+  VERTEXS = [
+    Vector[0.0, 0.0, +1.0, 1.0], # left bottom
+    Vector[1.0, 0.0, +1.0, 1.0], # right bottom
+    Vector[1.0, 1.0, +1.0, 1.0], # right top
+    Vector[0.0, 1.0, +1.0, 1.0], # left top
+  ]
+  # the texture unit: left-hand 2d Gtk::DrawingArea coordinates
+  TEXTURES = [
+    Vector[0.0, 1.0], # left bottom
+    Vector[1.0, 1.0], # right bottom
+    Vector[1.0, 0.0], # right top
+    Vector[0.0, 0.0], # left top
+  ]
+
+  def create
+    scale = Matrix3d::scale(SCALE)
+    divide = MESH.to_f
+    FACES.inject([]) do |list, face|
+      transform = scale * Matrix3d::rotate(face['angle'], face['axis'])
+      (0 ... MESH).to_a.product((0 ... MESH).to_a).each do |part|
+        x, y = part.map{|i| i.to_f }
+        v = VERTEXS.map {|c|
+          transform * Vector[
+            (c[0] + x) * 2.0 / divide - 1.0,
+            (c[1] + divide - 1.0 - y) * 2.0 / divide - 1.0,
+            c[2],
+            c[3]
+          ]
+        }
+        t = TEXTURES.map {|c|
+          left, top, width, height = face['texture']
+          Vector[
+            (c[0] + x) * width / divide + left,
+            (c[1] + y) * height / divide + top
+          ]
+        }
+
+        # to keep simple calculations on S^{-1},
+        # we assume s1 - s0 = (s00, 0.0), s2 - s0 = (0.0, s11)
+        # left-bottom triangle counterclockwise
+        #   (left, bottom) -> (right, bottom) -> (left, top)
+        list.push({
+          'vertex' => [0, 1, 3].map {|i| v[i] },
+          'texture' => [0, 1, 3].map {|i| t[i] },
+        })
+        # right-top triangle counterclockwise
+        #   (right, top) -> (left, top) -> (right, bottom)
+        list.push({
+          'vertex' => [2, 3, 1].map {|i| v[i] },
+          'texture' => [2, 3, 1].map {|i| t[i] },
+        })
+      end
+      list
+    end
+  end
+  module_function :create
+end
+
+class TextureMappingData
+  include Observable
+
+  SCALE_A = 50.0
+
+  attr_reader :texture, :transform, :face_list
+  def texture=(x)   @texture =   x; update; x end
+  def transform=(x) @transform = x; update; x end
+  def face_list=(x) @face_list = x; update; x end
+
+  def initialize
+    @texture = nil
+    @transform = Matrix3d::identity
+    @transform *= Matrix3d::rotate(+20.0, Vector[1.0, 0.0, 0.0, 1.0])
+    @transform *= Matrix3d::rotate(+30.0, Vector[0.0, 1.0, 0.0, 1.0])
+    @transform *= Matrix3d::rotate(+90.0, Vector[0.0, 0.0, 1.0, 1.0])
+    @face_list = []
+    @transform_begin = nil
+  end
+
+  def update
+    changed
+    notify_observers
+    self
+  end
+
+  def begin_work
+    @transform_begin = @transform
+    self
+  end
+
+  def swing_step(dx, dy)
+    a = Math::sqrt(dx * dx + dy * dy) * SCALE_A
+    a > a * Float::EPSILON or return self
+    self.transform = Matrix3d::rotate(a, Vector[dy, dx, 0.0, 1.0]) * @transform_begin
+    self
+  end
+
+  def commit
+    @transform_begin = nil
+    self
+  end
+end
+
+class Projector
+  include Observable
+
+  attr_accessor :widget
+  attr_reader :controller
+
+  def controller=(c)
+    @controller = c
+    @controller.add_observer(self)
+    c
+  end
+
+  def initialize
+    @widget = nil
+    @invalid_drawing = true
+  end
+
+  def update
+    @invalid_drawing = true
+    self
+  end
+
+  def draw
+    @invalid_drawing or return self
+    drawing_area_context = @widget.window.create_cairo_context
+    port = @widget.allocation
+    fb = Cairo::ImageSurface.new(Cairo::FORMAT_ARGB32, port.width, port.height)
+    fb_context = Cairo::Context.new(fb)
+    scene(fb_context, port)
+    drawing_area_context.set_source(fb)
+    drawing_area_context.paint
+    @invalid_drawing = false
+    self
+  end
+
+private
+
+  def scene(context, port)
+    context.set_source_rgb(0, 0, 0)
+    context.paint
+    w = port.width.to_f / 2
+    h = port.height.to_f / 2
+    projection = Matrix3d::perspective(50.0, w/h, 1.0, 100.0)
+    projection *= Matrix3d::translate(Vector[0.0, 0.0, -5.0, 1.0])
+    projection *= controller.content.transform
+    texture = controller.content.texture
+    controller.content.face_list.each do |face|
+      vertex_list = face['vertex'].map{|r|
+        v = projection * r
+        Vector[w + v[0]/v[3] * w, h - v[1]/v[3] * h] # widget canvas coordinate
+      }
+      vertex10 = vertex_list[1] - vertex_list[0]
+      vertex20 = vertex_list[2] - vertex_list[0]
+      next if vertex10[0] * vertex20[1] - vertex10[1] * vertex20[0] > 0
+      fill_triangle(context, texture, vertex_list, face['texture'])
+    end
+    self
+  end
+
+  # left-hand Gtk::DrawingArea coordinates
+  def fill_triangle(context, texture, dst, src_uv)
+    scale_x, scale_y = texture.width.to_f, texture.height.to_f
+    src = src_uv.map {|v| Vector[scale_x * v[0], scale_y * v[1]] }
+    # r_d = D S^-1 (r_s - r_s0) + r_d0
+    # we assume S is a daigonal matrix.
+    s00 = src[1][0] - src[0][0]
+    s11 = src[2][1] - src[0][1]
+    d0 = dst[1] - dst[0]
+    d1 = dst[2] - dst[0]
+    ds = Matrix[[d0[0]/s00, d1[0]/s11], [d0[1]/s00, d1[1]/s11]]
+    ds0 = dst[0] - ds * src[0]
+    context.save do
+      context.set_antialias(Cairo::ANTIALIAS_NONE)
+      context.transform(Cairo::Matrix.new(ds[0, 0], ds[1, 0], ds[0, 1], ds[1, 1], ds0[0], ds0[1]))
+      texture.source_set(context)
+      context.move_to(src[0][0], src[0][1])
+      context.line_to(src[1][0], src[1][1])
+      context.line_to(src[2][0], src[2][1])
+      context.line_to(src[0][0], src[0][1])
+      context.fill
+    end
+    self
+  end
+end
+
+class SwingController
+  include Observable
+
+  attr_reader :content
+
+  def initialize
+    @content = nil
+    @drag = false
+    @ratio_x = 0.01
+    @ratio_y = 0.01
+    @start_x = 0
+    @start_y = 0
+  end
+
+  def content=(x)
+    @content = x
+    @content.add_observer(self)
+    x
+  end
+
+  def update
+    changed
+    notify_observers
+    self
+  end
+
+  def region(allocation)
+    @ratio_x = 1.0 / allocation.width.to_f
+    @ratio_y = 1.0 / allocation.height.to_f
+    self
+  end
+
+  def press(event)
+    @drag = true
+    @start_x, @start_y = event.x, event.y
+    content.begin_work
+    self
+  end
+
+  def motion(event)
+    @drag or return self
+    swing_to(event.x, event.y)
+    self
+  end
+
+  def release(event)
+    swing_to(event.x, event.y)
+    content.commit
+    @drag = false
+    self
+  end
+
+private
+
+  def swing_to(x, y)
+    dx = (x - @start_x).to_f * @ratio_x
+    dy = (y - @start_y).to_f * @ratio_y
+    content.swing_step(dx, dy)
+    self
+  end
+end