graphics 1.0.0b1

data/lib/graphics.rb

@@ -0,0 +1,9 @@
+##
+# The top-level namespace.
+
+class Graphics
+  VERSION = "1.0.0b1" # :nodoc:
+end
+
+require "graphics/simulation"
+require "graphics/body"

data/lib/graphics/body.rb

@@ -0,0 +1,216 @@
+# -*- coding: utf-8 -*-
+
+require "graphics/v"
+require "graphics/extensions"
+
+##
+# A body in the simulation.
+#
+# All bodies know their position, their angle, goal angle (optional),
+# and momentum.
+
+class Graphics::Body
+
+  # degrees to radians
+  D2R = Graphics::Simulation::D2R
+
+  # radians to degrees
+  R2D = Graphics::Simulation::R2D
+
+  ##
+  # The normals for the cardinal directions.
+
+  NORMAL = {
+           :north => 270,
+           :south => 90,
+           :east  => 180,
+           :west  => 0,
+           }
+
+  attr_accessor :x, :y, :a, :ga, :m, :w # :nodoc:
+
+  ##
+  # Create a new body in windowing system +w+ with a random x/y and
+  # everything else zero'd out.
+
+  def initialize w
+    self.w = w
+
+    self.x, self.y = rand(w.w), rand(w.h)
+    self.a = 0.0
+    self.ga = 0.0
+    self.m = 0.0
+  end
+
+  def inspect # :nodoc:
+    "%s(%.2fx%.2f @ %.2f°x%.2f == %p @ %p)" %
+      [self.class, x, y, a, m, position, velocity]
+  end
+
+  ##
+  # Convert the body to a vector representing its velocity.
+  #
+  # DO NOT modify this vector expecting it to modify the body. It is a
+  # copy.
+
+  def velocity
+    x, y = dx_dy
+    V[x, y]
+  end
+
+  ##
+  # Set the body's magnitude and angle from a velocity vector.
+
+  def velocity= o
+    dx, dy = o.x, o.y
+    self.m = Math.sqrt(dx*dx + dy*dy)
+    self.a = Math.atan2(dy, dx) * R2D
+  end
+
+  ##
+  # Convert the body to a vector representing its position.
+  #
+  # DO NOT modify this vector expecting it to modify the body. It is a
+  # copy.
+
+  def position
+    V[x, y]
+  end
+
+  ##
+  # Set the body's position from a velocity vector.
+
+  def position= o
+    self.x = o.x
+    self.y = o.y
+  end
+
+  def dx_dy # :nodoc:
+    rad = a * D2R
+    dx = Math.cos(rad) * m
+    dy = Math.sin(rad) * m
+    [dx, dy]
+  end
+
+  def m_a # :nodoc:
+    [m, a]
+  end
+
+  ##
+  # Turn the body +dir+ degrees.
+
+  def turn dir
+    self.a = (a + dir).degrees if dir
+  end
+
+  ##
+  # Move the body via its current angle and momentum.
+
+  def move
+    move_by a, m
+  end
+
+  ##
+  # Move the body by a specified angle and momentum.
+
+  def move_by a, m
+    rad = a * D2R
+    self.x += Math.cos(rad) * m
+    self.y += Math.sin(rad) * m
+  end
+
+  ##
+  # Keep the body in bounds of the window. If it went out of bounds,
+  # set its position to be on that bound and return the cardinal
+  # direction of the wall it hit.
+  #
+  # See also: NORMALS
+
+  def clip
+    max_h, max_w = w.h, w.w
+
+    if x < 0 then
+      self.x = 0
+      return :west
+    elsif x > max_w then
+      self.x = max_w
+      return :east
+    end
+
+    if y < 0 then
+      self.y = 0
+      return :north
+    elsif y > max_h then
+      self.y = max_h
+      return :south
+    end
+
+    nil
+  end
+
+  ##
+  # Return a random angle 0...360.
+
+  def random_angle
+    360 * rand
+  end
+
+  ###
+  # Randomly turn the body inside an arc of +deg+ degrees from where
+  # it is currently facing.
+
+  def random_turn deg
+    rand(deg) - (deg/2)
+  end
+
+  ##
+  # clip and then set the goal angle to the normal plus or minus a
+  # random 45 degrees.
+
+  def clip_off_wall
+    if wall = clip then
+      normal = NORMAL[wall]
+      self.ga = (normal + random_turn(90)).degrees unless (normal - ga).abs < 45
+    end
+  end
+
+  ##
+  # Like clip, keep the body in bounds of the window, but set the
+  # angle to the angle of reflection. Also slows momentum by 20%.
+
+  def bounce
+    # TODO: rewrite this using clip + NORMAL to clean it up
+    max_h, max_w = w.h, w.w
+    normal = nil
+
+    if x < 0 then
+      self.x, normal = 0, 0
+    elsif x > max_w then
+      self.x, normal = max_w, 180
+    end
+
+    if y < 0 then
+      self.y, normal = 0, 90
+    elsif y > max_h then
+      self.y, normal = max_h, 270
+    end
+
+    if normal then
+      self.a = (2 * normal - 180 - a).degrees
+      self.m *= 0.8
+    end
+  end
+
+  ##
+  # Wrap the body if it hits an edge.
+
+  def wrap
+    max_h, max_w = w.h, w.w
+
+    self.x = max_w if x < 0
+    self.y = max_h if y < 0
+
+    self.x = 0 if x > max_w
+    self.y = 0 if y > max_h
+  end
+end

data/lib/graphics/extensions.rb

@@ -0,0 +1,48 @@
+class Integer
+  ##
+  # Calculate a random chance using easy notation: 1 =~ 50 :: 1 in 50 chance
+
+  def =~ n #
+    rand(n) <= (self - 1)
+  end
+end
+
+class Numeric
+  ##
+  # Is M close to N within a certain delta?
+
+  def close_to? n, delta = 0.01
+    (self - n).abs < delta
+  end
+
+  ##
+  # Normalize a number to be within 0...360
+
+  def degrees
+    (self < 0 ? self + 360 : self) % 360
+  end
+
+  ##
+  # I am honestly befuddled by this code, and I wrote it.
+  #
+  # I should probably remove it and start over.
+  #
+  # Consider this method private, even tho it is in use by the demos.
+
+  def relative_angle n, max
+    deltaCW = (self - n).degrees
+    deltaCC = (n - self).degrees
+
+    return if deltaCC < 0.1 || deltaCW < 0.1
+
+    if deltaCC.abs < max then
+      deltaCC
+    elsif deltaCW.close_to? 180 then
+      [-max, max].sample
+    elsif deltaCW < deltaCC then
+      -max
+    else
+      max
+    end
+  end
+end

data/lib/graphics/simulation.rb

@@ -0,0 +1,377 @@
+# -*- coding: utf-8 -*-
+
+require "sdl"
+
+module SDL; end # :nodoc: -- stupid rdoc :(
+
+##
+# A simulation. This ties everything together and provides a bunch of
+# convenience methods to make life easier.
+
+class Graphics::Simulation
+
+  # degrees to radians
+  D2R = Math::PI / 180.0
+
+  # radians to degrees
+  R2D = 1 / D2R
+
+  # The window the simulation is drawing in.
+  attr_accessor :screen
+
+  # The window width.
+  attr_accessor :w
+
+  # The window height.
+  attr_accessor :h
+
+  # Pause the simulation.
+  attr_accessor :paused
+
+  # The current font for rendering text.
+  attr_accessor :font
+
+  # A hash of color names to their values.
+
+  attr_accessor :color
+
+  # A hash of color values to their rgb values. For text, apparently. *shrug*
+  attr_accessor :rgb
+
+  ##
+  # Create a new simulation of a certain width and height. Optionally,
+  # you can set the bits per pixel (0 for current screen settings),
+  # the name of the window, and whether or not to run in full screen mode.
+  #
+  # This also names a bunch colors and hues for convenience.
+
+  def initialize w, h, bpp = 0, name = self.class.name, full = false
+    SDL.init SDL::INIT_VIDEO
+    SDL::TTF.init
+
+    full = full ? SDL::FULLSCREEN : 0
+
+    self.font = SDL::TTF.open("/System/Library/Fonts/Menlo.ttc", 32, 0)
+
+    SDL::WM.set_caption name, name
+
+    self.screen = SDL::Screen.open w, h, bpp, SDL::HWSURFACE|SDL::DOUBLEBUF|full
+    self.w, self.h = screen.w, screen.h
+
+    self.color = {}
+    self.rgb   = Hash.new { |hash, k| hash[k] = screen.get_rgb(color[k]) }
+
+    register_color :black,     0,   0,   0
+    register_color :white,     255, 255, 255
+    register_color :red,       255, 0,   0
+    register_color :green,     0,   255, 0
+    register_color :blue,      0,   0,   255
+    register_color :gray,      127, 127, 127
+    register_color :yellow,    255, 255, 0
+    register_color :alpha,     0, 0, 0, 0
+
+    (0..99).each do |n|
+      m = (255 * (n / 100.0)).to_i
+      register_color ("gray%02d"  % n).to_sym, m, m, m
+      register_color ("red%02d"   % n).to_sym, m, 0, 0
+      register_color ("green%02d" % n).to_sym, 0, m, 0
+      register_color ("blue%02d"  % n).to_sym, 0, 0, m
+    end
+
+    self.paused = false
+  end
+
+  ##
+  # Name a color w/ rgba values.
+
+  def register_color name, r, g, b, a = 255
+    color[name] = screen.format.map_rgba r, g, b, a
+  end
+
+  ##
+  # Return an array populated by instances of +klass+. You can specify
+  # how many to create here or it will access +klass::COUNT+ as the
+  # default.
+
+  def populate klass, n = klass::COUNT
+    n.times.map {
+      o = klass.new self
+      yield o if block_given?
+      o }
+  end
+
+  ##
+  # Handle an event. By default only handles the Quit event. Override
+  # if you want to add more handlers. Be sure to call super or you
+  # won't be able to quit.
+
+  def handle_event event, n
+    exit if SDL::Event::Quit === event
+  end
+
+  ##
+  # Handle key events. By default handles ESC & Q (quit) and P
+  # (pause). Override this if you want to handle more key events. Be
+  # sure to call super or provide your own means of quitting and/or
+  # pausing.
+
+  def handle_keys
+    exit                  if SDL::Key.press? SDL::Key::ESCAPE
+    exit                  if SDL::Key.press? SDL::Key::Q
+    self.paused = !paused if SDL::Key.press? SDL::Key::P
+  end
+
+  ##
+  # Run the simulation. This handles all events by polling and
+  # scanning for key presses (multiple keys at once are possible).
+  #
+  # On each tick, call update, then draw the scene.
+
+  def run
+    self.start_time = Time.now
+    n = 0
+    event = nil
+    loop do
+      handle_event event, n while event = SDL::Event.poll
+      SDL::Key.scan
+      handle_keys
+
+      unless paused then
+        update n unless paused
+
+        draw_and_flip n
+
+        n += 1 unless paused
+      end
+    end
+  end
+
+  def draw_and_flip n # :nodoc:
+    self.draw n
+    screen.flip
+  end
+
+  ##
+  # Draw the scene. This is a subclass responsibility and must draw
+  # the entire window (including calling clear).
+
+  def draw n
+    raise NotImplementedError, "Subclass Responsibility"
+  end
+
+  ##
+  # Update the simulation. This does nothing by default and must be
+  # overridden by the subclass.
+
+  def update n
+    # do nothing
+  end
+
+  ##
+  # Clear the whole screen
+
+  def clear c = :black
+    fast_rect 0, 0, w, h, c
+  end
+
+  ##
+  # Draw an antialiased line from x1/y1 to x2/y2 in color c.
+
+  def line x1, y1, x2, y2, c
+    h = self.h
+    screen.draw_line x1, h-y1, x2, h-y2, color[c], :antialiased
+  end
+
+  ##
+  # Draw a horizontal line from x1 to x2 at y in color c.
+
+  def hline y, c, x1 = 0, x2 = h
+    line x1, y, x2, y, c
+  end
+
+  ##
+  # Draw a vertical line from y1 to y2 at y in color c.
+
+  def vline x, c, y1 = 0, y2 = w
+    line x, y1, x, y2, c
+  end
+
+  ##
+  # Draw a closed form polygon from an array of points in a particular
+  # color.
+
+  def polygon *points, color
+    points << points.first
+    points.each_cons(2) do |p1, p2|
+      w.line(*p1, *p2, color)
+    end
+  end
+
+  ##
+  # Draw a line from x1/y1 to a particular magnitude and angle in color c.
+
+  def angle x1, y1, a, m, c
+    x2, y2 = project x1, y1, a, m
+    line x1, y1, x2, y2, c
+  end
+
+  ##
+  # Draw a rect at x/y with w by h dimensions in color c. Ignores blending.
+
+  def fast_rect x, y, w, h, c
+    screen.fill_rect x, self.h-y-h, w, h, color[c]
+  end
+
+  ##
+  # Draw a point at x/y w/ color c.
+
+  def point x, y, c
+    screen[x, h-y] = color[c]
+  end
+
+  ##
+  # Calculate the x/y coordinate offset from x1/y1 with an angle and a
+  # magnitude.
+
+  def project x1, y1, a, m
+    rad = a * D2R
+    [x1 + Math.cos(rad) * m, y1 + Math.sin(rad) * m]
+  end
+
+  ##
+  # Draw a rect at x/y with w by h dimensions in color c.
+
+  def rect x, y, w, h, c, fill = false
+    screen.draw_rect x, self.h-y-h, w, h, color[c], fill
+  end
+
+  ##
+  # Draw a circle at x/y with radius r in color c.
+
+  def circle x, y, r, c, fill = false
+    screen.draw_circle x, h-y, r, color[c], fill, :antialiased
+  end
+
+  ##
+  # Draw a circle at x/y with radiuses w/h in color c.
+
+  def ellipse x, y, w, h, c, fill = false
+    screen.draw_ellipse x, self.h-y, w, h, color[c], fill, :antialiased
+  end
+
+  ##
+  # Draw an antialiased curve from x1/y1 to x2/y2 via control points
+  # cx1/cy1 & cx2/cy2 in color c.
+
+  def bezier x1, y1, cx1, cy1, cx2, cy2, x2, y2, c, l = 7
+    h = self.h
+    screen.draw_bezier x1, h-y1, cx1, h-cy1, cx2, h-cy2, x2, h-y2, l, color[c], :antialiased
+  end
+
+  ## Text
+
+  ##
+  # Return the w/h of the text s in font f.
+
+  def text_size s, f = font
+    f.text_size s
+  end
+
+  ##
+  # Return the rendered text s in color c in font f.
+
+  def render_text s, c, f = font
+    f.render_solid_utf8 s, *rgb[c]
+  end
+
+  ##
+  # Draw text s at x/y in color c in font f.
+
+  def text s, x, y, c, f = font
+    f.draw_solid_utf8 screen, s, x, self.h-y-f.height, *rgb[c]
+  end
+
+  ##
+  # Print out some extra debugging information underneath the fps line
+  # (if any).
+
+  def debug fmt, *args
+    s = fmt % args
+    text s, 10, h-40-font.height, :white
+  end
+
+  attr_accessor :start_time # :nodoc:
+
+  ##
+  # Draw the current frames-per-second in the top left corner in green.
+
+  def fps n
+    secs = Time.now - start_time
+    fps = "%5.1f fps" % [n / secs]
+    text fps, 10, h-font.height, :green
+  end
+
+  ### Blitting Methods:
+
+  ## utilities for later
+
+  # put_pixel(x, y, color)
+  # []=(x, y, color)
+  # get_pixel(x, y)
+  # [](x, y)
+  # put(src, x, y) # see blit
+  # copy_rect(x,y,w,h)
+  # transform_surface(bgcolor,angle,xscale,yscale,flags)
+
+  ##
+  # Load an image at path into a new surface.
+
+  def image path
+    SDL::Surface.load path
+  end
+
+  ##
+  # Return the current mouse state: x, y, buttons.
+
+  def mouse
+    r = SDL::Mouse.state
+    r[1] = h-r[1]
+    r
+  end
+
+  ##
+  # Draw a bitmap at x/y with an angle and optional x/y scale.
+
+  def blit o, x, y, a°, xs=1, ys=1, opt=0
+    SDL::Surface.transform_blit o, screen, -a°, 1, 1, o.w/2, o.h/2, x, h-y, opt
+  end
+
+  ##
+  # Create a new sprite with a given width and height and yield to a
+  # block with the new sprite as the current screen. All drawing
+  # primitives will work and the resulting surface is returned.
+
+  def sprite w, h
+    new_screen = SDL::Surface.new SDL::SWSURFACE, w, h, screen
+    old_screen = screen
+    old_w, old_h = self.w, self.h
+    self.w, self.h = w, h
+
+    self.screen = new_screen
+    yield if block_given?
+
+    new_screen.set_color_key SDL::SRCCOLORKEY, 0
+
+    new_screen
+  ensure
+    self.screen = old_screen
+    self.w, self.h = old_w, old_h
+  end
+end
+
+if $0 == __FILE__ then
+  SDL.init SDL::INIT_EVERYTHING
+  SDL.set_video_mode(640, 480, 16, SDL::SWSURFACE)
+  sleep 1
+  puts "if you saw a window, it was working"
+end