pixelflow_canvas 0.4.1 → 0.4.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4824696c6996cc136b56dd83a716fa12a273e0682744473b67f0ffb7693b7335
-  data.tar.gz: 612927ef865f29432b41adbaa11b0d4b6e824a9af15cd75413c7e5c7fa0c84b1
+  metadata.gz: 03bac01ad660c83aac3bb58e8b9dc009f07d99d773ebf3e4c9c77106c9016a08
+  data.tar.gz: 810c59ec0266aec7f5b4b20b7b411fe5e7c4383db0dd0c1614e0fc1446ae5ffc
 SHA512:
-  metadata.gz: ed40b86854a8779791ca67eb41d0b881ea76e917e72305e391f693cdbfaa6157f2e34402038c300f30b1b7d67414c4722ba3808caf5abd50ea76149fe3915016
-  data.tar.gz: e0311899a97ba6959dc457f1dbb1397c8495a730e99c813e5b5809875e9127344410856d4bfc3e2afed6b504492693aeffedf62b4f1937702edc6a49f4d11af7
+  metadata.gz: 1f4d69987a229d3c369acaab172efb8d39a189ed739b0e21f5078de233b612eff4b8daaf9d85eea46a8b9c5020aafdc528fd3e6cca2f5618ca3d87e5328f1b41
+  data.tar.gz: 921f5a582cd70c7024e502feae11dbd2eed01eb59fa6487bc9534913b859125d8d0fe6a13665bf389184137a6f9f2b563be266832002e5fa88c772b5e5476b6f

data/lib/pixelflow_canvas/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module PixelflowCanvas
-  VERSION = "0.4.1"
+  VERSION = "0.4.3"
 end

data/lib/pixelflow_canvas/vga_palette.rb

@@ -0,0 +1,50 @@
+VGA_PALETTE = [
+    0x00,0x00,0x00,0x00,0x00,0xaa,0x00,0xaa,0x00,0x00,0xaa,0xaa,0xaa,0x00,0x00,0xaa,
+    0x00,0xaa,0xaa,0x55,0x00,0xaa,0xaa,0xaa,0x55,0x55,0x55,0x55,0x55,0xff,0x55,0xff,
+    0x55,0x55,0xff,0xff,0xff,0x55,0x55,0xff,0x55,0xff,0xff,0xff,0x55,0xff,0xff,0xff,
+    0x00,0x00,0x00,0x14,0x14,0x14,0x20,0x20,0x20,0x2c,0x2c,0x2c,0x38,0x38,0x38,0x45,
+    0x45,0x45,0x51,0x51,0x51,0x61,0x61,0x61,0x71,0x71,0x71,0x82,0x82,0x82,0x92,0x92,
+    0x92,0xa2,0xa2,0xa2,0xb6,0xb6,0xb6,0xcb,0xcb,0xcb,0xe3,0xe3,0xe3,0xff,0xff,0xff,
+    0x00,0x00,0xff,0x41,0x00,0xff,0x7d,0x00,0xff,0xbe,0x00,0xff,0xff,0x00,0xff,0xff,
+    0x00,0xbe,0xff,0x00,0x7d,0xff,0x00,0x41,0xff,0x00,0x00,0xff,0x41,0x00,0xff,0x7d,
+    0x00,0xff,0xbe,0x00,0xff,0xff,0x00,0xbe,0xff,0x00,0x7d,0xff,0x00,0x41,0xff,0x00,
+    0x00,0xff,0x00,0x00,0xff,0x41,0x00,0xff,0x7d,0x00,0xff,0xbe,0x00,0xff,0xff,0x00,
+    0xbe,0xff,0x00,0x7d,0xff,0x00,0x41,0xff,0x7d,0x7d,0xff,0x9e,0x7d,0xff,0xbe,0x7d,
+    0xff,0xdf,0x7d,0xff,0xff,0x7d,0xff,0xff,0x7d,0xdf,0xff,0x7d,0xbe,0xff,0x7d,0x9e,
+    0xff,0x7d,0x7d,0xff,0x9e,0x7d,0xff,0xbe,0x7d,0xff,0xdf,0x7d,0xff,0xff,0x7d,0xdf,
+    0xff,0x7d,0xbe,0xff,0x7d,0x9e,0xff,0x7d,0x7d,0xff,0x7d,0x7d,0xff,0x9e,0x7d,0xff,
+    0xbe,0x7d,0xff,0xdf,0x7d,0xff,0xff,0x7d,0xdf,0xff,0x7d,0xbe,0xff,0x7d,0x9e,0xff,
+    0xb6,0xb6,0xff,0xc7,0xb6,0xff,0xdb,0xb6,0xff,0xeb,0xb6,0xff,0xff,0xb6,0xff,0xff,
+    0xb6,0xeb,0xff,0xb6,0xdb,0xff,0xb6,0xc7,0xff,0xb6,0xb6,0xff,0xc7,0xb6,0xff,0xdb,
+    0xb6,0xff,0xeb,0xb6,0xff,0xff,0xb6,0xeb,0xff,0xb6,0xdb,0xff,0xb6,0xc7,0xff,0xb6,
+    0xb6,0xff,0xb6,0xb6,0xff,0xc7,0xb6,0xff,0xdb,0xb6,0xff,0xeb,0xb6,0xff,0xff,0xb6,
+    0xeb,0xff,0xb6,0xdb,0xff,0xb6,0xc7,0xff,0x00,0x00,0x71,0x1c,0x00,0x71,0x38,0x00,
+    0x71,0x55,0x00,0x71,0x71,0x00,0x71,0x71,0x00,0x55,0x71,0x00,0x38,0x71,0x00,0x1c,
+    0x71,0x00,0x00,0x71,0x1c,0x00,0x71,0x38,0x00,0x71,0x55,0x00,0x71,0x71,0x00,0x55,
+    0x71,0x00,0x38,0x71,0x00,0x1c,0x71,0x00,0x00,0x71,0x00,0x00,0x71,0x1c,0x00,0x71,
+    0x38,0x00,0x71,0x55,0x00,0x71,0x71,0x00,0x55,0x71,0x00,0x38,0x71,0x00,0x1c,0x71,
+    0x38,0x38,0x71,0x45,0x38,0x71,0x55,0x38,0x71,0x61,0x38,0x71,0x71,0x38,0x71,0x71,
+    0x38,0x61,0x71,0x38,0x55,0x71,0x38,0x45,0x71,0x38,0x38,0x71,0x45,0x38,0x71,0x55,
+    0x38,0x71,0x61,0x38,0x71,0x71,0x38,0x61,0x71,0x38,0x55,0x71,0x38,0x45,0x71,0x38,
+    0x38,0x71,0x38,0x38,0x71,0x45,0x38,0x71,0x55,0x38,0x71,0x61,0x38,0x71,0x71,0x38,
+    0x61,0x71,0x38,0x55,0x71,0x38,0x45,0x71,0x51,0x51,0x71,0x59,0x51,0x71,0x61,0x51,
+    0x71,0x69,0x51,0x71,0x71,0x51,0x71,0x71,0x51,0x69,0x71,0x51,0x61,0x71,0x51,0x59,
+    0x71,0x51,0x51,0x71,0x59,0x51,0x71,0x61,0x51,0x71,0x69,0x51,0x71,0x71,0x51,0x69,
+    0x71,0x51,0x61,0x71,0x51,0x59,0x71,0x51,0x51,0x71,0x51,0x51,0x71,0x59,0x51,0x71,
+    0x61,0x51,0x71,0x69,0x51,0x71,0x71,0x51,0x69,0x71,0x51,0x61,0x71,0x51,0x59,0x71,
+    0x00,0x00,0x41,0x10,0x00,0x41,0x20,0x00,0x41,0x30,0x00,0x41,0x41,0x00,0x41,0x41,
+    0x00,0x30,0x41,0x00,0x20,0x41,0x00,0x10,0x41,0x00,0x00,0x41,0x10,0x00,0x41,0x20,
+    0x00,0x41,0x30,0x00,0x41,0x41,0x00,0x30,0x41,0x00,0x20,0x41,0x00,0x10,0x41,0x00,
+    0x00,0x41,0x00,0x00,0x41,0x10,0x00,0x41,0x20,0x00,0x41,0x30,0x00,0x41,0x41,0x00,
+    0x30,0x41,0x00,0x20,0x41,0x00,0x10,0x41,0x20,0x20,0x41,0x28,0x20,0x41,0x30,0x20,
+    0x41,0x38,0x20,0x41,0x41,0x20,0x41,0x41,0x20,0x38,0x41,0x20,0x30,0x41,0x20,0x28,
+    0x41,0x20,0x20,0x41,0x28,0x20,0x41,0x30,0x20,0x41,0x38,0x20,0x41,0x41,0x20,0x38,
+    0x41,0x20,0x30,0x41,0x20,0x28,0x41,0x20,0x20,0x41,0x20,0x20,0x41,0x28,0x20,0x41,
+    0x30,0x20,0x41,0x38,0x20,0x41,0x41,0x20,0x38,0x41,0x20,0x30,0x41,0x20,0x28,0x41,
+    0x2c,0x2c,0x41,0x30,0x2c,0x41,0x34,0x2c,0x41,0x3c,0x2c,0x41,0x41,0x2c,0x41,0x41,
+    0x2c,0x3c,0x41,0x2c,0x34,0x41,0x2c,0x30,0x41,0x2c,0x2c,0x41,0x30,0x2c,0x41,0x34,
+    0x2c,0x41,0x3c,0x2c,0x41,0x41,0x2c,0x3c,0x41,0x2c,0x34,0x41,0x2c,0x30,0x41,0x2c,
+    0x2c,0x41,0x2c,0x2c,0x41,0x30,0x2c,0x41,0x34,0x2c,0x41,0x3c,0x2c,0x41,0x41,0x2c,
+    0x3c,0x41,0x2c,0x34,0x41,0x2c,0x30,0x41,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+    0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
+]

data/lib/pixelflow_canvas.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 require_relative "pixelflow_canvas/version"
+require_relative "pixelflow_canvas/vga_palette.rb"
+require 'chunky_png'
 require 'socket'
 require 'time'
 
@@ -18,36 +20,35 @@ module Pixelflow
             :direct => 0,
             :buffered => 1
         }
+        COMPOSE_MODES = {
+            :over => 0,
+            :add => 1,
+            :subtract => 2
+        }
+        INTERPOLATION_MODES = {
+            :nearest => 0,
+            :bilinear => 1,
+        }
         def initialize(width, height, color_mode = nil)
             @width = 320
             @height = 180
             @x = 0
             @y = 0
+            @r = color_mode == :palette ? 15 : 255
+            @g = color_mode == :palette ? 0 : 255
+            @b = color_mode == :palette ? 0 : 255
             @color_mode = :rgb
             @advance_mode = :right
             @draw_mode = :direct
-            @palette = [0] * 768
+            @compose_mode = :over
+            @palette = VGA_PALETTE.dup
             @socket = TCPSocket.new('127.0.0.1', 19223)
             set_size(width, height)
             set_color_mode(color_mode) if color_mode
             @last_timestamp = Time.now.to_f
         end
 
-        def run(&block)
-            yield(self)
-        end
-
-        def recreate_screen()
-            @screen = [0] * @width * @height * (@color_mode == :rgb ? 3 : 1)
-        end
-
-        def set_draw_mode(mode)
-            unless DRAW_MODES.keys.include?(mode)
-                raise "Invalid draw mode: #{mode}"
-            end
-            @draw_mode = mode
-            recreate_screen()
-        end
+        attr_reader :width, :height
 
         def set_size(width, height)
             @x = 0
@@ -59,25 +60,24 @@ module Pixelflow
             @socket.flush
         end
 
+        def recreate_screen()
+            @screen = [0] * @width * @height * (@color_mode == :rgb ? 3 : 1)
+        end
+
         def set_color_mode(mode)
             unless COLOR_MODES.keys.include?(mode)
                 raise "Invalid color mode: #{mode}"
             end
             @color_mode = mode
+            if mode == :palette
+                @palette = VGA_PALETTE.dup
+            end
             recreate_screen()
             @socket.write([2, COLOR_MODES[@color_mode]].pack('CC'))
             @socket.flush
         end
 
-        def set_palette(i, r, g, b)
-            i = i % 256
-            r = (r % 256) << 2
-            g = (g % 256) << 2
-            b = (b % 256) << 2
-            @socket.write([3, i, r, g, b].pack('CCCCC'))
-        end
-
-        def set_advance(mode)
+        def set_advance_mode(mode)
             unless ADVANCE_MODES.keys.include?(mode)
                 raise "Invalid advance mode: #{mode}"
             end
@@ -86,11 +86,91 @@ module Pixelflow
             @socket.flush
         end
 
+        def set_draw_mode(mode)
+            unless DRAW_MODES.keys.include?(mode)
+                raise "Invalid draw mode: #{mode}"
+            end
+            @draw_mode = mode
+        end
+
+        def set_compose_mode(mode)
+            unless COMPOSE_MODES.keys.include?(mode)
+                raise "Invalid compose mode: #{mode}"
+            end
+            if mode != :over && @color_mode != :rgb
+                raise "Cannot switch compose mode to #{mode} in palette color mode!"
+            end
+            @compose_mode = mode
+        end
+
+        def set_interpolation_mode(mode)
+            unless INTERPOLATION_MODES.keys.include?(mode)
+                raise "Invalid interpolation mode: #{mode}"
+            end
+            @socket.write([8, INTERPOLATION_MODES[mode]].pack('CC'))
+            @socket.flush
+        end
+
+        def flip()
+            if @draw_mode == :buffered
+                @socket.write([7].pack('C'))
+                @socket.write(@screen.pack('C*'))
+                @socket.flush
+            end
+        end
+
+        def ensure_max_fps(fps)
+            fps1 = 1.0 / fps
+            t = Time.now.to_f
+            dt = t - @last_timestamp
+            sleep(fps1 - dt) if dt < fps1
+            @last_timestamp = t
+        end
+
+        def save_as_png(path)
+            if @color_mode == :rgb
+                image = ChunkyPNG::Image.from_rgb_stream(@width, @height, @screen.pack('C*'))
+                image.save(path)
+            else
+                buffer = [0] * @width * @height * 3
+                offset = 0
+                source = 0
+                (0...@height).each do |y|
+                    (0...@width).each do |x|
+                        i = @screen[source]
+                        buffer[offset + 0] = @palette[i + 0]
+                        buffer[offset + 1] = @palette[i + 1]
+                        buffer[offset + 2] = @palette[i + 2]
+                        source += 1
+                        offset += 3
+                    end
+                end
+                image = ChunkyPNG::Image.from_rgb_stream(@width, @height, buffer.pack('C*'))
+                image.save(path)
+            end
+        end
+
+        def set_color(r, g = 0, b = 0)
+            @r = r
+            @g = g
+            @b = b
+        end
+
+        def set_palette(i, r, g, b)
+            i = i.to_i.clamp(0, 255)
+            r = r.to_i.clamp(0, 255)
+            g = g.to_i.clamp(0, 255)
+            b = b.to_i.clamp(0, 255)
+            @palette[i * 3 + 0] = r
+            @palette[i * 3 + 1] = g
+            @palette[i * 3 + 2] = b
+            @socket.write([3, i, r, g, b].pack('CCCCC'))
+            @socket.flush
+        end
+
         def move_to(x, y)
-            x0 = x0.to_i
-            y0 = y0.to_i
-            x1 = x1.to_i
-            y1 = y1.to_i
+            x = x.to_i
+            y = y.to_i
             return if x < 0 || x >= @width || y < 0 || y >= @height
             @x = x
             @y = y
@@ -101,7 +181,10 @@ module Pixelflow
             @socket.flush
         end
 
-        def set_pixel(x, y, r, g = 0, b = 0)
+        def set_pixel(x, y, r = nil, g = nil, b = nil)
+            r ||= @r
+            g ||= @g
+            b ||= @b
             x0 = x0.to_i
             y0 = y0.to_i
             x1 = x1.to_i
@@ -112,6 +195,14 @@ module Pixelflow
             end
             if @color_mode == :rgb
                 offset = (@y * @width + @x) * 3
+                if @compose_mode == :add
+                    r += @screen[offset + 0]
+                    g += @screen[offset + 1]
+                    b += @screen[offset + 2]
+                    r = 255 if r > 255
+                    g = 255 if g > 255
+                    b = 255 if b > 255
+                end
                 @screen[offset + 0] = r
                 @screen[offset + 1] = g
                 @screen[offset + 2] = b
@@ -155,52 +246,36 @@ module Pixelflow
             end
         end
 
-        def flip()
-            if @draw_mode == :buffered
-                @socket.write([7].pack('C'))
-                @socket.write(@screen.pack('C*'))
-                @socket.flush
-            end
-        end
-
-        def ensure_max_fps(fps)
-            fps1 = 1.0 / fps
-            t = Time.now.to_f
-            dt = t - @last_timestamp
-            sleep(fps1 - dt) if dt < fps1
-            @last_timestamp = t
-        end
-
-        def draw_rect(x0, y0, x1, y1, color)
+        def draw_rect(x0, y0, x1, y1)
             x0 = x0.to_i
             y0 = y0.to_i
             x1 = x1.to_i
             y1 = y1.to_i
             (x0..x1).each do |x|
-                set_pixel(x, y0, color)
+                set_pixel(x, y0)
             end
             (x0..x1).each do |x|
-                set_pixel(x, y1, color)
+                set_pixel(x, y1)
             end
             (y0+1..y1-1).each do |y|
-                set_pixel(x0, y, color)
-                set_pixel(x1, y, color)
+                set_pixel(x0, y)
+                set_pixel(x1, y)
             end
         end
 
-        def fill_rect(x0, y0, x1, y1, color)
+        def fill_rect(x0, y0, x1, y1)
             x0 = x0.to_i
             y0 = y0.to_i
             x1 = x1.to_i
             y1 = y1.to_i
             (y0..y1).each do |y|
                 (x0..x1).each do |x|
-                    set_pixel(x, y, color)
+                    set_pixel(x, y)
                 end
             end
         end
 
-        def draw_line(x0, y0, x1, y1, color)
+        def draw_line(x0, y0, x1, y1)
             x0 = x0.to_i
             y0 = y0.to_i
             x1 = x1.to_i
@@ -211,7 +286,7 @@ module Pixelflow
             sy = y0 < y1 ? 1 : -1
             err = dx - dy
             loop do
-                set_pixel(x0, y0, color)
+                set_pixel(x0, y0)
                 break if x0 == x1 && y0 == y1
                 e2 = 2 * err
                 if e2 > -dy
@@ -225,19 +300,19 @@ module Pixelflow
             end
         end
 
-        def draw_circle(x, y, radius, color)
+        def draw_circle(x, y, r)
             x = x.to_i
             y = y.to_i
-            radius = radius.to_i
-            f = 1 - radius
+            r = r.to_i
+            f = 1 - r
             ddF_x = 1
-            ddF_y = -2 * radius
+            ddF_y = -2 * r
             xx = 0
-            yy = radius
-            set_pixel(x, y + radius, color)
-            set_pixel(x, y - radius, color)
-            set_pixel(x + radius, y, color)
-            set_pixel(x - radius, y, color)
+            yy = r
+            set_pixel(x, y + r)
+            set_pixel(x, y - r)
+            set_pixel(x + r, y)
+            set_pixel(x - r, y)
             while xx < yy
                 if f >= 0
                     yy -= 1
@@ -247,18 +322,18 @@ module Pixelflow
                 xx += 1
                 ddF_x += 2
                 f += ddF_x
-                set_pixel(x + xx, y + yy, color)
-                set_pixel(x - xx, y + yy, color)
-                set_pixel(x + xx, y - yy, color)
-                set_pixel(x - xx, y - yy, color)
-                set_pixel(x + yy, y + xx, color)
-                set_pixel(x - yy, y + xx, color)
-                set_pixel(x + yy, y - xx, color)
-                set_pixel(x - yy, y - xx, color)
+                set_pixel(x + xx, y + yy)
+                set_pixel(x - xx, y + yy)
+                set_pixel(x + xx, y - yy)
+                set_pixel(x - xx, y - yy)
+                set_pixel(x + yy, y + xx)
+                set_pixel(x - yy, y + xx)
+                set_pixel(x + yy, y - xx)
+                set_pixel(x - yy, y - xx)
             end
         end
 
-        def fill_circle(x, y, r, color)
+        def fill_circle(x, y, r)
             x = x.to_i
             y = y.to_i
             r = r.to_i
@@ -268,7 +343,7 @@ module Pixelflow
             xx = 0
             yy = r
             (y - r..y + r).each do |i|
-                set_pixel(x, i, color)
+                set_pixel(x, i)
             end
             while xx < yy
                 if f >= 0
@@ -280,33 +355,33 @@ module Pixelflow
                 ddF_x += 2
                 f += ddF_x
                 (y - yy..y + yy).each do |i|
-                    set_pixel(x + xx, i, color)
-                    set_pixel(x - xx, i, color)
+                    set_pixel(x + xx, i)
+                    set_pixel(x - xx, i)
                 end
                 (y - xx..y + xx).each do |i|
-                    set_pixel(x + yy, i, color)
-                    set_pixel(x - yy, i, color)
+                    set_pixel(x + yy, i)
+                    set_pixel(x - yy, i)
                 end
             end
         end
 
-        def draw_ellipse(x, y, a, b, color)
+        def draw_ellipse(x, y, ra, rb)
             x = x.to_i
             y = y.to_i
-            a = a.to_i
-            b = b.to_i
-            a2 = a * a
-            b2 = b * b
+            ra = ra.to_i
+            rb = rb.to_i
+            a2 = ra * ra
+            b2 = rb * rb
             fa2 = 4 * a2
             fb2 = 4 * b2
             x0 = 0
             y0 = b
-            sigma = 2 * b2 + a2 * (1 - 2 * b)
+            sigma = 2 * b2 + a2 * (1 - 2 * rb)
             while b2 * x0 <= a2 * y0
-                set_pixel(x + x0, y + y0, color)
-                set_pixel(x - x0, y + y0, color)
-                set_pixel(x + x0, y - y0, color)
-                set_pixel(x - x0, y - y0, color)
+                set_pixel(x + x0, y + y0)
+                set_pixel(x - x0, y + y0)
+                set_pixel(x + x0, y - y0)
+                set_pixel(x - x0, y - y0)
                 if sigma >= 0
                     sigma += fa2 * (1 - y0)
                     y0 -= 1
@@ -316,12 +391,12 @@ module Pixelflow
             end
             x0 = a
             y0 = 0
-            sigma = 2 * a2 + b2 * (1 - 2 * a)
+            sigma = 2 * a2 + b2 * (1 - 2 * ra)
             while a2 * y0 <= b2 * x0
-                set_pixel(x + x0, y + y0, color)
-                set_pixel(x - x0, y + y0, color)
-                set_pixel(x + x0, y - y0, color)
-                set_pixel(x - x0, y - y0, color)
+                set_pixel(x + x0, y + y0)
+                set_pixel(x - x0, y + y0)
+                set_pixel(x + x0, y - y0)
+                set_pixel(x - x0, y - y0)
                 if sigma >= 0
                     sigma += fb2 * (1 - x0)
                     x0 -= 1
@@ -331,22 +406,22 @@ module Pixelflow
             end
         end
 
-        def fill_ellipse(x, y, a, b, color)
+        def fill_ellipse(x, y, ra, rb)
             x = x.to_i
             y = y.to_i
-            a = a.to_i
-            b = b.to_i
-            a2 = a * a
-            b2 = b * b
+            ra = ra.to_i
+            rb = rb.to_i
+            a2 = ra * ra
+            b2 = rb * rb
             fa2 = 4 * a2
             fb2 = 4 * b2
             x0 = 0
             y0 = b
-            sigma = 2 * b2 + a2 * (1 - 2 * b)
+            sigma = 2 * b2 + a2 * (1 - 2 * rb)
             while b2 * x0 <= a2 * y0
                 (x - x0..x + x0).each do |i|
-                    set_pixel(i, y + y0, color)
-                    set_pixel(i, y - y0, color)
+                    set_pixel(i, y + y0)
+                    set_pixel(i, y - y0)
                 end
                 if sigma >= 0
                     sigma += fa2 * (1 - y0)
@@ -357,11 +432,11 @@ module Pixelflow
             end
             x0 = a
             y0 = 0
-            sigma = 2 * a2 + b2 * (1 - 2 * a)
+            sigma = 2 * a2 + b2 * (1 - 2 * ra)
             while a2 * y0 <= b2 * x0
                 (x - x0..x + x0).each do |i|
-                    set_pixel(i, y + y0, color)
-                    set_pixel(i, y - y0, color)
+                    set_pixel(i, y + y0)
+                    set_pixel(i, y - y0)
                 end
                 if sigma >= 0
                     sigma += fb2 * (1 - x0)
@@ -372,7 +447,7 @@ module Pixelflow
             end
         end
 
-        def draw_quadratic_bezier(x0, y0, x1, y1, x2, y2, color, steps = 100)
+        def draw_quadratic_bezier(x0, y0, x1, y1, x2, y2, steps = 100)
             steps = steps.to_i
             xp = nil
             yp = nil
@@ -381,14 +456,14 @@ module Pixelflow
                 x = (1 - t) ** 2 * x0 + 2 * (1 - t) * t * x1 + t ** 2 * x2
                 y = (1 - t) ** 2 * y0 + 2 * (1 - t) * t * y1 + t ** 2 * y2
                 if xp && yp
-                    draw_line(xp.to_i, yp.to_i, x.to_i, y.to_i, color)
+                    draw_line(xp.to_i, yp.to_i, x.to_i, y.to_i)
                 end
                 xp = x
                 yp = y
             end
         end
 
-        def draw_cubic_bezier(x0, y0, x1, y1, x2, y2, x3, y3, color, steps = 100)
+        def draw_cubic_bezier(x0, y0, x1, y1, x2, y2, x3, y3, steps = 100)
             steps = steps.to_i
             xp = nil
             yp = nil
@@ -397,17 +472,49 @@ module Pixelflow
                 x = (1 - t) ** 3 * x0 + 3 * (1 - t) ** 2 * t * x1 + 3 * (1 - t) * t ** 2 * x2 + t ** 3 * x3
                 y = (1 - t) ** 3 * y0 + 3 * (1 - t) ** 2 * t * y1 + 3 * (1 - t) * t ** 2 * y2 + t ** 3 * y3
                 if xp && yp
-                    draw_line(xp.to_i, yp.to_i, x.to_i, y.to_i, color)
+                    draw_line(xp.to_i, yp.to_i, x.to_i, y.to_i)
                 end
                 xp = x
                 yp = y
             end
         end
 
-        def draw_triangle(x0, y0, x1, y1, x2, y2, color)
-            draw_line(x0, y0, x1, y1, color)
-            draw_line(x1, y1, x2, y2, color)
-            draw_line(x2, y2, x0, y0, color)
+        def draw_triangle(x0, y0, x1, y1, x2, y2)
+            draw_line(x0, y0, x1, y1)
+            draw_line(x1, y1, x2, y2)
+            draw_line(x2, y2, x0, y0)
+        end
+    end
+
+    class Turtle
+        def initialize(canvas)
+            @canvas = canvas
+            @x = canvas.width / 2.0
+            @y = canvas.height / 2.0
+            @phi = 270.0
+            @pen_down = true
+        end
+
+        attr_accessor :x, :y, :phi, :color, :pen_down
+
+        def forward(l)
+            nx = @x + Math.cos(@phi * Math::PI / 180.0) * l
+            ny = @y + Math.sin(@phi * Math::PI / 180.0) * l
+            @canvas.draw_line(@x, @y, nx, ny) if @pen_down
+            @x = nx
+            @y = ny
+        end
+
+        def set_color(r = 0, g = nil, b = nil)
+            @canvas.set_color(r, g, b)
+        end
+
+        def turn_left(phi)
+            @phi -= phi
+        end
+
+        def turn_right(phi)
+            @phi += phi
         end
     end
 end

data/test-anaglyph.rb

@@ -0,0 +1,15 @@
+require './lib/pixelflow_canvas.rb'
+
+width = 256
+height = 256
+
+canvas = Pixelflow::Canvas.new(width, height, :rgb)
+canvas.set_compose_mode(:add)
+
+canvas.set_color(255, 0, 0)
+canvas.draw_line(10, 10, 100, 200)
+
+canvas.set_color(0, 255, 0)
+canvas.draw_line(20, 10, 90, 200)
+
+canvas.save_as_png('anaglyph.png')

data/test-draw.rb

@@ -0,0 +1,26 @@
+require './lib/pixelflow_canvas.rb'
+
+width = 256
+height = 256
+
+canvas = Pixelflow::Canvas.new(width, height, :palette)
+canvas.set_interpolation_mode(:bilinear)
+turtle = Pixelflow::Turtle.new(canvas)
+turtle.set_color(13)
+
+def draw(canvas, x0, y0, x1, y1, x2, y2, level)
+    canvas.draw_triangle(x0, y0, x1, y1, x2, y2)
+    mx0 = (x0 + x1) / 2
+    my0 = (y0 + y1) / 2
+    mx1 = (x1 + x2) / 2
+    my1 = (y1 + y2) / 2
+    mx2 = (x2 + x0) / 2
+    my2 = (y2 + y0) / 2
+    if level > 0
+        draw(canvas, x0, y0, mx0, my0, mx2, my2, level - 1)
+        draw(canvas, x1, y1, mx1, my1, mx0, my0, level - 1)
+        draw(canvas, x2, y2, mx2, my2, mx1, my1, level - 1)
+    end
+end
+
+draw(canvas, 128, 10, 10, 186, 246, 246, 5)

data/test-sirds.rb

@@ -0,0 +1,37 @@
+require './lib/pixelflow_canvas.rb'
+
+def depth(x, y)
+    r = (x - 128) ** 2 + (y - 128) ** 2
+    return 10 if r < 5000
+    r * 0.001
+end
+
+width = 256
+height = 256
+
+canvas = Pixelflow::Canvas.new(width, height, :palette)
+(0...64).each { |i| canvas.set_palette(i, i * 4, i * 4, i * 4) }
+(0...height).each do |y|
+    (0...48).each do |x|
+        canvas.set_pixel(x, y, rand(64))
+    end
+end
+(0...height).each do |y|
+    sx = 0
+    dx = 48
+    while dx < width
+        c = canvas.get_pixel(sx, y)
+        canvas.set_pixel(dx, y, c)
+        dx += 1
+        sx = dx - 48 + depth(dx - 24, y)
+    end
+end
+
+# (0...height).each do |y|
+#     (0...width).each do |x|
+#         d = depth(x, y)
+#         canvas.set_pixel(x, y, d)
+#     end
+# end
+
+canvas.save_as_png('sirds.png')

data/test-turtle.rb

@@ -0,0 +1,14 @@
+require './lib/pixelflow_canvas.rb'
+
+width = 256
+height = 256
+
+canvas = Pixelflow::Canvas.new(width, height, :palette)
+turtle = Pixelflow::Turtle.new(canvas)
+turtle.set_color(13)
+
+turtle.forward(10)
+turtle.turn_right(90)
+turtle.forward(10)
+turtle.turn_right(90)
+turtle.forward(10)

data/test.rb

@@ -0,0 +1,36 @@
+require './lib/pixelflow_canvas.rb'
+
+def depth(x, y)
+    r = (x - 128) ** 2 + (y - 128) ** 2
+    return 10 if r < 5000
+    r * 0.001
+end
+
+width = 256
+height = 256
+
+canvas = Pixelflow::Canvas.new(width, height, :palette)
+(0...64).each { |i| canvas.set_palette(i, i, i, i) }
+(0...height).each do |y|
+    (0...48).each do |x|
+        canvas.set_pixel(x, y, rand(64))
+    end
+end
+(0...height).each do |y|
+    sx = 0
+    dx = 48
+    while dx < width
+        c = canvas.get_pixel(sx, y)
+        canvas.set_pixel(dx, y, c)
+        dx += 1
+        sx = dx - 48 + depth(dx - 24, y)
+    end
+end
+
+# (0...height).each do |y|
+#     (0...width).each do |x|
+#         d = depth(x, y)
+#         canvas.set_pixel(x, y, d)
+#     end
+# end
+

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: pixelflow_canvas
 version: !ruby/object:Gem::Version
-  version: 0.4.1
+  version: 0.4.3
 platform: ruby
 authors:
 - Michael Specht
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-10-24 00:00:00.000000000 Z
-dependencies: []
+date: 2024-10-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: chunky_png
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.4.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.4.0
 description: Use a virtual CRT for old school graphics programming, in VS Code, from
   Ruby.
 email:
@@ -23,7 +37,13 @@ files:
 - Rakefile
 - lib/pixelflow_canvas.rb
 - lib/pixelflow_canvas/version.rb
+- lib/pixelflow_canvas/vga_palette.rb
 - sig/pixelflow_canvas.rbs
+- test-anaglyph.rb
+- test-draw.rb
+- test-sirds.rb
+- test-turtle.rb
+- test.rb
 homepage: https://github.com/specht/pixelflow_canvas_ruby
 licenses:
 - GPL-3.0-only