graphics 1.0.0b5 → 1.0.0b6

data/examples/radar.rb

@@ -3,6 +3,8 @@
 require "graphics"
 
 class TargetSimulation < Graphics::Simulation
+  CLEAR_COLOR = :darker_green
+
   def initialize
     super 640, 640, 16, "Target Practice"
 
@@ -12,7 +14,7 @@ class TargetSimulation < Graphics::Simulation
   end
 
   def draw n
-    clear :darker_green
+    clear
 
     (0..640).step(64).each do |r|
       hline r, :dark_green

data/examples/rainbow_fluid.rb

@@ -0,0 +1,243 @@
+require "graphics"
+require "graphics/rainbows"
+
+class Float
+  ##
+  # A floating-point friendly `between?` function that excludes
+  # the lower bound.
+  # Equivalent to `min < x <= max`
+  ##
+  def xbetween? min, max
+    min < self && self <= max
+  end
+end
+
+class Particle
+  attr_accessor :density, :position, :velocity,
+                :pressure_force, :viscosity_force
+  def initialize pos
+    # Scalars
+    @density = 0
+
+    # Forces
+    @position        = pos
+    @velocity        = V::ZERO
+    @pressure_force  = V::ZERO
+    @viscosity_force = V::ZERO
+  end
+end
+
+class SPH
+  ##
+  # Constants
+  #
+
+  MASS          = 5  # Particle mass
+  DENSITY       = 1  # Rest density
+  GRAVITY       = V[0, -0.5]
+  H             = 1  # Smoothing cutoff- essentially, particle size
+  K             = 20 # Temperature constant- higher means particle repel more strongly
+  ETA           = 1  # Viscosity constant- higher for more viscous
+
+  attr_reader :particles
+
+  def initialize
+    # Instantiate particles!
+    @particles = []
+    (0..10).each do |x|
+      (0..10).each do |y|
+        jitter = rand * 0.1
+        particles << Particle.new(V[x+1+jitter, y+5])
+      end
+    end
+  end
+
+  ##
+  # A weighting function (kernel) for the contribution of each neighbor
+  # to a particle's density. Forms a nice smooth gradient from the center
+  # of a particle to H, where it's 0
+  #
+
+  def weight r, h
+    len_r = r.magnitude
+
+    if len_r.xbetween? 0, h
+      315.0 / (64 * Math::PI * h**9) * (h**2 - len_r**2)**3
+    else
+      0.0
+    end
+  end
+
+  ##
+  # Gradient ( that is, V(dx, dy) ) of a weighting function for
+  # a particle's pressure. This weight function is spiky (not flat or
+  # smooth at x=0) so particles close together repel strongly.
+  #
+
+  def gradient_weight_spiky r, h
+    len_r = r.magnitude
+
+    if len_r.xbetween? 0, h
+      r * (45.0 / (Math::PI * h**6 * len_r)) * (h - len_r)**2 * (-1.0)
+    else
+      V::ZERO
+    end
+  end
+
+  ##
+  # The laplacian of a weighting function that tends towards infinity when
+  # approching 0 (slows down particles moving faster than their neighbors)
+  #
+
+  def laplacian_weight_viscosity r, h
+    len_r = r.magnitude
+
+    if len_r.xbetween? 0, h
+      45.0 / (2 * Math::PI * h**5) * (1 - len_r / h)
+    else
+      0.0
+    end
+  end
+
+  def clear
+    # Clear everything
+    particles.each do |particle|
+      particle.density = DENSITY
+      particle.pressure_force = V::ZERO
+      particle.viscosity_force = V::ZERO
+    end
+  end
+
+  def calculate_density
+    # Calculate fluid density around each particle
+    particles.each do |particle|
+      particles.each do |neighbor|
+        # If particles are close together, density increases
+        distance = particle.position - neighbor.position
+
+        if distance.magnitude < H then
+          # Particles are close enough to matter
+          particle.density += MASS * weight(distance, H)
+        end
+      end
+    end
+  end
+
+  def calculate_forces
+    # Calculate forces on each particle based on density
+    particles.each do |particle|
+      particles.each do |neighbor|
+        distance = particle.position - neighbor.position
+        if  distance.magnitude <= H then
+          # Temporary terms used to caclulate forces
+          density_p = particle.density
+          density_n = neighbor.density
+
+          # This *should* never happen, but it's good to check,
+          # because we're dividing by density later
+          raise "Particle density is, impossibly, 0" unless density_n != 0
+
+          # Pressure derived from the ideal gas law (constant temp)
+          pressure_p = K * (density_p - DENSITY)
+          pressure_n = K * (density_n - DENSITY)
+
+          # Navier-Stokes equations for pressure and viscosity
+          # (ignoring surface tension)
+          particle.pressure_force += gradient_weight_spiky(distance, H) *
+            (-1.0 * MASS * (pressure_p + pressure_n) / (2 * density_n))
+
+          particle.viscosity_force +=
+            (neighbor.velocity - particle.velocity) *
+            (ETA * MASS * (1/density_n) * laplacian_weight_viscosity(distance, H))
+        end
+      end
+    end
+  end
+
+  def apply_forces delta_time
+    # Apply forces to particles- make them move!
+    particles.each do |particle|
+      total_force = particle.pressure_force + particle.viscosity_force
+
+      # 'Eulerian' style momentum:
+
+      # Calculate acceleration from forces
+      acceleration = (total_force * (1.0 / particle.density * delta_time)) + GRAVITY
+
+      # Update position and velocity
+      particle.velocity += acceleration * delta_time
+      particle.position += particle.velocity * delta_time
+    end
+  end
+
+  def step delta_time
+    clear
+    calculate_density
+    calculate_forces
+    apply_forces delta_time
+  end
+
+  ##
+  # The walls nudge particles back in-bounds, plus a little jitter
+  # so nothing gets stuck
+  #
+
+  def make_particles_stay_in_bounds scale
+    # TODO: Better boundary conditions (THESE ARE A LAME WORKAROUND)
+    particles.each do |particle|
+      if particle.position.x >= scale - 0.01
+        particle.position.x = scale - (0.01 + 0.1*rand)
+        particle.velocity.x = 0
+      elsif particle.position.x < 0.01
+        particle.position.x = 0.01 + 0.1*rand
+        particle.velocity.x = 0
+      end
+
+      if particle.position.y >= scale - 0.01
+        particle.position.y = scale - (0.01+rand*0.1)
+        particle.velocity.y = 0
+      elsif particle.position.y < 0.01
+        particle.position.y = 0.01 + rand*0.1
+        particle.velocity.y = 0
+      end
+    end
+  end
+end
+
+class SimulationWindow < Graphics::Simulation
+  WINSIZE = 500
+
+  attr_reader :simulation, :s, :spectrum
+
+  DELTA_TIME = 0.1
+
+  def initialize
+    super WINSIZE, WINSIZE, 16, "Smoothed Particle Hydrodynamics"
+    @simulation = SPH.new
+    @scale = 15
+    @s = WINSIZE.div @scale
+    @spectrum = Graphics::Cubehelix.new
+    self.initialize_rainbow spectrum, "cubehelix"
+  end
+
+  def update time
+    simulation.step DELTA_TIME
+    simulation.make_particles_stay_in_bounds @scale
+  end
+
+  def draw time
+    clear
+
+    simulation.particles.each do |particle|
+      pos = particle.position * s
+      color = spectrum.clamp(particle.density*30 + 60, 0, 360).to_i
+
+      # Particles
+      circle(pos.x, pos.y, 5, "cubehelix_#{color}".to_sym, true)
+
+      fps time
+    end
+  end
+end
+
+SimulationWindow.new.run

data/examples/tank.rb

@@ -55,9 +55,11 @@ class Tank < Graphics::Body
     end
   end
 
-  def draw
-    w.blit w.body_img, x, y, a
-    t.draw
+  class View
+    def self.draw w, b
+      w.blit w.body_img, b.x, b.y, b.a
+      Turret::View.draw w, b.t
+    end
   end
 
   def turn_right; turn(-ROTATION); aim_right; end
@@ -89,8 +91,10 @@ class Turret < Graphics::Body
     self.y = y
   end
 
-  def draw
-    w.blit w.turret_img, x, y, a
+  class View
+    def self.draw w, b
+      w.blit w.turret_img, b.x, b.y, b.a
+    end
   end
 end
 
@@ -109,9 +113,11 @@ class Bullet < Graphics::Body
     w.bullets.delete self if clip
   end
 
-  def draw
-    w.rect x, y, 2, 2, :white
-    w.debug "%.2f", m
+  class View
+    def self.draw w, b
+      w.rect b.x, b.y, 2, 2, :white
+      w.debug "%.2f", b.m
+    end
   end
 end
 
@@ -126,6 +132,9 @@ class TargetSimulation < Graphics::Simulation
     self.tank = Tank.new self
     self.bullets = []
 
+    register_body tank
+    register_bodies bullets
+
     self.body_img   = image "resources/images/body.png"
     self.turret_img = image "resources/images/turret.png"
   end
@@ -142,16 +151,9 @@ class TargetSimulation < Graphics::Simulation
     add_key_handler(:SPACE)     { tank.fire }
   end
 
-  def update n
-    tank.update
-
-    bullets.each(&:update)
-  end
-
   def draw n
-    clear
-    tank.draw
-    bullets.each(&:draw)
+    super
+
     fps n
   end
 end

data/examples/tank2.rb

@@ -69,6 +69,17 @@ class Tank
 
   def accelerate; self.speed += ACCELERATE; end
   def decelerate; self.speed -= DECELERATE; end
+
+  class View
+    def self.draw w, b
+      x, y, a, t = b.x, b.y, b.angle, b.turret
+
+      w.blit w.body_img, x, y, a
+      w.blit w.turret_img, x, y, t
+
+      w.debug "%3d @ %.2f @ %d", a, b.speed, b.energy
+    end
+  end
 end
 
 class Bullet
@@ -87,6 +98,12 @@ class Bullet
     self.x += Math.cos(rad) * v
     self.y += Math.sin(rad) * v
   end
+
+  class View
+    def self.draw w, b
+      w.rect b.x, b.y, 2, 2, :white
+    end
+  end
 end
 
 class TargetSimulation < Graphics::Simulation
@@ -100,6 +117,9 @@ class TargetSimulation < Graphics::Simulation
     self.tank = Tank.new w/2, h/2
     self.bullets = []
 
+    register_body tank
+    register_bodies bullets
+
     self.body_img = sprite 40, 30 do
       rect 0,  0, 39, 29, :white
       rect 0,  4, 39, 21, :white
@@ -119,6 +139,8 @@ class TargetSimulation < Graphics::Simulation
   def initialize_keys
     super
 
+    keydown_handler.delete "q"  # HACK
+
     add_key_handler(:RIGHT)     { tank.turn_right }
     add_key_handler(:LEFT)      { tank.turn_left }
     add_key_handler(:UP)        { tank.accelerate }
@@ -134,34 +156,16 @@ class TargetSimulation < Graphics::Simulation
   end
 
   def update n
-    tank.update
-
-    bullets.each(&:update)
+    super
 
     if tank.x < 0 then tank.x = 0 elsif tank.x > w then tank.x = w end
     if tank.y < 0 then tank.y = 0 elsif tank.y > h then tank.y = h end
   end
 
   def draw n
-    clear
-    draw_tank
-    draw_bullets
-    fps n
-  end
-
-  def draw_tank
-    x, y, a, t = tank.x, tank.y, tank.angle, tank.turret
-
-    blit body_img, x, y, a
-    blit turret_img, x, y, t
-
-    debug "%3d @ %.2f @ %d", tank.angle, tank.speed, tank.energy
-  end
+    super
 
-  def draw_bullets
-    bullets.each do |b|
-      rect b.x, b.y, 2, 2, :white
-    end
+    fps n
   end
 end
 

data/examples/targeting.rb

@@ -3,6 +3,8 @@
 require "graphics"
 
 class TargetSimulation < Graphics::Simulation
+  CLEAR_COLOR = :darker_green
+
   attr_accessor :bombs
 
   def initialize
@@ -20,7 +22,7 @@ class TargetSimulation < Graphics::Simulation
   end
 
   def draw n
-    clear :darker_green
+    clear
 
     bombs.each do |(birth, bx, by)|
       r = n - birth

data/examples/vants.rb

@@ -1,8 +1,6 @@
 #!/usr/local/bin/ruby -w
 # -*- coding: utf-8 -*-
 
-srand 42
-
 require "graphics"
 
 ##
@@ -23,7 +21,7 @@ class Vant < Graphics::Body
     self.black = w.color[:black]
   end
 
-  def forward
+  def update
     move_by a, M
     mutate
   end
@@ -39,30 +37,16 @@ class Vant < Graphics::Body
   end
 end
 
-class Vants < Graphics::Simulation
+class Vants < Graphics::Drawing
   attr_accessor :vs
 
+  CLEAR_COLOR = :white
+
   def initialize
     super 850, 850, 16, self.class.name
 
-    # cheat and reopen screen w/o double buffering
-    self.screen = SDL::Screen.open 850, 850, 16, SDL::HWSURFACE
-    clear :white
-
     self.vs = populate Vant
-  end
-
-  def update n
-    vs.each(&:forward)
-  end
-
-  def draw_and_flip n
-    self.draw n
-    # no flip
-  end
-
-  def draw n
-    screen.update 0, 0, 0, 0
+    register_bodies vs
   end
 end