reight 0.1.6 → 0.1.7

data/lib/reight/app/runner.rb

@@ -1,117 +1,139 @@
-using Reight
+class Reight::Runner < Reight::App
 
+  include Xot::Inspectable
 
-class Reight::Runner < Reight::App
+  ROOT_CONTEXT   = Reight::CONTEXT__
 
   TEMPORARY_HASH = {}
 
   def activated()
-    super
     run force: true
-    @context.call_activated__
+    @context.call_activated__ {|&b| call_event(ignore_pause: true, &b)}
+    super
   end
 
   def deactivated()
     super
-    @context.call_deactivated__
+    @context.call_deactivated__ {|&b| call_event(ignore_pause: true, &b)}
     pause
+    cleanup
   end
 
   def draw()
-    push do
-      @context&.call_draw__ unless paused?
+    return unless @context
+    @initial_resize ||= true.tap do
+      call_event {@context.size ROOT_CONTEXT.width, ROOT_CONTEXT.height}
+    end
+    @context.call_draw__ {|push: true, &b| call_event(push: push, &b)}
+    if canvasFrame = @context.canvasFrame__
+      ROOT_CONTEXT.background 0
+      ROOT_CONTEXT.image @context, *canvasFrame
+    else
+      ROOT_CONTEXT.image @context, 0, 0
     end
     super
   end
 
   def key_pressed()
     super
-    @context&.key_pressed unless paused?
+    call_event {@context.key_pressed}
   end
 
   def key_released()
     super
-    @context&.key_released unless paused?
+    call_event {@context.key_released}
   end
 
   def key_typed()
     super
-    @context&.key_typed unless paused?
+    call_event {@context.key_typed}
   end
 
   def mouse_pressed()
     super
-    @context&.mouse_pressed unless paused?
+    call_event {@context.mouse_pressed}
   end
 
   def mouse_released()
     super
-    @context&.mouse_released unless paused?
+    call_event {@context.mouse_released}
   end
 
   def mouse_moved()
     super
-    @context&.mouse_moved unless paused?
-    navigator.visible = mouse_y < NAVIGATOR_HEIGHT
+    navigator.visible = ROOT_CONTEXT.mouse_y < NAVIGATOR_HEIGHT
+    call_event {@context.mouse_moved}
   end
 
   def mouse_dragged()
     super
-    @context&.mouse_dragged unless paused?
+    call_event {@context.mouse_dragged}
   end
 
   def mouse_clicked()
     super
-    @context&.mouse_clicked unless paused?
+    call_event {@context.mouse_clicked}
   end
 
   def double_clicked()
     super
-    @context&.double_clicked unless paused?
+    call_event {@context.double_clicked}
   end
 
   def mouse_wheel()
     super
-    @context&.mouse_wheel unless paused?
+    call_event {@context.mouse_wheel}
   end
 
   def touch_started()
     super
-    @context&.touch_started unless paused?
+    call_event {@context.touch_started}
   end
 
   def touch_ended()
     super
-    @context&.touch_ended unless paused?
+    call_event {@context.touch_ended}
   end
 
   def touch_moved()
     super
-    @context&.touch_moved unless paused?
+    call_event {@context.touch_moved}
   end
 
   def window_moved()
     super
-    @context&.window_moved
+    call_event(ignore_pause: true) {@context.window_moved}
   end
 
   def window_resized()
     super
-    @context&.window_resized
+    call_event(ignore_pause: true) {@context.window_resized}
   end
 
   private
 
+  def call_event(push: true, ignore_pause: false, &block)
+    return unless @context
+    @context.beginDraw__
+    @context.push if push
+    block.call unless paused?
+  rescue ScriptError, StandardError => e
+    puts e.full_message
+  ensure
+    @context.pop  if push
+    @context.endDraw__
+  end
+
   def running? = @context && !@paused
 
   def paused?  = @context && @paused
 
   def run(force: false)
     return pause false if paused? && !force
-    cleanup
     backup_global_vars
     @context = create_context
     @paused  = false
+    Processing::Context.setContext__ @context
     begin_wrapping_user_classes @context
     eval_user_script @context, project.code_paths.zip(project.codes).to_h
   end
@@ -121,9 +143,12 @@ class Reight::Runner < Reight::App
   end
 
   def cleanup()
-    remove_world @context.sprite_world__ if @context
+    ROOT_CONTEXT.remove_world @context.spriteWorld__ if @context
+    Processing::Context.setContext__ nil
     @context = nil
     end_wrapping_user_classes
+    clear_all_timers
+    project.clear_all_sprites
     restore_global_vars
     GC.enable
     GC.start
@@ -131,55 +156,52 @@ class Reight::Runner < Reight::App
 
   def create_context()
     klass = Class.new do
-      def project        = @project__
+      include Reight::Context
 
-      def sprite_world__ = @sprite_world__ ||= SpriteWorld.new(pixels_per_meter: 5)
-
-      def call_activated__()
-        add_world sprite_world__
-        activated
+      def call_activated__(&caller)
+        add_world spriteWorld__
+        caller.call {activated}
       end
 
-      def call_deactivated__()
-        deactivated
-        remove_world sprite_world__
+      def call_deactivated__(&caller)
+        caller.call {deactivated}
+        remove_world spriteWorld__
         @background_cleared__ = false
       end
 
-      def call_draw__()
-        unless @setup_done__
-               @setup_done__ = true
-          setup
-        end
-        unless @background_cleared__
-               @background_cleared__ = true
-          background 100, 100, 100
-        end
-        draw
+      def call_draw__(&caller)
+        @setup_done__         ||= true.tap {caller.call(push: false) {setup}}
+        @background_cleared__ ||= true.tap {caller.call {background 100}}
+        caller.call {draw}
       end
 
-      def createSprite(...) = sprite_world__.createSprite(...)
-      def addSprite(...)    = sprite_world__.addSprite(...)
-      def removeSprite(...) = sprite_world__.removeSprite(...)
-      def gravity(...)      = sprite_world__.gravity(...)
-    end
-    Processing.to_snake_case__(
-      %i[activated deactivated] + Processing::EVENT_NAMES__
-    ).each do |camel, snake|
-      klass.class_eval <<~END
-        def #{camel}(&block)
-          if block
-            @#{camel}_block__ = block
-          else
-            @#{camel}_block__&.call
+      methods = (instance_methods - Object.instance_methods)
+        .reject {_1.end_with? '__'}
+      Processing.to_snake_case__(methods).each do |camel, snake|
+        alias_method snake, camel if snake != camel
+      end
+
+      Processing.to_snake_case__(
+        %i[activated deactivated] + Processing::EVENT_NAMES__
+      ).each do |camel, snake|
+        class_eval <<~END
+          def #{camel}(&block)
+            if block
+              @#{camel}_block__ = block
+            else
+              @#{camel}_block__&.call
+            end
           end
-        end
-      END
-      klass.alias_method snake, camel if snake != camel
-    end
-    klass.new.tap do |context|
-      context.instance_variable_set :@project__, project
+        END
+        alias_method snake, camel if snake != camel
+      end
+
+      Processing.funcs__(ROOT_CONTEXT).each do |func|
+        next if method_defined? func
+        define_method(func) {|*a, **k, &b| ROOT_CONTEXT.__send__ func, *a, **k, &b}
+      end
     end
+    klass.new(ROOT_CONTEXT, project)
   end
 
   def begin_wrapping_user_classes(context)
@@ -207,27 +229,17 @@ class Reight::Runner < Reight::App
 
   def create_user_class_wrapper(context)
     Module.new.tap do |wrapper|
-      wrap_methods context, wrapper
-    end
-  end
-
-  def wrap_methods(context, klass)
-    klass.define_method :respond_to_missing? do |name, include_private = false|
-      context.respond_to?(name, false) || super(name, include_private)
-    end
-    klass.define_method :method_missing do |name, *args, **kwargs, &block|
-      if context.respond_to? name
-        klass.define_method(name) {|*a, **k, &b| context.public_send name, *a, **k, &b}
-        context.public_send name, *args, **kwargs, &block
-      else
-        super name, *args, **kwargs, &block
+      wrapper.define_method :respond_to_missing? do |name, include_private = false|
+        context.respond_to?(name, false) || super(name, include_private)
+      end
+      wrapper.define_method :method_missing do |name, *args, **kwargs, &block|
+        if context.respond_to? name
+          wrapper.define_method(name) {|*a, **k, &b| context.public_send name, *a, **k, &b}
+          context.public_send name, *args, **kwargs, &block
+        else
+          super name, *args, **kwargs, &block
+        end
       end
-    end
-    Processing.to_snake_case__(%i[
-      project createSprite addSprite removeSprite gravity
-    ]).each do |camel, snake|
-      klass.define_method(camel) {|*a, **k, &b| context.public_send camel, *a, **k, &b}
-      klass.alias_method snake, camel if snake != camel
     end
   end
 
@@ -237,6 +249,8 @@ class Reight::Runner < Reight::App
       ::Reight::Runner::TEMPORARY_HASH[:params] => {context:, codes:}
       codes.each {|path, code| context.instance_eval code, path if code}
     END
+  rescue ScriptError, StandardError => e
+    puts e.full_message
   ensure
     TEMPORARY_HASH.delete :params
   end
@@ -247,6 +261,14 @@ class Reight::Runner < Reight::App
       .freeze
   end
 
+  def clear_all_timers()
+    prefix = Reight::Context::TIMER_PREFIX__
+    ROOT_CONTEXT.instance_eval do
+      @timers__      .delete_if {|id| id in [prefix, _]}
+      @firingTimers__.delete_if {|id| id in [prefix, _]}
+    end
+  end
+
   def restore_global_vars()
     return unless @global_vars
     global_variables

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

@@ -0,0 +1,32 @@
+class Reight::SoundEditor::Brush < Reight::SoundEditor::Tool
+
+  def initialize(app, &block)
+    super app, icon: app.icon(1, 2, 8), &block
+    set_help left: name, right: 'Pick Tone'
+  end
+
+  def brush(x, y, button)
+    canvas.put x, y
+  end
+
+  def canvas_pressed(x, y, button)
+    return unless button == LEFT
+    canvas.begin_editing
+    brush 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
+    brush x, y, button
+  end
+
+  def canvas_clicked(x, y, button)
+    pick_tone x, y if button == RIGHT
+  end
+
+end# Brush

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