graphics 1.0.0b1

data/examples/bounce.rb

@@ -0,0 +1,86 @@
+#!/usr/local/bin/ruby -w
+
+require "graphics"
+
+class Ball < Graphics::Body
+  COUNT = 50
+
+  G = V[0, -18 / 60.0]
+
+  attr_accessor :g
+
+  def initialize w
+    super
+
+    self.a = rand 180
+    self.m = rand 100
+    self.g = G
+  end
+
+  def update
+    fall
+    move
+    bounce
+  end
+
+  def fall
+    self.velocity += g
+  end
+
+  def label
+    l = "%.1f %.1f" % dx_dy
+    w.text l, x-10, y-40, :white
+  end
+
+  def draw
+    # w.angle x, y, a, 3*m, :red
+    w.angle x, y, a, 50, :red
+    w.circle x, y, 5, :white, :filled
+    # label
+  end
+end
+
+class BounceSimulation < Graphics::Simulation
+  attr_accessor :bs
+
+  def initialize
+    super 640, 640, 16, "Bounce"
+
+    self.bs = populate Ball
+  end
+
+  def update n
+    bs.each(&:update)
+  end
+
+  def draw n
+    clear
+    bs.each(&:draw)
+    bs.first.label
+    fps n
+  end
+
+  def handle_keys
+    super
+    randomize if SDL::Key.press? SDL::Key::SPACE
+    reverse if SDL::Key.press? SDL::Key::R
+  end
+
+  def randomize
+    bs.each do |b|
+      b.m = rand(100)
+      b.a = rand(180)
+    end
+  end
+
+  def reverse
+    return if @guard
+    @guard = true
+    bs.each do |b|
+      b.g *= -1
+    end
+    @guard = false
+  end
+end
+
+BounceSimulation.new.run

data/examples/collision.rb

@@ -0,0 +1,74 @@
+#!/usr/local/bin/ruby -w
+
+require "graphics"
+
+class Sprite < Graphics::Body
+  COUNT = 8
+
+  attr_accessor :image
+
+  def initialize w
+    super w
+
+    self.a = random_angle
+    self.m = 5
+  end
+
+  def update
+    move
+    bounce
+  end
+
+  def collide
+    self.a = (a + 180).degrees
+  end
+
+  def draw
+    w.blit image, x, y, a
+  end
+
+  def collide_with? other
+    w.cmap.collision_check(x, y, w.cmap, other.x, other.y) != nil
+  end
+end
+
+class Collision < Graphics::Simulation
+  attr_accessor :sprites, :cmap, :image
+
+  def initialize
+    super 850, 850, 16, "Collision"
+
+    self.image = SDL::Surface.load "resources/images/body.png"
+    self.cmap = image.make_collision_map
+
+    self.sprites = populate Sprite do |s|
+      s.image = image
+    end
+  end
+
+  def inspect
+    "<Screen ...>"
+  end
+
+  def detect_collisions(sprites)
+    collisions = []
+    sprites.combination(2).each do |a, b|
+      collisions << a << b if a.collide_with? b
+    end
+    collisions.uniq
+  end
+
+  def update n
+    sprites.each(&:update)
+    detect_collisions(sprites).each(&:collide)
+  end
+
+  def draw n
+    clear
+
+    sprites.each(&:draw)
+    fps n
+  end
+end
+
+Collision.new.run

data/examples/demo.rb

@@ -0,0 +1,90 @@
+#!/usr/local/bin/ruby -w
+# -*- coding: utf-8 -*-
+
+require "graphics"
+
+class Ball < Graphics::Body
+  def initialize w
+    super
+
+    self.x = 50
+    self.y = 50
+
+    self.a = 60
+    self.m = 3
+  end
+
+  def update
+    move
+    wrap
+  end
+
+  def draw n
+    a = n % 360
+
+    w.angle  x, y, a, 50,     :green
+    w.circle x, y, 5, :white, :filled
+  end
+end
+
+class Demo < Graphics::Simulation
+  attr_accessor :ball, :img
+
+  def initialize
+    super 800, 800, 16, "Boid"
+    self.ball = Ball.new self
+
+    r = color[:red]
+
+    self.img = sprite 10, 10 do
+      circle 5, 5, 5, :white, :filled
+    end
+  end
+
+  def update n
+    ball.update
+  end
+
+  def draw n
+    clear
+
+    line 100, 50, 125, 75, :white
+
+    hline 100, :white
+
+    vline 100, :white
+
+    angle 125, 50, 45, 10, :white
+
+    fast_rect 150, 50, 10, 10, :white
+
+    point 175, 50, :green
+
+    rect 200, 50, 10, 10, :white
+
+    circle 225, 50, 10, :white
+
+    ellipse 250, 50, 10, 10, :white
+
+    bezier 275, 50, 275, 100, 285, 0, 300, 50, :white
+
+    rect 300, 25, 50, 50, :white
+    blit img, 325, 50, 0
+
+    text "blah", 350, 50, :white
+
+    x, y, * = mouse
+    rect x, y, 150, 50, :white
+    text "#{x}/#{y}", x, y, :white
+
+    debug "debug"
+
+    ball.draw n
+
+    fps n
+  end
+end
+
+if $0 == __FILE__
+  Demo.new.run
+end

data/examples/editor.rb

@@ -0,0 +1,70 @@
+#!/usr/local/bin/ruby -w
+# -*- coding: utf-8 -*-
+
+require "graphics"
+
+class Editor < Graphics::Simulation
+  attr_accessor :overlay, :s, :lines
+
+  alias :overlay? :overlay
+
+  def initialize
+    super 850, 850, 16, self.class.name
+
+    self.overlay = true
+    self.s = ""
+    self.lines = []
+  end
+
+  def handle_event e, n
+    case e
+    when SDL::Event::KeyDown then
+      if e.mod & (SDL::Key::MOD_LCTRL | SDL::Key::MOD_RCTRL) != 0 then
+        case e.sym.chr
+        when "t" then
+          self.overlay = ! self.overlay
+        end
+      else
+        c = e.sym.chr rescue ""
+        c.upcase! if e.mod & (SDL::Key::MOD_LSHIFT | SDL::Key::MOD_RSHIFT) != 0
+        case c
+        when "\r" then
+          c = "\n"
+          lines << s.dup
+          s.clear
+          return
+        when "\b" then
+          self.s = s[0..-2]
+          return
+        end
+        s << c
+      end
+    else
+      super
+    end
+  end
+
+  def draw n
+    clear
+
+    draw_scene
+    draw_overlay
+  end
+
+  def draw_scene
+  end
+
+  def draw_overlay
+    if overlay? then
+      lines.each_with_index do |l, i|
+        text l, 10, ((lines.size-i)*font.height), :gray
+      end
+
+      text "> #{s}_", 10, 0, :white
+    end
+  end
+end
+
+if $0 == __FILE__
+  Editor.new.run
+end

data/examples/fluid.rb

@@ -0,0 +1,246 @@
+require "graphics"
+
+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  # Particles are close enough to matter
+          particle.density += MASS * weight(distance, H)
+        end
+      end
+      # p particle.density if particle.density > 2*H
+    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
+
+  DELTA_TIME = 0.1
+
+  def initialize
+    super WINSIZE, WINSIZE, 16, "Smoothed Particle Hydrodynamics"
+    @simulation = SPH.new
+    @scale = 15
+    @s = WINSIZE.div @scale
+  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
+      vel = particle.velocity * s
+
+      # Particles
+      circle(pos.x, pos.y, 5, :white)
+      circle(pos.x, pos.y, particle.density, :gray)
+
+      # Velocity vectors
+      p2 = pos + vel
+      line(pos.x, pos.y, p2.x, p2.y, :red)
+
+      fps time
+    end
+  end
+end
+
+SimulationWindow.new.run