pixelflow_canvas 0.4.1 → 0.4.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4824696c6996cc136b56dd83a716fa12a273e0682744473b67f0ffb7693b7335
-  data.tar.gz: 612927ef865f29432b41adbaa11b0d4b6e824a9af15cd75413c7e5c7fa0c84b1
+  metadata.gz: 5ca8e55731e1b45c39343e18a6f7d2c5726d4a856824ff826aca5dc502c2a0d4
+  data.tar.gz: 5ad774dabd0ad2de3b32f180e000eb6bc42ed10f28b974cd1466bcf3451f0fb2
 SHA512:
-  metadata.gz: ed40b86854a8779791ca67eb41d0b881ea76e917e72305e391f693cdbfaa6157f2e34402038c300f30b1b7d67414c4722ba3808caf5abd50ea76149fe3915016
-  data.tar.gz: e0311899a97ba6959dc457f1dbb1397c8495a730e99c813e5b5809875e9127344410856d4bfc3e2afed6b504492693aeffedf62b4f1937702edc6a49f4d11af7
+  metadata.gz: c4e30f5c0a236957f8fa13b69f9d479e22eb51febe7f6c1969eb93024cef0179506618ef876742312783f4c7e52d7ad927302ad66f6381374f7b80ae1f326a16
+  data.tar.gz: 6c7b2ba6efe13bc6b0ef3cd9327025b092b3d14997d33b32dba6eaff9cb3864879690b108280d98e647a02a44c7edbea402c39ecb0af955759adcd04c40b367f

data/lib/pixelflow_canvas/version.rb

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

data/lib/pixelflow_canvas.rb

@@ -18,14 +18,27 @@ 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
+            @compose_mode = :over
             @palette = [0] * 768
             @socket = TCPSocket.new('127.0.0.1', 19223)
             set_size(width, height)
@@ -33,21 +46,7 @@ module Pixelflow
             @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,6 +58,10 @@ 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}"
@@ -69,15 +72,7 @@ module Pixelflow
             @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 +81,64 @@ 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 set_color(r, g = 0, b = 0)
+            @r = r
+            @g = g
+            @b = b
+        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 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 +149,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 +163,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 +214,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 +254,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 +268,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 +290,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 +311,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 +323,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 +359,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 +374,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 +400,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 +415,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 +424,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 +440,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,13 @@
+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)

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,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
+

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,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pixelflow_canvas
 version: !ruby/object:Gem::Version
-  version: 0.4.1
+  version: 0.4.2
 platform: ruby
 authors:
 - Michael Specht
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-10-24 00:00:00.000000000 Z
+date: 2024-10-27 00:00:00.000000000 Z
 dependencies: []
 description: Use a virtual CRT for old school graphics programming, in VS Code, from
   Ruby.
@@ -24,6 +24,11 @@ files:
 - lib/pixelflow_canvas.rb
 - lib/pixelflow_canvas/version.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