rubysketch 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: a4fb1ce0ec59953e88fa85ffcacf60abf3773d01e7e628d02e6e5d273e5356af
+  data.tar.gz: d99ec6f101c8456241eddf75a0e9ca047afa10c4190c41ee8389e16b2b5c3f53
+SHA512:
+  metadata.gz: 66d7c30df9e46e6c282226b1bfedc5a79f7121fcfa4525753de7a1aa2e1735a701ac3ce0caf6af298727f9074355a7f497bdec7a8baef6d00b05a2f246b2fa0f
+  data.tar.gz: cfb0138fb530d661d7a0a0f2f6e4b8dd9432719322967890b0117bb4f53c132d5c5e3e720ed1920defeea4f7ab075d645831505d396e2f1fb22df950882175da

data/.gitignore

@@ -0,0 +1 @@
+*~

data/README.md

@@ -0,0 +1,3 @@
+# RubySketch - Processing like Creative Coding Framework
+
+by xordog@gmail.com

data/Rakefile

@@ -0,0 +1,22 @@
+# -*- mode: ruby -*-
+
+
+%w[../xot ../rucy ../rays ../reflex .]
+  .map  {|s| File.expand_path "#{s}/lib", __dir__}
+  .each {|s| $:.unshift s if !$:.include?(s) && File.directory?(s)}
+
+require 'rucy/rake'
+
+require 'xot/module'
+require 'rucy/module'
+require 'rays/module'
+require 'reflex/module'
+require 'rubysketch/module'
+
+
+MODULES = [Xot, Rucy, Rays, Reflex, RubySketch]
+
+generate_documents
+build_ruby_gem
+
+task :default => :test

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/examples/glsl.rb

@@ -0,0 +1,17 @@
+%w[xot rays reflex rubysketch]
+  .map  {|s| File.expand_path "../../#{s}/lib", __dir__}
+  .each {|s| $:.unshift s if !$:.include?(s) && File.directory?(s)}
+
+require 'rubysketch'
+
+
+RubySketch::GLSL.start <<END
+  varying vec4 v_TexCoord;
+  uniform vec2 resolution;
+  uniform float time;
+  void main ()
+  {
+    vec2 pos = v_TexCoord.xy / resolution;
+    gl_FragColor = vec4(pos, float(mod(time, 1.0)), 1);
+  }
+END

data/examples/hello.rb

@@ -0,0 +1,11 @@
+%w[xot rays reflex rubysketch]
+  .map  {|s| File.expand_path "../../#{s}/lib", __dir__}
+  .each {|s| $:.unshift s if !$:.include?(s) && File.directory?(s)}
+
+require 'rubysketch-processing'
+
+
+draw do
+  textSize 50
+  text 'hello, world!', 10, 10
+end

data/lib/rubysketch/glsl.rb

@@ -0,0 +1,35 @@
+module RubySketch
+
+
+  # @private
+  class GLSL1
+
+    extend Starter
+
+    def initialize (glsl)
+      @shader = Reflex::Shader.new glsl
+    end
+
+    def on_start__ (window)
+      start = Time.now.to_f
+
+      window.draw = proc do |e, painter|
+        painter.paint do |p|
+          c = window.canvas
+          w = c.width
+          h = c.height
+          t = Time.now.to_f - start
+          p.shader @shader, resolution: [w, h], time: t if @shader
+          p.fill 1
+          p.rect 0, 0, w, h
+        end
+      end
+    end
+
+  end# GLSL1
+
+
+  GLSL = GLSL1
+
+
+end# RubySketch

data/lib/rubysketch/module.rb

@@ -0,0 +1,23 @@
+module RubySketch
+
+
+  module Module
+
+    module_function
+
+    def name ()
+      super.split('::')[-2]
+    end
+
+    def version ()
+      open(root_dir 'VERSION') {|f| f.readline.chomp}
+    end
+
+    def root_dir (path = '')
+      File.expand_path "../../#{path}", __dir__
+    end
+
+  end# Module
+
+
+end# RubySketch

data/lib/rubysketch/processing.rb

@@ -0,0 +1,773 @@
+module RubySketch
+
+
+  # Processing compatible API v1
+  #
+  class Processing1
+
+    extend Starter
+
+    PI         = Math::PI
+    HALF_PI    = PI / 2
+    QUARTER_PI = PI / 4
+    TWO_PI     = PI * 2
+    TAU        = PI * 2
+
+    # RGB mode for colorMode() function.
+    #
+    RGB = :RGB
+
+    # HSB mode for colorMode() function.
+    #
+    HSB = :HSB
+
+    # Radian mode for angleMode() function.
+    #
+    RADIANS = :RADIANS
+
+    # Degree mode for angleMode() function.
+    #
+    DEGREES = :DEGREES
+
+    # @private
+    DEG2RAD__ = PI / 180.0
+
+    # @private
+    RAD2DEG__ = 180.0 / PI
+
+    # @private
+    def initialize ()
+      @frameCount__   = 0
+      @hsbColor__     = false
+      @colorMaxes__   = [1.0] * 4
+      @angleScale__   = 1.0
+      @mouseX__       =
+      @mouseY__       =
+      @mousePrevX__   =
+      @mousePrevY__   = 0
+      @mousePressed__ = false
+
+      colorMode RGB, 255
+      angleMode RADIANS
+    end
+
+    def on_start__ (window)
+      @window__  = window
+      @painter__ = window.canvas.painter
+
+      setupDrawBlock__
+      setupMousePressedBlock__
+      setupMouseReleasedBlock__
+      setupMouseMovedBlock__
+      setupMouseDraggedBlock__
+    end
+
+    def abs (value)
+      value.abs
+    end
+
+    def ceil (value)
+      value.ceil
+    end
+
+    def floor (value)
+      value.floor
+    end
+
+    def round (value)
+      value.round
+    end
+
+    # Returns minimum value.
+    #
+    # @overload min(a, b)
+    # @overload min(a, b, c)
+    # @overload min(array)
+    #
+    # @param a     [Numeric] value to compare
+    # @param b     [Numeric] value to compare
+    # @param c     [Numeric] value to compare
+    # @param array [Numeric] values to compare
+    #
+    # @return [Numeric] minimum value
+    #
+    def min (*args)
+      args.flatten.min
+    end
+
+    # Returns maximum value.
+    #
+    # @overload max(a, b)
+    # @overload max(a, b, c)
+    # @overload max(array)
+    #
+    # @param a     [Numeric] value to compare
+    # @param b     [Numeric] value to compare
+    # @param c     [Numeric] value to compare
+    # @param array [Numeric] values to compare
+    #
+    # @return [Numeric] maximum value
+    #
+    def max (*args)
+      args.flatten.max
+    end
+
+    def constrain (value, min, max)
+      value < min ? min : (value > max ? max : value)
+    end
+
+    # Converts degree to radian.
+    #
+    # @param degree [Numeric] degree to convert
+    #
+    # @return [Numeric] radian
+    #
+    def radians (degree)
+      degree * DEG2RAD__
+    end
+
+    # Converts radian to degree.
+    #
+    # @param radian [Numeric] radian to convert
+    #
+    # @return [Numeric] degree
+    #
+    def degrees (radian)
+      radian * RAD2DEG__
+    end
+
+    def setup (&block)
+      @window__.setup = block
+      nil
+    end
+
+    # @private
+    def setupDrawBlock__ ()
+      @window__.draw = proc do |e, painter|
+        @painter__ = painter
+        @painter__.paint {|_| @drawBlock__.call e} if @drawBlock__
+        @frameCount__ += 1
+        updateMousePrevPos__
+      end
+    end
+
+    def draw (&block)
+      @drawBlock__ = block if block
+      nil
+    end
+
+    def key (&block)
+      @window__.key = block
+      nil
+    end
+
+    # @private
+    def setupMousePressedBlock__ ()
+      @window__.pointer_down = proc do |e|
+        updateMouseState__ e.x, e.y, true
+        @mousePressedBlock__.call e if @mousePressedBlock__
+      end
+    end
+
+    def mousePressed (&block)
+      @mousePressedBlock__ = block if block
+      @mousePressed__
+    end
+
+    # @private
+    def setupMouseReleasedBlock__ ()
+      @window__.pointer_up = proc do |e|
+        updateMouseState__ e.x, e.y, false
+        @mouseReleasedBlock__.call e if @mouseReleasedBlock__
+      end
+    end
+
+    def mouseReleased (&block)
+      @mouseReleasedBlock__ = block if block
+      nil
+    end
+
+    # @private
+    def setupMouseMovedBlock__ ()
+      @window__.pointer_move = proc do |e|
+        updateMouseState__ e.x, e.y
+        @mouseMovedBlock__.call e if @mouseMovedBlock__
+      end
+    end
+
+    def mouseMoved (&block)
+      @mouseMovedBlock__ = block if block
+      nil
+    end
+
+    # @private
+    def setupMouseDraggedBlock__ ()
+      @window__.pointer_drag = proc do |e|
+        updateMouseState__ e.x, e.y
+        @mouseDraggedBlock__.call e if @mouseDraggedBlock__
+      end
+    end
+
+    def mouseDragged (&block)
+      @mouseDraggedBlock__ = block if block
+      nil
+    end
+
+    # @private
+    def updateMouseState__ (x, y, pressed = nil)
+      @mouseX__       = x
+      @mouseY__       = y
+      @mousePressed__ = pressed if pressed != nil
+    end
+
+    # @private
+    def updateMousePrevPos__ ()
+      @mousePrevX__ = @mouseX__
+      @mousePrevY__ = @mouseY__
+    end
+
+    def size (width, height)
+      raise 'size() must be called on startup or setup block' if @started__
+
+      @painter__.send :end_paint
+      reset_canvas width, height
+      @painter__.send :begin_paint
+
+      @auto_resize__ = false
+    end
+
+    def width ()
+      @window__.canvas.width
+    end
+
+    def height ()
+      @window__.canvas.height
+    end
+
+    def windowWidth ()
+      @window__.width
+    end
+
+    def windowHeight ()
+      @window__.height
+    end
+
+    # Returns number of frames since program started.
+    #
+    # @return [Integer] total number of frames
+    #
+    def frameCount ()
+      @frameCount__
+    end
+
+    # Returns number of frames per second.
+    #
+    # @return [Float] frames per second
+    #
+    def frameRate ()
+      @window__.event.fps
+    end
+
+    # Returns pixel density
+    #
+    # @return [Numeric] pixel density
+    #
+    def displayDensity ()
+      @painter__.pixel_density
+    end
+
+    # Returns mouse x position
+    #
+    # @return [Numeric] horizontal position of mouse
+    #
+    def mouseX ()
+      @mouseX__
+    end
+
+    # Returns mouse y position
+    #
+    # @return [Numeric] vertical position of mouse
+    #
+    def mouseY ()
+      @mouseY__
+    end
+
+    # Returns mouse x position in previous frame
+    #
+    # @return [Numeric] horizontal position of mouse
+    #
+    def pmouseX ()
+      @mousePrevX__
+    end
+
+    # Returns mouse y position in previous frame
+    #
+    # @return [Numeric] vertical position of mouse
+    #
+    def pmouseY ()
+      @mousePrevY__
+    end
+
+    # Sets color mode and max color values.
+    #
+    # @overload colorMode(mode)
+    # @overload colorMode(mode, max)
+    # @overload colorMode(mode, max1, max2, max3)
+    # @overload colorMode(mode, max1, max2, max3, maxA)
+    #
+    # @param mode [RGB, HSB] RGB or HSB
+    # @param max  [Numeric]  max values for all color values
+    # @param max1 [Numeric]  max value for red or hue
+    # @param max2 [Numeric]  max value for green or saturation
+    # @param max3 [Numeric]  max value for blue or brightness
+    # @param maxA [Numeric]  max value for alpha
+    #
+    # @return [nil] nil
+    #
+    def colorMode (mode, *maxes)
+      raise ArgumentError, "Invalid color mode: #{mode}" unless [RGB, HSB].include?(mode)
+      raise ArgumentError unless [0, 1, 3, 4].include?(maxes.size)
+
+      @hsbColor__ = mode.upcase == HSB
+      case maxes.size
+        when 1    then @colorMaxes__                 = [maxes.first.to_f] * 4
+        when 3, 4 then @colorMaxes__[0...maxes.size] = maxes.map &:to_f
+      end
+      nil
+    end
+
+    # @private
+    def to_rgba__ (*args)
+      _0, _1, _2, _3 = args
+      return parse_color__(_0, _1 || alphaMax__) if _0.kind_of?(String)
+
+      rgba  = case args.size
+        when 1, 2 then [_0, _0, _0, _1 || alphaMax__]
+        when 3, 4 then [_0, _1, _2, _3 || alphaMax__]
+        else raise ArgumentError
+      end
+      rgba  = rgba.map.with_index {|value, i| value / @colorMaxes__[i]}
+      color = @hsbColor__ ? Rays::Color.hsv(*rgba) : Rays::Color.new(*rgba)
+      color.to_a
+    end
+
+    # @private
+    def parse_color__ (str, alpha)
+      result = str.match /^\s*##{'([0-9a-f]{2})' * 3}\s*$/i
+      raise ArgumentError, "Invalid color code: '#{str}'" unless result
+
+      rgb = result[1..3].map.with_index {|hex, i| hex.to_i(16) / @colorMaxes__[i]}
+      return *rgb, (alpha / alphaMax__)
+    end
+
+    # @private
+    def alphaMax__ ()
+      @colorMaxes__[3]
+    end
+
+    # Sets angle mode.
+    #
+    # @param mode [RADIANS, DEGREES] RADIANS or DEGREES
+    #
+    # @return [nil] nil
+    #
+    def angleMode (mode)
+      @angleScale__ = case mode
+        when RADIANS then RAD2DEG__
+        when DEGREES then 1.0
+        else raise ArgumentError, "Invalid angle mode: #{mode}"
+      end
+    end
+
+    # @private
+    def to_angle__ (angle)
+      angle * @angleScale__
+    end
+
+    # Clears screen.
+    #
+    # @overload background(str)
+    # @overload background(str, alpha)
+    # @overload background(gray)
+    # @overload background(gray, alpha)
+    # @overload background(r, g, b)
+    # @overload background(r, g, b, alpha)
+    #
+    # @param str   [String]  color code like '#00AAFF'
+    # @param gray  [Integer]  gray value (0..255)
+    # @param r     [Integer]   red value (0..255)
+    # @param g     [Integer] green value (0..255)
+    # @param b     [Integer]  blue value (0..255)
+    # @param alpha [Integer] alpha value (0..255)
+    #
+    # @return [nil] nil
+    #
+    def background (*args)
+      @painter__.background(*to_rgba__(*args))
+      nil
+    end
+
+    # Sets fill color.
+    #
+    # @overload fill(rgb)
+    # @overload fill(rgb, alpha)
+    # @overload fill(gray)
+    # @overload fill(gray, alpha)
+    # @overload fill(r, g, b)
+    # @overload fill(r, g, b, alpha)
+    #
+    # @param rgb   [String]  color code like '#00AAFF'
+    # @param gray  [Integer]  gray value (0..255)
+    # @param r     [Integer]   red value (0..255)
+    # @param g     [Integer] green value (0..255)
+    # @param b     [Integer]  blue value (0..255)
+    # @param alpha [Integer] alpha value (0..255)
+    #
+    # @return [nil] nil
+    #
+    def fill (*args)
+      @painter__.fill(*to_rgba__(*args))
+      nil
+    end
+
+    # Sets stroke color.
+    #
+    # @overload stroke(rgb)
+    # @overload stroke(rgb, alpha)
+    # @overload stroke(gray)
+    # @overload stroke(gray, alpha)
+    # @overload stroke(r, g, b)
+    # @overload stroke(r, g, b, alpha)
+    #
+    # @param rgb   [String]  color code like '#00AAFF'
+    # @param gray  [Integer]  gray value (0..255)
+    # @param r     [Integer]   red value (0..255)
+    # @param g     [Integer] green value (0..255)
+    # @param b     [Integer]  blue value (0..255)
+    # @param alpha [Integer] alpha value (0..255)
+    #
+    # @return [nil] nil
+    #
+    def stroke (*args)
+      @painter__.stroke(*to_rgba__(*args))
+      nil
+    end
+
+    # Sets stroke weight.
+    #
+    # @param weight [Numeric] width of stroke
+    #
+    # @return [nil] nil
+    #
+    def strokeWeight (weight)
+      @painter__.stroke_width weight
+      nil
+    end
+
+    # Disables filling.
+    #
+    # @return [nil] nil
+    #
+    def noFill ()
+      @painter__.fill nil
+      nil
+    end
+
+    # Disables drawing stroke.
+    #
+    # @return [nil] nil
+    #
+    def noStroke ()
+      @painter__.stroke nil
+      nil
+    end
+
+    # Sets font.
+    #
+    # @param name [String]  font name
+    # @param size [Numeric] font size
+    #
+    # @return [Font] current font
+    #
+    def textFont (name = nil, size = nil)
+      @painter__.font name, size if name || size
+      Font.new @painter__.font
+    end
+
+    # Sets text size.
+    #
+    # @param size [Numeric] font size
+    #
+    # @return [nil] nil
+    #
+    def textSize (size)
+      @painter__.font @painter__.font.name, size
+      nil
+    end
+
+    # Draws a line.
+    #
+    # @param x1 [Numeric] horizontal position for first point
+    # @param y1 [Numeric] vertical position for first point
+    # @param x2 [Numeric] horizontal position for second point
+    # @param y2 [Numeric] vertical position for second point
+    #
+    # @return [nil] nil
+    #
+    def line (x1, y1, x2, y2)
+      @painter__.line x1, y1, x2, y2
+      nil
+    end
+
+    # Draws a rectangle.
+    #
+    # @overload rect(x, y, w, h)
+    # @overload rect(x, y, w, h, r)
+    # @overload rect(x, y, w, h, tl, tr, br, bl)
+    #
+    # @param x  [Numeric] horizontal position
+    # @param y  [Numeric] vertical position
+    # @param w  [Numeric] width of the shape
+    # @param h  [Numeric] height of the shape
+    # @param r  [Numeric] radius for all corners
+    # @param tl [Numeric] radius for top-left corner
+    # @param tr [Numeric] radius for top-right corner
+    # @param br [Numeric] radius for bottom-right corner
+    # @param bl [Numeric] radius for bottom-left corner
+    #
+    # @return [nil] nil
+    #
+    def rect (x, y, w, h, *args)
+      case args.size
+        when 0 then @painter__.rect x, y, w, h
+        when 1 then @painter__.rect x, y, w, h, round: args[0]
+        when 4 then @painter__.rect x, y, w, h, lt: args[0], rt: args[1], rb: args[2], lb: args[3]
+        else raise ArgumentError # ToDo: refine error message
+      end
+      nil
+    end
+
+    # Draws a ellipse.
+    #
+    # @param x [Numeric] horizontal position
+    # @param y [Numeric] vertical position
+    # @param w [Numeric] width of the shape
+    # @param h [Numeric] height of the shape
+    #
+    # @return [nil] nil
+    #
+    def ellipse (x, y, w, h = w)
+      @painter__.ellipse (x - w / 2.0), (y - h / 2.0), w, h
+      nil
+    end
+
+    # Draws a circle.
+    #
+    # @param x      [Numeric] horizontal position
+    # @param y      [Numeric] vertical position
+    # @param extent [Numeric] width and height of the shape
+    #
+    # @return [nil] nil
+    #
+    def circle (x, y, extent)
+      ellipse x, y, extent, extent
+    end
+
+    # Draws an arc.
+    #
+    # @param x     [Numeric] horizontal position
+    # @param y     [Numeric] vertical position
+    # @param w     [Numeric] width of the shape
+    # @param h     [Numeric] height of the shape
+    # @param start [Numeric] angle to start the arc
+    # @param stop  [Numeric] angle to stop the arc
+    #
+    # @return [nil] nil
+    #
+    def arc (x, y, w, h, start, stop)
+      start = to_angle__ start
+      stop  = to_angle__ stop
+      @painter__.ellipse x - w / 2, y - h / 2, w, h, from: start, to: stop
+      nil
+    end
+
+    # Draws a point.
+    #
+    # @param x [Numeric] horizontal position
+    # @param y [Numeric] vertical position
+    #
+    # @return [nil] nil
+    #
+    def point (x, y)
+      @painter__.rect x - 0.5, y - 0.5, 1, 1
+      nil
+    end
+
+    # Draws a text.
+    #
+    # @overload text(str)
+    # @overload text(str, x, y)
+    #
+    # @param str [String]  text to draw
+    # @param x   [Numeric] horizontal position
+    # @param y   [Numeric] vertical position
+    #
+    # @return [nil] nil
+    #
+    def text (str, x = 0, y = 0)
+      @painter__.text str, x, y
+      nil
+    end
+
+    # Applies translation matrix to current transformation matrix.
+    #
+    # @param x [Numeric] horizontal transformation
+    # @param y [Numeric] vertical transformation
+    #
+    # @return [nil] nil
+    #
+    def translate (x, y)
+      @painter__.translate x, y
+      nil
+    end
+
+    # Applies scale matrix to current transformation matrix.
+    #
+    # @overload scale(s)
+    # @overload scale(x, y)
+    #
+    # @param s [Numeric] horizontal and vertical scale
+    # @param x [Numeric] horizontal scale
+    # @param y [Numeric] vertical scale
+    #
+    # @return [nil] nil
+    #
+    def scale (x, y)
+      @painter__.scale x, y
+      nil
+    end
+
+    # Applies rotation matrix to current transformation matrix.
+    #
+    # @param angle [Numeric] angle for rotation
+    #
+    # @return [nil] nil
+    #
+    def rotate (angle)
+      @painter__.rotate to_angle__ angle
+      nil
+    end
+
+    # Pushes the current transformation matrix to stack.
+    #
+    # @return [nil] nil
+    #
+    def pushMatrix ()
+      @painter__.push_matrix
+      nil
+    end
+
+    # Pops the current transformation matrix from stack.
+    #
+    # @return [nil] nil
+    #
+    def popMatrix ()
+      @painter__.pop_matrix
+      nil
+    end
+
+    # Reset current transformation matrix with identity matrix.
+    #
+    # @return [nil] nil
+    #
+    def resetMatrix ()
+      @painter__.matrix = 1
+      nil
+    end
+
+    # Returns the perlin noise value.
+    #
+    # @overload noise(x)
+    # @overload noise(x, y)
+    #
+    # @param x [Numeric] horizontal point in noise space
+    # @param y [Numeric] vertical point in noise space
+    #
+    # @return [Numeric] noise value (0.0..1.0)
+    #
+    def noise (x, y = 0)
+      Rays.perlin(x, y) / 2.0 + 1.0
+    end
+
+    # Font object.
+    #
+    class Font
+
+      # Initialize font.
+      #
+      # @private
+      #
+      def initialize (font)
+        @font = font
+      end
+
+      # Returns bounding box.
+      #
+      # @overload textBounds(str)
+      # @overload textBounds(str, x, y)
+      # @overload textBounds(str, x, y, fontSize)
+      #
+      # @param str      [String]  text to calculate bounding box
+      # @param x        [Numeric] horizontal position of bounding box
+      # @param y        [Numeric] vertical position of bounding box
+      # @param fontSize [Numeric] font size
+      #
+      # @return [TextBounds] bounding box for text
+      #
+      def textBounds (str, x = 0, y = 0, fontSize = nil)
+        f = fontSize ? Rays::Font.new(@font.name, fontSize) : @font
+        TextBounds.new x, y, x + f.width(str), y + f.height
+      end
+
+      # Bounding box for text.
+      #
+      class TextBounds
+
+        # Horizontal position
+        #
+        attr_reader :x
+
+        # Vertical position
+        #
+        attr_reader :y
+
+        # Width of bounding box
+        #
+        attr_reader :w
+
+        # Height of bounding box
+        #
+        attr_reader :h
+
+        # Initialize bouding box.
+        #
+        # @param x [Numeric] horizontal position
+        # @param y [Numeric] vertical position
+        # @param w [Numeric] width of bounding box
+        # @param h [Numeric] height of bounding box
+        #
+        def initialize (x, y, w, h)
+          @x, @y, @w, @h = x, y, w, h
+        end
+
+      end# TextBounds
+
+    end# Font
+
+  end# Processing1
+
+
+  Processing = Processing1
+
+
+end# RubySketch

data/lib/rubysketch/starter.rb

@@ -0,0 +1,61 @@
+module RubySketch
+
+
+  extend module Functions
+
+    def start (context, start_at_exit: false, &block)
+      window = Window.new
+
+      context.on_start__ window
+      context.instance_eval &block if block
+
+      start = proc do
+        Reflex.start {window.show}
+      end
+
+      if start_at_exit
+        at_exit &start unless $!
+      else
+        start.call
+      end
+    end
+
+    private
+
+    def start_on_object_at_exit (object, context)
+      klass   = context.class
+      methods = klass.instance_methods(false)
+        .reject {|name| name =~ /__$/}
+      consts  = klass.constants
+        .reject {|name| name =~ /__$/}
+        .each_with_object({}) {|name, h| h[name] = klass.const_get name}
+
+      object.class.class_eval do
+        methods.each do |name|
+          define_method name do |*args, &block|
+            context.__send__ name, *args, &block
+          end
+        end
+        consts.each do |(name, value)|
+          const_set name, value
+        end
+      end
+
+      start context, start_at_exit: true
+    end
+
+    self
+
+  end# Functions
+
+
+  module Starter
+
+    def start (*args, &block)
+      RubySketch.start self.new(*args), start_at_exit: true, &block
+    end
+
+  end# Starter
+
+
+end# RubySketch

data/lib/rubysketch/window.rb

@@ -0,0 +1,93 @@
+module RubySketch
+
+
+  class Window < Reflex::Window
+
+    attr_accessor :setup, :update, :draw, :key, :motion, :resize,
+      :pointer_down, :pointer_up, :pointer_move, :pointer_drag
+
+    attr_accessor :auto_resize
+
+    attr_reader :canvas
+
+    def initialize (width = 500, height = 500, *args, &block)
+      @canvas      = nil
+      @events      = []
+      @auto_resize = true
+      @error       = nil
+
+      super *args, size: [width, height] do |_|
+        @canvas.painter.paint do |_|
+          block.call if block
+          on_setup
+        end
+      end
+    end
+
+    def event ()
+      @events.last
+    end
+
+    def on_setup ()
+      call_block @setup, nil
+    end
+
+    def on_update (e)
+      call_block @update, e
+      redraw
+    end
+
+    def on_draw (e)
+      call_block @draw, e, @canvas.painter
+      e.painter.image @canvas if @canvas
+    end
+
+    def on_key (e)
+      call_block @key, e
+    end
+
+    def on_pointer (e)
+      block = case e.type
+        when :down then @pointer_down
+        when :up   then @pointer_up
+        when :move then e.drag? ? @pointer_drag : @pointer_move
+      end
+      call_block block, e if block
+    end
+
+    def on_motion (e)
+      call_block @motion, e
+    end
+
+    def on_resize (e)
+      reset_canvas e.width, e.height if @auto_resize
+      call_block @resize, e
+    end
+
+    private
+
+    def reset_canvas (width, height)
+      return if width * height == 0
+      return if width == @canvas&.width && height == @canvas&.height
+
+      old     = @canvas
+      pd      = @canvas&.pixel_density || painter.pixel_density
+      @canvas = Rays::Image.new width, height, Rays::ColorSpace::RGBA, pd
+
+      @canvas.paint {image old} if old
+    end
+
+    def call_block (block, event, *args)
+      @events.push event
+      block.call event, *args if block && !@error
+    rescue => e
+      @error = e
+      $stderr.puts e.full_message
+    ensure
+      @events.pop
+    end
+
+  end# Window
+
+
+end# RubySketch

data/lib/rubysketch-processing.rb

@@ -0,0 +1,4 @@
+require 'rubysketch'
+
+
+RubySketch.__send__ :start_on_object_at_exit, self, RubySketch::Processing.new

data/lib/rubysketch.rb

@@ -0,0 +1,6 @@
+require 'reflex'
+require 'rubysketch/module'
+require 'rubysketch/starter'
+require 'rubysketch/window'
+require 'rubysketch/processing'
+require 'rubysketch/glsl'

data/rubysketch.gemspec

@@ -0,0 +1,44 @@
+# -*- mode: ruby -*-
+
+
+File.expand_path('lib', __dir__)
+  .tap {|s| $:.unshift s if !$:.include?(s) && File.directory?(s)}
+
+require 'rubysketch/module'
+
+
+Gem::Specification.new do |s|
+  glob = -> *patterns do
+    patterns.map {|pat| Dir.glob(pat).to_a}.flatten
+  end
+
+  mod   = RubySketch::Module
+  name  = mod.name.downcase
+  rdocs = glob.call *%w[README]
+
+  s.name        = name
+  s.summary     = 'Processing like Creative Coding Framework.'
+  s.description = 'Creative Coding Framework have API compatible to Processing API or p5.js.'
+  s.version     = mod.version
+
+  s.authors  = %w[xordog]
+  s.email    = 'xordog@gmail.com'
+  s.homepage = "https://github.com/xord/rubysketch"
+
+  s.platform              = Gem::Platform::RUBY
+  s.required_ruby_version = '~> 2'
+
+  s.add_runtime_dependency 'yard'
+  s.add_runtime_dependency 'xot',       '~> 0.1'
+  s.add_runtime_dependency 'beeps',     '~> 0.1'
+  s.add_runtime_dependency 'rucy',      '~> 0.1'
+  s.add_runtime_dependency 'rays',      '~> 0.1'
+  s.add_runtime_dependency 'reflexion', '~> 0.1'
+
+  s.files            = `git ls-files`.split $/
+  s.test_files       = s.files.grep %r{^(test|spec|features)/}
+  s.extra_rdoc_files = rdocs.to_a
+  s.has_rdoc         = true
+
+  s.extensions << 'Rakefile'
+end

metadata

@@ -0,0 +1,140 @@
+--- !ruby/object:Gem::Specification
+name: rubysketch
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- xordog
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-11-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: xot
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+- !ruby/object:Gem::Dependency
+  name: beeps
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+- !ruby/object:Gem::Dependency
+  name: rucy
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+- !ruby/object:Gem::Dependency
+  name: rays
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+- !ruby/object:Gem::Dependency
+  name: reflexion
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+description: Creative Coding Framework have API compatible to Processing API or p5.js.
+email: xordog@gmail.com
+executables: []
+extensions:
+- Rakefile
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- README.md
+- Rakefile
+- VERSION
+- examples/glsl.rb
+- examples/hello.rb
+- lib/rubysketch-processing.rb
+- lib/rubysketch.rb
+- lib/rubysketch/glsl.rb
+- lib/rubysketch/module.rb
+- lib/rubysketch/processing.rb
+- lib/rubysketch/starter.rb
+- lib/rubysketch/window.rb
+- rubysketch.gemspec
+homepage: https://github.com/xord/rubysketch
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - "~>"
+    - !ruby/object:Gem::Version
+      version: '2'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3
+signing_key: 
+specification_version: 4
+summary: Processing like Creative Coding Framework.
+test_files: []