refinement

Author: monkstone

processing_app/library/glvideo/library/corners/corners.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+require 'forwardable'
+# placeholder for vector coordinates
+Vect = Struct.new(:x, :y)
+
+# A class to contain frame corners, uses forwardable
+class Corners
+  include Enumerable
+  extend Forwardable
+  def_delegators :@corners, :each_with_index, :[], :[]=, :<<
+  attr_reader :idx
+
+  def initialize(width, height, ws, wh)
+    @corners = [
+      Vect.new(width / 2 - ws, height / 2 - wh),
+      Vect.new(width / 2 + ws, height / 2 - wh),
+      Vect.new(width / 2 + ws, height / 2 + wh),
+      Vect.new(width / 2 - ws, height / 2 + wh)
+    ]
+    @idx = -1
+  end
+
+  def set_corner(mx, my)
+    self[idx] = Vect.new(mx, my)
+  end
+
+  def selected?
+    idx != -1
+  end
+
+  def set_index(sel)
+    @idx = sel
+  end
+end

processing_app/library/glvideo/video_mapping.rb

@@ -1,38 +1,30 @@
-load_library :glvideo
+load_libraries :glvideo, :corners
 include_package 'gohai.glvideo'
 
-# placeholder for vector coordinates
-Vect = Struct.new(:x, :y)
 # placeholder for image sources
 ImageSource = Struct.new(:video, :image)
 
-attr_reader :sources, :sel, :video, :corners, :quads, :last_mouse_move, :sel_corner
+attr_reader :sources, :sel, :video, :corners, :quads, :last_mouse_move
 RES = 5	# number of subdivisions (e.g. 5 x 5)
 
 def setup
   @last_mouse_move = 0
-  @sel_corner = -1
   no_cursor
   @video = GLMovie.new(self, data_path('launch2.mp4'))
   video.loop
   image = load_image(data_path('checkerboard.png'))
   @sources = ImageSource.new(video, image)
   @sel = sources.video
-  @corners = [
-    Vect.new(width / 2 - 100, height / 2 - 100),
-    Vect.new(width / 2 + 100, height / 2 - 100),
-    Vect.new(width / 2 + 100, height / 2 + 100),
-    Vect.new(width / 2 - 100, height / 2 + 100)
-  ]
+  @corners = Corners.new(width, height, sources.image.width / 2, sources.image.height / 2)
   @quads = create_mesh(sel, corners, RES)
 end
 
 def draw
   background(0)
-  video.read if (sel.respond_to?(:read) && video.available)
+  video.read if sel.respond_to?(:read) && video.available
   # regenerate mesh if we're dragging a corner
-  if (sel_corner != -1 && (pmouse_x != mouse_x || pmouse_y != mouse_y))
-    corners[sel_corner] = Vect.new(mouse_x, mouse_y)
+  if corners.selected? && (pmouse_x != mouse_x || pmouse_y != mouse_y)
+    corners.set_corner(mouse_x, mouse_y)
     # this improves performance, but will be replaced by a
     # more elegant way in a future release
     @quads = []
@@ -41,28 +33,28 @@ def draw
   end
 
   # display
-  quads.map { |quad| shape(quad) } if !quads.empty?
+  quads.map { |quad| shape(quad) } unless quads.empty?
   # hide the mouse cursor after two seconds
-  if (pmouse_x != mouse_x || pmouse_y != mouse_y)
+  if pmouse_x != mouse_x || pmouse_y != mouse_y
     cursor
     @last_mouse_move = millis
-  elsif (!last_mouse_move.zero? && 2000 < millis - last_mouse_move)
+  elsif !last_mouse_move.zero? && 2000 < millis - last_mouse_move
     no_cursor
     @last_mouse_move = 0
   end
 end
 
 def mouse_pressed
   corners.each_with_index do |corner, i|
-    return @sel_corner = i if dist(mouse_x, mouse_y, corner.x, corner.y) < 20
+    return corners.set_index(i) if dist(mouse_x, mouse_y, corner.x, corner.y) < 20
   end
   # no corner? then switch texture
   @sel = sel.respond_to?(:loop) ? sources.image : sources.video
-  quads = create_mesh(sel, corners, RES)
+  @quads = create_mesh(sel, corners, RES)
 end
 
 def mouse_released
-  @sel_corner = -1
+  corners.set_index(-1)
 end
 
 def create_mesh(tex, corners, res)
@@ -86,9 +78,9 @@ def create_mesh(tex, corners, res)
       sh.normal(0, 0, 1)
       point = warp_perspective.map_dest_point(x * x_step, y * y_step)
       sh.vertex(point.get_x.to_f, point.get_y.to_f, 0, x.to_f / res, y.to_f / res)
-      point = warp_perspective.map_dest_point((x+1) * x_step, y * y_step)
+      point = warp_perspective.map_dest_point((x + 1) * x_step, y * y_step)
       sh.vertex(point.get_x.to_f, point.get_y.to_f, 0, (x + 1).to_f / res, y.to_f / res)
-      point = warp_perspective.map_dest_point((x+1) * x_step, (y + 1) * y_step)
+      point = warp_perspective.map_dest_point((x + 1) * x_step, (y + 1) * y_step)
       sh.vertex(point.get_x.to_f, point.get_y.to_f, 0, (x + 1).to_f / res, (y + 1).to_f / res)
       point = warp_perspective.map_dest_point(x * x_step, (y + 1) * y_step)
       sh.vertex(point.get_x.to_f, point.get_y.to_f, 0, x.to_f / res, (y + 1).to_f / res)