rubysketch 0.3.21 → 0.3.22

data/lib/rubysketch/processing.rb

@@ -555,7 +555,7 @@ module RubySketch
       end
 
       # @private
-      protected def getInternal__()
+      def getInternal__()
         @point
       end
 
@@ -592,6 +592,20 @@ module RubySketch
         @image.height
       end
 
+      # Applies an image filter.
+      #
+      # overload filter(shader)
+      # overload filter(type)
+      # overload filter(type, param)
+      #
+      # @param shader [Shader]  a fragment shader to apply
+      # @param type   [THRESHOLD, GRAY, INVERT, BLUR] filter type
+      # @param param  [Numeric] a parameter for each filter
+      #
+      def filter(*args)
+        @filter = Shader.createFilter__(*args)
+      end
+
       # Resizes image.
       #
       # @param width  [Numeric] width for resized image
@@ -633,14 +647,14 @@ module RubySketch
       # @overload blend(img, sx, sy, sw, sh, dx, dy, dw, dh, mode)
       #
       # @param img  [Image]   image for blend source
-      # @param sx   [Numrtic] x position of source region
-      # @param sy   [Numrtic] y position of source region
-      # @param sw   [Numrtic] width of source region
-      # @param sh   [Numrtic] height of source region
-      # @param dx   [Numrtic] x position of destination region
-      # @param dy   [Numrtic] y position of destination region
-      # @param dw   [Numrtic] width of destination region
-      # @param dh   [Numrtic] height of destination region
+      # @param sx   [Numeric] x position of source region
+      # @param sy   [Numeric] y position of source region
+      # @param sw   [Numeric] width of source region
+      # @param sh   [Numeric] height of source region
+      # @param dx   [Numeric] x position of destination region
+      # @param dy   [Numeric] y position of destination region
+      # @param dw   [Numeric] width of destination region
+      # @param dh   [Numeric] height of destination region
       # @param mode [BLEND, ADD, SUBTRACT, LIGHTEST, DARKEST, EXCLUSION, MULTIPLY, SCREEN, REPLACE] blend mode
       #
       # @return [nil] nil
@@ -648,11 +662,9 @@ module RubySketch
       def blend(img = nil, sx, sy, sw, sh, dx, dy, dw, dh, mode)
         img ||= self
         @image.paint do |painter|
-          current = painter.blend_mode
-          painter.blend_mode = mode
-          painter.image img.getInternal__, sx, sy, sw, sh, dx, dy, dw, dh
-          painter.blend_mode = current
+          img.drawImage__ painter, sx, sy, sw, sh, dx, dy, dw, dh, blend_mode: mode
         end
+        nil
       end
 
       # Saves image to file.
@@ -668,6 +680,14 @@ module RubySketch
         @image
       end
 
+      # @private
+      def drawImage__(painter, *args, **states)
+        shader = painter.shader || @filter&.getInternal__
+        painter.push shader: shader, **states do |_|
+          painter.image getInternal__, *args
+        end
+      end
+
     end# Image
 
 
@@ -753,6 +773,159 @@ module RubySketch
     end# Touch
 
 
+    # Shader object.
+    #
+    class Shader
+
+      # Initialize shader object.
+      #
+      # @param vertSrc [String] vertex shader source
+      # @param fragSrc [String] fragment shader source
+      #
+      def initialize(vertSrc, fragSrc)
+        @shader = Rays::Shader.new fragSrc, vertSrc, ENV__
+      end
+
+      # Sets uniform variables.
+      #
+      # @overload set(name, a)
+      # @overload set(name, a, b)
+      # @overload set(name, a, b, c)
+      # @overload set(name, a, b, c, d)
+      # @overload set(name, nums)
+      # @overload set(name, vec)
+      # @overload set(name, vec, ncoords)
+      # @overload set(name, tex)
+      #
+      # @param name    [String]  uniform variable name
+      # @param a       [Numeric] int or float value
+      # @param b       [Numeric] int or float value
+      # @param c       [Numeric] int or float value
+      # @param d       [Numeric] int or float value
+      # @param nums    [Array]   int or float array
+      # @param vec     [Vector]  vector
+      # @param ncoords [Integer] number of coordinates, max 4
+      # @param tex     [Image]   texture image
+      #
+      def setUniform(name, *args)
+        arg = args.first
+        case
+        when Array === arg
+          @shader.uniform name, *arg
+        when Numeric === arg
+          @shader.uniform name, *args
+        when Vector === arg
+          vec, ncoords = args
+          @shader.uniform name, vec.getInternal__.to_a(ncoords || 3)
+        when arg.respond_to?(:getInternal__)
+          @shader.uniform name, arg.getInternal__
+        else
+          raise ArgumentError
+        end
+      end
+
+      alias set setUniform
+
+      # @private
+      def getInternal__()
+        @shader
+      end
+
+      # @private
+      ENV__ = {
+        attribute_position:      [:vertex, :position],
+        attribute_texcoord:      :texCoord,
+        attribute_color:         :color,
+        varying_position:        :vertPosition,
+        varying_texcoord:        :vertTexCoord,
+        varying_color:           :vertColor,
+        uniform_position_matrix: [:transform, :transformMatrix],
+        uniform_texcoord_matrix: :texMatrix,
+        uniform_texcoord_min:    :texMin,
+        uniform_texcoord_max:    :texMax,
+        uniform_texcoord_offset: :texOffset,
+        uniform_texture:         [:texMap, :texture]
+      }.freeze
+
+      # @private
+      def self.createFilter__(*args)
+        case arg = args.shift
+        when Shader
+          arg
+        when :threshold
+          self.new(nil, <<~END).tap {|sh| sh.set :threshold, (args.shift || 0.5)}
+            uniform float threshold;
+            uniform sampler2D texMap;
+            varying vec4 vertTexCoord;
+            varying vec4 vertColor;
+            void main() {
+              vec4 col     = texture2D(texMap, vertTexCoord.xy) * vertColor;
+              float gray   = col.r * 0.3 + col.g * 0.59 + col.b * 0.11;
+              gl_FragColor = vec4(vec3(gray > threshold ? 1.0 : 0.0), 1.0);
+            }
+          END
+        when :gray
+          self.new nil, <<~END
+            uniform sampler2D texMap;
+            varying vec4 vertTexCoord;
+            varying vec4 vertColor;
+            void main() {
+              vec4 col     = texture2D(texMap, vertTexCoord.xy);
+              float gray   = col.r * 0.3 + col.g * 0.59 + col.b * 0.11;
+              gl_FragColor = vec4(vec3(gray), 1.0) * vertColor;
+            }
+          END
+        when :invert
+          self.new nil, <<~END
+            uniform sampler2D texMap;
+            varying vec4 vertTexCoord;
+            varying vec4 vertColor;
+            void main() {
+              vec4 col     = texture2D(texMap, vertTexCoord.xy);
+              gl_FragColor = vec4(vec3(1.0 - col.rgb), 1.0) * vertColor;
+            }
+          END
+        when :blur
+          self.new(nil, <<~END).tap {|sh| sh.set :radius, (args.shift || 1).to_f}
+            #define PI 3.1415926538
+            uniform float radius;
+            uniform sampler2D texMap;
+            uniform vec3 texMin;
+            uniform vec3 texMax;
+            uniform vec3 texOffset;
+            varying vec4 vertTexCoord;
+            varying vec4 vertColor;
+            float gaussian(vec2 pos, float sigma) {
+              float s2 = sigma * sigma;
+              return 1.0 / (2.0 * PI * s2) * exp(-(dot(pos, pos) / (2.0 * s2)));
+            }
+            void main() {
+              float sigma        = radius * 0.5;
+              vec3 color         = vec3(0.0);
+              float total_weight = 0.0;
+              for (float y = -radius; y < radius; y += 1.0)
+              for (float x = -radius; x < radius; x += 1.0) {
+                vec2 offset   = vec2(x, y);
+                float weight  = gaussian(offset, sigma);
+                vec2 texcoord = vertTexCoord.xy + offset * texOffset.xy;
+                if (
+                  texcoord.x < texMin.x || texMax.x < texcoord.x ||
+                  texcoord.y < texMin.y || texMax.y < texcoord.y
+                ) continue;
+                color += texture2D(texMap, texcoord).rgb * weight;
+                total_weight += weight;
+              }
+              gl_FragColor = vec4(color / total_weight, 1.0) * vertColor;
+            }
+          END
+        else
+          nil
+        end
+      end
+
+    end# Shader
+
+
     # Camera object.
     #
     class Capture
@@ -838,14 +1011,31 @@ module RubySketch
         @camera.image&.height || 0
       end
 
+      # Applies an image filter.
+      #
+      # overload filter(shader)
+      # overload filter(type)
+      # overload filter(type, param)
+      #
+      # @param shader [Shader]  a fragment shader to apply
+      # @param type   [THRESHOLD, GRAY, INVERT, BLUR] filter type
+      # @param param  [Numeric] a parameter for each filter
+      #
+      def filter(*args)
+        @filter = Shader.createFilter__(*args)
+      end
+
       # @private
       def getInternal__()
-        @camera.image || dummyImage__
+        @camera.image || (@dummyImage ||= Rays::Image.new 1, 1)
       end
 
       # @private
-      private def dummyImage__()
-        @dummy ||= Rays::Image.new 1, 1
+      def drawImage__(painter, *args, **states)
+        shader = painter.shader || @filter&.getInternal__
+        painter.push shader: shader, **states do |_|
+          painter.image getInternal__, *args
+        end
       end
 
     end# Capture
@@ -978,6 +1168,18 @@ module RubySketch
       # Mode for textAlign().
       BASELINE = :baseline
 
+      # Filter type for filter()
+      THRESHOLD = :threshold
+
+      # Filter type for filter()
+      GRAY      = :gray
+
+      # Filter type for filter()
+      INVERT    = :invert
+
+      # Filter type for filter()
+      BLUR      = :blur
+
       # Key codes.
       ENTER     = :enter
       SPACE     = :space
@@ -1036,9 +1238,10 @@ module RubySketch
         @rectMode__    = nil
         @ellipseMode__ = nil
         @imageMode__   = nil
-        @tint__        = nil
         @textAlignH__  = nil
         @textAlignV__  = nil
+        @tint__        = nil
+        @filter__      = nil
         @matrixStack__ = []
         @styleStack__  = []
         @fontCache__   = {}
@@ -1068,6 +1271,7 @@ module RubySketch
 
       # @private
       def beginDraw__()
+        raise "call beginDraw() before drawing" if @drawing__
         @matrixStack__.clear
         @styleStack__.clear
         @drawing__ = true
@@ -1075,6 +1279,7 @@ module RubySketch
 
       # @private
       def endDraw__()
+        raise unless @drawing__
         @drawing__ = false
       end
 
@@ -1442,6 +1647,40 @@ module RubySketch
         @painter__.font = font
       end
 
+      # Sets shader.
+      #
+      # @param shader [Shader] a shader to apply
+      #
+      # @return [nil] nil
+      #
+      def shader(shader)
+        @painter__.shader shader&.getInternal__
+        nil
+      end
+
+      # Resets shader.
+      #
+      # @return [nil] nil
+      #
+      def resetShader()
+        @painter__.no_shader
+        nil
+      end
+
+      # Applies an image filter to screen.
+      #
+      # overload filter(shader)
+      # overload filter(type)
+      # overload filter(type, param)
+      #
+      # @param shader [Shader]  a shader to apply
+      # @param type   [THRESHOLD, GRAY, INVERT, BLUR] filter type
+      # @param param  [Numeric] a parameter for each filter
+      #
+      def filter(*args)
+        @filter__ = Shader.createFilter__(*args)
+      end
+
       # Clears screen.
       #
       # @overload background(str)
@@ -1727,12 +1966,9 @@ module RubySketch
       #
       def image(img, a, b, c = nil, d = nil)
         assertDrawing__
-        i          = img.getInternal__
-        x, y, w, h = toXYWH__ @imageMode__, a, b, c || i.width, d || i.height
+        x, y, w, h = toXYWH__ @imageMode__, a, b, c || img.width, d || img.height
         tint       = @tint__ ? toRGBA__(*@tint__) : 1
-        @painter__.push fill: tint, stroke: :none do |_|
-          @painter__.image i, x, y, w, h
-        end
+        img.drawImage__ @painter__, x, y, w, h, fill: tint, stroke: :none
         nil
       end
 
@@ -1777,12 +2013,8 @@ module RubySketch
       #
       def blend(img = nil, sx, sy, sw, sh, dx, dy, dw, dh, mode)
         assertDrawing__
-        src     = img&.getInternal__ || @window__.canvas_image
-        current = @painter__.blend_mode
-
-        @painter__.blend_mode = mode
-        @painter__.image src, sx, sy, sw, sh, dx, dy, dw, dh
-        @painter__.blend_mode = current
+        img ||= self
+        img.drawImage__ @painter__, sx, sy, sw, sh, dx, dy, dw, dh, blend_mode: mode
       end
 
       # Saves screen image to file.
@@ -1846,11 +2078,10 @@ module RubySketch
       def pushMatrix(&block)
         assertDrawing__
         @matrixStack__.push @painter__.matrix
-        if block
-          block.call
-          popMatrix
-        end
+        block.call if block
         nil
+      ensure
+        popMatrix if block
       end
 
       # Pops the current transformation matrix from stack.
@@ -1889,18 +2120,22 @@ module RubySketch
           @painter__.clip,
           @painter__.blend_mode,
           @painter__.font,
+          @painter__.shader,
           @hsbColor__,
           @colorMaxes__,
           @angleScale__,
           @rectMode__,
           @ellipseMode__,
-          @imageMode__
+          @imageMode__,
+          @textAlignH__,
+          @textAlignV__,
+          @tint__,
+          @filter__,
         ]
-        if block
-          block.call
-          popStyle
-        end
+        block.call if block
         nil
+      ensure
+        popStyle if block
       end
 
       # Restore style values from the style stack.
@@ -1918,12 +2153,17 @@ module RubySketch
         @painter__.clip,
         @painter__.blend_mode,
         @painter__.font,
+        @painter__.shader,
         @hsbColor__,
         @colorMaxes__,
         @angleScale__,
         @rectMode__,
         @ellipseMode__,
-        @imageMode__ = @styleStack__.pop
+        @imageMode__,
+        @textAlignH__,
+        @textAlignV__,
+        @tint__,
+        @filter__ = @styleStack__.pop
         nil
       end
 
@@ -1934,10 +2174,9 @@ module RubySketch
       def push(&block)
         pushMatrix
         pushStyle
-        if block
-          block.call
-          pop
-        end
+        block.call if block
+      ensure
+        pop if block
       end
 
       # Restore styles and transformations from stack.
@@ -1954,951 +2193,993 @@ module RubySketch
         @image__
       end
 
+      # @private
+      def drawImage__(painter, *args, **states)
+        shader = painter.shader || @filter__&.getInternal__
+        painter.push shader: shader, **states do |_|
+          painter.image getInternal__, *args
+        end
+      end
+
       # @private
       private def assertDrawing__()
         raise "call beginDraw() before drawing" unless @drawing__
       end
 
-    end# GraphicsContext
-
-
-    # Draws graphics into an offscreen buffer
-    #
-    class Graphics
-
-      include GraphicsContext
+      #
+      # Utilities
+      #
 
-      # Initialize graphics object.
+      # Returns the absolute number of the value.
       #
-      def initialize(width, height)
-        image = Rays::Image.new width, height
-        init__ image, image.painter
+      # @param value [Numeric] number
+      #
+      # @return [Numeric] absolute number
+      #
+      def abs(value)
+        value.abs
       end
 
-      # Start drawing.
+      # Returns the closest integer number greater than or equal to the value.
       #
-      def beginDraw(&block)
-        @painter__.__send__ :begin_paint
-        beginDraw__
-        push
-        if block
-          block.call
-          endDraw
-        end
+      # @param value [Numeric] number
+      #
+      # @return [Numeric] rounded up number
+      #
+      def ceil(value)
+        value.ceil
       end
 
-      # End drawing.
+      # Returns the closest integer number less than or equal to the value.
       #
-      def endDraw()
-        pop
-        endDraw__
-        @painter__.__send__ :end_paint
+      # @param value [Numeric] number
+      #
+      # @return [Numeric] rounded down number
+      #
+      def floor(value)
+        value.floor
       end
 
-    end# Graphics
-
+      # Returns the closest integer number.
+      #
+      # @param value [Numeric] number
+      #
+      # @return [Numeric] rounded number
+      #
+      def round(value)
+        value.round
+      end
 
-    # Processing context
-    #
-    class Context
+      # Returns the natural logarithm (the base-e logarithm) of a number.
+      #
+      # @param value [Numeric] number (> 0.0)
+      #
+      # @return [Numeric] result number
+      #
+      def log(n)
+        Math.log n
+      end
 
-      include GraphicsContext
+      # Returns Euler's number e raised to the power of value.
+      #
+      # @param value [Numeric] number
+      #
+      # @return [Numeric] result number
+      #
+      def exp(n)
+        Math.exp n
+      end
 
-      Vector   = Processing::Vector
-      Capture  = Processing::Capture
-      Graphics = Processing::Graphics
+      # Returns value raised to the power of exponent.
+      #
+      # @param value    [Numeric] base number
+      # @param exponent [Numeric] exponent number
+      #
+      # @return [Numeric] value ** exponent
+      #
+      def pow(value, exponent)
+        value ** exponent
+      end
 
-      # @private
-      @@context__ = nil
+      # Returns squared value.
+      #
+      # @param value [Numeric] number
+      #
+      # @return [Numeric] squared value
+      #
+      def sq(value)
+        value * value
+      end
 
-      # @private
-      def self.context__()
-        @@context__
+      # Returns squared value.
+      #
+      # @param value [Numeric] number
+      #
+      # @return [Numeric] squared value
+      #
+      def sqrt(value)
+        Math.sqrt value
       end
 
-      # @private
-      def initialize(window)
-        @@context__ = self
+      # Returns the magnitude (or length) of a vector.
+      #
+      # @overload mag(x, y)
+      # @overload mag(x, y, z)
+      #
+      # @param x [Numeric] x of point
+      # @param y [Numeric] y of point
+      # @param z [Numeric] z of point
+      #
+      # @return [Numeric] magnitude
+      #
+      def mag(*args)
+        x, y, z = *args
+        case args.size
+        when 2 then Math.sqrt x * x + y * y
+        when 3 then Math.sqrt x * x + y * y + z * z
+        else raise ArgumentError
+        end
+      end
 
-        tmpdir__.tap {|dir| FileUtils.rm_r dir.to_s if dir.directory?}
+      # Returns distance between 2 points.
+      #
+      # @overload dist(x1, y1, x2, y2)
+      # @overload dist(x1, y1, z1, x2, y2, z2)
+      #
+      # @param x1 [Numeric] x of first point
+      # @param y1 [Numeric] y of first point
+      # @param z1 [Numeric] z of first point
+      # @param x2 [Numeric] x of second point
+      # @param y2 [Numeric] y of second point
+      # @param z2 [Numeric] z of second point
+      #
+      # @return [Numeric] distance between 2 points
+      #
+      def dist(*args)
+        case args.size
+        when 4
+          x1, y1, x2, y2 = *args
+          xx, yy = x2 - x1, y2 - y1
+          Math.sqrt xx * xx + yy * yy
+        when 3
+          x1, y1, z1, x2, y2, z2 = *args
+          xx, yy, zz = x2 - x1, y2 - y1, z2 - z1
+          Math.sqrt xx * xx + yy * yy + zz * zz
+        else raise ArgumentError
+        end
+      end
 
-        @window__ = window
-        init__(
-          @window__.canvas_image,
-          @window__.canvas_painter.paint {background 0.8})
-
-        @loop__            = true
-        @redraw__          = false
-        @frameCount__      = 0
-        @key__             = nil
-        @keyCode__         = nil
-        @keysPressed__     = Set.new
-        @pointerPos__      =
-        @pointerPrevPos__  = Rays::Point.new 0
-        @pointersPressed__ = []
-        @touches__         = []
-        @motionGravity__   = createVector 0, 0
-
-        @window__.before_draw = proc {beginDraw__}
-        @window__.after_draw  = proc {endDraw__}
-
-        drawFrame = -> {
-          updateCanvas__ @window__.canvas_image, @window__.canvas_painter
-          begin
-            push
-            @drawBlock__.call if @drawBlock__
-          ensure
-            pop
-            @frameCount__ += 1
-          end
-        }
-
-        @window__.draw = proc do |e|
-          if @loop__ || @redraw__
-            @redraw__ = false
-            drawFrame.call
-          end
-        end
-
-        updateKeyStates = -> event, pressed {
-          @key__     = event.chars
-          @keyCode__ = event.key
-          if pressed != nil
-            set, key = @keysPressed__, event.key
-            pressed ? set.add(key) : set.delete(key)
-          end
-        }
-
-        mouseButtonMap = {
-          mouse_left:   LEFT,
-          mouse_right:  RIGHT,
-          mouse_middle: CENTER
-        }
-
-        updatePointerStates = -> event, pressed = nil {
-          @pointerPrevPos__ = @pointerPos__
-          @pointerPos__ = event.pos.dup
-          @touches__    = event.pointers.map {|p| Touch.new(p.id, *p.pos.to_a)}
-          if pressed != nil
-            array = @pointersPressed__
-            event.types
-              .tap {|types| types.delete :mouse}
-              .map {|type| mouseButtonMap[type] || type}
-              .each {|type| pressed ? array.push(type) : array.delete(type)}
-          end
-        }
-
-        @window__.key_down = proc do |e|
-          updateKeyStates.call e, true
-          @keyPressedBlock__&.call
-          @keyTypedBlock__&.call if @key__ && !@key__.empty?
-        end
-
-        @window__.key_up = proc do |e|
-          updateKeyStates.call e, false
-          @keyReleasedBlock__&.call
-        end
-
-        @window__.pointer_down = proc do |e|
-          updatePointerStates.call e, true
-          @pointerDownStartPos__ = @pointerPos__.dup
-          (@touchStartedBlock__ || @mousePressedBlock__)&.call
-        end
-
-        @window__.pointer_up = proc do |e|
-          updatePointerStates.call e, false
-          (@touchEndedBlock__ || @mouseReleasedBlock__)&.call
-          if startPos = @pointerDownStartPos__
-            @mouseClickedBlock__&.call if (@pointerPos__ - startPos).length < 3
-            @pointerDownStartPos__ = nil
-          end
-        end
-
-        @window__.pointer_move = proc do |e|
-          updatePointerStates.call e
-          (@touchMovedBlock__ || @mouseMovedBlock__)&.call
-        end
-
-        @window__.pointer_drag = proc do |e|
-          updatePointerStates.call e
-          (@touchMovedBlock__ || @mouseDraggedBlock__)&.call
-        end
-
-        @window__.motion = proc do |e|
-          @motionGravity__ = createVector(*e.gravity.to_a(3))
-          @motionBlock__&.call
-        end
-      end
-
-      # Defines setup block.
+      # Normalize the value from range start..stop into 0..1.
       #
-      # @return [nil] nil
+      # @param value [Numeric] number to be normalized
+      # @param start [Numeric] lower bound of the range
+      # @param stop  [Numeric] upper bound of the range
       #
-      def setup(&block)
-        @window__.setup = block
-        nil
+      # @return [Numeric] normalized value between 0..1
+      #
+      def norm(value, start, stop)
+        (value.to_f - start.to_f) / (stop.to_f - start.to_f)
       end
 
-      # Defines draw block.
+      # Returns the interpolated number between range start..stop.
       #
-      # @return [nil] nil
+      # @param start  [Numeric] lower bound of the range
+      # @param stop   [Numeric] upper bound of the range
+      # @param amount [Numeric] amount to interpolate
       #
-      def draw(&block)
-        @drawBlock__ = block if block
-        nil
+      # @return [Numeric] interporated number
+      #
+      def lerp(start, stop, amount)
+        start + (stop - start) * amount
       end
 
-      # Defines keyPressed block.
+      # Maps a number from range start1..stop1 to range start2..stop2.
       #
-      # @return [Boolean] is any key pressed or not
+      # @param value  [Numeric] number to be mapped
+      # @param start1 [Numeric] lower bound of the range1
+      # @param stop1  [Numeric] upper bound of the range1
+      # @param start2 [Numeric] lower bound of the range2
+      # @param stop2  [Numeric] upper bound of the range2
       #
-      def keyPressed(&block)
-        @keyPressedBlock__ = block if block
-        not @keysPressed__.empty?
+      # @return [Numeric] mapped number
+      #
+      def map(value, start1, stop1, start2, stop2)
+        lerp start2, stop2, norm(value, start1, stop1)
       end
 
-      # Defines keyReleased block.
+      # Returns minimum value.
       #
-      # @return [nil] nil
+      # @overload min(a, b)
+      # @overload min(a, b, c)
+      # @overload min(array)
       #
-      def keyReleased(&block)
-        @keyReleasedBlock__ = block if block
-        nil
-      end
-
-      # Defines keyTyped block.
+      # @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 [nil] nil
+      # @return [Numeric] minimum value
       #
-      def keyTyped(&block)
-        @keyTypedBlock__ = block if block
-        nil
+      def min(*args)
+        args.flatten.min
       end
 
-      # Defines mousePressed block.
+      # Returns maximum value.
       #
-      # @return [Boolean] is any mouse button pressed or not
+      # @overload max(a, b)
+      # @overload max(a, b, c)
+      # @overload max(array)
       #
-      def mousePressed(&block)
-        @mousePressedBlock__ = block if block
-        not @pointersPressed__.empty?
+      # @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
 
-      # Defines mouseReleased block.
+      # Constrains the number between min..max.
       #
-      # @return [nil] nil
+      # @param value [Numeric] number to be constrained
+      # @param min   [Numeric] lower bound of the range
+      # @param max   [Numeric] upper bound of the range
       #
-      def mouseReleased(&block)
-        @mouseReleasedBlock__ = block if block
-        nil
+      # @return [Numeric] constrained number
+      #
+      def constrain(value, min, max)
+        value < min ? min : (value > max ? max : value)
       end
 
-      # Defines mouseMoved block.
+      # Converts degree to radian.
       #
-      # @return [nil] nil
+      # @param degree [Numeric] degree to convert
       #
-      def mouseMoved(&block)
-        @mouseMovedBlock__ = block if block
-        nil
+      # @return [Numeric] radian
+      #
+      def radians(degree)
+        degree * DEG2RAD__
       end
 
-      # Defines mouseDragged block.
+      # Converts radian to degree.
       #
-      # @return [nil] nil
+      # @param radian [Numeric] radian to convert
       #
-      def mouseDragged(&block)
-        @mouseDraggedBlock__ = block if block
-        nil
+      # @return [Numeric] degree
+      #
+      def degrees(radian)
+        radian * RAD2DEG__
       end
 
-      # Defines mouseClicked block.
+      # Returns the sine of an angle.
       #
-      # @return [nil] nil
+      # @param angle [Numeric] angle in radians
       #
-      def mouseClicked(&block)
-        @mouseClickedBlock__ = block if block
-        nil
+      # @return [Numeric] the sine
+      #
+      def sin(angle)
+        Math.sin angle
       end
 
-      # Defines touchStarted block.
+      # Returns the cosine of an angle.
       #
-      # @return [nil] nil
+      # @param angle [Numeric] angle in radians
       #
-      def touchStarted(&block)
-        @touchStartedBlock__ = block if block
-        nil
+      # @return [Numeric] the cosine
+      #
+      def cos(angle)
+        Math.cos angle
       end
 
-      # Defines touchEnded block.
+      # Returns the ratio of the sine and cosine of an angle.
       #
-      # @return [nil] nil
+      # @param angle [Numeric] angle in radians
       #
-      def touchEnded(&block)
-        @touchEndedBlock__ = block if block
-        nil
+      # @return [Numeric] the tangent
+      #
+      def tan(angle)
+        Math.tan angle
       end
 
-      # Defines touchMoved block.
+      # Returns the inverse of sin().
       #
-      # @return [nil] nil
+      # @param value [Numeric] value for calculation
       #
-      def touchMoved(&block)
-        @touchMovedBlock__ = block if block
-        nil
+      # @return [Numeric] the arc sine
+      #
+      def asin(value)
+        Math.asin value
       end
 
-      # Defines motion block.
+      # Returns the inverse of cos().
       #
-      # @return [nil] nil
+      # @param value [Numeric] value for calculation
       #
-      def motion(&block)
-        @motionBlock__ = block if block
-        nil
+      # @return [Numeric] the arc cosine
+      #
+      def acos(value)
+        Math.acos value
       end
 
-      # Changes canvas size.
+      # Returns the inverse of tan().
       #
-      # @param width        [Integer] new width
-      # @param height       [Integer] new height
-      # @param pixelDensity [Numeric] new pixel density
+      # @param value [Numeric] value for valculation
       #
-      # @return [nil] nil
+      # @return [Numeric] the arc tangent
       #
-      def size(width, height, pixelDensity: self.pixelDensity)
-        resizeCanvas__ :size, width, height, pixelDensity
-        nil
+      def atan(value)
+        Math.atan value
       end
 
-      # Changes canvas size.
+      # Returns the angle from a specified point.
       #
-      # @param width        [Integer] new width
-      # @param height       [Integer] new height
-      # @param pixelDensity [Numeric] new pixel density
+      # @param y [Numeric] y of the point
+      # @param x [Numeric] x of the point
       #
-      # @return [nil] nil
+      # @return [Numeric] the angle in radians
       #
-      def createCanvas(width, height, pixelDensity: self.pixelDensity)
-        resizeCanvas__ :createCanvas, width, height, pixelDensity
-        nil
+      def atan2(y, x)
+        Math.atan2 y, x
       end
 
-      # Changes title of window.
+      # Returns the perlin noise value.
       #
-      # @param title [String] new title
+      # @overload noise(x)
+      # @overload noise(x, y)
+      # @overload noise(x, y, z)
       #
-      # @return [nil] nil
+      # @param x [Numeric] horizontal point in noise space
+      # @param y [Numeric] vertical point in noise space
+      # @param z [Numeric] depth point in noise space
       #
-      def setTitle(title)
-        @window__.title = title
-        nil
+      # @return [Numeric] noise value (0.0..1.0)
+      #
+      def noise(x, y = 0, z = 0)
+        Rays.perlin(x, y, z) / 2.0 + 0.5
       end
 
-      # Changes and returns canvas pixel density.
+      # Returns a random number in range low...high
       #
-      # @param density [Numeric] new pixel density
+      # @overload random()
+      # @overload random(high)
+      # @overload random(low, high)
+      # @overload random(choices)
       #
-      # @return [Numeric] current pixel density
+      # @param low     [Numeric] lower limit
+      # @param high    [Numeric] upper limit
+      # @param choices [Array]   array to choose from
       #
-      def pixelDensity(density = nil)
-        resizeCanvas__ :pixelDensity, width, height, density if density
-        @painter__.pixel_density
-      end
-
-      # @private
-      def resizeCanvas__(name, width, height, pixelDensity)
-        raise '#{name}() must be called on startup or setup block' if @started__
-
-        @painter__.__send__ :end_paint
-        begin
-          @window__.__send__ :resize_canvas, width, height, pixelDensity
-          updateCanvas__ @window__.canvas_image, @window__.canvas_painter
-        ensure
-          @painter__.__send__ :begin_paint
-        end
-
-        @window__.auto_resize = false
+      # @return [Float] random number
+      #
+      def random(*args)
+        return args.first.sample if args.first.kind_of? Array
+        high, low = args.reverse
+        rand (low || 0).to_f...(high || 1).to_f
       end
 
-      # Returns pixel density of display.
+      # Creates a new vector.
       #
-      # @return [Numeric] pixel density
+      # @overload createVector()
+      # @overload createVector(x, y)
+      # @overload createVector(x, y, z)
       #
-      def displayDensity()
-        @window__.painter.pixel_density
-      end
-
-      # Returns window width.
+      # @param x [Numeric] x of new vector
+      # @param y [Numeric] y of new vector
+      # @param z [Numeric] z of new vector
       #
-      # @return [Numeric] window width
+      # @return [Vector] new vector
       #
-      def windowWidth()
-        @window__.width
+      def createVector(*args)
+        Vector.new(*args, context: self)
       end
 
-      # Returns window height.
+      # Creates a new image.
       #
-      # @return [Numeric] window height
+      # @overload createImage(w, h)
+      # @overload createImage(w, h, format)
       #
-      def windowHeight()
-        @window__.height
-      end
-
-      # Returns number of frames since program started.
+      # @param w      [Numeric]   width of new image
+      # @param h      [Numeric]   height of new image
+      # @param format [RGB, RGBA] image format
       #
-      # @return [Integer] total number of frames
+      # @return [Image] new image
       #
-      def frameCount()
-        @frameCount__
+      def createImage(w, h, format = RGBA)
+        colorspace = {RGB => Rays::RGB, RGBA => Rays::RGBA}[format]
+        raise ArgumentError, "Unknown image format" unless colorspace
+        Image.new Rays::Image.new(w, h, colorspace).paint {background 0, 0}
       end
 
-      # Returns number of frames per second.
+      # Creates a new off-screen graphics context object.
       #
-      # @return [Float] frames per second
+      # @param width  [Numeric] width of graphics image
+      # @param height [Numeric] height of graphics image
       #
-      def frameRate()
-        @window__.event.fps
+      # @return [Graphics] graphics object
+      #
+      def createGraphics(width, height)
+        Graphics.new width, height
       end
 
-      # Returns the last key that was pressed or released.
+      # Creates a shader object.
       #
-      # @return [String] last key
+      # @overload createShader(vertPath, fragPath)
+      # @overload createShader(vertSource, fragSource)
       #
-      def key()
-        @key__
-      end
-
-      # Returns the last key code that was pressed or released.
+      # @param vertPath   [String] vertex shader file path
+      # @param fragPath   [String] fragment shader file path
+      # @param vertSource [String] vertex shader source
+      # @param fragSource [String] fragment shader source
       #
-      # @return [Symbol] last key code
+      # @return [Shader] shader object
       #
-      def keyCode()
-        @keyCode__
+      def createShader(vert, frag)
+        vert = File.read if vert && File.exist?(vert)
+        frag = File.read if frag && File.exist?(frag)
+        Shader.new vert, frag
       end
 
-      # Returns mouse x position
+      # Creates a camera object as a video input device.
       #
-      # @return [Numeric] horizontal position of mouse
+      # @return [Capture] camera object
       #
-      def mouseX()
-        @pointerPos__.x
+      def createCapture(*args)
+        Capture.new(*args)
       end
 
-      # Returns mouse y position
+      # Loads image.
       #
-      # @return [Numeric] vertical position of mouse
+      # @param filename  [String] file name to load image
+      # @param extension [String] type of image to load (ex. 'png')
       #
-      def mouseY()
-        @pointerPos__.y
+      # @return [Image] loaded image object
+      #
+      def loadImage(filename, extension = nil)
+        filename = getImage__ filename, extension if filename =~ %r|^https?://|
+        Image.new Rays::Image.load filename
       end
 
-      # Returns mouse x position in previous frame
+      # Loads shader file.
       #
-      # @return [Numeric] horizontal position of mouse
+      # @overload loadShader(fragPath)
+      # @overload loadShader(fragPath, vertPath)
       #
-      def pmouseX()
-        @pointerPrevPos__.x
-      end
-
-      # Returns mouse y position in previous frame
+      # @param fragPath [String] fragment shader file path
+      # @param vertPath [String] vertex shader file path
       #
-      # @return [Numeric] vertical position of mouse
+      # @return [Shader] loaded shader object
       #
-      def pmouseY()
-        @pointerPrevPos__.y
+      def loadShader(fragPath, vertPath = nil)
+        createShader vertPath, fragPath
       end
 
-      # Returns which mouse button was pressed
-      #
-      # @return [Numeric] LEFT, RIGHT, CENTER or 0
-      #
-      def mouseButton()
-        (@pointersPressed__ & [LEFT, RIGHT, CENTER]).last || 0
+      # @private
+      private def getImage__(uri, ext)
+        ext ||= File.extname uri
+        raise "unsupported image type -- #{ext}" unless ext =~ /^\.?(png|jpg|gif)$/i
+
+        tmpdir = tmpdir__
+        path   = tmpdir + Digest::SHA1.hexdigest(uri)
+        path   = path.sub_ext ext
+
+        unless path.file?
+          URI.open uri do |input|
+            input.set_encoding nil# disable default_internal
+            tmpdir.mkdir unless tmpdir.directory?
+            path.open('w') do |output|
+              output.set_encoding Encoding::ASCII_8BIT
+              while buf = input.read(2 ** 16)
+                output.write buf
+              end
+            end
+          end
+        end
+        path.to_s
       end
 
-      # Returns array of touches
-      #
-      # @return [Array] Touch objects
-      #
-      def touches()
-        @touches__
+      # @private
+      private def tmpdir__()
+        Pathname(Dir.tmpdir) + Digest::SHA1.hexdigest(self.class.name)
       end
 
-      # Returns vector for real world gravity
-      #
-      # @return [Vector] gravity vector
+    end# GraphicsContext
+
+
+    # Draws graphics into an offscreen buffer
+    #
+    class Graphics
+
+      include GraphicsContext
+
+      # Initialize graphics object.
       #
-      def motionGravity()
-        @motionGravity__
+      def initialize(width, height)
+        image = Rays::Image.new width, height
+        init__ image, image.painter
       end
 
-      # Enables calling draw block on every frame.
-      #
-      # @return [nil] nil
+      # Start drawing.
       #
-      def loop()
-        @loop__ = true
+      def beginDraw(&block)
+        beginDraw__
+        @painter__.__send__ :begin_paint
+        push
+        if block
+          block.call
+          endDraw
+        end
       end
 
-      # Disables calling draw block on every frame.
-      #
-      # @return [nil] nil
+      # End drawing.
       #
-      def noLoop()
-        @loop__ = false
+      def endDraw()
+        pop
+        @painter__.__send__ :end_paint
+        endDraw__
       end
 
-      # Calls draw block to redraw frame.
-      #
-      # @return [nil] nil
-      #
-      def redraw()
-        @redraw__ = true
+    end# Graphics
+
+
+    # Processing context
+    #
+    class Context
+
+      include GraphicsContext
+
+      Vector   = Processing::Vector
+      Capture  = Processing::Capture
+      Graphics = Processing::Graphics
+      Shader   = Processing::Shader
+
+      # @private
+      @@context__ = nil
+
+      # @private
+      def self.context__()
+        @@context__
       end
 
-      #
-      # Utilities
-      #
+      # @private
+      def initialize(window)
+        @@context__ = self
+
+        tmpdir__.tap {|dir| FileUtils.rm_r dir.to_s if dir.directory?}
+
+        @window__ = window
+        init__(
+          @window__.canvas_image,
+          @window__.canvas_painter.paint {background 0.8})
+
+        @loop__            = true
+        @redraw__          = false
+        @frameCount__      = 0
+        @key__             = nil
+        @keyCode__         = nil
+        @keysPressed__     = Set.new
+        @pointerPos__      =
+        @pointerPrevPos__  = Rays::Point.new 0
+        @pointersPressed__ = []
+        @touches__         = []
+        @motionGravity__   = createVector 0, 0
+
+        @window__.before_draw   = proc {beginDraw__}
+        @window__.after_draw    = proc {endDraw__}
+        @window__.update_canvas = proc {|i, p| updateCanvas__ i, p}
+
+        @window__.instance_variable_set :@context, self
+        def @window__.draw_screen(painter)
+          @context.drawImage__ painter
+        end
+
+        drawFrame = -> {
+          begin
+            push
+            @drawBlock__.call if @drawBlock__
+          ensure
+            pop
+            @frameCount__ += 1
+          end
+        }
+
+        @window__.draw = proc do |e|
+          if @loop__ || @redraw__
+            @redraw__ = false
+            drawFrame.call
+          end
+        end
+
+        updateKeyStates = -> event, pressed {
+          @key__     = event.chars
+          @keyCode__ = event.key
+          if pressed != nil
+            set, key = @keysPressed__, event.key
+            pressed ? set.add(key) : set.delete(key)
+          end
+        }
+
+        mouseButtonMap = {
+          mouse_left:   LEFT,
+          mouse_right:  RIGHT,
+          mouse_middle: CENTER
+        }
+
+        updatePointerStates = -> event, pressed = nil {
+          @pointerPrevPos__ = @pointerPos__
+          @pointerPos__ = event.pos.dup
+          @touches__    = event.pointers.map {|p| Touch.new(p.id, *p.pos.to_a)}
+          if pressed != nil
+            array = @pointersPressed__
+            event.types
+              .tap {|types| types.delete :mouse}
+              .map {|type| mouseButtonMap[type] || type}
+              .each {|type| pressed ? array.push(type) : array.delete(type)}
+          end
+        }
+
+        @window__.key_down = proc do |e|
+          updateKeyStates.call e, true
+          @keyPressedBlock__&.call
+          @keyTypedBlock__&.call if @key__ && !@key__.empty?
+        end
+
+        @window__.key_up = proc do |e|
+          updateKeyStates.call e, false
+          @keyReleasedBlock__&.call
+        end
+
+        @window__.pointer_down = proc do |e|
+          updatePointerStates.call e, true
+          @pointerDownStartPos__ = @pointerPos__.dup
+          (@touchStartedBlock__ || @mousePressedBlock__)&.call
+        end
 
-      # Returns the absolute number of the value.
-      #
-      # @param value [Numeric] number
-      #
-      # @return [Numeric] absolute number
-      #
-      def abs(value)
-        value.abs
-      end
+        @window__.pointer_up = proc do |e|
+          updatePointerStates.call e, false
+          (@touchEndedBlock__ || @mouseReleasedBlock__)&.call
+          if startPos = @pointerDownStartPos__
+            @mouseClickedBlock__&.call if (@pointerPos__ - startPos).length < 3
+            @pointerDownStartPos__ = nil
+          end
+        end
 
-      # Returns the closest integer number greater than or equal to the value.
-      #
-      # @param value [Numeric] number
-      #
-      # @return [Numeric] rounded up number
-      #
-      def ceil(value)
-        value.ceil
-      end
+        @window__.pointer_move = proc do |e|
+          updatePointerStates.call e
+          (@touchMovedBlock__ || @mouseMovedBlock__)&.call
+        end
 
-      # Returns the closest integer number less than or equal to the value.
-      #
-      # @param value [Numeric] number
-      #
-      # @return [Numeric] rounded down number
-      #
-      def floor(value)
-        value.floor
-      end
+        @window__.pointer_drag = proc do |e|
+          updatePointerStates.call e
+          (@touchMovedBlock__ || @mouseDraggedBlock__)&.call
+        end
 
-      # Returns the closest integer number.
-      #
-      # @param value [Numeric] number
-      #
-      # @return [Numeric] rounded number
-      #
-      def round(value)
-        value.round
+        @window__.motion = proc do |e|
+          @motionGravity__ = createVector(*e.gravity.to_a(3))
+          @motionBlock__&.call
+        end
       end
 
-      # Returns the natural logarithm (the base-e logarithm) of a number.
-      #
-      # @param value [Numeric] number (> 0.0)
+      # Defines setup block.
       #
-      # @return [Numeric] result number
+      # @return [nil] nil
       #
-      def log(n)
-        Math.log n
+      def setup(&block)
+        @window__.setup = block
+        nil
       end
 
-      # Returns Euler's number e raised to the power of value.
-      #
-      # @param value [Numeric] number
+      # Defines draw block.
       #
-      # @return [Numeric] result number
+      # @return [nil] nil
       #
-      def exp(n)
-        Math.exp n
+      def draw(&block)
+        @drawBlock__ = block if block
+        nil
       end
 
-      # Returns value raised to the power of exponent.
-      #
-      # @param value    [Numeric] base number
-      # @param exponent [Numeric] exponent number
+      # Defines keyPressed block.
       #
-      # @return [Numeric] value ** exponent
+      # @return [Boolean] is any key pressed or not
       #
-      def pow(value, exponent)
-        value ** exponent
+      def keyPressed(&block)
+        @keyPressedBlock__ = block if block
+        not @keysPressed__.empty?
       end
 
-      # Returns squared value.
-      #
-      # @param value [Numeric] number
+      # Defines keyReleased block.
       #
-      # @return [Numeric] squared value
+      # @return [nil] nil
       #
-      def sq(value)
-        value * value
+      def keyReleased(&block)
+        @keyReleasedBlock__ = block if block
+        nil
       end
 
-      # Returns squared value.
-      #
-      # @param value [Numeric] number
+      # Defines keyTyped block.
       #
-      # @return [Numeric] squared value
+      # @return [nil] nil
       #
-      def sqrt(value)
-        Math.sqrt value
+      def keyTyped(&block)
+        @keyTypedBlock__ = block if block
+        nil
       end
 
-      # Returns the magnitude (or length) of a vector.
-      #
-      # @overload mag(x, y)
-      # @overload mag(x, y, z)
-      #
-      # @param x [Numeric] x of point
-      # @param y [Numeric] y of point
-      # @param z [Numeric] z of point
+      # Defines mousePressed block.
       #
-      # @return [Numeric] magnitude
+      # @return [Boolean] is any mouse button pressed or not
       #
-      def mag(*args)
-        x, y, z = *args
-        case args.size
-        when 2 then Math.sqrt x * x + y * y
-        when 3 then Math.sqrt x * x + y * y + z * z
-        else raise ArgumentError
-        end
+      def mousePressed(&block)
+        @mousePressedBlock__ = block if block
+        not @pointersPressed__.empty?
       end
 
-      # Returns distance between 2 points.
-      #
-      # @overload dist(x1, y1, x2, y2)
-      # @overload dist(x1, y1, z1, x2, y2, z2)
-      #
-      # @param x1 [Numeric] x of first point
-      # @param y1 [Numeric] y of first point
-      # @param z1 [Numeric] z of first point
-      # @param x2 [Numeric] x of second point
-      # @param y2 [Numeric] y of second point
-      # @param z2 [Numeric] z of second point
+      # Defines mouseReleased block.
       #
-      # @return [Numeric] distance between 2 points
+      # @return [nil] nil
       #
-      def dist(*args)
-        case args.size
-        when 4
-          x1, y1, x2, y2 = *args
-          xx, yy = x2 - x1, y2 - y1
-          Math.sqrt xx * xx + yy * yy
-        when 3
-          x1, y1, z1, x2, y2, z2 = *args
-          xx, yy, zz = x2 - x1, y2 - y1, z2 - z1
-          Math.sqrt xx * xx + yy * yy + zz * zz
-        else raise ArgumentError
-        end
+      def mouseReleased(&block)
+        @mouseReleasedBlock__ = block if block
+        nil
       end
 
-      # Normalize the value from range start..stop into 0..1.
-      #
-      # @param value [Numeric] number to be normalized
-      # @param start [Numeric] lower bound of the range
-      # @param stop  [Numeric] upper bound of the range
+      # Defines mouseMoved block.
       #
-      # @return [Numeric] normalized value between 0..1
+      # @return [nil] nil
       #
-      def norm(value, start, stop)
-        (value.to_f - start.to_f) / (stop.to_f - start.to_f)
+      def mouseMoved(&block)
+        @mouseMovedBlock__ = block if block
+        nil
       end
 
-      # Returns the interpolated number between range start..stop.
-      #
-      # @param start  [Numeric] lower bound of the range
-      # @param stop   [Numeric] upper bound of the range
-      # @param amount [Numeric] amount to interpolate
+      # Defines mouseDragged block.
       #
-      # @return [Numeric] interporated number
+      # @return [nil] nil
       #
-      def lerp(start, stop, amount)
-        start + (stop - start) * amount
+      def mouseDragged(&block)
+        @mouseDraggedBlock__ = block if block
+        nil
       end
 
-      # Maps a number from range start1..stop1 to range start2..stop2.
-      #
-      # @param value  [Numeric] number to be mapped
-      # @param start1 [Numeric] lower bound of the range1
-      # @param stop1  [Numeric] upper bound of the range1
-      # @param start2 [Numeric] lower bound of the range2
-      # @param stop2  [Numeric] upper bound of the range2
+      # Defines mouseClicked block.
       #
-      # @return [Numeric] mapped number
+      # @return [nil] nil
       #
-      def map(value, start1, stop1, start2, stop2)
-        lerp start2, stop2, norm(value, start1, stop1)
+      def mouseClicked(&block)
+        @mouseClickedBlock__ = block if block
+        nil
       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
+      # Defines touchStarted block.
       #
-      # @return [Numeric] minimum value
+      # @return [nil] nil
       #
-      def min(*args)
-        args.flatten.min
+      def touchStarted(&block)
+        @touchStartedBlock__ = block if block
+        nil
       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
+      # Defines touchEnded block.
       #
-      # @return [Numeric] maximum value
+      # @return [nil] nil
       #
-      def max(*args)
-        args.flatten.max
+      def touchEnded(&block)
+        @touchEndedBlock__ = block if block
+        nil
       end
 
-      # Constrains the number between min..max.
-      #
-      # @param value [Numeric] number to be constrained
-      # @param min   [Numeric] lower bound of the range
-      # @param max   [Numeric] upper bound of the range
+      # Defines touchMoved block.
       #
-      # @return [Numeric] constrained number
+      # @return [nil] nil
       #
-      def constrain(value, min, max)
-        value < min ? min : (value > max ? max : value)
+      def touchMoved(&block)
+        @touchMovedBlock__ = block if block
+        nil
       end
 
-      # Converts degree to radian.
-      #
-      # @param degree [Numeric] degree to convert
+      # Defines motion block.
       #
-      # @return [Numeric] radian
+      # @return [nil] nil
       #
-      def radians(degree)
-        degree * DEG2RAD__
+      def motion(&block)
+        @motionBlock__ = block if block
+        nil
       end
 
-      # Converts radian to degree.
+      # Changes canvas size.
       #
-      # @param radian [Numeric] radian to convert
+      # @param width        [Integer] new width
+      # @param height       [Integer] new height
+      # @param pixelDensity [Numeric] new pixel density
       #
-      # @return [Numeric] degree
+      # @return [nil] nil
       #
-      def degrees(radian)
-        radian * RAD2DEG__
+      def size(width, height, pixelDensity: self.pixelDensity)
+        resizeCanvas__ :size, width, height, pixelDensity
+        nil
       end
 
-      # Returns the sine of an angle.
+      # Changes canvas size.
       #
-      # @param angle [Numeric] angle in radians
+      # @param width        [Integer] new width
+      # @param height       [Integer] new height
+      # @param pixelDensity [Numeric] new pixel density
       #
-      # @return [Numeric] the sine
+      # @return [nil] nil
       #
-      def sin(angle)
-        Math.sin angle
+      def createCanvas(width, height, pixelDensity: self.pixelDensity)
+        resizeCanvas__ :createCanvas, width, height, pixelDensity
+        nil
       end
 
-      # Returns the cosine of an angle.
+      # Changes title of window.
       #
-      # @param angle [Numeric] angle in radians
+      # @param title [String] new title
       #
-      # @return [Numeric] the cosine
+      # @return [nil] nil
       #
-      def cos(angle)
-        Math.cos angle
+      def setTitle(title)
+        @window__.title = title
+        nil
       end
 
-      # Returns the ratio of the sine and cosine of an angle.
+      # Changes and returns canvas pixel density.
       #
-      # @param angle [Numeric] angle in radians
+      # @param density [Numeric] new pixel density
       #
-      # @return [Numeric] the tangent
+      # @return [Numeric] current pixel density
       #
-      def tan(angle)
-        Math.tan angle
+      def pixelDensity(density = nil)
+        resizeCanvas__ :pixelDensity, width, height, density if density
+        @painter__.pixel_density
       end
 
-      # Returns the inverse of sin().
-      #
-      # @param value [Numeric] value for calculation
+      # @private
+      def resizeCanvas__(name, width, height, pixelDensity)
+        raise '#{name}() must be called on startup or setup block' if @started__
+
+        @painter__.__send__ :end_paint
+        @window__.resize_canvas width, height, pixelDensity
+        @window__.auto_resize = false
+      ensure
+        @painter__.__send__ :begin_paint
+      end
+
+      # Returns pixel density of display.
       #
-      # @return [Numeric] the arc sine
+      # @return [Numeric] pixel density
       #
-      def asin(value)
-        Math.asin value
+      def displayDensity()
+        @window__.painter.pixel_density
       end
 
-      # Returns the inverse of cos().
-      #
-      # @param value [Numeric] value for calculation
+      # Returns window width.
       #
-      # @return [Numeric] the arc cosine
+      # @return [Numeric] window width
       #
-      def acos(value)
-        Math.acos value
+      def windowWidth()
+        @window__.width
       end
 
-      # Returns the inverse of tan().
-      #
-      # @param value [Numeric] value for valculation
+      # Returns window height.
       #
-      # @return [Numeric] the arc tangent
+      # @return [Numeric] window height
       #
-      def atan(value)
-        Math.atan value
+      def windowHeight()
+        @window__.height
       end
 
-      # Returns the angle from a specified point.
-      #
-      # @param y [Numeric] y of the point
-      # @param x [Numeric] x of the point
+      # Returns number of frames since program started.
       #
-      # @return [Numeric] the angle in radians
+      # @return [Integer] total number of frames
       #
-      def atan2(y, x)
-        Math.atan2 y, x
+      def frameCount()
+        @frameCount__
       end
 
-      # Returns the perlin noise value.
+      # Returns number of frames per second.
       #
-      # @overload noise(x)
-      # @overload noise(x, y)
-      # @overload noise(x, y, z)
+      # @return [Float] frames per second
       #
-      # @param x [Numeric] horizontal point in noise space
-      # @param y [Numeric] vertical point in noise space
-      # @param z [Numeric] depth point in noise space
+      def frameRate()
+        @window__.event.fps
+      end
+
+      # Returns the last key that was pressed or released.
       #
-      # @return [Numeric] noise value (0.0..1.0)
+      # @return [String] last key
       #
-      def noise(x, y = 0, z = 0)
-        Rays.perlin(x, y, z) / 2.0 + 0.5
+      def key()
+        @key__
       end
 
-      # Returns a random number in range low...high
+      # Returns the last key code that was pressed or released.
       #
-      # @overload random()
-      # @overload random(high)
-      # @overload random(low, high)
-      # @overload random(choices)
+      # @return [Symbol] last key code
       #
-      # @param low     [Numeric] lower limit
-      # @param high    [Numeric] upper limit
-      # @param choices [Array]   array to choose from
+      def keyCode()
+        @keyCode__
+      end
+
+      # Returns mouse x position
       #
-      # @return [Float] random number
+      # @return [Numeric] horizontal position of mouse
       #
-      def random(*args)
-        return args.first.sample if args.first.kind_of? Array
-        high, low = args.reverse
-        rand (low || 0).to_f...(high || 1).to_f
+      def mouseX()
+        @pointerPos__.x
       end
 
-      # Creates a new vector.
+      # Returns mouse y position
       #
-      # @overload createVector()
-      # @overload createVector(x, y)
-      # @overload createVector(x, y, z)
+      # @return [Numeric] vertical position of mouse
       #
-      # @param x [Numeric] x of new vector
-      # @param y [Numeric] y of new vector
-      # @param z [Numeric] z of new vector
+      def mouseY()
+        @pointerPos__.y
+      end
+
+      # Returns mouse x position in previous frame
       #
-      # @return [Vector] new vector
+      # @return [Numeric] horizontal position of mouse
       #
-      def createVector(*args)
-        Vector.new(*args, context: self)
+      def pmouseX()
+        @pointerPrevPos__.x
       end
 
-      # Creates a new image.
+      # Returns mouse y position in previous frame
       #
-      # @overload createImage(w, h)
-      # @overload createImage(w, h, format)
+      # @return [Numeric] vertical position of mouse
       #
-      # @param w      [Numeric]   width of new image
-      # @param h      [Numeric]   height of new image
-      # @param format [RGB, RGBA] image format
+      def pmouseY()
+        @pointerPrevPos__.y
+      end
+
+      # Returns which mouse button was pressed
       #
-      # @return [Image] new image
+      # @return [Numeric] LEFT, RIGHT, CENTER or 0
       #
-      def createImage(w, h, format = RGBA)
-        colorspace = {RGB => Rays::RGB, RGBA => Rays::RGBA}[format]
-        raise ArgumentError, "Unknown image format" unless colorspace
-        Image.new Rays::Image.new(w, h, colorspace).paint {background 0, 0}
+      def mouseButton()
+        (@pointersPressed__ & [LEFT, RIGHT, CENTER]).last || 0
       end
 
-      # Creates a camera object as a video input device.
+      # Returns array of touches
       #
-      # @return [Capture] camera object
+      # @return [Array] Touch objects
       #
-      def createCapture(*args)
-        Capture.new(*args)
+      def touches()
+        @touches__
       end
 
-      # Creates a new off-screen graphics context object.
-      #
-      # @param width  [Numeric] width of graphics image
-      # @param height [Numeric] height of graphics image
+      # Returns vector for real world gravity
       #
-      # @return [Graphics] graphics object
+      # @return [Vector] gravity vector
       #
-      def createGraphics(width, height)
-        Graphics.new width, height
+      def motionGravity()
+        @motionGravity__
       end
 
-      # Loads image.
-      #
-      # @param filename  [String] file name to load image
-      # @param extension [String] type of image to load (ex. 'png')
+      # Enables calling draw block on every frame.
       #
-      # @return [Image] loaded image object
+      # @return [nil] nil
       #
-      def loadImage(filename, extension = nil)
-        filename = getImage__ filename, extension if filename =~ %r|^https?://|
-        Image.new Rays::Image.load filename
+      def loop()
+        @loop__ = true
       end
 
-      # @private
-      private def getImage__(uri, ext)
-        ext ||= File.extname uri
-        raise "unsupported image type -- #{ext}" unless ext =~ /^\.?(png)$/i
-
-        tmpdir = tmpdir__
-        path   = tmpdir + Digest::SHA1.hexdigest(uri)
-        path   = path.sub_ext ext
-
-        unless path.file?
-          URI.open uri do |input|
-            input.set_encoding nil# disable default_internal
-            tmpdir.mkdir unless tmpdir.directory?
-            path.open('w') do |output|
-              output.set_encoding Encoding::ASCII_8BIT
-              while buf = input.read(2 ** 16)
-                output.write buf
-              end
-            end
-          end
-        end
-        path.to_s
+      # Disables calling draw block on every frame.
+      #
+      # @return [nil] nil
+      #
+      def noLoop()
+        @loop__ = false
       end
 
-      # @private
-      private def tmpdir__()
-        Pathname(Dir.tmpdir) + Digest::SHA1.hexdigest(self.class.name)
+      # Calls draw block to redraw frame.
+      #
+      # @return [nil] nil
+      #
+      def redraw()
+        @redraw__ = true
       end
 
     end# Context