graphics 1.0.0b5 → 1.0.0b6

data/examples/walker.rb

@@ -37,15 +37,6 @@ class Person < Graphics::Body
     self.m += D_M unless m >= M_M
   end
 
-  def draw
-    trail.draw
-
-    w.angle x, y, ga,   60, :red
-
-    # the blit looks HORRIBLE when rotated... dunno why
-    w.blit w.body_img, x, y
-  end
-
   def turn_towards_goal
     turn a.relative_angle(ga, D_A)
   end
@@ -66,6 +57,17 @@ class Person < Graphics::Body
     self.a = (a + 180).degrees
     change_goal
   end
+
+  class View
+    def self.draw w, b
+      b.trail.draw
+
+      w.angle b.x, b.y, b.ga, 60, :red
+
+      # the blit looks HORRIBLE when rotated... dunno why
+      w.blit w.body_img, b.x, b.y
+    end
+  end
 end
 
 class WalkerSimulation < Graphics::Simulation
@@ -75,6 +77,7 @@ class WalkerSimulation < Graphics::Simulation
     super 850, 850, 16, "Walker"
 
     self.ps = populate Person
+    register_bodies ps
 
     self.body_img = sprite 20, 20 do
       circle 10, 10, 5, :white, :filled
@@ -84,14 +87,14 @@ class WalkerSimulation < Graphics::Simulation
   end
 
   def update n
-    ps.each(&:update)
+    super
+
     detect_collisions(ps).each(&:collide)
   end
 
   def draw n
-    clear
+    super
 
-    ps.each(&:draw)
     fps n
   end
 

data/examples/walker2.rb

@@ -1,7 +1,5 @@
 #!/usr/local/bin/ruby -w
 
-# srand 42
-
 require "graphics"
 require "graphics/trail"
 
@@ -90,26 +88,6 @@ class Person < Graphics::Body
     self.m += D_M unless m >= max
   end
 
-  def draw
-    if debug? and attack? then
-      w.angle x, y, a-75, VISIBILITY, :yellow
-      w.angle x, y, a-25, VISIBILITY, :yellow
-      w.angle x, y, a+25, VISIBILITY, :yellow
-      w.angle x, y, a+75, VISIBILITY, :yellow
-      nearby.each do |o|
-        w.line x, y, o.x, o.y, :yellow
-      end
-      # sleep 0.25 unless nearby.empty?
-    end
-
-    w.angle x, y,  a,   20, :green
-    w.angle x, y, ga,   10, :red
-
-    # the blit looks HORRIBLE when rotated... dunno why
-    w.blit w.body_img, x, y
-    w.circle x, y, 5, :red, :filled if attack?
-  end
-
   def turn_towards_goal
     turn a.relative_angle(ga, D_A)
   end
@@ -133,6 +111,30 @@ class Person < Graphics::Body
     self.a = (a + 180).degrees
     change_goal
   end
+
+  class View
+    def self.draw w, b
+      x, y, a, ga = b.x, b.y, b.a, b.ga
+
+      if b.debug? and b.attack? then
+        w.angle x, y, a-75, VISIBILITY, :yellow
+        w.angle x, y, a-25, VISIBILITY, :yellow
+        w.angle x, y, a+25, VISIBILITY, :yellow
+        w.angle x, y, a+75, VISIBILITY, :yellow
+        b.nearby.each do |o|
+          w.line x, y, o.x, o.y, :yellow
+        end
+        # sleep 0.25 unless nearby.empty?
+      end
+
+      w.angle x, y,  a,   20, :green
+      w.angle x, y, ga,   10, :red
+
+      # the blit looks HORRIBLE when rotated... dunno why
+      w.blit w.body_img, x, y
+      w.circle x, y, 5, :red, :filled if b.attack?
+    end
+  end
 end
 
 class WalkerSimulation < Graphics::Simulation
@@ -142,6 +144,7 @@ class WalkerSimulation < Graphics::Simulation
     super 850, 850, 16, "Walker"
 
     self.ps = populate Person, 2
+    register_bodies ps
 
     # 5.times do |n|
     #   ps[n].attack = true
@@ -168,7 +171,8 @@ class WalkerSimulation < Graphics::Simulation
   end
 
   def update n
-    ps.each(&:update)
+    super
+
     detect_collisions(ps).each do |a, b|
       a.collide b
     end
@@ -177,9 +181,7 @@ class WalkerSimulation < Graphics::Simulation
   end
 
   def draw n
-    clear
-
-    ps.each(&:draw)
+    super
 
     debug "#{ps.size}"
     fps n

data/examples/zombies.rb

@@ -1,7 +1,5 @@
 #!/usr/local/bin/ruby -w
 
-srand 42
-
 require "graphics"
 
 class Entity

data/ext/sdl/sdl.c

@@ -727,6 +727,12 @@ static VALUE Surface_transform(VALUE self, VALUE bgcolor, VALUE angle,
   return TypedData_Wrap_Struct(cSurface, &_Surface_type, result);
 }
 
+static VALUE Surface_save(VALUE self, VALUE path) {
+  DEFINE_SELF(Surface, surface, self);
+
+  return INT2NUM(SDL_SaveBMP(surface, RSTRING_PTR(path)));
+}
+
 //// SDL::TTFFont methods:
 
 static void _TTFFont_free(void* font) {
@@ -909,9 +915,10 @@ void Init_sdl() {
   rb_define_method(cSurface, "w",            Surface_w,            0);
   rb_define_method(cSurface, "[]",           Surface_index,        2);
   rb_define_method(cSurface, "[]=",          Surface_index_equals, 3);
-  rb_define_method(cSurface, "transform", Surface_transform, 5);
-  rb_define_method(cSurface, "flags", Surface_flags, 0);
-  rb_define_method(cSurface, "set_alpha", Surface_set_alpha, 2);
+  rb_define_method(cSurface, "transform",    Surface_transform,    5);
+  rb_define_method(cSurface, "save",         Surface_save,         1);
+  rb_define_method(cSurface, "flags",        Surface_flags,        0);
+  rb_define_method(cSurface, "set_alpha",    Surface_set_alpha,    2);
 
   //// SDL::TTFFont methods:
 

data/ext/sdl/sge/sge_primitives.cpp

@@ -2514,3 +2514,14 @@ void sge_AABezier(SDL_Surface *surface, Sint16 x1, Sint16 y1, Sint16 x2, Sint16
 	sge_AABezierAlpha(surface,x1,y1,x2,y2,x3,y3,x4,y4,level, SDL_MapRGB(surface->format,R,G,B),255);
 }
 
+//==================================================================================
+// Added by zenspider:
+//==================================================================================
+
+void sge_FastFilledRect(SDL_Surface *Surface, Sint16 x1, Sint16 y1, Sint16 x2, Sint16 y2, Uint32 color) {
+  for (Sint16 y = y1; y <= y2; y++) {
+    _HLine(Surface, x1, x2, y, color);
+  }
+
+  sge_UpdateRect(Surface, x1, y1, x2, y2);
+}

data/ext/sdl/sge/sge_primitives.h

@@ -105,6 +105,9 @@ DECLSPEC void sge_Bezier(SDL_Surface *surface, Sint16 x1, Sint16 y1, Sint16 x2,
 DECLSPEC void sge_BezierAlpha(SDL_Surface *surface, Sint16 x1, Sint16 y1, Sint16 x2, Sint16 y2,Sint16 x3, Sint16 y3, Sint16 x4, Sint16 y4, int level, Uint8 R, Uint8 G, Uint8 B, Uint8 alpha);
 DECLSPEC void sge_AABezier(SDL_Surface *surface, Sint16 x1, Sint16 y1, Sint16 x2, Sint16 y2,Sint16 x3, Sint16 y3, Sint16 x4, Sint16 y4, int level, Uint8 R, Uint8 G, Uint8 B);
 DECLSPEC void sge_AABezierAlpha(SDL_Surface *surface, Sint16 x1, Sint16 y1, Sint16 x2, Sint16 y2,Sint16 x3, Sint16 y3, Sint16 x4, Sint16 y4, int level, Uint8 R, Uint8 G, Uint8 B, Uint8 alpha);
+
+// Added by zenspider
+DECLSPEC void sge_FastFilledRect(SDL_Surface *Surface, Sint16 x1, Sint16 y1, Sint16 x2, Sint16 y2, Uint32 color);
 #endif /* sge_C_ONLY */
 
 

data/lib/graphics.rb

@@ -2,8 +2,9 @@
 # The top-level namespace.
 
 class Graphics
-  VERSION = "1.0.0b5" # :nodoc:
+  VERSION = "1.0.0b6" # :nodoc:
 end
 
 require "graphics/simulation"
 require "graphics/body"
+require "graphics/decorators"

data/lib/graphics/body.rb

@@ -177,18 +177,18 @@ class Graphics::Body
     max_h, max_w = w.h, w.w
 
     if x < 0 then
-      self.x = 0
+      self.x = x.abs
       return :west
     elsif x > max_w then
-      self.x = max_w
+      self.x = 2 * max_w - x
       return :east
     end
 
     if y < 0 then
-      self.y = 0
+      self.y = y.abs
       return :south
     elsif y > max_h then
-      self.y = max_h
+      self.y = 2 * max_h - y
       return :north
     end
 
@@ -223,28 +223,13 @@ class Graphics::Body
 
   ##
   # Like clip, keep the body in bounds of the window, but set the
-  # angle to the angle of reflection. Also slows momentum by 20%.
+  # angle to the angle of reflection. Also slows momentum by +friction+%.
 
-  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
+  def bounce friction = 0.2
+    if wall = clip then
+      self.a = (2 * NORMAL[wall] - 180 - a).degrees
+      self.m *= (1.0 - friction) if friction and friction > 0
+      true
     end
   end
 

data/lib/graphics/decorators.rb

@@ -0,0 +1,21 @@
+module ShowFPS
+  def draw n
+    super
+    fps n
+  end
+end
+
+module DrawGrid
+  def pre_draw n
+    super
+
+    (0...w).step(self.class::GRID_WIDTH).each do |x|
+      hline x, :gray
+      vline x, :gray
+    end
+  end
+end
+
+module WhiteBackground
+  CLEAR_COLOR = :white
+end

data/lib/graphics/rainbows.rb

@@ -0,0 +1,128 @@
+class Graphics::Rainbow
+  attr_reader :cache
+
+  def initialize
+    @cache = self.cache_colors
+  end
+
+  def clamp d, min, max
+    [[min, d].max, max].min
+  end
+
+  ##
+  # Takes a value and a range,
+  # and scales that range to 0-360
+  def scale d, min, max
+    range = max - min
+    if range != 0
+      scaled = (d.to_f / range) * 360
+      return clamp(scaled, 0, 360).round
+    else
+      0
+    end
+  end
+
+  def cache_colors
+    # Saves all the colors to a hash
+    cache = {}
+    (0..360).each do |degree|
+      cache[degree] = _color degree
+    end
+    cache
+  end
+
+  def color d, min=0, max=360
+    scaled = scale d, min, max
+    @cache[scaled]
+  end
+
+  def _color degree
+    raise "Subclass responsibility"
+  end
+  private :_color
+end
+
+##
+# Black to white gradient
+#
+class Graphics::Greyscale < Graphics::Rainbow
+  def initialize
+    super
+  end
+
+  def _color degree
+    brightness_unit = degree/360.0
+    brightness = (brightness_unit*255.0).floor # Scale back to RGB
+
+    [brightness, brightness, brightness]
+  end
+end
+
+##
+# The full RGB spectrum
+#
+class Graphics::Hue < Graphics::Rainbow
+
+  def initialize
+    super
+  end
+
+  def _color degree
+    main_color = 1 * 255 # Let chroma (saturation * brightness) always == 1
+    second_strongest_color = ((1 - (degree/60.0 % 2 - 1).abs) * 255).floor
+
+    case degree
+    when 0..60
+      [main_color, second_strongest_color, 0]
+    when 61..120
+      [second_strongest_color, main_color, 0]
+    when 121..180
+      [0, main_color, second_strongest_color]
+    when 181..240
+      [0, second_strongest_color, main_color]
+    when 241..300
+      [second_strongest_color, 0, main_color]
+    when 301..360
+      [main_color, 0, second_strongest_color]
+    end
+  end
+end
+
+
+##
+# Spectrum with linearly increasing brightness
+#
+class Graphics::Cubehelix < Graphics::Rainbow
+
+  def initialize
+    super
+  end
+
+  def _color degree
+    d = degree/360.0
+    start = 0.5 # Starting position in color space - 0=blue, 1=red, 2=green
+    rotations = -1.5 # How many rotations through the rainbow?
+    saturation = 1.2
+    gamma = 1.0
+    fract = d**gamma # Position on the spectrum
+
+    # Amplitude of the helix
+    amp = saturation * fract * (1 - fract) / 2.0
+    angle = 2*Math::PI*(start/3.0 + 1.0 + rotations*fract)
+    # From the CubeHelix Equations
+    r = fract + amp * (-0.14861 * Math.cos(angle) + 1.78277 * Math.sin(angle))
+    g = fract + amp * (-0.29227 * Math.cos(angle) - 0.90649 * Math.sin(angle))
+    b = fract + amp * (1.97294 * Math.cos(angle))
+
+    [(r * 255).round, (g * 255).round, (b * 255).round]
+  end
+end
+
+class Graphics::Simulation
+  def initialize_rainbow rainbow, name
+    rainbow.cache.each do |degree, color|
+      color_name = "#{name}_#{degree}".to_sym
+      self.register_color(color_name, *color, 255)
+    end
+  end
+end

data/lib/graphics/simulation.rb

@@ -5,10 +5,12 @@ require "sdl/sdl"
 module SDL; end # :nodoc: -- stupid rdoc :(
 
 ##
-# A simulation. This ties everything together and provides a bunch of
-# convenience methods to make life easier.
+# An abstract simulation. See Graphics::Simulation and Graphics::Drawing.
 
-class Graphics::Simulation
+class Graphics::AbstractSimulation
+
+  # The default color to clear the screen.
+  CLEAR_COLOR = :black
 
   # degrees to radians
   D2R = Math::PI / 180.0
@@ -19,6 +21,9 @@ class Graphics::Simulation
   # Call +log+ every N ticks, if +log+ is defined.
   LOG_INTERVAL = 60
 
+  # Collection of collections of Bodies to auto-update and draw.
+  attr_accessor :_bodies
+
   # The window the simulation is drawing in.
   attr_accessor :screen
 
@@ -49,6 +54,9 @@ class Graphics::Simulation
   # Procs registered to handle keydown events.
   attr_accessor :keydown_handler
 
+  # Is the application done?
+  attr_accessor :done
+
   ##
   # Create a new simulation of a certain width and height. Optionally,
   # you can set the bits per pixel (0 for current screen settings),
@@ -61,11 +69,13 @@ class Graphics::Simulation
 
     full = full ? SDL::FULLSCREEN : 0
 
+    self._bodies = []
+
     self.font = find_font("Menlo", 32)
 
     SDL::WM.set_caption name, name
 
-    self.screen = SDL::Screen.open w, h, bpp, SDL::HWSURFACE|SDL::DOUBLEBUF|full
+    self.screen = SDL::Screen.open w, h, bpp, self.class::SCREEN_FLAGS|full
     self.w, self.h = screen.w, screen.h
 
     self.color = {}
@@ -85,8 +95,8 @@ class Graphics::Simulation
   # Register default key events. Handles ESC & Q (quit) and P (pause).
 
   def initialize_keys
-    add_keydown_handler("\e") { exit }
-    add_keydown_handler("q")  { exit }
+    add_keydown_handler("\e") { self.done = true }
+    add_keydown_handler("q")  { self.done = true }
     add_keydown_handler("p")  { self.paused = !paused }
     add_keydown_handler("/")  { self.iter_per_tick += 1 }
     add_keydown_handler("-")  { self.iter_per_tick -= 1; self.iter_per_tick = 1  if iter_per_tick < 1 }
@@ -95,10 +105,12 @@ class Graphics::Simulation
   def initialize_colors # :nodoc:
     register_color :black,     0,   0,   0
     register_color :white,     255, 255, 255
+    register_color :gray,      127, 127, 127
     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 :cyan,      0, 255, 255
+    register_color :magenta,   255, 0, 255
     register_color :yellow,    255, 255, 0
     register_color :alpha,     0, 0, 0, 0
 
@@ -108,6 +120,20 @@ class Graphics::Simulation
       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)
+      register_color(("cyan%02d"    % n).to_sym, 0, m, m)
+      register_color(("magenta%02d" % n).to_sym, m, 0, m)
+      register_color(("yellow%02d"  % n).to_sym, m, m, 0)
+    end
+
+    (0...256).each do |n|
+      m = (256 * n / 255.0).to_i
+      register_color(("gray%03d"    % n).to_sym, m, m, m)
+      register_color(("red%03d"     % n).to_sym, m, 0, 0)
+      register_color(("green%03d"   % n).to_sym, 0, m, 0)
+      register_color(("blue%03d"    % n).to_sym, 0, 0, m)
+      register_color(("cyan%03d"    % n).to_sym, 0, m, m)
+      register_color(("magenta%03d" % n).to_sym, m, 0, m)
+      register_color(("yellow%03d"  % n).to_sym, m, m, 0)
     end
   end
 
@@ -127,6 +153,22 @@ class Graphics::Simulation
     SDL::TTF.open(font, size)
   end
 
+  ##
+  # Register a collection of bodies to be auto-updated and drawn.
+
+  def register_bodies ary
+    _bodies << ary
+    ary
+  end
+
+  ##
+  # Register a single Body to be auto-updated and drawn.
+
+  def register_body obj
+    _bodies << [obj]
+    obj
+  end
+
   ##
   # Name a color w/ rgba values.
 
@@ -203,6 +245,7 @@ class Graphics::Simulation
     self.start_time = Time.now
     n = 0
     event = nil
+    self.done = false
 
     logger = respond_to? :log
     log_interval = self.class::LOG_INTERVAL
@@ -217,6 +260,8 @@ class Graphics::Simulation
       draw_and_flip n
 
       log if logger and n % log_interval == 0
+
+      break if done
     end
   end
 
@@ -226,25 +271,54 @@ class Graphics::Simulation
   end
 
   ##
-  # Draw the scene. This is a subclass responsibility and must draw
-  # the entire window (including calling clear).
+  # Draw the scene by clearing the window and drawing all registered
+  # bodies. You are free to completely override this or call super and
+  # add any extras at the end.
 
   def draw n
-    raise NotImplementedError, "Subclass Responsibility"
+    pre_draw n
+    post_draw n
+  end
+
+  def pre_draw n
+    clear
+  end
+
+  def post_draw n
+    _bodies.each do |ary|
+      draw_collection ary
+    end
+  end
+
+  ##
+  # Draw a homogeneous collection of bodies. This assumes that the MVC
+  # pattern described on this class is being used.
+
+  def draw_collection ary
+    return if ary.empty?
+
+    cls = ary.first.class.const_get :View
+
+    ary.each do |obj|
+      cls.draw self, obj
+    end
   end
 
   ##
-  # Update the simulation. This does nothing by default and must be
-  # overridden by the subclass.
+  # Update the simulation by telling all registered bodies to update.
+  # You are free to completely override this or call super and add any
+  # extras at the end.
 
   def update n
-    # do nothing
+    _bodies.each do |ary|
+      ary.each(&:update)
+    end
   end
 
   ##
-  # Clear the whole screen
+  # Clear the whole screen. Defaults to CLEAR_COLOR.
 
-  def clear c = :black
+  def clear c = self.class::CLEAR_COLOR
     fast_rect 0, 0, w, h, c
   end
 
@@ -454,6 +528,13 @@ class Graphics::Simulation
     SDL::Surface.blit img, 0, 0, 0, 0, screen, x-1, h-y-img.h
   end
 
+  ##
+  # Save the current screen to a bmp
+
+  def save path
+    screen.save path
+  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
@@ -477,6 +558,49 @@ class Graphics::Simulation
   end
 end
 
+##
+# A simulation. This ties everything together and provides a bunch of
+# convenience methods to make life easier.
+#
+# In the Model View Controller (MVC) pattern, the simulation is the
+# Controller and controls both the window and all bodies involved in
+# the simulation. The bodies are the Model and each body class is
+# expected to have an inner View class w/ a #draw class method for the
+# View.
+#
+# For example, in examples/bounce.rb:
+#
+# + BounceSimulation subclasses Graphics::Simulation
+# + BounceSimulation has many Balls
+# + Ball#update maintains all ball movement.
+# + BounceSimulation#draw automatically calls Ball::View.draw on all balls.
+# + Ball::View.draw takes a window and a ball and draws it.
+
+class Graphics::Simulation < Graphics::AbstractSimulation
+  SCREEN_FLAGS = SDL::HWSURFACE|SDL::DOUBLEBUF
+end
+
+##
+# A drawing. Like a Simulation, but on a canvas that doesn't have
+# double buffering or clearing on each tick.
+#
+# See AbstractSimulation for most methods.
+
+class Graphics::Drawing < Graphics::AbstractSimulation
+  SCREEN_FLAGS = SDL::HWSURFACE
+
+  def initialize(*a)
+    super
+
+    clear
+  end
+
+  def draw_and_flip n
+    screen.update 0, 0, 0, 0
+    # no flip
+  end
+end
+
 if $0 == __FILE__ then
   SDL.init SDL::INIT_EVERYTHING
   SDL.set_video_mode(640, 480, 16, SDL::SWSURFACE)