reflexion 0.1.12 → 0.1.13

data/samples/model.rb

@@ -15,8 +15,10 @@ class SliderView < View
   has_model
 
   def initialize ()
-    add @back = RectShape.new {set name: :back, border: :white, follow: :all}
-    add @knob = RectShape.new {set name: :knob, border: :white, follow: [:top, :bottom], color: :gray, width: 50, x: 50}
+    add @back = View.new(name: :back, background: :white)
+    add @knob = View.new(name: :knob, background: :gray, x: 50) {
+      style.width 50
+    }
 
     start = nil
     @knob.on :pointer do |e|
@@ -28,7 +30,7 @@ class SliderView < View
         start = nil
         @knob.capture :none
       when :move
-        self.data = (@knob.x + e.x - start.x) / knob_left_max.to_f if start
+        self.data = (@knob.x + e.x - start.x) / knob_x_max.to_f if start
       end
     end
 
@@ -36,13 +38,13 @@ class SliderView < View
   end
 
   def on_data_update (e)
-    @knob.x = knob_left_max * data.to_f
+    @knob.x = knob_x_max * data.to_f
     super
   end
 
   private
 
-    def knob_left_max ()
+    def knob_x_max ()
       width - @knob.width
     end
 
@@ -72,13 +74,14 @@ end# ArrayView
 
 
 win = Window.new do
+  title 'Model View Sample'
+  frame 100, 100, 500, 400
+
   add @slider = SliderView.new {set name: :slider, frame: [50, 50, 300, 30]}
   add @text   = LabelView.new  {set name: :text,   frame: [50, 150, 300, 30]}
   add @array  = ArrayView.new  {set name: :array,  frame: [50, 250, 300, 30]}
 
   @slider.model = @text.model = @array.model = Model.new(0) {set minmax: 0..1}
-
-  set title: 'Model View Sample', frame: [100, 100, 500, 400]
 end
 
 

data/samples/physics.rb

@@ -10,38 +10,40 @@ require 'reflex'
 
 Reflex.start name: "Physics" do |app|
   Reflex::Window.show title: app.name, frame: [100, 100, 500, 500] do
-    root.set gravity: Reflex::Point.new(0, 9.8), debug: true
-
-    add_dynamic = -> size = 50, x = rand(10..400), y = rand(10..100) do
-      add Reflex::EllipseShape.new {
-        set :fill, [:red, :green, :blue, :yellow, :cyan, :magenta, :gray].sample
-        set :pos, [x, y]
-        set :size, [rand(5..size)] * 2
-        body.set dynamic: true, density: 1
+    gravity 0, 9.8 * meter
+    #debug   true
+
+    add_dynamic = -> x = rand(10..400), y = rand(10..100), size_ = 50 do
+      add Reflex::View.new {
+        pos        x, y
+        size       rand 5..size_
+        background [:red, :green, :blue, :yellow, :orange, :pink, :peach].sample
+        dynamic    true
+        shape      Reflex::EllipseShape.new(density: 1)
       }
     end
 
-    add_static = -> size = 50 do
-      add Reflex::RectShape.new {
-        set :fill, :white
-        set :pos, [rand(10..400), rand(200..400)]
-        set :size, [rand(5..(size * 2)), rand(5..size)]
-        body.set static: true
+    add_static = -> size_ = 50 do
+      add Reflex::View.new {
+        pos        rand(10..400), rand(200..400)
+        size       rand(5..(size_ * 2)), rand(5..size_)
+        background :darkgray
+        static     true
       }
     end
 
     50.times {|n| add_dynamic.call}
-    5.times {|n| add_static.call}
+    5.times  {|n| add_static.call}
 
     after :draw do |e|
-      e.painter.fill :white
-      e.painter.text "#{e.fps.to_i} FPS", 10, 10
+      e.painter.push do
+        fill :white
+        text "#{e.fps.to_i} FPS", 10, 10
+      end
     end
 
     on :pointer do |e|
-      if e.down? || e.drag?
-        add_dynamic.call 50, *e.pos.to_a
-      end
+      add_dynamic.call *e.pos.to_a if e.down? || e.drag?
     end
   end
 end

data/samples/reflexion/breakout.rb

@@ -11,23 +11,22 @@ require 'reflexion/include'
 $hit, $bang = [880, 440].map {|n| Sound.new SineWave.new(freq: n), 0.1}
 
 def add_shape (klass: RectShape, frame: [0, 0, 100, 100], color: :white, type: :static)
-  window.add klass.new {
-    set frame: frame, fill: color, density: 1, friction: 0, restitution: 1, type => true
+  window.add View.new {
+    set frame: frame, background: color, type => true, shape: klass.new(density: 1, friction: 0, restitution: 1)
   }
 end
 
 setup do
-  style.flow = :none
   set size: [600, 400], friction: 0
   5.times do |y|
     10.times do |x|
       shape = add_shape frame: [(x + 1) * 50, (y + 1) * 20, 30, 10], color: [:white, :red, :green, :blue, :yellow][y]
-      shape.on(:contact) {$hit.play; shape.parent.remove shape}
+      shape.on(:contact) {$hit.play; shape.remove_self}
     end
   end
   $bar   = add_shape frame: [0, 350, 100, 20], color: :blue
   bottom = add_shape frame: [0, window.h - 1, window.w, 1]
-  bottom.on(:contact) {|e| $bang.play; e.view.parent.remove e.view}
+  bottom.on(:contact) {|e| $bang.play; e.view.remove_self}
 end
 
 pointer do |e|

data/samples/reflexion/hello.rb

@@ -1,7 +1,7 @@
 # -*- coding: utf-8 -*-
 
 
-%w[xot rays reflex]
+%w[xot beeps rays reflex]
   .map  {|s| File.expand_path "../../../../#{s}/lib", __FILE__}
   .each {|s| $:.unshift s if !$:.include?(s) && File.directory?(s)}
 
@@ -14,7 +14,7 @@ array = []
 draw do
   gray += 0.01
   gray %= 1
-  background gray, gray, gray
+  background gray
   array.unshift event.fps
   array.slice! 32..-1
   text "#{array.reduce(0) {|sum, n| sum + n}.tap {|n| break n / array.size}.to_i} FPS", 10, 30

data/samples/reflexion/jump_action.rb

@@ -0,0 +1,191 @@
+# -*- coding: utf-8 -*-
+
+
+%w[xot beeps rays reflex]
+  .map  {|s| File.expand_path "../../../../#{s}/lib", __FILE__}
+  .each {|s| $:.unshift s if !$:.include?(s) && File.directory?(s)}
+
+require 'reflexion/include'
+
+
+$player   =
+$ground   = nil
+$score    = 0
+$gameover = false
+$left     =
+$right    = false
+
+class View
+  alias center_noangle center
+  def center
+    p, c, a = pos, center_noangle, angle
+    a == 0 ? c : p + (c - p).rotate(a)
+  end
+end
+
+class KeyEvent
+  def left? ()
+    code == 123
+  end
+  def right? ()
+    code == 124
+  end
+  def space? ()
+    code == 49
+  end
+end
+
+setup do
+  size 640, 320
+  flow :none
+  gravity 0, 9.8 * meter
+
+  root.wall.clear_fixtures
+  add_ground
+  add_bricks
+  add_coins
+  add_enemies
+  add_player
+end
+
+def add_ground ()
+  $ground = window.add View.new {
+    width 10000
+    height parent.height
+    static true
+  }
+
+  w, h = $ground.width, $ground.height
+  edges = (0..w).step(5).map {|x|
+    [x, h + Rays.perlin(x / 100.0, 0) * 30 - 50]
+  }
+  edges = [[0, 0]] + edges + [[w, 0]]
+
+  $ground.body.clear_fixtures
+  $ground.body.add_edge *edges
+  $ground.on :draw do |e|
+    e.painter.push fill: nil, stroke: :white do
+      lines *edges
+    end
+  end
+end
+
+def add_bricks ()
+  range = place_range
+  50.times do
+    window.add RectShape.new {
+      pos rand(range), 200
+      size *(0..1).map {rand(20..100)}
+      fill rand, rand, rand
+      dynamic true
+      density 1
+    }
+  end
+end
+
+def add_coins ()
+  range = place_range
+  50.times do
+    window.add EllipseShape.new {
+      pos rand(range), 100
+      size 30
+      fill :yellow
+      static true
+      sensor true
+      on :contact do
+        remove_self
+        $score += 1
+      end
+    }
+  end
+end
+
+def add_enemies ()
+  range = place_range
+  10.times do
+    window.add RectShape.new {
+      pos rand(range), 200
+      size 50
+      fill :red
+      static true
+      sensor true
+      on :contact do |e|
+        $gameover = true if e.view == $player
+      end
+    }
+  end
+end
+
+def place_range ()
+  $ground.frame.inset_by(100).tap {|f| break f.left .. f.right}
+end
+
+def add_player ()
+  $player = window.add EllipseShape.new {
+    @jump_count = 0
+
+    pos 50, 50
+    size 30
+    dynamic true
+    density 1
+    friction 1
+
+    player_image = Image.new(*size.to_a).paint do |p|
+      step, colors = 5, [:green, :blue]
+      (0..height).step step do |y|
+        (0..width).step step do |x|
+          p.fill colors[(x + y) % 2]
+          p.rect x, y, step, step
+        end
+      end
+    end
+
+    def self.jumpable? ()
+      @jump_count <= 1
+    end
+    def self.jump ()
+      return unless jumpable?
+      velocity velocity.tap {|v| v.y = -5 * meter}
+      @jump_count += 1
+    end
+
+    on :update do
+      dir = 0
+      dir -= 1 if $left
+      dir += 1 if $right
+      self.angular_velocity = 360 * 3 * dir
+    end
+    on :draw do |e|
+      e.painter.push fill: :white do
+        image player_image
+      end
+    end
+    on :contact_begin do
+      @jump_count = 0
+    end
+  }
+end
+
+update do
+  old_x, new_x = window.root.scroll.x, $player.center.x - window.width / 2
+  window.root.scroll_to (old_x + new_x) / 2, 0
+end
+
+draw do
+  fill :white
+  font nil, 30
+  text "SCORE: #{$score}", 10, 10
+  text "#{event.fps.to_i} FPS", 10, 50
+  if $gameover
+    fill :red
+    font nil, 100
+    text "GAMEOVER!", 100, 100
+  end
+end
+
+key do
+  next unless down? || up?
+  $left  = down? if left?
+  $right = down? if right?
+  $player.jump   if space? && down?
+end

data/samples/reflexion/noise.rb

@@ -0,0 +1,23 @@
+# -*- coding: utf-8 -*-
+
+
+%w[xot beeps rays reflex]
+  .map  {|s| File.expand_path "../../../../#{s}/lib", __FILE__}
+  .each {|s| $:.unshift s if !$:.include?(s) && File.directory?(s)}
+
+require 'reflexion/include'
+
+
+y = 0
+
+draw do
+  stroke :white
+  lines *(0..200).map {|x|
+    xx = x * 5
+    yy = 200 + Rays.perlin(x / 10.0, y / 100.0) * 100
+    [xx, yy]
+  }
+  y += 1
+
+  text "#{event.fps.to_i} FPS", 10, 10
+end

data/samples/reflexion/paint.rb

@@ -1,7 +1,7 @@
 # -*- coding: utf-8 -*-
 
 
-%w[xot rays reflex]
+%w[xot beeps rays reflex]
   .map  {|s| File.expand_path "../../../../#{s}/lib", __FILE__}
   .each {|s| $:.unshift s if !$:.include?(s) && File.directory?(s)}
 
@@ -10,21 +10,22 @@ require 'reflexion/include'
 
 FILENAME = 'paint.png'
 
-canvas =
+$canvas =
   Image.load(FILENAME) rescue nil ||
   Image.new(512, 512).paint {background :white}
 
+
 setup do
-  size canvas.size
+  size $canvas.size
 end
 
 draw do
-  image canvas
+  image $canvas
 end
 
 pointer do
   if down? || drag?
-    canvas.paint do
+    $canvas.paint do
       fill event.left? ? :red : event.right? ? :blue : :white
       ellipse *(event.pos - 10).to_a, 20, 20
     end
@@ -33,7 +34,7 @@ end
 
 key do
   case chars
-  when /s/i       then canvas.save FILENAME
+  when /s/i       then $canvas.save FILENAME
   when /q/i, "\e" then quit
   end
 end

data/samples/reflexion/physics.rb

@@ -1,28 +1,35 @@
 # -*- coding: utf-8 -*-
 
 
-%w[xot rays reflex]
+%w[xot beeps rays reflex]
   .map  {|s| File.expand_path "../../../../#{s}/lib", __FILE__}
   .each {|s| $:.unshift s if !$:.include?(s) && File.directory?(s)}
 
 require 'reflexion/include'
 
 
+COLORS = [:red, :green, :blue, :orange, :yellow, :indigo, :pink, :peach, :brown]
+
+count = 0
+
 setup do
-  set size: [600, 400], gravity: Point.new(0, 9.8) * meter #, debug: true
+  size    600, 400
+  gravity 0, 9.8 * meter
 end
 
 draw do
-  text "#{event.fps.to_i} FPS", 10, 10
+  text "#{event.fps.to_i} FPS | #{count} BLOCKS", 10, 10
 end
 
 pointer do
   if down? || drag?
-    window.add [RectShape, EllipseShape].sample.new {
-      size  = rand 20..40
-      color = event.right? ? :gray : [:red, :green, :blue].sample
-      set frame: [*event.pos.to_a, size, size], fill: color
-      set dynamic: event.left?, density: 1
+    count += 1 if window.add View.new {
+      pos        event.pos
+      size       rand 20..40
+      background event.right? ? :gray : COLORS.sample
+      dynamic    event.left?
+      shape      [RectShape, EllipseShape].sample.new(density: 1)
+      interval(1) {fill rand, rand, rand}
     }
   end
 end

data/samples/reflexion/pulse.rb

@@ -1,36 +1,50 @@
 # -*- coding: utf-8 -*-
 
 
-%w[xot rays reflex]
+%w[xot beeps rays reflex]
   .map  {|s| File.expand_path "../../../../#{s}/lib", __FILE__}
   .each {|s| $:.unshift s if !$:.include?(s) && File.directory?(s)}
 
 require 'reflexion/include'
 
 
-frame = 0
-fps   = 0
+frame = fps = 0
 
 
 setup do
-  set width: 600, height: 300
+  size 600, 300
   painter.font = Font.new nil, 24
+  interval do
+    3.times {put $pos} if $pos
+  end
 end
 
 draw do
   frame += 1
   fps = event.fps.to_i if (frame % 5) == 0
-  text "#{fps} FPS | FRAME: #{frame}", 10, 10
+  text "FRAME: #{frame} | #{fps} FPS", 10, 10
 end
 
 key do
   quit if chars == 'q' || code == 53
 end
 
+def put (pos)
+  window.add View.new {
+    position pos
+    size     20
+    fill     1, rand(0.2..0.7), rand(0.2..0.4)
+    shape    EllipseShape.new
+    interval do
+      self.pos += [rand(-1.0..1.0) * 4, rand(-1.0..0.0) * 8]
+    end
+    interval do
+      self.fill = fill.tap {|f| f.alpha -= 0.02}
+      parent.remove self if fill.alpha <= 0
+    end
+  }
+end
+
 pointer do
-  if down? || drag?
-    window.add EllipseShape.new {
-      set frame: [*(event.pos - 10).to_a, 20, 20], fill: :red
-    }
-  end
+  $pos = pos
 end

data/samples/shader.rb

@@ -12,21 +12,23 @@ win = Reflex::Window.new do
   set :title, "Shader Sample"
   set :frame, 100, 100, 300, 300
 
-  start  = Time.now.to_f
-  shader = Reflex::Shader.new <<-END
+  start = Time.now.to_f
+
+  painter.shader <<-END
+    varying vec4 v_TexCoord;
     uniform vec2 resolution;
     uniform float time;
     void main ()
     {
-      vec2 pos = gl_FragCoord.xy / resolution;
+      vec2 pos = v_TexCoord.xy / resolution;
       gl_FragColor = vec4(pos, float(mod(time, 1.0)), 1);
     }
   END
 
   on :draw do |e|
-    e.painter.push do
-      attach shader, resolution: bounds.size.to_a, time: Time.now.to_f - start
-      rect *bounds.to_a
+    e.paint do
+      shader.uniform resolution: bounds.size.to_a, time: Time.now.to_f - start
+      rect bounds
     end
   end
 

data/samples/shapes.rb

@@ -7,24 +7,73 @@
 
 require 'reflex'
 
-include Reflex
 
+Reflex::Window.new do
+  title 'Shape Sample'
+  frame 100, 100, 800, 500
 
-win = Window.new do
-  set title: 'Shape Sample', frame: [100, 100, 500, 400]
+  def on_draw (e)
+    e.painter.push do
+      fill :pink
+      stroke 1
+      stroke_width 2
 
-  p = painter
-  p.background 0
-  p.fill 1
+      x, y, y2, w, h = 10, 10, 100, 50, 50
 
-  %w[rect ellipse arc].each.with_index do |shape, i|
-    add Reflex.const_get("#{shape.capitalize}Shape").new {
-      set frame: [32 + 64 * i, 32, 50, 50], fill: :gray, stroke: :white
-    }
+      push do
+        rect                       x, y,  w, h
+        polygon Rays::Polygon.rect x, y2, w, h
+
+        translate 100, 0
+        rect                       x, y,  w, h, 5
+        polygon Rays::Polygon.rect x, y2, w, h, 5
+
+        translate 100, 0
+        rect                       x, y,  w, h, 5, 10, 15, 20
+        polygon Rays::Polygon.rect x, y2, w, h, 5, 10, 15, 20
+
+        translate 100, 0
+        ellipse                       x, y,  w, h
+        polygon Rays::Polygon.ellipse x, y2, w, h
+
+        translate 100, 0
+        ellipse                       x, y,  w, h, from: 45, to: 180
+        polygon Rays::Polygon.ellipse x, y2, w, h, from: 45, to: 180
+
+        translate 100, 0
+        ellipse                       x, y,  w, h, hole: 10
+        polygon Rays::Polygon.ellipse x, y2, w, h, hole: 10
+
+        translate 100, 0
+        ellipse                       x, y,  w, h, hole: 10, from: 200, to: 300
+        polygon Rays::Polygon.ellipse x, y2, w, h, hole: 10, from: 200, to: 300
+      end
+
+      translate 0, 200
+      push do
+        line                    x, y,  x + w, y  + h
+        line Rays::Polyline.new x, y2, x + w, y2 + h
+
+        translate 100, 0
+        line                    x, y,  x + w, y  + h, x, y  + h
+        line Rays::Polyline.new x, y2, x + w, y2 + h, x, y2 + h
+
+        translate 100, 0
+        line                    x, y,  x + w, y  + h, x, y  + h, loop: true
+        line Rays::Polyline.new x, y2, x + w, y2 + h, x, y2 + h, loop: true
+
+        translate 100, 0
+        polygon Rays::Polyline.new(x, y, x + w, y + h).expand 10
+
+        translate 100, 0
+        polygon Rays::Polyline.new(x, y, x + w, y + h, x, y + h).expand 10
+
+        translate 100, 0
+        polygon Rays::Polyline.new(x, y, x + w, y + h, x, y + h, loop: true).expand 10
+      end
+    end
   end
-end
+end.show
 
 
-Reflex.start do
-  win.show
-end
+Reflex.start

data/samples/tree.rb

@@ -10,9 +10,8 @@ require 'reflex'
 
 class V < Reflex::View
 
-  def initialize (offset = [0, 0])
-    super()
-    frame *offset, 400, 200
+  def initialize (offset = 0)
+    super position: offset, size: [400, 200]
   end
 
   def on_update (e)
@@ -23,14 +22,14 @@ class V < Reflex::View
     e.painter.push do
       b = e.bounds.to_a
 
-      color [0.2, 0.1]
+      fill 0.2
+      stroke 1
+      stroke_width 2
       rect *b
 
-      color :green, :red
+      fill :green
+      stroke :red
       text e.fps.to_i.to_s + " FPS."
-
-      color :none, [1, 0, 0, 0.4]
-      rect *b
     end
   end
 
@@ -41,7 +40,7 @@ class W < Reflex::Window
 
   def initialize ()
     set :title, "View Tree Sample"
-    set :frame, 100, 100, 320, 240
+    set :frame, 100, 100, 800, 600
 
     painter.background 0
     painter.fill 1
@@ -58,7 +57,7 @@ end# W
 def setup (parent, level)
   return unless level > 0
   1.times do |i|
-    v = V.new [i * 10] * 2
+    v = V.new i * 10
     parent.add v
     setup v, level - 1
   end