graphics 1.0.0b1

data/examples/fluid2.rb

@@ -0,0 +1,199 @@
+require "graphics"
+
+class Particle < Graphics::Body
+  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 repels more strongly
+  ETA        = 1          # Viscosity constant: higher for more viscous
+  DELTA_TIME = 0.1        #
+
+  attr_accessor :density, :pressure_force, :viscosity_force, :s
+  attr_writer :nearby
+
+  def initialize w, x, y, s
+    super w
+    self.x = x
+    self.y = y
+    self.s = s
+    self.nearby = nil
+
+    clear
+  end
+
+  def draw
+    x = self.x * s
+    y = self.y * s
+
+    w.circle(x, y, density, :gray)
+    w.circle(x, y, 5, :white)
+
+    w.angle x, y, a, m * s, :red
+  end
+
+  def clear
+    self.nearby          = nil
+    self.density         = DENSITY
+    self.pressure_force  = V::ZERO
+    self.viscosity_force = V::ZERO
+  end
+
+  def nearby
+    @nearby ||= begin
+                  p = self.position
+                  w.particles.find_all { |neighbor|
+                    (p - neighbor.position).magnitude < H
+                  }
+                end
+  end
+
+  def calculate_density
+    nearby.each do |neighbor|
+      distance = (position - neighbor.position)
+
+      self.density += MASS * weight(distance, H) # if distance.magnitude < H
+    end
+  end
+
+  def calculate_forces
+    particle = self
+    nearby.each do |neighbor|
+      distance = (particle.position - neighbor.position)
+
+      # 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
+
+  def apply_forces
+    particle = self
+    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
+
+    limit
+  end
+
+  E = 0.01
+
+  def limit width = 15
+    if x >= width - E
+      self.x = width - (E + 0.1*rand)
+      self.m = 0
+    elsif x < E
+      self.x = E + 0.1*rand
+      self.m = 0
+    end
+
+    if y >= width - E
+      self.y = width - (E+rand*0.1)
+      self.m = 0
+    elsif y < E
+      self.y = E + rand*0.1
+      self.m = 0
+    end
+  end
+
+  ######################################################################
+  # Helpers
+
+  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
+
+  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
+
+  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
+end
+
+class Float
+  def xbetween? min, max
+    min < self && self <= max
+  end
+end
+
+class FluidDynamics < Graphics::Simulation
+  WINSIZE = 500
+  SCALE = 15
+  S = WINSIZE / SCALE
+
+  attr_accessor :particles, :scale
+
+  def initialize
+    super WINSIZE, WINSIZE, 16, "Smoothed Particle Hydrodynamics"
+
+    self.particles = []
+    self.scale = SCALE
+
+    # Instantiate particles!
+    (0..10).each do |x|
+      (0..10).each do |y|
+        jitter = rand * 0.1
+
+        particles << Particle.new(self, x + 1 + jitter, y + 5, S)
+      end
+    end
+  end
+
+  def draw n
+    clear
+    particles.each(&:draw)
+    fps n
+  end
+
+  def update n
+    particles.each(&:clear)
+    particles.each(&:calculate_density)
+    particles.each(&:calculate_forces)
+    particles.each(&:apply_forces)
+  end
+end
+
+FluidDynamics.new.run

data/examples/lito.rb

@@ -0,0 +1,108 @@
+require 'matrix'
+
+class Matrix
+  def rotate x, y
+    # I can't find a neat matrix-math solution for
+    # this, so let's do it with regular 'ol `map`.
+    Matrix[ *self.to_a.rotate(y).map {|row| row.rotate x} ]
+  end
+
+  # Pad or shrink a matrix
+  def take x, y
+    Matrix.build(y, x){|i, j| if self[i, j].nil? then 0 else self[i, j] end }
+  end
+
+  # Bitwise operations on boolean matrices
+  def & other
+    Matrix.Raise ErrDimensionMismatch unless
+      self.row_count == other.row_count and
+      self.column_count == other.column_count
+
+    Matrix.build(self.row_count){|i, j| self[i, j] & other[i, j] }
+  end
+
+  def | other
+    Matrix.Raise ErrDimensionMismatch unless
+      self.row_count == other.row_count and
+      self.column_count == other.column_count
+
+    Matrix.build(self.row_count){|i, j| self[i, j] | other[i, j] }
+  end
+end
+
+def sum l
+  l.reduce :+
+end
+
+def twos grid
+  grid.map{|i| if i == 2 then 1 else 0 end}
+end
+
+def threes grid
+  grid.map{|i| if i == 3 then 1 else 0 end}
+end
+
+AROUND = [-1, 0, 1].product([-1, 0, 1])
+
+def neighbors grid
+  sum(AROUND.map{|x, y| grid.rotate x, y } ) - grid
+end
+
+def life grid
+  ((twos neighbors grid) & grid) | (threes neighbors grid)
+end
+
+size, width, count = 10, 64, 256
+
+require "sdl"
+
+SDL.init SDL::INIT_VIDEO
+SDL::WM::set_caption "Conway's Game of Life", "Conway's Game of Life"
+
+screen = SDL::Screen.open 640, 640, 16, SDL::HWSURFACE|SDL::DOUBLEBUF
+
+black = screen.format.map_rgb   0,   0,   0
+white = screen.format.map_rgb 255, 255, 255
+
+w, h = screen.w, screen.h
+
+matrix = Matrix[[1, 1, 1],
+                [0, 0, 1],
+                [1, 1, 1]].take(width, width).rotate(-(width/2), -(width/2))
+
+paused = false
+step = false
+(1..(1.0/0)).each do |n|
+  puts n if n % 100 == 0
+
+  screen.fill_rect 0, 0, w, h, black
+
+  matrix.to_a.each_with_index do |row, y|
+    row.each_with_index do |c, x|
+      if c == 1 then
+        screen.fill_rect x*size, y*size, size-1, size-1, white
+      end
+    end
+  end
+
+  screen.flip
+
+  while event = SDL::Event.poll
+    case event
+    when SDL::Event::KeyDown then
+      c = event.sym.chr
+      exit if c == "q" or c == "Q" or c == "\e"
+      step = true if c == " "
+      puts n
+      paused = ! paused
+    when SDL::Event::Quit then
+      exit
+    end
+  end
+
+  matrix = life matrix unless paused
+  if step then
+    paused = true
+    step = false
+  end
+end

data/examples/lito2.rb

@@ -0,0 +1,110 @@
+require "matrix"
+require "graphics"
+
+class Matrix
+  def rotate x, y
+    # I can't find a neat matrix-math solution for
+    # this, so let's do it with regular 'ol `map`.
+    Matrix[ *self.to_a.rotate(y).map {|row| row.rotate x} ]
+  end
+
+  # Pad or shrink a matrix
+  def take x, y
+    Matrix.build(y, x){|i, j| if self[i, j].nil? then 0 else self[i, j] end }
+  end
+
+  # Bitwise operations on boolean matrices
+  def & other
+    Matrix.Raise ErrDimensionMismatch unless
+      self.row_count == other.row_count and
+      self.column_count == other.column_count
+
+    Matrix.build(self.row_count){|i, j| self[i, j] & other[i, j] }
+  end
+
+  def | other
+    Matrix.Raise ErrDimensionMismatch unless
+      self.row_count == other.row_count and
+      self.column_count == other.column_count
+
+    Matrix.build(self.row_count){|i, j| self[i, j] | other[i, j] }
+  end
+end
+
+class LitoGol
+  AROUND = [-1, 0, 1].product([-1, 0, 1])
+
+  attr_accessor :matrix
+
+  def initialize width
+    count = ((width*width) * 0.15).to_i
+    dimensions = width.times.to_a
+    data = dimensions.product(dimensions).sample(count).sort
+
+    self.matrix = Matrix.build(width, width) do |r, c|
+      data.include?([r, c]) ? 1 : 0
+    end
+  end
+
+  def sum l
+    l.reduce :+
+  end
+
+  def twos grid
+    grid.map{|i| if i == 2 then 1 else 0 end}
+  end
+
+  def threes grid
+    grid.map{|i| if i == 3 then 1 else 0 end}
+  end
+
+  def neighbors grid
+    sum(AROUND.map{|x, y| grid.rotate x, y } ) - grid
+  end
+
+  def life grid
+    ((twos neighbors grid) & grid) | (threes neighbors grid)
+  end
+
+  def update
+    self.matrix = life matrix
+  end
+
+  def each
+    matrix.to_a.each_with_index do |row, y|
+      row.each_with_index do |c, x|
+        yield c, x, y
+      end
+    end
+  end
+end
+
+class LitoGolSimulation < Graphics::Simulation
+  attr_accessor :gol
+
+  SIZE, WIDTH = 10, 64
+
+  def initialize
+    super 640, 640, 16, "Conway's Game of Life"
+
+    self.gol = LitoGol.new WIDTH
+  end
+
+  def draw n
+    clear
+
+    gol.each do |c, x, y|
+      if c == 1 then
+        ellipse x*SIZE, y*SIZE, (SIZE-1)/2, (SIZE-1)/2, :white
+      end
+    end
+
+    fps n
+  end
+
+  def update n
+    self.gol.update
+  end
+end
+
+LitoGolSimulation.new.run

data/examples/logo.rb

@@ -0,0 +1,73 @@
+#!/usr/local/bin/ruby -w
+# -*- coding: utf-8 -*-
+
+require "graphics"
+$: << "."
+require "examples/editor"
+
+class Turtle < Graphics::Body
+  attr_accessor :src, :pen
+
+  def initialize w, src
+    super w
+    self.x = w.w/2
+    self.y = w.h/2
+    self.a = 90
+    self.src = src
+    self.pen = true
+  end
+
+  def draw
+    self.x = w.w/2
+    self.y = w.h/2
+    self.a = 90
+
+    src.each do |line|
+      case line
+      when "pd" then
+        self.pen = true
+      when "pu" then
+        self.pen = false
+      when /rt (\d+)/ then
+        self.a -= $1.to_i
+      when /lt (\d+)/ then
+        self.a += $1.to_i
+      when /f (\d+)/ then
+        dist = $1.to_i
+        if pen then
+          w.angle x, y, a, dist, :white
+        end
+        move_by a, dist
+      else
+        src.delete line
+        warn "ERROR: #{line}"
+      end
+    end
+    draw_turtle
+  end
+
+  def draw_turtle
+    p1 = w.project(x, y, a, 15)
+    p2 = w.project(x, y, a+90, 5)
+    p3 = w.project(x, y, a-90, 5)
+
+    polygon p1, p2, p3, :green
+  end
+end
+
+class Logo < Editor
+  attr_accessor :turtle
+
+  def initialize
+    super
+    self.turtle = Turtle.new self, lines
+  end
+
+  def draw_scene
+    turtle.draw
+  end
+end
+
+if $0 == __FILE__
+  Logo.new.run
+end