reight 0.1.6 → 0.1.8

data/lib/reight/app/sound/canvas.rb

@@ -0,0 +1,190 @@
+using Reight
+
+
+class Reight::SoundEditor::Canvas
+
+  include Reight::Hookable
+
+  SEQUENCE_LEN = 32
+  NOTE_HEIGHT  = 3
+
+  def initialize(app)
+    hook :sound_changed
+
+    @app, @sound = app, app.project.sounds.first
+    @scrolly     = NOTE_HEIGHT * Reight::Sound::Note::MAX / 3
+  end
+
+  attr_accessor :tone, :tool
+
+  attr_reader :sound
+
+  def sound=(sound)
+    @sound = sound
+    sound_changed! sound
+  end
+
+  def save()
+    @app.project.save
+  end
+
+  def begin_editing(&block)
+    @app.history.begin_grouping
+    block.call if block
+  ensure
+    end_editing if block
+  end
+
+  def end_editing()
+    @app.history.end_grouping
+    save
+  end
+
+  def note_pos_at(x, y)
+    sp         = sprite
+    notew      = sp.w / SEQUENCE_LEN
+    max        = Reight::Sound::Note::MAX
+    time_index = (x / notew).floor
+    note_index = max - ((@scrolly + y) / NOTE_HEIGHT).floor
+    return time_index, note_index.clamp(0, max)
+  end
+
+  def put(x, y)
+    time_i, note_i = note_pos_at x, y
+
+    @sound.each_note(time_index: time_i)
+      .select {|note,| (note.index == note_i) != (note.tone == tone)}
+      .each   {|note,| remove_note time_i, note.index, note.tone}
+    add_note time_i, note_i, tone
+
+    @app.flash note_name y
+  end
+
+  def delete(x, y)
+    time_i, note_i = note_pos_at x, y
+    note           = @sound.at time_i, note_i
+    return unless note
+
+    remove_note time_i, note_i, note.tone
+
+    @app.flash note_name y
+  end
+
+  def sprite()
+    @sprite ||= RubySketch::Sprite.new.tap do |sp|
+      pos = -> {return sp.mouse_x, sp.mouse_y}
+      sp.draw           {draw}
+      sp.mouse_pressed  {mouse_pressed( *pos.call, sp.mouse_button)}
+      sp.mouse_released {mouse_released(*pos.call, sp.mouse_button)}
+      sp.mouse_moved    {mouse_moved(   *pos.call)}
+      sp.mouse_dragged  {mouse_dragged( *pos.call, sp.mouse_button)}
+      sp.mouse_clicked  {mouse_clicked( *pos.call, sp.mouse_button)}
+    end
+  end
+
+  private
+
+  def add_note(ti, ni, tone)
+    return if @sound.at(ti, ni)&.tone == tone
+    @sound.add ti, ni, tone
+    @sound.at(ti, ni)&.play 120
+    @app.history.append [:put_note, ti, ni, tone]
+  end
+
+  def remove_note(ti, ni, tone)
+    #@sound.at(ti, ni)&.play @sound.bpm
+    @sound.remove ti, ni
+    @app.history.append [:delete_note, ti, ni, tone]
+  end
+
+  def draw()
+    sp = sprite
+    clip sp.x, sp.y, sp.w, sp.h
+
+    no_stroke
+    fill 0
+    rect 0, 0, sp.w, sp.h
+
+    translate 0, -@scrolly
+    draw_grids
+    draw_notes
+    draw_note_names
+  end
+
+  TONE_COLORS = {
+    sine:      5,
+    triangle:  29,
+    square:    19,
+    sawtooth:  30,
+    pulse12_5: 27,
+    pulse25:   14,
+    noise:     12
+  }.transform_values {Reight::App::PALETTE_COLORS[_1]}
+
+  GRID_COLORS = [1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1]
+    .map.with_index {|n, i| i == 0 ? 100 : (n == 1 ? 80 : 60)}
+
+  def draw_grids()
+    sp    = sprite
+    noteh = NOTE_HEIGHT
+    Reight::Sound::Note::MAX.downto(0).with_index do |y, index|
+      fill GRID_COLORS[index % GRID_COLORS.size]
+      rect 0, y * noteh, sp.w, noteh
+    end
+  end
+
+  def draw_notes()
+    sp           = sprite
+    notew, noteh = sp.w / SEQUENCE_LEN, NOTE_HEIGHT
+    tones, max   = Reight::Sound::Note::TONES, Reight::Sound::Note::MAX
+    @sound.each_note do |note, index|
+      fill TONE_COLORS[note.tone]
+      rect index * notew, (max - note.index) * noteh, notew, noteh
+    end
+  end
+
+  def draw_note_names()
+    fill 200
+    text_size 4
+    text_align LEFT, CENTER
+    noteh = NOTE_HEIGHT
+    max   = Reight::Sound::Note::MAX
+    (0..Reight::Sound::Note::MAX).step(12).with_index do |y, index|
+      text "C#{index}", 2, (max - y) * noteh, 10, noteh
+    end
+  end
+
+  def mouse_pressed(...)
+    tool&.canvas_pressed(...)  unless hand?
+  end
+
+  def mouse_released(...)
+    tool&.canvas_released(...) unless hand?
+  end
+
+  def mouse_moved(x, y)
+    tool&.canvas_moved(x, y)
+    @app.flash note_name y
+  end
+
+  def mouse_dragged(...)
+    if hand?
+      sp        = sprite
+      @scrolly -= sp.mouse_y - sp.pmouse_y
+    else
+      tool&.canvas_dragged(...)
+    end
+  end
+
+  def mouse_clicked(...)
+    tool&.canvas_clicked(...) unless hand?
+  end
+
+  def hand? = @app.pressing?(SPACE)
+
+  def note_name(y)
+    _, note_i = note_pos_at 0, y
+    Reight::Sound::Note.new(note_i).to_s.split(':').first.capitalize
+  end
+
+end# Canvas

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

@@ -3,23 +3,183 @@ using Reight
 
 class Reight::SoundEditor < Reight::App
 
+  def canvas()
+    @canvas ||= Canvas.new self
+  end
+
+  def setup()
+    super
+    history.disable do
+      tones[0].click
+      tools[0].click
+    end
+  end
+
   def draw()
     background 200
+    sprite(*sprites)
+    super
+  end
 
-    push do
-      text_align LEFT, CENTER
+  def key_pressed()
+    super
+    case key_code
+    when ENTER then play_or_stop.click
+    when :b    then  brush.click
+    when :e    then eraser.click
+    when /^[#{(1..Reight::Sound::Note::TONES.size).to_a.join}]$/
+      tones[key_code.to_s.to_i - 1].click
+    end
+  end
 
-      text_size 10
-      fill 220; text "Sound Editor", 150, 1, 200, height
-      fill 150; text "Sound Editor", 150, 0, 200, height
+  def window_resized()
+    super
+    index.sprite.tap do |sp|
+      sp.w, sp.h = 32, BUTTON_SIZE
+      sp.x       = SPACE
+      sp.y       = NAVIGATOR_HEIGHT + SPACE
+    end
+    bpm.sprite.tap do |sp|
+      sp.w, sp.h = 40, BUTTON_SIZE
+      sp.x       = index.sprite.right + SPACE
+      sp.y       = index.sprite.y
+    end
+    edits.map(&:sprite).each.with_index do |sp, i|
+      sp.w, sp.h = 32, BUTTON_SIZE
+      sp.x       = bpm.sprite.right + SPACE + (sp.w + 1) * i
+      sp.y       = bpm.sprite.y
+    end
+    controls.map(&:sprite).each.with_index do |sp, i|
+      sp.w, sp.h = 32, BUTTON_SIZE
+      sp.x       = SPACE + (sp.w + 1) * i
+      sp.y       = height - (SPACE + sp.h)
+    end
+    tools.map(&:sprite).each.with_index do |sp, i|
+      sp.w = sp.h = BUTTON_SIZE
+      sp.x        = controls.last.sprite.right + SPACE * 2 + (sp.w + 1) * i
+      sp.y        = controls.last.sprite.y
+    end
+    tones.map(&:sprite).each.with_index do |sp, i|
+      sp.w = sp.h = BUTTON_SIZE
+      sp.x        = tools.last.sprite.right + SPACE * 2 + (sp.w + 1) * i
+      sp.y        = tools.last.sprite.y
+    end
+    canvas.sprite.tap do |sp|
+      sp.x      = SPACE
+      sp.y      = index.sprite.bottom + SPACE
+      sp.right  = width  - SPACE
+      sp.bottom = tools.first.sprite.y - SPACE
+    end
+  end
 
-      text_size 8
-      dots = '.' * (frame_count / 60 % 4).to_i
-      fill 220; text "is under construction#{dots}", 150, 11, 200, height
-      fill 150; text "is under construction#{dots}", 150, 10, 200, height
+  def undo(flash: true)
+    history.undo do |action|
+      case action
+      in [:put_note,    ti, ni, _]    then canvas.sound.remove ti, ni
+      in [:delete_note, ti, ni, tone] then canvas.sound.add    ti, ni, tone
+      end
+      self.flash 'Undo!' if flash
     end
+  end
 
-    super
+  def redo(flash: true)
+    history.redo do |action|
+      case action
+      in [:put_note,    ti, ni, tone] then canvas.sound.add    ti, ni, tone
+      in [:delete_note, ti, ni, _]    then canvas.sound.remove ti, ni
+      end
+      self.flash 'Redo!' if flash
+    end
+  end
+
+  private
+
+  def sprites()
+    [index, bpm, *edits, *controls, *tools, *tones, canvas]
+      .map(&:sprite) + super
+  end
+
+  def index()
+    @index ||= Reight::Index.new do |index|
+      canvas.sound = project.sounds[index] ||= Reight::Sound.new
+    end
+  end
+
+  def bpm()
+    @bpm ||= Reight::Text.new(
+      canvas.sound.bpm, label: 'BPM ', regexp: /^\-?\d+$/, editable: true
+    ) do |str, text|
+      bpm = str.to_i.clamp(0, Reight::Sound::BPM_MAX)
+      next text.revert if bpm <= 0
+      text.value = canvas.sound.bpm = bpm
+      canvas.save
+    end.tap do |text|
+      canvas.sound_changed {text.value = _1.bpm}
+    end
+  end
+
+  def edits()
+    @edits ||= [
+      Reight::Button.new(name: 'Clear All Notes', label: 'Clear') {
+        canvas.sound.clear
+        canvas.save
+      },
+      Reight::Button.new(name: 'Delete Sound', label: 'Delete') {
+        project.sounds.delete_at index.index
+        canvas.sound = project.sounds[index.index] ||= Reight::Sound.new
+        canvas.save
+      },
+    ]
+  end
+
+  def controls()
+    @controls ||= [play_or_stop]
+  end
+
+  def play_or_stop()
+    @play_or_stop ||= Reight::Button.new(name: 'Play Sound', label: 'Play') {|b|
+      played  = -> {b.name, b.label = 'Stop Sound', 'Stop'}
+      stopped = -> {b.name, b.label = 'Play Sound', 'Play'}
+      if canvas.sound.playing?
+        canvas.sound.stop
+        stopped.call
+      else
+        canvas.sound.play {stopped.call}
+        played.call
+      end
+    }
+  end
+
+  def tools()
+    @tools ||= group brush, eraser
+  end
+
+  def brush  = @brush  ||= Brush.new(self)  {canvas.tool = _1}
+  def eraser = @eraser ||= Eraser.new(self) {canvas.tool = _1}
+
+  def tones()
+    @tones ||= group(*Reight::Sound::Note::TONES.map.with_index {|tone, index|
+      name  = tone.to_s.capitalize.gsub('_', '.')
+      name += ' Wave' if name !~ /noise/i
+      color = Canvas::TONE_COLORS[tone]
+      Reight::Button.new name: name, icon: icon(index, 3, 8) do
+        canvas.tone = tone
+        Reight::Sound::Note.new(60, tone).play 120 if active?
+      end.tap do |b|
+        b.instance_variable_set :@color, color
+        class << b
+          alias draw_ draw
+          def draw
+            draw_
+            no_fill
+            stroke @color
+            stroke_weight 1
+            w, h = sprite.width, sprite.height
+            line 3, h - 1, w - 3, h - 1
+          end
+        end
+      end
+    })
   end
 
 end# SoundEditor

data/lib/reight/app/sound/eraser.rb

@@ -0,0 +1,28 @@
+class Reight::SoundEditor::Eraser < Reight::SoundEditor::Tool
+
+  def initialize(app, &block)
+    super app, icon: app.icon(3, 2, 8), &block
+    set_help left: name
+  end
+
+  def erase(x, y, button)
+    canvas.delete x, y
+  end
+
+  def canvas_pressed(x, y, button)
+    return unless button == LEFT
+    canvas.begin_editing
+    erase x, y, button
+  end
+
+  def canvas_released(x, y, button)
+    return unless button == LEFT
+    canvas.end_editing
+  end
+
+  def canvas_dragged(x, y, button)
+    return unless button == LEFT
+    erase x, y, button
+  end
+
+end# Eraser

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

@@ -0,0 +1,29 @@
+using Reight
+
+
+class Reight::SoundEditor::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 name = self.class.name.split('::').last
+
+  def pick_tone(x, y)
+    canvas.tone = canvas.tone_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/sound.rb

@@ -1 +1,5 @@
 require 'reight/app/sound/editor'
+require 'reight/app/sound/canvas'
+require 'reight/app/sound/tool'
+require 'reight/app/sound/brush'
+require 'reight/app/sound/eraser'

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

@@ -6,17 +6,21 @@ class Reight::SpriteEditor::Canvas
   include Reight::Hookable
 
   def initialize(app, image, path)
-    hook :tool_changed, :color_changed
+    hook :frame_changed
+    hook :selection_changed
+    hook :color_changed
 
     @app, @image, @path       = app, image, path
-    @tool, @color, @selection = nil, [255, 255, 255], nil
+    @tool, @color, @selection = nil, [255, 255, 255, 255], nil
 
     @app.history.disable do
       set_frame 0, 0, 16, 16
     end
   end
 
-  attr_reader :x, :y, :w, :h, :tool, :color
+  attr_accessor :tool
+
+  attr_reader :x, :y, :w, :h, :color
 
   def width  = @image.width
 
@@ -27,17 +31,12 @@ class Reight::SpriteEditor::Canvas
     @app.project.save
   end
 
-  def tool=(tool)
-    @tool = tool
-    tool_changed! tool
-  end
-
   def set_frame(x, y, w, h)
     old            = [@x, @y, @w, @h]
     new            = correct_bounds x, y, w, h
     return if new == old
     @x, @y, @w, @h = new
-    @app.history.append [:frame, old, new]
+    frame_changed! old, new
   end
 
   def frame = [x, y, w, h]
@@ -53,7 +52,7 @@ class Reight::SpriteEditor::Canvas
     new        = correct_bounds x, y, w, h
     return if new == old
     @selection = new
-    @app.history.append [:select, old, new]
+    selection_changed! old, new
   end
 
   def selection()
@@ -68,7 +67,7 @@ class Reight::SpriteEditor::Canvas
   def deselect()
     return if @selection == nil
     old, @selection = @selection, nil
-    @app.history.append [:deselect, old]
+    selection_changed! old, nil
   end
 
   def paint(&block)
@@ -76,6 +75,7 @@ class Reight::SpriteEditor::Canvas
       g.clip(*(selection || frame))
       g.push do
         g.translate x, y
+        g.blend_mode REPLACE
         block.call g
       end
     end
@@ -85,24 +85,24 @@ class Reight::SpriteEditor::Canvas
     tmp = sub_image x, y, w, h
     tmp.update_pixels {|pixels| block.call pixels}
     @image.begin_draw do |g|
-      g.copy tmp, 0, 0, w, h, x, y, w, h
+      g.blend tmp, 0, 0, w, h, x, y, w, h, REPLACE
     end
   end
 
   def sub_image(x, y, w, h)
     create_graphics(w, h).tap do |g|
-      g.begin_draw {g.copy @image, x, y, w, h, 0, 0, w, h}
+      g.begin_draw {g.blend @image, x, y, w, h, 0, 0, w, h, REPLACE}
     end
   end
 
   def pixel_at(x, y)
-    img = sub_image x, y, 1, 1
+    img = sub_image self.x + x, self.y + y, 1, 1
     img.load_pixels
     c = img.pixels[0]
     [red(c), green(c), blue(c), alpha(c)].map &:to_i
   end
 
-  def clear(frame, color: [0, 0, 0])
+  def clear(frame, color:)
     paint do |g|
       g.fill(*color)
       g.no_stroke
@@ -127,7 +127,7 @@ class Reight::SpriteEditor::Canvas
     x, y, w, h = frame
     create_graphics(w, h).tap do |g|
       g.begin_draw do
-        g.copy @image, x, y, w, h, 0, 0, w, h
+        g.blend @image, x, y, w, h, 0, 0, w, h, REPLACE
       end
     end
   end
@@ -135,13 +135,13 @@ class Reight::SpriteEditor::Canvas
   def apply_frame(image, x, y)
     @image.begin_draw do |g|
       w, h = image.width, image.height
-      g.copy image, 0, 0, w, h, x, y, w, h
+      g.blend image, 0, 0, w, h, x, y, w, h, REPLACE
     end
     save
   end
 
   def sprite()
-    @sprite ||= Sprite.new.tap do |sp|
+    @sprite ||= RubySketch::Sprite.new.tap do |sp|
       pos = -> {to_image sp.mouse_x, sp.mouse_y}
       sp.draw           {draw}
       sp.mouse_pressed  {tool&.canvas_pressed( *pos.call, sp.mouse_button)}
@@ -171,6 +171,11 @@ class Reight::SpriteEditor::Canvas
   def draw()
     sp = sprite
     clip sp.x, sp.y, sp.w, sp.h
+
+    fill 0
+    no_stroke
+    rect 0, 0, sp.w, sp.h
+
     copy @image, x, y, w, h, 0, 0, sp.w, sp.h if @image && x && y && w && h
 
     sx, sy = sp.w / w, sp.h / h

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

@@ -4,8 +4,9 @@ using Reight
 class Reight::SpriteEditor::Color < Reight::Button
 
   def initialize(color, &clicked)
-    super name: '', &clicked
+    super name: color[0, 3].map {_1.to_s(16).upcase}.join, &clicked
     @color = color
+    set_help name: "##{name}"
   end
 
   attr_reader :color
@@ -15,6 +16,7 @@ class Reight::SpriteEditor::Color < Reight::Button
 
     fill(*color)
     no_stroke
+    blend_mode REPLACE
     rect 0, 0, sp.w, sp.h
 
     if active?