tung-tea 0.2.2 → 0.2.3

data/README.rdoc

@@ -68,7 +68,7 @@ Below is a simple bouncing circle demo.
 What's working:
 
 * Events/Input - done
-* Graphics - halfway done, fixing transparency, grabbing sub-bitmaps
+* Graphics - nearly done, still need sub-bitmap grabbing
 
 What isn't done yet:
 

data/doc/example/circle_alpha.rb

@@ -1,5 +1,6 @@
 # Test that alpha blending works for circles.
-# Expected results
+# Expected results: 8 green circles drawn over the edges of a white rectangle,
+# varying in outline, anti-aliasing and blend/replace alpha mixing.
 
 require 'tea'
 

data/doc/example/circle_alpha_bitmap.rb

@@ -0,0 +1,50 @@
+# Test that alpha blending works for circles.
+# Expected results: 8 green circles drawn over the edges of a white-bordered
+# blue rectangle, varying in outline, anti-aliasing and blend/replace alpha
+# mixing.
+
+require 'tea'
+
+puts <<TEST
+You should see a white-bordered blue rectangle and circles along the edges:
+
+--b     --r     -ab
+
+-ar             o-b
+
+o-r     oab     oar
+
+o--   = outline
+-a-   = antialias
+--b/r = blend/replace
+
+Press any key to exit.
+TEST
+
+Tea.init
+Tea::Screen.set_mode 400, 300
+
+Tea::Screen.rect 100, 75, 200, 150, 0xffffffff
+
+b = Tea::Bitmap.new(Tea::Screen.w, Tea::Screen.h, 0x00000000)
+b.rect 105, 80, 190, 140, 0x0000ffff
+
+b.circle 100,  75, 25, 0x00ff0080, :outline => false, :antialias => false, :mix => :blend
+b.circle 200,  75, 25, 0x00ff0080, :outline => false, :antialias => false, :mix => :replace
+b.circle 300,  75, 25, 0x00ff0080, :outline => false, :antialias => true,  :mix => :blend
+
+b.circle 100, 150, 25, 0x00ff0080, :outline => false, :antialias => true,  :mix => :replace
+b.circle 300, 150, 25, 0x00ff0080, :outline => true,  :antialias => false, :mix => :blend
+
+b.circle 100, 225, 25, 0x00ff0080, :outline => true,  :antialias => false, :mix => :replace
+b.circle 200, 225, 25, 0x00ff0080, :outline => true,  :antialias => true,  :mix => :blend
+b.circle 300, 225, 25, 0x00ff0080, :outline => true,  :antialias => true,  :mix => :replace
+
+Tea::Screen.blit b, 0, 0
+
+Tea::Screen.update
+
+loop do
+  e = Tea::Event.get(true)
+  break if e.class == Tea::App::Exit || e.class == Tea::Kbd::Down
+end

data/doc/example/circle_bitmap.rb

@@ -0,0 +1,18 @@
+# Test that a circle drawn to a bitmap is drawn correctly.
+# Expected result is a filled white circle.
+
+require 'tea'
+
+puts <<TEST
+You should see a filled white circle for 5 seconds.
+TEST
+
+Tea.init
+Tea::Screen.set_mode 320, 240
+
+b = Tea::Bitmap.new(320, 240, 0x00000000)
+b.circle 160, 120, 100, 0xffffffff, :mix => :replace
+Tea::Screen.blit b, 0, 0
+
+Tea::Screen.update
+sleep 5

data/doc/example/clip.rb

@@ -0,0 +1,46 @@
+# Test that getting, setting and using the clip rectangle all work.
+# Expected result is a rectangle of smileys, and one at the bottom-right
+# corner.
+
+require 'tea'
+
+puts <<TEST
+You should see a rectangle of smileys, and one in the bottom-right corner,
+for 10 seconds.
+
+Expected output:
+Clip rect is 0, 0, 400, 300
+Clip rect is now 50, 50, 290, 185
+Clip rect is 0, 0, 400, 300 again
+Clip rect is now 368, 268, 32, 32
+
+Actual output:
+TEST
+
+Tea.init
+Tea::Screen.set_mode 400, 300
+
+puts "Clip rect is #{Tea::Screen.clip.join(", ")}"
+
+smiley = Tea::Bitmap.new('smile.png')
+
+Tea::Screen.clip(50, 50, 290, 185) do
+  puts "Clip rect is now #{Tea::Screen.clip.join(", ")}"
+
+  for y in 0..(Tea::Screen.h / smiley.h)
+    for x in 0..(Tea::Screen.w / smiley.w)
+      Tea::Screen.blit smiley, x * smiley.w, y * smiley.h
+    end
+  end
+end
+
+puts "Clip rect is #{Tea::Screen.clip.join(", ")} again"
+
+Tea::Screen.clip Tea::Screen.w - smiley.w, Tea::Screen.h - smiley.h, smiley.w, smiley.h
+Tea::Screen.blit smiley, Tea::Screen.w - smiley.w, Tea::Screen.h - smiley.h
+
+puts "Clip rect is now #{Tea::Screen.clip.join(", ")}"
+
+Tea::Screen.update
+
+sleep 10

data/doc/reference.textile

@@ -25,6 +25,13 @@ Instances of Tea::Bitmap share methods from the following modules:
 Tea::Blitting:
 * blit(source_blittable, x, y)
 
+Tea::Clipping:
+* clip
+* clip(x, y, w, h)
+* clip(x, y, w, h) { ... }
+
+These clip methods get, set and run a block with a clipping rectangle respectively.  While a clipping rectangle is set, drawing will be clipped inside it.
+
 Tea::PrimitiveDrawing:
 * clear()
 * point(x, y, color)
@@ -62,6 +69,13 @@ Since Tea::Screen is an object and not a class, its mixins add methods to Tea::S
 Tea::Blitting:
 * blit(source_blittable, x, y)
 
+Tea::Clipping:
+* clip
+* clip(x, y, w, h)
+* clip(x, y, w, h) { ... }
+
+These clip methods get, set and run a block with a clipping rectangle respectively.  While a clipping rectangle is set, drawing will be clipped inside it.
+
 Tea::PrimitiveDrawing:
 * clear()
 * point(x, y, color)

data/lib/tea/c_bitmap.rb

@@ -4,6 +4,7 @@
 require 'sdl'
 
 require 'tea/m_blitting'
+require 'tea/m_clipping'
 require 'tea/m_primitive_drawing'
 
 #
@@ -43,6 +44,11 @@ module Tea
       @buffer
     end
 
+    include Tea::Clipping
+    def clipping_buffer
+      @buffer
+    end
+
     include Tea::PrimitiveDrawing
     def primitive_buffer
       @buffer

data/lib/tea/m_clipping.rb

@@ -0,0 +1,69 @@
+# This file holds the Clipping mixin.
+
+require 'sdl'
+
+#
+module Tea
+
+  # The Clipping mixin enables anything with an SDL-like buffer can get, set
+  # and use a clipping rectangle to restrict where drawing takes place.
+  #
+  # To use the Clipping mixin, include it, and provide a clipping_buffer method
+  # that returns the buffer to be clipped.
+  #
+  #   include Tea::Clipping
+  #   def clipping_buffer; @sdl_buffer; end
+  module Clipping
+
+    # Get, set or run a block with a clipping rectangle that restricts where
+    # drawing can take place.
+    #
+    # Getting the current clipping rectangle:
+    #
+    #   x, y, width, height = clippable_object.clip
+    #
+    # Setting a new clipping rectangle:
+    #
+    #   old_x, old_y, old_w, old_h = clippable_object.clip(new_x, new_y, new_w, new_h)
+    #
+    # Running a block with a clipping rectangle temporarily set:
+    #
+    #   clippable_object.clip(clip_x, clip_y, clip_w, clip_h) do
+    #     # Draw onto clippable_object within clip rect here.
+    #   end
+    #
+    def clip(x=nil, y=nil, w=nil, h=nil)
+      buffer = clipping_buffer
+
+      # rubysdl's SDL::Surface#get_clip_rect doesn't return anything useful.
+      # Seems to be a bug, or at least compilation quirk.
+      @clipping_rect = [0, 0, buffer.w, buffer.h] unless @clipping_rect
+      old_clipping_rect = @clipping_rect
+
+      case
+      when !(x || y || w || h)                  # Get clip rect.
+        # Do nothing.
+      when x && y && w && h && !block_given?    # Set clip rect.
+        @clipping_rect = [x, y, w, h]
+        buffer.set_clip_rect *@clipping_rect
+      when x && y && w && h &&  block_given?    # Run block with clip rect.
+        @clipping_rect = [x, y, w, h]
+        buffer.set_clip_rect *@clipping_rect
+        begin
+          yield
+        ensure
+          @clipping_rect = old_clipping_rect
+          buffer.set_clip_rect *old_clipping_rect
+        end
+      else
+        arg_count = 0
+        [x, y, w, h].each { |arg| arg_count += 1 if arg == nil }
+        raise ArgumentError, "wrong number of arguments (#{arg_count} for 0 or 4)", caller
+      end
+
+      old_clipping_rect
+    end
+
+  end
+
+end

data/lib/tea/m_primitive_drawing.rb

@@ -165,26 +165,33 @@ module Tea
         end
       end
 
-      case mix
-      when :blend
-        r, g, b, a = primitive_hex_to_rgba(color)
-        if !outline && antialias && a < 0xff
-          # rubysdl can't draw filled antialiased alpha circles for some reason.
-          # Big endian because the SGE-powered circle antialiasing apparently
-          # doesn't like it any other way.
-          ts = SDL::Surface.new(SDL::SWSURFACE, (radius + 1) * 2, (radius + 1) * 2, 32,
-                                0xff000000,
-                                0x00ff0000,
-                                0x0000ff00,
-                                0x000000ff)
-          ts.draw_circle radius + 1, radius + 1, radius, ts.map_rgba(r, g, b, a), true, true
-          SDL::Surface.blit ts, 0, 0, ts.w, ts.h, primitive_buffer, x - radius - 1, y - radius - 1
-        else
-          primitive_buffer.draw_circle x, y, radius, primitive_rgba_to_color(r, g, b, 255),
-                                       !outline, antialias, (a == 255 ? nil : a)
+      if primitive_buffer.class == SDL::Screen
+        case mix
+        when :blend
+          r, g, b, a = primitive_hex_to_rgba(color)
+          if !outline && antialias && a < 0xff
+            # rubysdl can't draw filled antialiased alpha circles for some reason.
+            # Big endian because the SGE-powered circle antialiasing apparently
+            # doesn't like it any other way.
+            ts = SDL::Surface.new(SDL::SWSURFACE, (radius + 1) * 2, (radius + 1) * 2, 32,
+                                  0xff000000,
+                                  0x00ff0000,
+                                  0x0000ff00,
+                                  0x000000ff)
+            ts.draw_circle radius + 1, radius + 1, radius, ts.map_rgba(r, g, b, a), true, true
+            SDL::Surface.blit ts, 0, 0, ts.w, ts.h, primitive_buffer, x - radius - 1, y - radius - 1
+          else
+            primitive_buffer.draw_circle x, y, radius, primitive_rgba_to_color(r, g, b, 255),
+                                         !outline, antialias, (a == 255 ? nil : a)
+          end
+        when :replace
+          primitive_buffer.draw_circle x, y, radius, primitive_color(color), !outline, antialias
         end
-      when :replace
-        primitive_buffer.draw_circle x, y, radius, primitive_color(color), !outline, antialias
+      else
+        # SGE and alpha mixing don't... mix.  Gotta do it ourselves.
+        mixer = (mix == :blend) ? BLEND_MIXER : REPLACE_MIXER
+        r, g, b, a = primitive_hex_to_rgba(color)
+        primitive_circle x, y, radius, !outline, antialias, r, g, b, a, mixer
       end
     end
 
@@ -247,9 +254,16 @@ module Tea
       dx = x2 - x1
       dy = y2 - y1
 
-      plot = Proc.new do |x, y, i|
-        buf_r, buf_g, buf_b, buf_a = buffer.get_rgba(buffer[x, y])
-        buffer[x, y] = buffer.map_rgba(*mixer.call(red, green, blue, alpha, buf_r, buf_g, buf_b, buf_a, i))
+      # Optimise for REPLACE_MIXER, which doesn't need source pixel info.
+      if mixer == REPLACE_MIXER
+        plot = Proc.new do |x, y, i|
+          buffer[x, y] = buffer.map_rgba(*mixer.call(red, green, blue, alpha, 0, 0, 0, 0, i))
+        end
+      else
+        plot = Proc.new do |x, y, i|
+          buf_r, buf_g, buf_b, buf_a = buffer.get_rgba(buffer[x, y])
+          buffer[x, y] = buffer.map_rgba(*mixer.call(red, green, blue, alpha, buf_r, buf_g, buf_b, buf_a, i))
+        end
       end
 
       case
@@ -330,9 +344,16 @@ module Tea
       dx = x2 - x1
       dy = y2 - y1
 
-      plot = Proc.new do |x, y, i|
-        buf_r, buf_g, buf_b, buf_a = buffer.get_rgba(buffer[x, y])
-        buffer[x, y] = buffer.map_rgba(*mixer.call(red, green, blue, alpha, buf_r, buf_g, buf_b, buf_a, i))
+      # Optimise for REPLACE_MIXER, which doesn't need source pixel info.
+      if mixer == REPLACE_MIXER
+        plot = Proc.new do |x, y, i|
+          buffer[x, y] = buffer.map_rgba(*mixer.call(red, green, blue, alpha, 0, 0, 0, 0, i))
+        end
+      else
+        plot = Proc.new do |x, y, i|
+          buf_r, buf_g, buf_b, buf_a = buffer.get_rgba(buffer[x, y])
+          buffer[x, y] = buffer.map_rgba(*mixer.call(red, green, blue, alpha, buf_r, buf_g, buf_b, buf_a, i))
+        end
       end
 
       case
@@ -450,16 +471,140 @@ module Tea
       h = y2 - y
       return unless w > 0 && h > 0
 
-      primitive_buffer_with_lock do
-        for py in y...(y + h)
-          for px in x...(x + w)
-            buf_r, buf_g, buf_b, buf_a = buffer.get_rgba(buffer[px, py])
-            buffer[px, py] = buffer.map_rgba(*mixer.call(red, green, blue, alpha, buf_r, buf_g, buf_b, buf_a, 1.0))
+      # Optimise for REPLACE_MIXER, which doesn't need source pixel info.
+      if mixer == REPLACE_MIXER
+        primitive_buffer_with_lock do
+          for py in y...(y + h)
+            for px in x...(x + w)
+              buffer[px, py] = buffer.map_rgba(*mixer.call(red, green, blue, alpha, 0, 0, 0, 0, 1.0))
+            end
+          end
+        end
+      else
+        primitive_buffer_with_lock do
+          for py in y...(y + h)
+            for px in x...(x + w)
+              buf_r, buf_g, buf_b, buf_a = buffer.get_rgba(buffer[px, py])
+              buffer[px, py] = buffer.map_rgba(*mixer.call(red, green, blue, alpha, buf_r, buf_g, buf_b, buf_a, 1.0))
+            end
           end
         end
       end
     end
 
+    # Draw a circle centred at (x, y) with the given radius.
+    def primitive_circle(x, y, radius, filled, antialias, red, green, blue, alpha, mixer)
+      buffer = primitive_buffer
+
+      radius = radius.round
+      return if radius < 1 ||
+                x + radius < 0 || x - radius >= buffer.w ||
+                y + radius < 0 || y - radius >= buffer.h
+
+      # Optimise for REPLACE_MIXER, which doesn't need source pixel info.
+      if mixer == REPLACE_MIXER
+        plot = Proc.new do |px, py, i|
+          buffer[px, py] = buffer.map_rgba(*mixer.call(red, green, blue, alpha, 0, 0, 0, 0, i))
+        end
+      else
+        plot = Proc.new do |px, py, i|
+          buf_r, buf_g, buf_b, buf_a = buffer.get_rgba(buffer[px, py])
+          buffer[px, py] = buffer.map_rgba(*mixer.call(red, green, blue, alpha, buf_r, buf_g, buf_b, buf_a, i))
+        end
+      end
+
+      # Xiaolin Wu's circle algorithm, with extra stuff.  Graphics Gems II, part IX, chapter 9.
+      plot.call x + radius, y,          1.0
+      plot.call x - radius, y,          1.0
+      plot.call x,          y + radius, 1.0
+      plot.call x,          y - radius, 1.0
+
+      if filled
+        # Fill the centre and cardinal directions before iterating.
+        plot.call x, y, 1.0
+        ((x + 1)..(x + radius - 1)).each { |fill_x| plot.call fill_x, y, 1.0 }
+        ((y + 1)..(y + radius - 1)).each { |fill_y| plot.call x, fill_y, 1.0 }
+        ((x - radius + 1)..(x - 1)).each { |fill_x| plot.call fill_x, y, 1.0 }
+        ((y - radius + 1)..(y - 1)).each { |fill_y| plot.call x, fill_y, 1.0 }
+      end
+
+      i = radius
+      j = 0
+      t = 0
+
+      # Stop two steps short so we can join the octants ourselves.
+      until i - 2 <= j
+        j += 1
+        radius2_j2_diff = Math.sqrt(radius * radius - j * j)
+        d = radius2_j2_diff.ceil - radius2_j2_diff
+        inv_d = 1.0 - d
+        # Graphics Gems II seems to get this wrong by writing the reverse condition.
+        i -= 1 unless d > t
+
+        if antialias
+          plot.call x + i, y + j, inv_d
+          plot.call x + j, y + i, inv_d
+          plot.call x - j, y + i, inv_d
+          plot.call x - i, y + j, inv_d
+          plot.call x - i, y - j, inv_d
+          plot.call x - j, y - i, inv_d
+          plot.call x + j, y - i, inv_d
+          plot.call x + i, y - j, inv_d
+        else
+          plot.call x + i, y + j, 1.0
+          plot.call x + j, y + i, 1.0
+          plot.call x - j, y + i, 1.0
+          plot.call x - i, y + j, 1.0
+          plot.call x - i, y - j, 1.0
+          plot.call x - j, y - i, 1.0
+          plot.call x + j, y - i, 1.0
+          plot.call x + i, y - j, 1.0
+        end
+
+        if filled
+          ((x + j    )..(x + i - 1)).each { |fill_x| plot.call fill_x, y + j,  1.0 }
+          ((y + j + 1)..(y + i - 1)).each { |fill_y| plot.call x + j,  fill_y, 1.0 }
+          ((y + j + 1)..(y + i - 1)).each { |fill_y| plot.call x - j,  fill_y, 1.0 }
+          ((x - i + 1)..(x - j    )).each { |fill_x| plot.call fill_x, y + j,  1.0 }
+          ((x - i + 1)..(x - j    )).each { |fill_x| plot.call fill_x, y - j,  1.0 }
+          ((y - i + 1)..(y - j - 1)).each { |fill_y| plot.call x - j,  fill_y, 1.0 }
+          ((y - i + 1)..(y - j - 1)).each { |fill_y| plot.call x + j,  fill_y, 1.0 }
+          ((x + j    )..(x + i - 1)).each { |fill_x| plot.call fill_x, y - j,  1.0 }
+        elsif antialias
+          # Anti-aliased drawing needs its inner pixel if no filling is happening.
+          plot.call x + i - 1, y + j,     d
+          plot.call x + j,     y + i - 1, d
+          plot.call x - j,     y + i - 1, d
+          plot.call x - i + 1, y + j,     d
+          plot.call x - i + 1, y - j,     d
+          plot.call x - j,     y - i + 1, d
+          plot.call x + j,     y - i + 1, d
+          plot.call x + i - 1, y - j,     d
+        end
+
+        t = d
+      end
+
+      # plot final octant meeting points relative to octants 1, 3, 5 & 7
+      j += 1
+      radius2_j2_diff = Math.sqrt(radius * radius - j * j)
+      d = radius2_j2_diff.ceil - radius2_j2_diff
+      inv_d = 1.0 - d
+      i -= 1 unless d > t
+      if antialias
+        plot.call x + i, y + j, inv_d
+        plot.call x - j, y + i, inv_d
+        plot.call x - i, y - j, inv_d
+        plot.call x + j, y - i, inv_d
+      else
+        plot.call x + i, y + j, 1.0
+        plot.call x - j, y + i, 1.0
+        plot.call x - i, y - j, 1.0
+        plot.call x + j, y - i, 1.0
+      end
+
+    end
+
   end
 
 end

data/lib/tea/screen.rb

@@ -3,6 +3,7 @@
 require 'sdl'
 
 require 'tea/m_blitting'
+require 'tea/m_clipping'
 require 'tea/m_primitive_drawing'
 
 #
@@ -51,6 +52,9 @@ module Tea
     extend Blitting
     def Screen.blittable_buffer; @screen; end
 
+    extend Clipping
+    def Screen.clipping_buffer; @screen; end
+
     extend PrimitiveDrawing
     def Screen.primitive_buffer; @screen; end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: tung-tea
 version: !ruby/object:Gem::Version 
-  version: 0.2.2
+  version: 0.2.3
 platform: ruby
 authors: 
 - Tung Nguyen
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-08-04 00:00:00 -07:00
+date: 2009-08-12 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -39,6 +39,9 @@ files:
 - doc/example/bitmap_new.rb
 - doc/example/circle.rb
 - doc/example/circle_alpha.rb
+- doc/example/circle_alpha_bitmap.rb
+- doc/example/circle_bitmap.rb
+- doc/example/clip.rb
 - doc/example/event_app.rb
 - doc/example/event_keyboard.rb
 - doc/example/event_mouse.rb
@@ -65,6 +68,7 @@ files:
 - lib/tea/c_bitmap.rb
 - lib/tea/c_error.rb
 - lib/tea/m_blitting.rb
+- lib/tea/m_clipping.rb
 - lib/tea/m_event.rb
 - lib/tea/m_event_app.rb
 - lib/tea/m_event_dispatch.rb