teek 0.1.0 → 0.1.2

data/sample/paint/sparse_pixel_buffer.rb

@@ -0,0 +1,202 @@
+# frozen_string_literal: true
+
+# Sparse storage for pixel data - only stores non-default pixels.
+# Memory efficient for layers with limited drawing.
+#
+# Stores pixels as 4-byte binary strings to avoid pack/unpack overhead
+# when interfacing with TkPhotoImage#put_block.
+#
+class SparsePixelBuffer
+  # Default: fully transparent
+  DEFAULT_PIXEL = "\x00\x00\x00\x00".b.freeze
+  PIXEL_SIZE = 4
+
+  attr_reader :width, :height, :default_pixel
+
+  def initialize(width, height, default: DEFAULT_PIXEL)
+    @width = width
+    @height = height
+    @default_pixel = default.frozen? ? default : default.dup.freeze
+    @pixels = {}  # {linear_index => 4-byte binary string}
+    @bbox = nil   # [min_x, min_y, max_x, max_y] or nil if empty
+  end
+
+  def get_pixel(x, y)
+    return nil if out_of_bounds?(x, y)
+    @pixels[y * @width + x] || @default_pixel
+  end
+
+  def set_pixel(x, y, rgba_bytes)
+    return if out_of_bounds?(x, y)
+
+    key = y * @width + x
+
+    if rgba_bytes == @default_pixel
+      @pixels.delete(key)
+      recalculate_bbox if @pixels.empty? || bbox_edge?(x, y)
+    else
+      @pixels[key] = rgba_bytes.frozen? ? rgba_bytes : rgba_bytes.dup
+      expand_bbox(x, y)
+    end
+  end
+
+  # Set pixel from RGBA integers (convenience method)
+  def set_rgba(x, y, r, g, b, a = 255)
+    set_pixel(x, y, [r, g, b, a].pack('CCCC'))
+  end
+
+  # Get pixel as RGBA integers (convenience method)
+  def get_rgba(x, y)
+    pixel = get_pixel(x, y)
+    pixel&.unpack('CCCC')
+  end
+
+  def empty?
+    @pixels.empty?
+  end
+
+  def pixel_count
+    @pixels.size
+  end
+
+  def bbox
+    @bbox&.dup
+  end
+
+  # Returns [x, y, width, height] for the bounding box
+  def bbox_xywh
+    return nil unless @bbox
+    [@bbox[0], @bbox[1], @bbox[2] - @bbox[0] + 1, @bbox[3] - @bbox[1] + 1]
+  end
+
+  # Materialize a region to a contiguous RGBA buffer for put_block
+  def materialize(x: 0, y: 0, width: @width, height: @height)
+    # Clamp to valid region
+    x = x.clamp(0, @width - 1)
+    y = y.clamp(0, @height - 1)
+    width = [width, @width - x].min
+    height = [height, @height - y].min
+
+    # Allocate buffer filled with default pixel
+    buffer = (@default_pixel * (width * height)).dup
+
+    # Patch in non-default pixels
+    @pixels.each do |key, rgba|
+      px = key % @width
+      py = key / @width
+
+      # Skip if outside requested region
+      next unless px >= x && px < x + width && py >= y && py < y + height
+
+      # Calculate offset in output buffer
+      offset = ((py - y) * width + (px - x)) * PIXEL_SIZE
+      buffer[offset, PIXEL_SIZE] = rgba
+    end
+
+    buffer
+  end
+
+  # Materialize only the bounding box (returns nil if empty)
+  def materialize_bbox
+    return nil if empty? || @bbox.nil?
+    bx, by, bw, bh = bbox_xywh
+    materialize(x: bx, y: by, width: bw, height: bh)
+  end
+
+  # Resize the buffer, preserving pixels that fit within new bounds
+  def resize(new_width, new_height)
+    return if new_width == @width && new_height == @height
+
+    new_pixels = {}
+    @pixels.each do |key, rgba|
+      x = key % @width
+      y = key / @width
+      next if x >= new_width || y >= new_height
+      new_pixels[y * new_width + x] = rgba
+    end
+
+    @width = new_width
+    @height = new_height
+    @pixels = new_pixels
+    recalculate_bbox
+  end
+
+  # Clear all pixels
+  def clear
+    @pixels.clear
+    @bbox = nil
+  end
+
+  # Create a full copy
+  def dup
+    copy = SparsePixelBuffer.new(@width, @height, default: @default_pixel)
+    copy.instance_variable_set(:@pixels, @pixels.dup)
+    copy.instance_variable_set(:@bbox, @bbox&.dup)
+    copy
+  end
+
+  # Memory usage estimate in bytes
+  def memory_usage
+    # Hash overhead (~40 bytes) + per-entry (~50 bytes: key + value + hash bucket)
+    40 + (@pixels.size * 50)
+  end
+
+  # Density as fraction of total pixels
+  def density
+    @pixels.size.to_f / (@width * @height)
+  end
+
+  # Iterate over non-default pixels
+  def each_pixel
+    return enum_for(:each_pixel) unless block_given?
+
+    @pixels.each do |key, rgba|
+      x = key % @width
+      y = key / @width
+      yield x, y, rgba
+    end
+  end
+
+  private
+
+  def out_of_bounds?(x, y)
+    x < 0 || x >= @width || y < 0 || y >= @height
+  end
+
+  def expand_bbox(x, y)
+    if @bbox.nil?
+      @bbox = [x, y, x, y]
+    else
+      @bbox[0] = x if x < @bbox[0]
+      @bbox[1] = y if y < @bbox[1]
+      @bbox[2] = x if x > @bbox[2]
+      @bbox[3] = y if y > @bbox[3]
+    end
+  end
+
+  def bbox_edge?(x, y)
+    return false unless @bbox
+    x == @bbox[0] || x == @bbox[2] || y == @bbox[1] || y == @bbox[3]
+  end
+
+  def recalculate_bbox
+    if @pixels.empty?
+      @bbox = nil
+      return
+    end
+
+    min_x = min_y = Float::INFINITY
+    max_x = max_y = -Float::INFINITY
+
+    @pixels.each_key do |key|
+      x = key % @width
+      y = key / @width
+      min_x = x if x < min_x
+      max_x = x if x > max_x
+      min_y = y if y < min_y
+      max_y = y if y > max_y
+    end
+
+    @bbox = [min_x, min_y, max_x, max_y]
+  end
+end

data/sample/sdl2_demo.rb

@@ -0,0 +1,318 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+# teek-record: title=SDL2 Demo
+
+# SDL2 Demo - GPU-accelerated rendering embedded in a Tk frame
+#
+# Demonstrates:
+# - Teek::SDL2::Viewport with animated rectangles
+# - SDL2_image: loading a PNG sprite (ruby gem)
+# - SDL2_ttf: text rendering
+# - Keyboard/mouse input via Tk event bindings
+# - Separate Tk event log window proving bidirectional event flow
+#
+# Ruby gem image: CC0 from https://purepng.com/photo/27996/clipart-ruby-gem
+#
+# Run: ruby -Ilib -Iteek-sdl2/lib sample/sdl2_demo.rb
+
+$LOAD_PATH.unshift File.expand_path('../lib', __dir__)
+$LOAD_PATH.unshift File.expand_path('../teek-sdl2/lib', __dir__)
+require 'teek'
+require 'teek/sdl2'
+
+FONT_PATH = File.join(__dir__, '..', 'teek-sdl2', 'assets', 'JetBrainsMonoNL-Regular.ttf')
+RUBY_GEM_PATH = File.join(__dir__, '..', 'teek-sdl2', 'assets', 'ruby_gem_64.png')
+
+class SDL2Demo
+  attr_reader :app
+
+  COLORS = [
+    [255, 60, 60],    # red
+    [60, 200, 60],    # green
+    [60, 100, 255],   # blue
+    [255, 200, 40],   # yellow
+    [200, 60, 255],   # purple
+  ].freeze
+
+  MAX_KEYSTROKES = 8
+  MAX_PARTICLES = 60
+
+  def initialize
+    @app = Teek::App.new
+    @app.show
+    @app.set_window_title('SDL2 Demo')
+    @app.set_window_geometry('640x520')
+
+    @title = 'SDL2 Demo'
+
+    # SDL2 viewport
+    @viewport = Teek::SDL2::Viewport.new(@app, width: 640, height: 480)
+    @viewport.pack(fill: :both, expand: true)
+
+    # Load font for text rendering
+    @font = @viewport.renderer.load_font(FONT_PATH, 18)
+    @font_small = @viewport.renderer.load_font(FONT_PATH, 12)
+
+    # Load ruby gem sprite via SDL2_image
+    @gem_tex = @viewport.renderer.load_image(RUBY_GEM_PATH)
+
+    # Bouncing boxes (last one is the gem sprite)
+    @boxes = COLORS.each_with_index.map do |color, i|
+      {
+        x: 40 + i * 100, y: 40 + i * 60,
+        w: 60, h: 40,
+        dx: 2 + i, dy: 1 + i,
+        r: color[0], g: color[1], b: color[2]
+      }
+    end
+    @boxes << {
+      x: 300, y: 200,
+      w: @gem_tex.width, h: @gem_tex.height,
+      dx: 3, dy: 2,
+      sprite: @gem_tex
+    }
+
+    # Input state
+    @recent_keys = []     # [{text:, age:}, ...]
+    @particles = []       # [{x:, y:, dx:, dy:, age:, r:, g:, b:}, ...]
+    @has_focus = false
+
+    # Wire up input
+    setup_input
+    setup_event_log
+
+    @frame_count = 0
+    @fps_frames = 0
+    @fps_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    @fps_text = '-- fps'
+    @running = true
+  end
+
+  def setup_input
+    # Key events (viewport tracks state internally, we also show them)
+    @viewport.bind('KeyPress', :keysym) do |k|
+      @recent_keys.unshift({ text: k, age: 0 })
+      @recent_keys.pop if @recent_keys.size > MAX_KEYSTROKES
+      log_event("KEY DOWN: #{k}")
+    end
+
+    @viewport.bind('KeyRelease', :keysym) do |k|
+      log_event("KEY UP:   #{k}")
+    end
+
+    # Mouse particles
+    @viewport.bind('Motion', :x, :y) do |x, y|
+      spawn_particle(x.to_i, y.to_i)
+      log_event("MOUSE:    #{x},#{y}")
+    end
+
+    @viewport.bind('ButtonPress-1', :x, :y) do |x, y|
+      5.times { spawn_particle(x.to_i, y.to_i) }
+      log_event("CLICK:    #{x},#{y}")
+    end
+
+    # Focus tracking
+    @viewport.bind('FocusIn') { @has_focus = true }
+    @viewport.bind('FocusOut') { @has_focus = false }
+  end
+
+  def setup_event_log
+    @log_path = '.evlog'
+    @app.command(:toplevel, @log_path)
+    @app.command(:wm, :title, @log_path, 'Event Log')
+    @app.command(:wm, :geometry, @log_path, '300x400+660+0')
+
+    @log_text = @app.create_widget(:text, @log_path + '.log',
+      width: 40, height: 25, font: '{TkFixedFont} 10',
+      state: :disabled, background: '#1e1e1e', foreground: '#cccccc')
+    @log_text.pack(fill: :both, expand: true)
+
+    @app.command(:wm, :protocol, @log_path, 'WM_DELETE_WINDOW',
+                 proc { @app.command(:wm, :withdraw, @log_path) })
+  end
+
+  def log_event(msg)
+    @app.command(@log_text, :configure, state: :normal)
+    @app.command(@log_text, :insert, 'end', msg + "\n")
+    @app.command(@log_text, :see, 'end')
+    @app.command(@log_text, :configure, state: :disabled)
+
+    # Keep last 200 lines
+    count = @app.command(@log_text, :count, '-lines', '1.0', 'end').to_i
+    if count > 200
+      @app.command(@log_text, :configure, state: :normal)
+      @app.command(@log_text, :delete, '1.0', "#{count - 200}.0")
+      @app.command(@log_text, :configure, state: :disabled)
+    end
+  end
+
+  def spawn_particle(x, y)
+    angle = rand * 2 * Math::PI
+    speed = 1 + rand * 3
+    color = COLORS.sample
+    @particles << {
+      x: x.to_f, y: y.to_f,
+      dx: Math.cos(angle) * speed, dy: Math.sin(angle) * speed,
+      age: 0, r: color[0], g: color[1], b: color[2]
+    }
+    @particles.shift if @particles.size > MAX_PARTICLES
+  end
+
+  def tick
+    return unless @running
+
+    w, h = @viewport.renderer.output_size
+
+    # Move boxes
+    @boxes.each do |box|
+      box[:x] += box[:dx]
+      box[:y] += box[:dy]
+
+      if box[:x] <= 0 || box[:x] + box[:w] >= w
+        box[:dx] = -box[:dx]
+        box[:x] = box[:x].clamp(0, w - box[:w])
+      end
+      if box[:y] <= 0 || box[:y] + box[:h] >= h
+        box[:dy] = -box[:dy]
+        box[:y] = box[:y].clamp(0, h - box[:h])
+      end
+    end
+
+    # Age particles
+    @particles.each { |p| p[:age] += 1; p[:x] += p[:dx]; p[:y] += p[:dy] }
+    @particles.reject! { |p| p[:age] > 30 }
+
+    # Age keystrokes
+    @recent_keys.each { |k| k[:age] += 1 }
+    @recent_keys.reject! { |k| k[:age] > 120 }
+
+    # Draw
+    @viewport.render do |r|
+      r.clear(20, 20, 30)
+
+      # Bouncing boxes (+ gem sprite)
+      @boxes.each do |box|
+        if box[:sprite]
+          r.copy(box[:sprite], nil, [box[:x], box[:y], box[:w], box[:h]])
+        else
+          r.fill_rect(box[:x], box[:y], box[:w], box[:h],
+                       box[:r], box[:g], box[:b])
+        end
+      end
+
+      # Particles
+      @particles.each do |p|
+        alpha = ((1.0 - p[:age] / 30.0) * 255).to_i
+        size = [4 - p[:age] / 10, 1].max
+        r.fill_rect(p[:x].to_i, p[:y].to_i, size, size,
+                     p[:r], p[:g], p[:b], alpha)
+      end
+
+      # Keystrokes in bottom-right
+      @recent_keys.each_with_index do |k, i|
+        alpha = ((1.0 - k[:age] / 120.0) * 255).to_i
+        r.draw_text(w - 150, h - 30 - i * 22, k[:text],
+                     font: @font, r: 255, g: 255, b: 255, a: alpha)
+      end
+
+      # FPS top-left
+      r.draw_text(8, 8, @fps_text, font: @font_small, r: 180, g: 180, b: 180)
+
+      # Focus hint
+      unless @has_focus
+        r.draw_text(w / 2 - 60, h / 2, "click to focus",
+                     font: @font_small, r: 100, g: 100, b: 100)
+      end
+    end
+
+    @frame_count += 1
+    @fps_frames += 1
+    now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    elapsed = now - @fps_time
+    if elapsed >= 0.5
+      @fps_text = "#{(@fps_frames / elapsed).round(1)} fps"
+      @fps_frames = 0
+      @fps_time = now
+    end
+  end
+
+  def animate(interval: 16, &on_done)
+    tick
+    if @running
+      @app.after(interval) { animate(interval: interval, &on_done) }
+    else
+      on_done&.call
+    end
+  end
+
+  def stop
+    @running = false
+  end
+
+  def run
+    animate
+    @app.mainloop
+  end
+end
+
+demo = SDL2Demo.new
+
+# Automated demo support (testing and recording)
+require_relative '../lib/teek/demo_support'
+TeekDemo.app = demo.app
+
+if TeekDemo.recording?
+  demo.app.set_window_geometry('+0+0')
+  demo.app.tcl_eval('. configure -cursor none')
+  TeekDemo.signal_recording_ready
+end
+
+if TeekDemo.active?
+  vp = demo.instance_variable_get(:@viewport)
+  fp = vp.frame.path
+
+  TeekDemo.after_idle do
+    d = TeekDemo.method(:delay)
+    app = demo.app
+    gen = proc { |ev, **opts|
+      args = opts.map { |k, v| "-#{k} #{v}" }.join(' ')
+      app.tcl_eval("event generate #{fp} <#{ev}> #{args}")
+    }
+
+    demo.animate
+
+    # Give focus (-force needed on X11/xvfb for event generate to deliver key events)
+    app.after(d.call(test: 1, record: 300)) { app.tcl_eval("focus -force #{fp}") }
+
+    # Click around to show particles
+    clicks = [[200, 150], [400, 300], [100, 350], [500, 200], [300, 100]]
+    clicks.each_with_index do |(x, y), i|
+      t = d.call(test: 1, record: 600) * (i + 1) + d.call(test: 1, record: 500)
+      app.after(t) {
+        gen.call('ButtonPress-1', x: x, y: y)
+        app.after(50) { gen.call('ButtonRelease-1', x: x, y: y) }
+      }
+    end
+
+    # Type some keys (overlaps with clicks)
+    keys = %w[H e l l o space S D L 2]
+    base = d.call(test: 1, record: 2000)
+    keys.each_with_index do |k, i|
+      t = base + d.call(test: 1, record: 150) * (i + 1)
+      app.after(t) {
+        gen.call('KeyPress', keysym: k)
+        app.after(80) { gen.call('KeyRelease', keysym: k) }
+      }
+    end
+
+    # Finish after ~5s recording / immediately in test
+    app.after(d.call(test: 50, record: 5000)) {
+      demo.stop
+      TeekDemo.finish
+    }
+  end
+else
+  demo.animate
+end
+
+demo.app.mainloop