reight 0.1.2

data/lib/reight/app/runner.rb

@@ -0,0 +1,275 @@
+using Reight
+
+
+class Reight::Runner < Reight::App
+
+  TEMPORARY_HASH = {}
+
+  def activated()
+    super
+    run force: true
+    @context.call_activated__
+  end
+
+  def deactivated()
+    super
+    @context.call_deactivated__
+    pause
+  end
+
+  def draw()
+    push do
+      @context&.call_draw__ unless paused?
+    end
+    super
+  end
+
+  def key_pressed()
+    super
+    @context&.key_pressed unless paused?
+  end
+
+  def key_released()
+    super
+    @context&.key_released unless paused?
+  end
+
+  def key_typed()
+    super
+    @context&.key_typed unless paused?
+  end
+
+  def mouse_pressed()
+    super
+    @context&.mouse_pressed unless paused?
+  end
+
+  def mouse_released()
+    super
+    @context&.mouse_released unless paused?
+  end
+
+  def mouse_moved()
+    super
+    @context&.mouse_moved unless paused?
+    navigator.visible = mouse_y < NAVIGATOR_HEIGHT
+  end
+
+  def mouse_dragged()
+    super
+    @context&.mouse_dragged unless paused?
+  end
+
+  def mouse_clicked()
+    super
+    @context&.mouse_clicked unless paused?
+  end
+
+  def double_clicked()
+    super
+    @context&.double_clicked unless paused?
+  end
+
+  def mouse_wheel()
+    super
+    @context&.mouse_wheel unless paused?
+  end
+
+  def touch_started()
+    super
+    @context&.touch_started unless paused?
+  end
+
+  def touch_ended()
+    super
+    @context&.touch_ended unless paused?
+  end
+
+  def touch_moved()
+    super
+    @context&.touch_moved unless paused?
+  end
+
+  def window_moved()
+    super
+    @context&.window_moved
+  end
+
+  def window_resized()
+    super
+    @context&.window_resized
+  end
+
+  private
+
+  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
+    begin_wrapping_user_classes @context
+    eval_user_script @context, project.code_paths.zip(project.codes).to_h
+  end
+
+  def pause(state = true)
+    @paused = state
+  end
+
+  def cleanup()
+    remove_world @context.sprite_world__ if @context
+    @context = nil
+    end_wrapping_user_classes
+    restore_global_vars
+    GC.enable
+    GC.start
+  end
+
+  def create_context()
+    klass = Class.new do
+      def project        = @project__
+
+      def sprite_world__ = @sprite_world__ ||= create_world(pixels_per_meter: 5)
+
+      def call_activated__()
+        add_world sprite_world__
+        activated
+      end
+
+      def call_deactivated__()
+        deactivated
+        remove_world sprite_world__
+        @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
+      end
+
+      def createSprite(...) = sprite_world__.createSprite(...)
+      def addSprite(...)    = sprite_world__.addSprite(...)
+      def removeSprite(...) = sprite_world__.removeSprite(...)
+      def gravity(...)      = sprite_world__.gravity(...)
+    end
+    Reight.to_snake_case(%i[
+      activated deactivated setup draw
+      keyPressed keyReleased keyRyped
+      mousePressed mouseReleased mouseMoved mouseDragged
+      mouseClicked doubleClicked mouseWheel
+      touchStarted touchEnded touchMoved
+      windowMoved windowResized
+    ]).each do |camel, snake|
+      klass.class_eval <<~END
+        def #{camel}(&block)
+          if block
+            @#{camel}_block__ = block
+          else
+            @#{camel}_block__&.call
+          end
+        end
+      END
+      klass.alias_method snake, camel if snake != camel
+    end
+    klass.new.tap do |context|
+      context.instance_variable_set :@project__, project
+    end
+  end
+
+  def begin_wrapping_user_classes(context)
+    prefix       = get_user_class_prefix context
+    wrapper      = create_user_class_wrapper context
+    @trace_point = TracePoint.trace :class do |tp|
+      tp.self.include wrapper if tp.self.name&.start_with? prefix
+    end
+  end
+
+  def end_wrapping_user_classes()
+    @trace_point&.disable
+    @trace_point = nil
+  end
+
+  def get_user_class_prefix(context)
+    prefix = nil
+    context.instance_eval <<~EVAL
+      class Reight_Dummy__; end
+      prefix = Reight_Dummy__.name[/^#<Class:0x[0-9a-zA-Z]+>::/]
+      singleton_class.__send__ :remove_const, :Reight_Dummy__
+    EVAL
+    prefix
+  end
+
+  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
+      end
+    end
+    Reight.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
+
+  def eval_user_script(context, codes)
+    TEMPORARY_HASH[:params] = {context: context, codes: codes}
+    context.class.class_eval <<~END
+      ::Reight::Runner::TEMPORARY_HASH[:params] => {context:, codes:}
+      codes.each {|path, code| context.instance_eval code, path if code}
+    END
+  ensure
+    TEMPORARY_HASH.delete :params
+  end
+
+  def backup_global_vars()
+    @global_vars = global_variables
+      .each.with_object({}) {|name, hash| hash[name] = eval name.to_s}
+      .freeze
+  end
+
+  def restore_global_vars()
+    return unless @global_vars
+    global_variables
+      .map    {|name| [name, eval(name.to_s)]}
+      .select {|name, value| value != nil && @global_vars[name] == nil}
+      .each   {|name, value| global_var_set name, nil}
+    %i[$, $/ $-0 $; $-F $-d $-i $-v $-w $. $\\ $_ $~ $DEBUG $VERBOSE]
+      .select {|name| @global_vars.key? name}
+      .each   {|name| global_var_set name, @global_vars[name]}
+    /x/ =~ '' # clear vars about last result for regexp
+    @global_vars = nil
+  end
+
+  def global_var_set(name, value)
+    TEMPORARY_HASH[:value] = value
+    eval "#{name} = ::Reight::Runner::TEMPORARY_HASH[:value]"
+  ensure
+    TEMPORARY_HASH.delete :value
+  end
+
+end# Runner

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

@@ -0,0 +1,25 @@
+using Reight
+
+
+class Reight::SoundEditor < Reight::App
+
+  def draw()
+    background 200
+
+    push do
+      text_align LEFT, CENTER
+
+      text_size 10
+      fill 220; text "Sound Editor", 150, 1, 200, height
+      fill 150; text "Sound Editor", 150, 0, 200, height
+
+      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
+    end
+
+    super
+  end
+
+end# SoundEditor

data/lib/reight/app/sound.rb

@@ -0,0 +1 @@
+require 'reight/app/sound/editor'

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

@@ -0,0 +1,43 @@
+using Reight
+
+
+class Reight::SpriteEditor::Brush < Reight::SpriteEditor::Tool
+
+  def initialize(app, &block)
+    super app, icon: app.icon(1, 2, 8), &block
+    @size = 1
+    set_help left: 'Brush', right: 'Pick Color'
+  end
+
+  attr_accessor :size
+
+  def brush(x, y, button)
+    canvas.paint do |g|
+      g.no_fill
+      g.stroke(*canvas.color)
+      g.stroke_weight size
+      g.point x, y
+    end
+  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_color x, y if button == RIGHT
+  end
+
+end# Brush

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

@@ -0,0 +1,254 @@
+using Reight
+
+
+class Reight::SpriteEditor::Canvas
+
+  include Reight::Hookable
+
+  def initialize(app, image, path)
+    hook :tool_changed, :color_changed
+
+    @app, @image, @path       = app, image, path
+    @tool, @color, @selection = nil, [255, 255, 255], nil
+
+    @app.history.disable do
+      set_frame 0, 0, 16, 16
+    end
+  end
+
+  attr_reader :x, :y, :w, :h, :tool, :color
+
+  def width  = @image.width
+
+  def height = @image.height
+
+  def save()
+    @image.save @path
+    @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]
+  end
+
+  def frame = [x, y, w, h]
+
+  def color=(color)
+    return if color == @color
+    @color = color
+    color_changed! color
+  end
+
+  def select(x, y, w, h)
+    old        = @selection
+    new        = correct_bounds x, y, w, h
+    return if new == old
+    @selection = new
+    @app.history.append [:select, old, new]
+  end
+
+  def selection()
+    xrange, yrange = x..(x + w), y..(y + h)
+    sx, sy, sw, sh = @selection
+    return nil unless
+      xrange.include?(sx) && xrange.include?(sx + sw) &&
+      yrange.include?(sy) && yrange.include?(sy + sh)
+    @selection
+  end
+
+  def deselect()
+    return if @selection == nil
+    old, @selection = @selection, nil
+    @app.history.append [:deselect, old]
+  end
+
+  def paint(&block)
+    @image.begin_draw do |g|
+      g.clip(*(selection || frame))
+      g.push do
+        g.translate x, y
+        block.call g
+      end
+    end
+  end
+
+  def update_pixels(&block)
+    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
+    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}
+    end
+  end
+
+  def pixel_at(x, y)
+    img = sub_image x, 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])
+    paint do |g|
+      g.fill(*color)
+      g.no_stroke
+      g.rect(*frame)
+    end
+  end
+
+  def begin_editing(&block)
+    @before = capture_frame
+    block.call if block
+  ensure
+    end_editing if block
+  end
+
+  def end_editing()
+    return unless @before
+    @app.history.append [:capture, @before, capture_frame, x, y]
+    save
+  end
+
+  def capture_frame(frame = self.frame)
+    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
+      end
+    end
+  end
+
+  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
+    end
+    save
+  end
+
+  def sprite()
+    @sprite ||= 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)}
+      sp.mouse_released {tool&.canvas_released(*pos.call, sp.mouse_button)}
+      sp.mouse_moved    {tool&.canvas_moved(   *pos.call)}
+      sp.mouse_dragged  {tool&.canvas_dragged( *pos.call, sp.mouse_button)}
+      sp.mouse_clicked  {tool&.canvas_clicked( *pos.call, sp.mouse_button)}
+    end
+  end
+
+  private
+
+  def to_image(x, y)
+    return x, y unless @w && @h
+    sp = sprite
+    return x * (@w.to_f / sp.w), y * (@h.to_f / sp.h)
+  end
+
+  def correct_bounds(x, y, w, h)
+    x2, y2 = x + w, y + h
+    x, x2  = x2, x if x > x2
+    y, y2  = y2, y if y > y2
+    x, y   = x.floor, y.floor
+    return x, y, (x2 - x).ceil, (y2 - y).ceil
+  end
+
+  def draw()
+    sp = sprite
+    clip sp.x, sp.y, 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
+    scale sx, sy
+    translate(-x, -y)
+    no_fill
+    stroke_weight 0
+
+    draw_grids
+    draw_selection sx, sy
+  end
+
+  def draw_grids()
+    push do
+      stroke 50, 50, 50
+      shape grid 8
+      stroke 100, 100, 100
+      shape grid 16
+      stroke 150, 150, 150
+      shape grid 32
+    end
+  end
+
+  def grid(interval)
+    (@grids ||= {})[interval] ||= create_shape.tap do |sh|
+      w, h = @image.width, @image.height
+      sh.begin_shape LINES
+      (0..w).step(interval).each do |x|
+        sh.vertex x, 0
+        sh.vertex x, h
+      end
+      (0..h).step(interval).each do |y|
+        sh.vertex 0, y
+        sh.vertex w, y
+      end
+      sh.end_shape
+    end
+  end
+
+  def draw_selection(scale_x, scale_y)
+    return unless @selection&.size == 4
+    push do
+      stroke 255, 255, 255
+      shader selection_shader.tap {|sh|
+        sh.set :time, frame_count.to_f / 60
+        sh.set :scale, scale_x, scale_y
+      }
+=begin
+      begin_shape LINES
+      x, y, w, h = @selection
+      vertex x,     y,     x, 0
+      vertex x + w, y,     x + w, 0
+      vertex x + w, y,     x, 0
+      vertex x + w, y + h, x + w, 0
+      vertex x + w, y + h, x, 0
+      vertex x,     y + h, x + w, 0
+      vertex x,     y + h, x, 0
+      vertex x,     y,     x + w, 0
+      end_shape
+=end
+      rect(*@selection)
+    end
+  end
+
+  def selection_shader()
+    @selection_shader ||= create_shader nil, <<~END
+      varying vec4  vertTexCoord;
+      uniform float time;
+      uniform vec2  scale;
+      void main()
+      {
+        vec2 pos = vertTexCoord.xy * scale;
+        float t  = floor(time * 4.) / 4.;
+        float x  = mod( pos.x + time, 4.) < 2. ? 1. : 0.;
+        float y  = mod(-pos.y + time, 4.) < 2. ? 1. : 0.;
+        gl_FragColor = x != y ? vec4(0., 0., 0., 1.) : vec4(1., 1., 1., 1.);
+      }
+    END
+  end
+
+end# Canvas

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

@@ -0,0 +1,92 @@
+using Reight
+
+
+class Reight::SpriteEditor::Chips
+
+  include Reight::Hookable
+
+  def initialize(app, image, size = 8, &block)
+    hook :frame_changed
+
+    @app, @image = app, image
+    @offset      = create_vector
+
+    @app.history.disable do
+      set_frame 0, 0, size, size
+    end
+
+    frame_changed(&block)
+  end
+
+  attr_reader :x, :y, :size
+
+  def set_frame(x, y, w, h)
+    raise 'Chips: width != height' if w != h
+    @x    = align_to_grid(x).clamp(0..@image.width)
+    @y    = align_to_grid(y).clamp(0..@image.height)
+    @size = w
+    frame_changed! @x, @y, @size, @size
+  end
+
+  def draw()
+    sp = sprite
+    clip sp.x, sp.y, sp.w, sp.h
+    translate(*clamp_offset(@offset).to_a)
+    image @image, 0, 0
+
+    no_fill
+    stroke 255, 255, 255
+    stroke_weight 1
+    rect @x, @y, @size, @size
+  end
+
+  def mouse_pressed(x, y)
+    @prev_pos = create_vector x, y
+  end
+
+  def mouse_released(x, y)
+    @offset = clamp_offset @offset
+  end
+
+  def mouse_dragged(x, y)
+    pos       = create_vector x, y
+    @offset  += pos - @prev_pos if @prev_pos
+    @prev_pos = pos
+  end
+
+  def mouse_clicked(x, y)
+    set_frame(
+      -@offset.x + align_to_grid(x),
+      -@offset.y + align_to_grid(y),
+      size,
+      size)
+  end
+
+  def sprite()
+    @sprite ||= Sprite.new.tap do |sp|
+      sp.draw           {draw}
+      sp.mouse_pressed  {mouse_pressed  sp.mouse_x, sp.mouse_y}
+      sp.mouse_released {mouse_released sp.mouse_x, sp.mouse_y}
+      sp.mouse_dragged  {mouse_dragged  sp.mouse_x, sp.mouse_y}
+      sp.mouse_clicked  {mouse_clicked  sp.mouse_x, sp.mouse_y}
+    end
+  end
+
+  private
+
+  def clamp_offset(offset)
+    sp = sprite
+    x  = offset.x.clamp([-(@image.width  - sp.w), 0].min..0)
+    y  = offset.y.clamp([-(@image.height - sp.h), 0].min..0)
+    create_vector align_to_grid(x), align_to_grid(y)
+  end
+
+  def align_to_grid(n)
+    n.to_i / 8 * 8
+  end
+
+  def selected()
+    @selected.call @x, @y, @size, @size
+  end
+
+end# Chips

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

@@ -0,0 +1,30 @@
+using Reight
+
+
+class Reight::SpriteEditor::Color < Reight::Button
+
+  def initialize(color, &clicked)
+    super name: '', &clicked
+    @color = color
+  end
+
+  attr_reader :color
+
+  def draw()
+    sp = sprite
+
+    fill(*color)
+    no_stroke
+    rect 0, 0, sp.w, sp.h
+
+    if active?
+      no_fill
+      stroke_weight 1
+      stroke '#000000'
+      rect 2, 2, sp.w - 4, sp.h - 4
+      stroke '#ffffff'
+      rect 1, 1, sp.w - 2, sp.h - 2
+    end
+  end
+
+end# Color