pixelflow_canvas 0.3.0 → 0.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 16988e8bddedf30d6888b7b10cf043c083bc160a4eb6de56e464a2305f4455d3
-  data.tar.gz: 3b5d6c3ce3fb0cd5ac830e2fd176f8ea79b4c02bc9326e14680f5efc19c370c6
+  metadata.gz: 4824696c6996cc136b56dd83a716fa12a273e0682744473b67f0ffb7693b7335
+  data.tar.gz: 612927ef865f29432b41adbaa11b0d4b6e824a9af15cd75413c7e5c7fa0c84b1
 SHA512:
-  metadata.gz: 5440dd62074ba1dbf5f0cb31262448b8bd7e1a2c666717f82af3d7ddcfea8eb25537505f76ae3cb3252984799f3bef87142ced690500d41fbd3e36b54ac5369a
-  data.tar.gz: d5b667dcf19fe88d8a8279f7a4ef9bd4d9411cff7b9b0eff85537c387e3bde622d2e586ce2e73dd10627ca6d40866c6e19f28c537a691a7d60434b682771f087
+  metadata.gz: ed40b86854a8779791ca67eb41d0b881ea76e917e72305e391f693cdbfaa6157f2e34402038c300f30b1b7d67414c4722ba3808caf5abd50ea76149fe3915016
+  data.tar.gz: e0311899a97ba6959dc457f1dbb1397c8495a730e99c813e5b5809875e9127344410856d4bfc3e2afed6b504492693aeffedf62b4f1937702edc6a49f4d11af7

data/lib/pixelflow_canvas/version.rb

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

data/lib/pixelflow_canvas.rb

@@ -2,6 +2,7 @@
 
 require_relative "pixelflow_canvas/version"
 require 'socket'
+require 'time'
 
 module Pixelflow
     class Canvas
@@ -29,6 +30,11 @@ module Pixelflow
             @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()
@@ -81,17 +87,25 @@ module Pixelflow
         end
 
         def move_to(x, y)
+            x0 = x0.to_i
+            y0 = y0.to_i
+            x1 = x1.to_i
+            y1 = y1.to_i
             return if x < 0 || x >= @width || y < 0 || y >= @height
             @x = x
             @y = y
             buffer = [5].pack('C')
-            buffer += [x].pack((@width < 256) ? 'C' : 'n')
-            buffer += [y].pack((@height < 256) ? 'C' : 'n')
+            buffer += [x].pack((@width <= 256) ? 'C' : 'n')
+            buffer += [y].pack((@height <= 256) ? 'C' : 'n')
             @socket.write(buffer)
             @socket.flush
         end
 
         def set_pixel(x, y, r, g = 0, b = 0)
+            x0 = x0.to_i
+            y0 = y0.to_i
+            x1 = x1.to_i
+            y1 = y1.to_i
             return if x < 0 || x >= @width || y < 0 || y >= @height
             unless x == @x && y == @y
                 move_to(x, y)
@@ -129,6 +143,10 @@ module Pixelflow
         end
 
         def get_pixel(x, y)
+            x0 = x0.to_i
+            y0 = y0.to_i
+            x1 = x1.to_i
+            y1 = y1.to_i
             return 0 if x < 0 || x >= @width || y < 0 || y >= @height
             if @color_mode == :rgb
                 return @screen[(y * @width + x) * 3, 3]
@@ -144,5 +162,252 @@ module Pixelflow
                 @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)
+            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)
+            end
+            (x0..x1).each do |x|
+                set_pixel(x, y1, color)
+            end
+            (y0+1..y1-1).each do |y|
+                set_pixel(x0, y, color)
+                set_pixel(x1, y, color)
+            end
+        end
+
+        def fill_rect(x0, y0, x1, y1, color)
+            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)
+                end
+            end
+        end
+
+        def draw_line(x0, y0, x1, y1, color)
+            x0 = x0.to_i
+            y0 = y0.to_i
+            x1 = x1.to_i
+            y1 = y1.to_i
+            dx = (x1 - x0).abs
+            dy = (y1 - y0).abs
+            sx = x0 < x1 ? 1 : -1
+            sy = y0 < y1 ? 1 : -1
+            err = dx - dy
+            loop do
+                set_pixel(x0, y0, color)
+                break if x0 == x1 && y0 == y1
+                e2 = 2 * err
+                if e2 > -dy
+                    err -= dy
+                    x0 += sx
+                end
+                if e2 < dx
+                    err += dx
+                    y0 += sy
+                end
+            end
+        end
+
+        def draw_circle(x, y, radius, color)
+            x = x.to_i
+            y = y.to_i
+            radius = radius.to_i
+            f = 1 - radius
+            ddF_x = 1
+            ddF_y = -2 * radius
+            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)
+            while xx < yy
+                if f >= 0
+                    yy -= 1
+                    ddF_y += 2
+                    f += ddF_y
+                end
+                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)
+            end
+        end
+
+        def fill_circle(x, y, r, color)
+            x = x.to_i
+            y = y.to_i
+            r = r.to_i
+            f = 1 - r
+            ddF_x = 1
+            ddF_y = -2 * r
+            xx = 0
+            yy = r
+            (y - r..y + r).each do |i|
+                set_pixel(x, i, color)
+            end
+            while xx < yy
+                if f >= 0
+                    yy -= 1
+                    ddF_y += 2
+                    f += ddF_y
+                end
+                xx += 1
+                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)
+                end
+                (y - xx..y + xx).each do |i|
+                    set_pixel(x + yy, i, color)
+                    set_pixel(x - yy, i, color)
+                end
+            end
+        end
+
+        def draw_ellipse(x, y, a, b, color)
+            x = x.to_i
+            y = y.to_i
+            a = a.to_i
+            b = b.to_i
+            a2 = a * a
+            b2 = b * b
+            fa2 = 4 * a2
+            fb2 = 4 * b2
+            x0 = 0
+            y0 = b
+            sigma = 2 * b2 + a2 * (1 - 2 * b)
+            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)
+                if sigma >= 0
+                    sigma += fa2 * (1 - y0)
+                    y0 -= 1
+                end
+                sigma += b2 * ((4 * x0) + 6)
+                x0 += 1
+            end
+            x0 = a
+            y0 = 0
+            sigma = 2 * a2 + b2 * (1 - 2 * a)
+            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)
+                if sigma >= 0
+                    sigma += fb2 * (1 - x0)
+                    x0 -= 1
+                end
+                sigma += a2 * ((4 * y0) + 6)
+                y0 += 1
+            end
+        end
+
+        def fill_ellipse(x, y, a, b, color)
+            x = x.to_i
+            y = y.to_i
+            a = a.to_i
+            b = b.to_i
+            a2 = a * a
+            b2 = b * b
+            fa2 = 4 * a2
+            fb2 = 4 * b2
+            x0 = 0
+            y0 = b
+            sigma = 2 * b2 + a2 * (1 - 2 * b)
+            while b2 * x0 <= a2 * y0
+                (x - x0..x + x0).each do |i|
+                    set_pixel(i, y + y0, color)
+                    set_pixel(i, y - y0, color)
+                end
+                if sigma >= 0
+                    sigma += fa2 * (1 - y0)
+                    y0 -= 1
+                end
+                sigma += b2 * ((4 * x0) + 6)
+                x0 += 1
+            end
+            x0 = a
+            y0 = 0
+            sigma = 2 * a2 + b2 * (1 - 2 * a)
+            while a2 * y0 <= b2 * x0
+                (x - x0..x + x0).each do |i|
+                    set_pixel(i, y + y0, color)
+                    set_pixel(i, y - y0, color)
+                end
+                if sigma >= 0
+                    sigma += fb2 * (1 - x0)
+                    x0 -= 1
+                end
+                sigma += a2 * ((4 * y0) + 6)
+                y0 += 1
+            end
+        end
+
+        def draw_quadratic_bezier(x0, y0, x1, y1, x2, y2, color, steps = 100)
+            steps = steps.to_i
+            xp = nil
+            yp = nil
+            (0..steps).each do |i|
+                t = i.to_f / steps
+                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)
+                end
+                xp = x
+                yp = y
+            end
+        end
+
+        def draw_cubic_bezier(x0, y0, x1, y1, x2, y2, x3, y3, color, steps = 100)
+            steps = steps.to_i
+            xp = nil
+            yp = nil
+            (0..steps).each do |i|
+                t = i.to_f / steps
+                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)
+                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)
+        end
     end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pixelflow_canvas
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.1
 platform: ruby
 authors:
 - Michael Specht
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-10-23 00:00:00.000000000 Z
+date: 2024-10-24 00:00:00.000000000 Z
 dependencies: []
 description: Use a virtual CRT for old school graphics programming, in VS Code, from
   Ruby.