reight 0.1.2

data/lib/reight/app/sprite/editor.rb

@@ -0,0 +1,272 @@
+using Reight
+
+
+class Reight::SpriteEditor < Reight::App
+
+  def canvas()
+    @canvas ||= Canvas.new(
+      self,
+      project.chips_image,
+      project.chips_image_path
+    ).tap do |canvas|
+      canvas. tool_changed {update_active_tool}
+      canvas.color_changed {update_active_color}
+    end
+  end
+
+  def activated()
+    super
+    history.disable do
+      colors[7].click
+      tools[1].click
+      chip_sizes[0].click
+      brush_sizes[0].click
+    end
+  end
+
+  def draw()
+    background 200
+    sprite(*sprites)
+    super
+  end
+
+  def key_pressed()
+    super
+    shift, ctrl, cmd = %i[shift control command].map {pressing? _1}
+    ch               = chips
+    case key_code
+    when LEFT  then ch.set_frame ch.x - ch.size, ch.y, ch.size, ch.size
+    when RIGHT then ch.set_frame ch.x + ch.size, ch.y, ch.size, ch.size
+    when UP    then ch.set_frame ch.x, ch.y - ch.size, ch.size, ch.size
+    when DOWN  then ch.set_frame ch.x, ch.y + ch.size, ch.size, ch.size
+    when :c    then copy  if ctrl || cmd
+    when :x    then cut   if ctrl || cmd
+    when :v    then paste if ctrl || cmd
+    when :z    then shift ? self.redo : undo if ctrl || cmd
+    when :s    then select.click
+    when :b    then  brush.click
+    when :l    then   line.click
+    when :f    then   fill.click
+    when :r    then (shift ? fill_rect    : stroke_rect   ).click
+    when :e    then (shift ? fill_ellipse : stroke_ellipse).click
+    end
+  end
+
+  def window_resized()
+    super
+    [colors, tools, chip_sizes, brush_sizes].flatten.map(&:sprite)
+      .each {|sp| sp.w = sp.h = BUTTON_SIZE}
+
+    chips.sprite.tap do |sp|
+      sp.x      = SPACE
+      sp.y      = NAVIGATOR_HEIGHT + SPACE
+      sp.w      = CHIPS_WIDTH
+      sp.bottom = height - SPACE
+    end
+    colors.map {_1.sprite}.each.with_index do |sp, index|
+      sp.x = chips.sprite.right + SPACE + sp.w * (index % 4)
+      sp.y = height - (SPACE + sp.h * (4 - index / 4))
+    end
+    tools.map {_1.sprite}.each.with_index do |sp, index|
+      line   = index < 3 ? 0 : 1
+      index -= 3 if line == 1
+      sp.x   = colors.last.sprite.right + SPACE + (sp.w + 1) * index
+      sp.y   = colors.first.sprite.y + (sp.h + 1) * line
+    end
+    canvas.sprite.tap do |sp|
+      sp.x      = chips.sprite.right + SPACE
+      sp.y      = chips.sprite.y
+      sp.bottom = colors.first.sprite.top - SPACE
+      sp.w      = sp.h
+    end
+    chip_sizes.map {_1.sprite}.each.with_index do |sp, index|
+      sp.x = canvas.sprite.right + SPACE + (sp.w + 1) * index
+      sp.y = canvas.sprite.y
+    end
+    brush_sizes.map {_1.sprite}.each.with_index do |sp, index|
+      sp.x = chip_sizes.first.sprite.x + (sp.w + 1) * index
+      sp.y = chip_sizes.last.sprite.bottom + SPACE
+    end
+    shapes.map {_1.sprite}.each.with_index do |sp, index|
+      sp.w = 30
+      sp.h = BUTTON_SIZE
+      sp.x = brush_sizes.first.sprite.x + (sp.w + 1) * index
+      sp.y = brush_sizes.last.sprite.bottom + SPACE
+    end
+    types.map {_1.sprite}.each.with_index do |sp, index|
+      sp.w = 50
+      sp.h = BUTTON_SIZE
+      sp.x = shapes.first.sprite.x + (sp.w + 1) * index
+      sp.y = shapes.last.sprite.bottom + SPACE
+    end
+  end
+
+  def undo(flash: true)
+    history.undo do |action|
+      case action
+      in [:frame, [x, y, w, h], _]   then chips.set_frame x, y, w, h
+      in [:capture, before, _, x, y] then canvas.apply_frame before, x, y
+      in [  :select, sel, _]         then sel ? canvas.select(*sel) : canvas.deselect
+      in [:deselect, sel]            then       canvas.select(*sel)
+      end
+      self.flash 'Undo!' if flash
+    end
+  end
+
+  def redo(flash: true)
+    history.redo do |action|
+      case action
+      in [:frame, _, [x, y, w, h]]  then chips.set_frame x, y, w, h
+      in [:capture, _, after, x, y] then canvas.apply_frame after, x, y
+      in [  :select, _, sel]        then canvas.select(*sel)
+      in [:deselect, _]             then canvas.deselect
+      end
+      self.flash 'Redo!' if flash
+    end
+  end
+
+  def cut(flash: true)
+    copy flash: false
+    image, x, y = @copy || return
+    canvas.begin_editing do
+      clear_canvas x, y, image.width, image.height
+    end
+    self.flash 'Cut!' if flash
+  end
+
+  def copy(flash: true)
+    sel   = canvas.selection || canvas.frame
+    image = canvas.capture_frame(sel) || return
+    x, y, = sel
+    @copy = [image, x - canvas.x, y - canvas.y]
+    self.flash 'Copy!' if flash
+  end
+
+  def paste(flash: true)
+    image, x, y = @copy || return
+    w, h        = image.width, image.height
+    history.group do
+      canvas.deselect
+      canvas.begin_editing do
+        canvas.paint do |g|
+          g.copy image, 0, 0, w, h, x, y, w, h
+        end
+      end
+      canvas.select canvas.x + x, canvas.y + y, w, h
+    end
+    self.flash 'Paste!' if flash
+  end
+
+  def can_cut?   = true
+  def can_copy?  = true
+  def can_paste? = @copy
+
+  def clear_canvas(x, y, w, h)
+    canvas.clear [x, y, w, h], color: colors.first.color
+  end
+
+  private
+
+  def sprites()
+    [canvas, chips, *chip_sizes, *colors, *tools, *brush_sizes, *shapes, *types]
+      .map(&:sprite) + super
+  end
+
+  def chips()
+    @chips ||= Chips.new self, project.chips_image do |x, y, w, h|
+      canvas.set_frame x, y, w, h
+      chip_changed x, y, w, h
+    end
+  end
+
+  def chip_sizes()
+    @chip_sizes ||= group(*[8, 16, 32].map {|size|
+      Reight::Button.new name: "#{size}x#{size}", label: size do
+        chips.set_frame chips.x, chips.y, size, size
+      end
+    })
+  end
+
+  def tools()
+    @tools ||= group(
+      select,
+      brush,
+      fill,
+      stroke_line,
+      stroke_rect,
+        fill_rect,
+      stroke_ellipse,
+        fill_ellipse
+    )
+  end
+
+  def select         = @select         ||= Select.new(self)                 {canvas.tool = _1}
+  def brush          = @brush          ||= Brush.new(self)                  {canvas.tool = _1}
+  def fill           = @fill           ||= Fill.new(self)                   {canvas.tool = _1}
+  def stroke_line    = @stroke_line    ||= Line.new(self)                   {canvas.tool = _1}
+  def stroke_rect    = @stroke_rect    ||= Shape.new(self, :rect,    false) {canvas.tool = _1}
+  def   fill_rect    =   @fill_rect    ||= Shape.new(self, :rect,    true)  {canvas.tool = _1}
+  def stroke_ellipse = @stroke_ellipse ||= Shape.new(self, :ellipse, false) {canvas.tool = _1}
+  def   fill_ellipse =   @fill_ellipse ||= Shape.new(self, :ellipse, true)  {canvas.tool = _1}
+
+  def brush_sizes()
+    @brush_sizes ||= group(*[1, 2, 3, 5, 10].map {|size|
+      Reight::Button.new name: "Button Size #{size}", label: size do
+        brush.size = size
+        flash "Brush Size #{size}"
+      end
+    })
+  end
+
+  def colors()
+    @colors ||= project.palette_colors.map {|color|
+      rgb = self.color(color)
+        .then {[red(_1), green(_1), blue(_1), alpha(_1)]}.map &:to_i
+      Color.new(rgb) {canvas.color = rgb}
+    }
+  end
+
+  def shapes()
+    @shapes ||= group(
+      Reight::Button.new(name: 'No Shape', label: 'None') {
+        project.chips.at(*canvas.frame).shape = nil
+      },
+      Reight::Button.new(name: 'Rect Shape', label: 'Rect') {
+        project.chips.at(*canvas.frame).shape = :rect
+      },
+      Reight::Button.new(name: 'Circle Shape', label: 'Circle') {
+        project.chips.at(*canvas.frame).shape = :circle
+      },
+    )
+  end
+
+  def types()
+    @types ||= group(
+      Reight::Button.new(name: 'Object', label: 'Object') {
+        project.chips.at(*canvas.frame).sensor = false
+      },
+      Reight::Button.new(name: 'Sensor', label: 'Sensor') {
+        project.chips.at(*canvas.frame).sensor = true
+      },
+    )
+  end
+
+  def chip_changed(x, y, w, h)
+    chip = project.chips.at x, y, w, h
+    shapes[[nil, :rect, :circle].index(chip.shape)].click
+    types[chip.sensor? ? 1 : 0].click
+  end
+
+  def update_active_tool()
+    tools.each do |tool|
+      tool.active = tool == canvas.tool
+    end
+  end
+
+  def update_active_color()
+    colors.each do |button|
+      button.active = button.color == canvas.color
+    end
+  end
+
+end# SpriteEditor

data/lib/reight/app/sprite/fill.rb

@@ -0,0 +1,45 @@
+using Reight
+
+
+class Reight::SpriteEditor::Fill < Reight::SpriteEditor::Tool
+
+  def initialize(app, &block)
+    super app, icon: app.icon(2, 2, 8), &block
+    set_help left: 'Fill', right: 'Pick Color'
+  end
+
+  def canvas_pressed(x, y, button)
+    return unless button == LEFT
+    x, y           = [x, y].map &:to_i
+    fx, fy, fw,    = canvas.frame
+    sx, sy, sw, sh = canvas.selection || canvas.frame
+    sx -= fx
+    sy -= fy
+    return unless (sx...(sx + sw)).include?(x) && (sy...(sy + sh)).include?(y)
+    canvas.begin_editing
+    count = 0
+    canvas.update_pixels do |pixels|
+      from = pixels[y * fw + x]
+      to   = color(*canvas.color)
+      rest = [[x, y]]
+      until rest.empty?
+        xx, yy = rest.shift
+        next if pixels[yy * fw + xx] == to
+        pixels[yy * fw + xx] = to
+        count += 1
+        _x, x_ = xx - 1, xx + 1
+        _y, y_ = yy - 1, yy + 1
+        rest << [_x, yy] if _x >= sx      && pixels[yy * fw + _x] == from
+        rest << [x_, yy] if x_ <  sx + sw && pixels[yy * fw + x_] == from
+        rest << [xx, _y] if _y >= sy      && pixels[_y * fw + xx] == from
+        rest << [xx, y_] if y_ <  sy + sh && pixels[y_ * fw + xx] == from
+      end
+    end
+    canvas.end_editing if count > 0
+  end
+
+  def canvas_clicked(x, y, button)
+    pick_color x, y if button == RIGHT
+  end
+
+end# Fill

data/lib/reight/app/sprite/line.rb

@@ -0,0 +1,37 @@
+using Reight
+
+
+class Reight::SpriteEditor::Line < Reight::SpriteEditor::Tool
+
+  def initialize(app, &block)
+    super app, icon: app.icon(3, 2, 8), &block
+    set_help left: name, right: 'Pick Color'
+  end
+
+  def draw_line(x, y)
+    canvas.begin_editing do
+      canvas.paint do |g|
+        g.stroke(*canvas.color)
+        g.stroke_weight 0
+        g.line @x, @y, x, y
+      end
+    end
+  end
+
+  def canvas_pressed(x, y, button)
+    return unless button == LEFT
+    @x, @y = x, y
+    draw_line x, y
+  end
+
+  def canvas_dragged(x, y, button)
+    return unless button == LEFT
+    app.undo flash: false
+    draw_line x, y
+  end
+
+  def canvas_clicked(x, y, button)
+    pick_color x, y if button == RIGHT
+  end
+
+end# Line

data/lib/reight/app/sprite/select.rb

@@ -0,0 +1,58 @@
+using Reight
+
+
+class Reight::SpriteEditor::Select < Reight::SpriteEditor::Tool
+
+  def initialize(app, &block)
+    super app, icon: app.icon(0, 2, 8), &block
+    set_help left: 'Select or Move'
+  end
+
+  def move_or_select(x, y)
+    x0, y0 = @press_pos&.to_a || return
+    if @moving
+      sx, sy, sw, sh = canvas.selection
+      dx, dy         = (x - x0).to_i, (y - y0).to_i
+      history.group do
+        canvas.begin_editing do
+          image = canvas.capture_frame [sx, sy, sw, sh]
+          app.clear_canvas sx, sy, sw, sh
+          canvas.apply_frame image, sx + dx, sy + dy
+          canvas.select sx + dx, sy + dy, sw, sh
+        end
+      end
+    else
+      canvas.select canvas.x + x0, canvas.y + y0, x - x0, y - y0
+    end
+  end
+
+  def canvas_pressed(x, y, button)
+    @press_pos = create_vector x, y
+    @moving    = button == LEFT && is_in_selection?(x, y)
+    move_or_select x, y
+  end
+
+  def canvas_released(x, y, button)
+    @press_pos = nil
+    @moving    = false
+  end
+
+  def canvas_dragged(x, y, button)
+    app.undo flash: false
+    move_or_select x, y
+  end
+
+  def canvas_clicked(x, y, button)
+    app.undo flash: false
+    canvas.deselect
+  end
+
+  private
+
+  def is_in_selection?(x, y)
+    return false unless sel = canvas.selection
+    sx, sy, sw, sh = sel
+    (sx..(sx + sw)).include?(canvas.x + x) && (sy..(sy + sh)).include?(canvas.y + y)
+  end
+
+end# Select

data/lib/reight/app/sprite/shape.rb

@@ -0,0 +1,43 @@
+using Reight
+
+
+class Reight::SpriteEditor::Shape < Reight::SpriteEditor::Tool
+
+  def initialize(app, shape, fill, &block)
+    @shape, @fill = shape, fill
+    icon_index = [:rect, :ellipse].product([false, true]).index([shape, fill])
+    super app, icon: app.icon(icon_index + 4, 2, 8), &block
+    set_help left: name, right: 'Pick Color'
+  end
+
+  def name = "#{@fill ? :Fill : :Stroke} #{@shape.capitalize}"
+
+  def draw_shape(x, y)
+    canvas.begin_editing do
+      canvas.paint do |g|
+        @fill ? g.fill(*canvas.color) : g.no_fill
+        g.stroke(*canvas.color)
+        g.rect_mode    CORNER
+        g.ellipse_mode CORNER
+        g.send @shape, @x, @y, x - @x, y - @y
+      end
+    end
+  end
+
+  def canvas_pressed(x, y, button)
+    return unless button == LEFT
+    @x, @y = x, y
+    draw_shape x, y
+  end
+
+  def canvas_dragged(x, y, button)
+    return unless button == LEFT
+    app.undo flash: false
+    draw_shape x, y
+  end
+
+  def canvas_clicked(x, y, button)
+    pick_color x, y if button == RIGHT
+  end
+
+end# Shape

data/lib/reight/app/sprite/tool.rb

@@ -0,0 +1,27 @@
+using Reight
+
+
+class Reight::SpriteEditor::Tool < Reight::Button
+
+  def initialize(app, *a, **k, &b)
+    super(*a, **k, &b)
+    @app = app
+  end
+
+  attr_reader :app
+
+  def canvas  = app.canvas
+
+  def history = app.history
+
+  def pick_color(x, y)
+    canvas.color = canvas.pixel_at x, y
+  end
+
+  def canvas_pressed( x, y, button) = nil
+  def canvas_released(x, y, button) = nil
+  def canvas_moved(   x, y)         = nil
+  def canvas_dragged( x, y, button) = nil
+  def canvas_clicked( x, y, button) = nil
+
+end# Tool

data/lib/reight/app/sprite.rb

@@ -0,0 +1,10 @@
+require 'reight/app/sprite/editor'
+require 'reight/app/sprite/canvas'
+require 'reight/app/sprite/chips'
+require 'reight/app/sprite/color'
+require 'reight/app/sprite/tool'
+require 'reight/app/sprite/select'
+require 'reight/app/sprite/brush'
+require 'reight/app/sprite/fill'
+require 'reight/app/sprite/line'
+require 'reight/app/sprite/shape'

data/lib/reight/app.rb

@@ -0,0 +1,123 @@
+using Reight
+
+
+class Reight::App
+
+  SCREEN_WIDTH     = 400
+  SCREEN_HEIGHT    = 224
+
+  SPACE            = 6
+  BUTTON_SIZE      = 12
+  NAVIGATOR_HEIGHT = BUTTON_SIZE + 2
+  CHIPS_WIDTH      = 128
+
+  def initialize(project)
+    @project = project
+  end
+
+  attr_reader :project
+
+  def flash(...)
+    navigator.flash(...) if history.enabled?
+  end
+
+  def group(*buttons)
+    buttons.each.with_index do |button, index|
+      button.clicked do
+        buttons.each.with_index {|b, i| b.active = i == index}
+      end
+    end
+    buttons
+  end
+
+  def pressing?(key)
+    pressing_keys.include? key
+  end
+
+  def name()
+    self.class.name
+  end
+
+  def history()
+    @history ||= Reight::History.new
+  end
+
+  def sprites()
+    navigator.sprites
+  end
+
+  def icon(xi, yi, size)
+    (@icon ||= {})[[xi, yi, size]] ||= createGraphics(size, size).tap do |g|
+      g.beginDraw do
+        g.copy r8.icons, xi * size, yi * size, size, size, 0, 0, size, size
+      end
+    end
+    # TODO: ||= r8.icons.sub_image xi * size, yi * size, size, size
+  end
+
+  def activated()
+    add_world world if world
+  end
+
+  def deactivated()
+    remove_world world if world
+  end
+
+  def draw()
+    navigator.draw
+  end
+
+  def key_pressed()
+    navigator.key_pressed
+    pressing_keys.add key_code
+  end
+
+  def key_released()
+    pressing_keys.delete key_code
+  end
+
+  def window_resized()
+    navigator.window_resized
+  end
+
+  def key_typed()      = nil
+  def mouse_pressed()  = nil
+  def mouse_released() = nil
+  def mouse_moved()    = nil
+  def mouse_dragged()  = nil
+  def mouse_clicked()  = nil
+  def double_clicked() = nil
+  def mouse_wheel()    = nil
+  def touch_started()  = nil
+  def touch_ended()    = nil
+  def touch_moved()    = nil
+  def window_moved()   = nil
+
+  #def undo(flash: true) = nil
+  #def redo(flash: true) = nil
+
+  #def cut(  flash: true) = nil
+  #def copy( flash: true) = nil
+  #def paste(flash: true) = nil
+
+  def inspect()
+    "#<#{self.class.name}:0x#{object_id}>"
+  end
+
+  private
+
+  def navigator()
+    @navigator ||= Reight::Navigator.new self
+  end
+
+  def world()
+    @world ||= SpriteWorld.new.tap do |w|
+      w.add_sprite(*sprites)
+    end
+  end
+
+  def pressing_keys()
+    @pressing_keys ||= Set.new
+  end
+
+end# App

data/lib/reight/button.rb

@@ -0,0 +1,93 @@
+using Reight
+
+
+class Reight::Button
+
+  include Reight::Activatable
+  include Reight::Hookable
+  include Reight::HasHelp
+
+  def initialize(name: nil, icon: nil, label: nil, &clicked)
+    raise if icon && label
+    @name, @icon, @label = name, icon, label
+    super()
+
+    hook :clicked
+    self.clicked(&clicked)
+    self.clicked {r8.flash name}
+  end
+
+  def draw()
+    sp = sprite
+    no_stroke
+
+    if @label
+      fill 210
+      rect 0, pressing? ? 2 : 1, sp.w, sp.h - 1, 2
+    end
+
+    if active?
+      fill 230
+      rect 0, pressing? ? 1 : 0, sp.w, sp.h, 2
+    end
+
+    if @icon
+      x  = (sp.w - @icon.width)  / 2
+      y  = (sp.h - @icon.height) / 2
+      y += 1 if pressing?
+      image enabled? ? @icon : disabled_icon, x, y
+    end
+
+    if @label
+      text_size r8.project.font_size - 1
+      text_align CENTER, CENTER
+      fill 100, 100, 100
+      text @label, 0, 1, sp.w, sp.h
+      fill 255, 255, 255
+      text @label, 0, 0, sp.w, sp.h
+    end
+  end
+
+  def pressed(x, y)
+    @pressing = true if enabled?
+  end
+
+  def released(x, y)
+    @pressing = false
+  end
+
+  def pressing? = @pressing
+
+  def hover(x, y)
+    r8.flash help, priority: 0.5
+  end
+
+  def click() = clicked! self
+
+  def enabled?(&block)
+    @enabled_block = block if block
+    @enabled_block ? @enabled_block.call : true
+  end
+
+  def disabled? = !enabled?
+
+  def sprite()
+    @sprite ||= Sprite.new(physics: false).tap do |sp|
+      sp.draw           {draw}
+      sp.mouse_pressed  {pressed  sp.mouse_x, sp.mouse_y}
+      sp.mouse_released {released sp.mouse_x, sp.mouse_y}
+      sp.mouse_moved    {hover    sp.mouse_x, sp.mouse_y}
+      sp.mouse_clicked  {clicked! self if enabled?}
+    end
+  end
+
+  def disabled_icon()
+    @disabled_icon ||= createGraphics(@icon.width, @icon.height).tap do |g|
+      g.beginDraw {g.image @icon, 0, 0}
+      g.load_pixels
+      g.pixels.map! {|c| alpha(c) > 0 ? color(180) : c}
+      g.update_pixels
+    end
+  end
+
+end# Button