tung-tea 0.2.1 → 0.2.2

data/README.rdoc

@@ -65,25 +65,15 @@ Below is a simple bouncing circle demo.
 
 == Status
 
-What's done:
-
-* Graphics
-  - Tea::Screen
-  - Tea::Bitmap (loaded from PNGs)
-  - Drawing of bitmaps on the screen/other bitmaps.
-  - Drawing of primitive shapes (rects, lines, circles).
-* Events
-  - Tea::Event.get.
-  - Tea::App::Minimized, Restored.
-  - Tea::Kbd::Down, Up.
-  - Tea::Mouse::Move, Down, Up, Scroll.
-  - State checking of App, Kbd, Mouse.
+What's working:
+
+* Events/Input - done
+* Graphics - halfway done, fixing transparency, grabbing sub-bitmaps
 
 What isn't done yet:
 
-* Sound
-* Screen resizing
-* Handling of alpha in colours for primitives
+* Fonts - support bitmap and TrueType fonts in ASCII
+* Sound - support loading and playing sound files
 
 
 == More information

data/doc/example/lines_aa.rb

@@ -8,7 +8,7 @@ require 'tea'
 
 puts <<TEST
 You should see 16 green lines in a wheel, with a green dot in the center,
-against a grey rectangle.
+against a grey square.
 
 Press any key to exit.
 TEST
@@ -28,7 +28,6 @@ Tea::Screen.rect 150, 100, 100, 100, 0x404040ff
 
 b.line CENTER_X, CENTER_Y, CENTER_X, CENTER_Y, LINE_COLOR, :antialias => true, :mix => :replace
 
-# TODO: Enable lines for all spokes.
 SPOKES.times do |n|
   angle = n * Math::PI * 2 / SPOKES
   x1 = CENTER_X +  LINE_CENTER_CLEARANCE                * Math.cos(angle)

data/doc/example/rect_alpha.rb

@@ -9,22 +9,62 @@
 require 'tea'
 
 puts <<TEST
-You should see for 5 seconds:
+You should see:
 
  * center:                   red   rectangle (background)
  * top-left:     translucent green rectangle
  * bottom-left:  translucent white rectangle
  * bottom-right: solid       blue  rectangle
+
+A smaller box with these same rectangles should appear in the top-right.  It
+can be moved with the arrow keys.
+
+Press ESC key to exit.
 TEST
 
 Tea.init
 Tea::Screen.set_mode 400, 300
 
-Tea::Screen.rect 100,  75, 200, 150, 0xff0000ff
-Tea::Screen.rect   0,   0, 200, 150, 0x00ff0080, :mix => :blend
-Tea::Screen.rect 200, 150, 200, 150, 0x0000ff80, :mix => :replace
-Tea::Screen.rect   0, 150, 200, 150, 0xffffff80
+x, y = 205, 15
+up, down, left, right = false, false, false, false
+wait_for_event = true
+
+begin
+  Tea::Screen.clear
+
+  Tea::Screen.rect 100,  75, 200, 150, 0xff0000ff
+  Tea::Screen.rect   0,   0, 200, 150, 0x00ff0080, :mix => :blend
+  Tea::Screen.rect 200, 150, 200, 150, 0x0000ff80, :mix => :replace
+  Tea::Screen.rect   0, 150, 200, 150, 0xffffff80
 
-Tea::Screen.update
+  b = Tea::Bitmap.new(180, 130, 0x00000000)
+  b.rect 45, 32, 90, 65, 0xff0000ff
+  b.rect  0,  0, 90, 65, 0x00ff0080, :mix => :blend
+  b.rect 90, 65, 90, 65, 0x0000ff80, :mix => :replace
+  b.rect  0, 65, 90, 65, 0xffffff80
+  Tea::Screen.blit b, x, y
 
-sleep 5
+  Tea::Screen.update
+  e = Tea::Event.get(wait_for_event)
+  case e
+  when Tea::Kbd::Down
+    case e.key
+    when Tea::Kbd::UP then up = true
+    when Tea::Kbd::DOWN then down = true
+    when Tea::Kbd::LEFT then left = true
+    when Tea::Kbd::RIGHT then right = true
+    end
+  when Tea::Kbd::Up
+    case e.key
+    when Tea::Kbd::UP then up = false
+    when Tea::Kbd::DOWN then down = false
+    when Tea::Kbd::LEFT then left = false
+    when Tea::Kbd::RIGHT then right = false
+    end
+  end
+  wait_for_event = !(up || down || left || right)
+  x -= 8 if left
+  x += 8 if right
+  y -= 8 if up
+  y += 8 if down
+end until e.class == Tea::App::Exit || (e.class == Tea::Kbd::Down && e.key == Tea::Kbd::ESCAPE)

data/doc/reference.textile

@@ -253,3 +253,8 @@ Returns true when the right mouse button is held down.
 h1. Sound
 
 Nothing yet.
+
+
+h1. Fonts
+
+Nothing yet.

data/lib/tea/m_primitive_drawing.rb

@@ -38,6 +38,23 @@ module Tea
       primitive_buffer[x, y] = primitive_color(color)
     end
 
+    # Mixer for alpha blend mix strategy.
+    BLEND_MIXER = lambda do |src_r, src_g, src_b, src_a, dest_r, dest_g, dest_b, dest_a, intensity|
+      ai = src_a * intensity
+      ratio = dest_a > 0 ? ai / dest_a.to_f : 1
+      ratio = 1 if ratio > 1
+      final_r = dest_r + (src_r - dest_r) * ratio
+      final_g = dest_g + (src_g - dest_g) * ratio
+      final_b = dest_b + (src_b - dest_b) * ratio
+      final_a = (dest_a + ai < 255) ? (dest_a + ai) : 255
+      [final_r, final_g, final_b, final_a]
+    end
+
+    # Mixer for replace mix strategy.
+    REPLACE_MIXER = lambda do |src_r, src_g, src_b, src_a, dest_r, dest_g, dest_b, dest_a, intensity|
+      [src_r, src_g, src_b, src_a * intensity]
+    end
+
     # Draw a rectangle of size w * h with the top-left corner at (x, y) with
     # the given color (0xRRGGBBAA).  Hash arguments that can be used:
     #
@@ -62,14 +79,24 @@ module Tea
         mix = options[:mix]
       end
 
+      r, g, b, a = primitive_hex_to_rgba(color)
       case mix
       when :blend
-        r, g, b, a = primitive_hex_to_rgba(color)
-        # draw_rect has an off-by-one error with the width and height, hence the "- 1"s.
-        return if w < 1 || h < 1
-        primitive_buffer.draw_rect x, y, w - 1, h - 1, primitive_rgba_to_color(r, g, b, 255), true, a
+        if a == 0xff
+          # Same as for mix == :replace
+          primitive_buffer.fill_rect x, y, w, h, primitive_rgba_to_color(r, g, b, a)
+        elsif primitive_buffer.class == SDL::Screen
+          # SGE's broken alpha blending doesn't matter on the screen, so
+          # optimise for it.  rubysdl's draw_rect is off-by-one for width and
+          # height, so compensate for that.
+          primitive_buffer.draw_rect x, y, w - 1, h - 1, primitive_rgba_to_color(r, g, b, 255), true, a
+        else
+          # CAUTION: This is _really_ slow, almost unusably so.  Perhaps I
+          # should consider not making :blend the default mix mode.
+          primitive_rect x, y, w, h, r, g, b, a, BLEND_MIXER
+        end
       when :replace
-        primitive_buffer.fill_rect x, y, w, h, primitive_color(color)
+        primitive_buffer.fill_rect x, y, w, h, primitive_rgba_to_color(r, g, b, a)
       end
     end
 
@@ -94,34 +121,15 @@ module Tea
         end
       end
 
-      mixer = nil
-      case mix
-      when :replace
-        mixer = lambda do |buffer, x, y, r, g, b, a, intensity|
-          return buffer.map_rgba(r, g, b, a * intensity)
-        end
-      when :blend
-        mixer = lambda do |buffer, x, y, r, g, b, a, intensity|
-          br, bg, bb, ba = buffer.get_rgba(buffer[x, y])
-          ai = a * intensity
-          ratio = ba > 0 ? ai / ba.to_f : 1
-          ratio = 1 if ratio > 1
-          fr = br + (r - br) * ratio
-          fg = bg + (g - bg) * ratio
-          fb = bb + (b - bb) * ratio
-          fa = (ba + ai < 255) ? (ba + ai) : 255
-          return buffer.map_rgba(fr, fg, fb, fa)
-        end
-      end
-
-      if antialias
-        r, g, b, a = primitive_hex_to_rgba(color)
-        primitive_aa_line x1, y1, x2, y2, r, g, b, a, mixer
-      elsif a == 0xff
-        primitive_buffer.draw_line x1, y1, x2, y2, primitive_color(color)
+      r, g, b, a = primitive_hex_to_rgba(color)
+      if primitive_buffer.class == SDL::Screen
+        primitive_buffer.draw_line x1, y1, x2, y2, primitive_rgba_to_color(r, g, b, (mix == :replace ? a : 255)), antialias, (mix == :blend ? a : nil)
       else
-        r, g, b, a = primitive_hex_to_rgba(color)
-        primitive_line x1, y1, x2, y2, r, g, b, a, mixer
+        if antialias
+          primitive_aa_line x1, y1, x2, y2, r, g, b, a, (mix == :blend ? BLEND_MIXER : REPLACE_MIXER)
+        else
+          primitive_line x1, y1, x2, y2, r, g, b, a, (mix == :blend ? BLEND_MIXER : REPLACE_MIXER)
+        end
       end
     end
 
@@ -160,7 +168,7 @@ module Tea
       case mix
       when :blend
         r, g, b, a = primitive_hex_to_rgba(color)
-        if !outline && antialias && a < 255
+        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.
@@ -232,26 +240,31 @@ module Tea
     # +alpha+ is passed to the +mixer+ proc to determine how the line and
     # bitmap colours should be mixed.
     #
-    # mixer = { |buffer, x, y, red, green, blue, alpha| ... }
+    # mixer = { |src_red, src_green, src_blue, src_alpha, dest_red, dest_green, dest_blue, dest_alpha, intensity| ... }
     def primitive_line(x1, y1, x2, y2, red, green, blue, alpha, mixer)
 
       buffer = primitive_buffer
       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))
+      end
+
       case
       when dx == 0 && dy == 0       # point
-        buffer[x1, y1] = mixer.call buffer, x1, y1, red, green, blue, alpha, 1.0
+        plot.call x1, y1, 1.0
       when dx == 0 && dy != 0       # vertical line
         primitive_buffer_with_lock do
           for y in (y1.to_i)..(y2.to_i)
-            buffer[x1, y] = mixer.call buffer, x1, y, red, green, blue, alpha, 1.0
+            plot.call x1, y, 1.0
           end
         end
       when dx != 0 && dy == 0       # horizontal line
         primitive_buffer_with_lock do
           for x in (x1.to_i)..(x2.to_i)
-            buffer[x, y1] = mixer.call buffer, x, y1, red, green, blue, alpha, 1.0
+            plot.call x, y1, 1.0
           end
         end
       else  # Use Bresenham's line algorithm, from John Hall's Programming Linux Games.
@@ -282,7 +295,7 @@ module Tea
         primitive_buffer_with_lock do
           if xspan < yspan    # Draw a mostly vertical line.
             for step in 0..yspan
-              buffer[x, y] = mixer.call buffer, x, y, red, green, blue, alpha, 1.0
+              plot.call x, y, 1.0
               error += xspan
               if error >= yspan
                 x += xinc
@@ -292,7 +305,7 @@ module Tea
             end
           else    # Draw a mostly horizontal line.
             for step in 0..xspan
-              buffer[x, y] = mixer.call buffer, x, y, red, green, blue, alpha, 1.0
+              plot.call x, y, 1.0
               error += yspan
               if error >= xspan
                 y += yinc
@@ -310,26 +323,31 @@ module Tea
     # blue).  The +alpha+ is passed to the +mixer+ proc to determine how the
     # line and bitmap colours should be mixed.
     #
-    # mixer = { |buffer, x, y, red, green, blue, alpha, intensity| ... }
+    # mixer = { |src_red, src_green, src_blue, src_alpha, dest_red, dest_green, dest_blue, dest_alpha, intensity| ... }
     def primitive_aa_line(x1, y1, x2, y2, red, green, blue, alpha, mixer)
 
       buffer = primitive_buffer
       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))
+      end
+
       case
       when dx == 0 && dy == 0       # point
-        buffer[x1, y1] = mixer.call buffer, x1, y1, red, green, blue, alpha, 1.0
+        plot.call x1, y1, 1.0
       when dx == 0 && dy != 0       # vertical line
         primitive_buffer_with_lock do
           for y in (y1.to_i)..(y2.to_i)
-            buffer[x1, y] = mixer.call buffer, x1, y, red, green, blue, alpha, 1.0
+            plot.call x1, y, 1.0
           end
         end
       when dx != 0 && dy == 0       # horizontal line
         primitive_buffer_with_lock do
           for x in (x1.to_i)..(x2.to_i)
-            buffer[x, y1] = mixer.call buffer, x, y1, red, green, blue, alpha, 1.0
+            plot.call x, y1, 1.0
           end
         end
       else  # Use Xiaolin Wu's line algorithm, described on Wikipedia.
@@ -347,8 +365,8 @@ module Tea
           xgap = primitive_rfpart(x1 + 0.5)
           xpxl1 = xend                # This will be used in the main loop.
           ypxl1 = yend.truncate
-          buffer[xpxl1, ypxl1]     = mixer.call buffer, xpxl1, ypxl1,     red, green, blue, alpha, primitive_rfpart(yend) * xgap
-          buffer[xpxl1, ypxl1 + 1] = mixer.call buffer, xpxl1, ypxl1 + 1, red, green, blue, alpha, primitive_fpart(yend)  * xgap
+          plot.call xpxl1, ypxl1, primitive_rfpart(yend) * xgap
+          plot.call xpxl1, ypxl1 + 1, primitive_fpart(yend) * xgap
           intery = yend + gradient    # First y-intersection for the main loop.
 
           # Handle second endpoint.
@@ -357,14 +375,14 @@ module Tea
           xgap = primitive_fpart(x2 + 0.5)
           xpxl2 = xend                # This will be used in the main loop.
           ypxl2 = yend.truncate
-          buffer[xpxl2, ypxl2]     = mixer.call buffer, xpxl2, ypxl2,     red, green, blue, alpha, primitive_rfpart(yend) * xgap
-          buffer[xpxl2, ypxl2 + 1] = mixer.call buffer, xpxl2, ypxl2 + 1, red, green, blue, alpha, primitive_fpart(yend)  * xgap
+          plot.call xpxl2, ypxl2, primitive_rfpart(yend) * xgap
+          plot.call xpxl2, ypxl2 = 1, primitive_fpart(yend) * xgap
 
           primitive_buffer_with_lock do
             for x in (xpxl1 + 1)..(xpxl2 - 1)
               intery_int = intery.truncate
-              buffer[x, intery_int]     = mixer.call buffer, x, intery_int,     red, green, blue, alpha, primitive_rfpart(intery)
-              buffer[x, intery_int + 1] = mixer.call buffer, x, intery_int + 1, red, green, blue, alpha, primitive_fpart(intery)
+              plot.call x, intery_int, primitive_rfpart(intery)
+              plot.call x, intery_int + 1, primitive_fpart(intery)
               intery += gradient
             end
           end
@@ -381,8 +399,8 @@ module Tea
           ygap = primitive_rfpart(y1 + 0.5)
           ypxl1 = yend                # This will be used in the main loop.
           xpxl1 = xend.truncate
-          buffer[xpxl1,     ypxl1] = mixer.call buffer, xpxl1,     ypxl1, red, green, blue, alpha, primitive_rfpart(xend) * ygap
-          buffer[xpxl1 + 1, ypxl1] = mixer.call buffer, xpxl1 + 1, ypxl1, red, green, blue, alpha, primitive_fpart(xend)  * ygap
+          plot.call xpxl1, ypxl1, primitive_rfpart(xend) * ygap
+          plot.call xpxl1 + 1, ypxl1, primitive_fpart(xend) * ygap
           interx = xend + gradient    # First x-intersection for the main loop.
 
           # Handle second endpoint.
@@ -391,14 +409,14 @@ module Tea
           ygap = primitive_fpart(y2 + 0.5)
           ypxl2 = yend                # This will be used in the main loop.
           xpxl2 = xend.truncate
-          buffer[xpxl2,     ypxl2] = mixer.call buffer, xpxl2,     ypxl2, red, green, blue, alpha, primitive_rfpart(xend) * ygap
-          buffer[xpxl2 + 1, ypxl2] = mixer.call buffer, xpxl2 + 1, ypxl2, red, green, blue, alpha, primitive_fpart(xend)  * ygap
+          plot.call xpxl2, ypxl2, primitive_rfpart(xend) * ygap
+          plot.call xpxl2 + 1, ypxl2, primitive_fpart(xend) * ygap
 
           primitive_buffer_with_lock do
             for y in (ypxl1 + 1)..(ypxl2 - 1)
               interx_int = interx.truncate
-              buffer[interx_int,     y] = mixer.call buffer, interx_int,     y, red, green, blue, alpha, primitive_rfpart(interx)
-              buffer[interx_int + 1, y] = mixer.call buffer, interx_int + 1, y, red, green, blue, alpha, primitive_fpart(interx)
+              plot.call interx_int, y, primitive_rfpart(interx)
+              plot.call interx_int + 1, y, primitive_fpart(interx)
               interx += gradient
             end
           end
@@ -407,6 +425,41 @@ module Tea
       end
     end
 
+    # Draw a rectangle of size (w, h) with the top-left corner at (x, y), with
+    # the colour (red, green, blue) and mixed with +alpha+ and +mixer+.
+    #
+    # mixer = { |src_red, src_green, src_blue, src_alpha, dest_red, dest_green, dest_blue, dest_alpha, intensity| ... }
+    def primitive_rect(x, y, w, h, red, green, blue, alpha, mixer)
+      buffer = primitive_buffer
+
+      # Keep x, y, w, h within the clipping rectangle.
+      x2 = x + w
+      y2 = y + h
+      clip_x, clip_y, clip_w, clip_h = buffer.get_clip_rect
+      clip_x = 0 unless clip_x
+      clip_y = 0 unless clip_y
+      clip_w = buffer.w unless clip_w
+      clip_h = buffer.h unless clip_h
+      clip_x2 = clip_x + clip_w
+      clip_y2 = clip_y + clip_h
+      x = clip_x if x < clip_x
+      y = clip_y if y < clip_y
+      x2 = clip_x2 if x2 > clip_x2
+      y2 = clip_y2 if y2 > clip_y2
+      w = x2 - x
+      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))
+          end
+        end
+      end
+    end
+
   end
 
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: tung-tea
 version: !ruby/object:Gem::Version 
-  version: 0.2.1
+  version: 0.2.2
 platform: ruby
 authors: 
 - Tung Nguyen
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-08-02 00:00:00 -07:00
+date: 2009-08-04 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency