rubysketch 0.3.22 → 0.5.2

data/lib/rubysketch/window.rb

@@ -1,232 +0,0 @@
-module RubySketch
-
-
-  class Window < Reflex::Window
-
-    class CanvasView < Reflex::View
-      def on_update(e)
-        window.on_canvas_update e
-      end
-
-      def on_draw(e)
-        window.on_canvas_draw e
-      end
-
-      def on_pointer(e)
-        window.on_canvas_pointer e
-      end
-
-      def on_resize(e)
-        window.on_canvas_resize e
-      end
-    end
-
-    attr_accessor :setup, :update, :draw, :resize,
-      :key_down, :key_up,
-      :pointer_down, :pointer_up, :pointer_move, :pointer_drag,
-      :motion,
-      :before_draw, :after_draw, :update_canvas
-
-    attr_accessor :auto_resize
-
-    def initialize(width = 500, height = 500, *args, **kwargs, &block)
-      RubySketch.instance_variable_set :@window, self
-
-      @events      = []
-      @error       = nil
-      @auto_resize = true
-      @canvas      = Canvas.new self
-      @canvas_view = add CanvasView.new name: :canvas
-
-      super(*args, size: [width, height], **kwargs, &block)
-    end
-
-    def canvas_image()
-      @canvas.image
-    end
-
-    def canvas_painter()
-      @canvas.painter
-    end
-
-    def window_painter()
-      self.painter
-    end
-
-    def event()
-      @events.last
-    end
-
-    def start(&block)
-      draw_canvas do
-        block.call if block
-        on_setup
-      end
-    end
-
-    def resize_canvas(width, height, pixel_density = nil)
-      if @canvas.resize width, height, pixel_density
-        @update_canvas.call canvas_image, canvas_painter if @update_canvas
-        size width, height
-      end
-    end
-
-    def on_setup()
-      call_block @setup, nil
-    end
-
-    def on_resize(e)
-      on_canvas_resize e
-    end
-
-    def on_draw(e)
-      window_painter.pixel_density.tap do |pd|
-        resize_canvas width, height, pd if pd != canvas_painter.pixel_density
-      end
-      update_canvas_view
-    end
-
-    def on_key(e)
-      block = case e.action
-        when :down then @key_down
-        when :up   then @key_up
-      end
-      draw_canvas {call_block block, e} if block
-    end
-
-    def on_motion(e)
-      draw_canvas {call_block @motion, e} if @motion
-    end
-
-    def on_canvas_update(e)
-      call_block @update, e
-      @canvas_view.redraw
-    end
-
-    def on_canvas_draw(e)
-      draw_canvas {call_block @draw, e} if @draw
-      draw_screen e.painter
-    end
-
-    def on_canvas_pointer(e)
-      block = case e.action
-        when :down        then @pointer_down
-        when :up, :cancel then @pointer_up
-        when :move        then e.drag? ? @pointer_drag : @pointer_move
-      end
-      draw_canvas {call_block block, e} if block
-    end
-
-    def on_canvas_resize(e)
-      resize_canvas e.width, e.height, window_painter.pixel_density if @auto_resize
-      draw_canvas {call_block @resize, e} if @resize
-    end
-
-    private
-
-    def update_canvas_view()
-      scrollx, scrolly, zoom = get_scroll_and_zoom
-      @canvas_view.scroll_to scrollx, scrolly
-      @canvas_view.zoom zoom
-    end
-
-    def get_scroll_and_zoom()
-      ww, wh =              width.to_f,              height.to_f
-      cw, ch = canvas_image.width.to_f, canvas_image.height.to_f
-      return [0, 0, 1] if ww == 0 || wh == 0 || cw == 0 || ch == 0
-
-      wratio, cratio = ww / wh, cw / ch
-      if wratio >= cratio
-        scaled_w = wh * cratio
-        return (ww - scaled_w) / 2, 0, scaled_w / cw
-      else
-        scaled_h = ww / cratio
-        return 0, (wh - scaled_h) / 2, ww / cw
-      end
-    end
-
-    def draw_canvas(&block)
-      begin_draw
-      block.call
-    ensure
-      end_draw
-    end
-
-    def begin_draw()
-      canvas_painter.__send__ :begin_paint
-      @before_draw&.call
-    end
-
-    def end_draw()
-      @after_draw&.call
-      canvas_painter.__send__ :end_paint
-    end
-
-    def draw_screen(painter)
-      window_painter.image canvas_image
-    end
-
-    def call_block(block, event, *args)
-      @events.push event
-      block.call event, *args if block && !@error
-    rescue Exception => e
-      @error = e
-      $stderr.puts e.full_message
-    ensure
-      @events.pop
-    end
-
-  end# Window
-
-
-  class Window::Canvas
-
-    attr_reader :image, :painter
-
-    def initialize(window)
-      @image   = nil
-      @painter = window.painter
-
-      resize 1, 1
-      painter.miter_limit = 10
-    end
-
-    def resize(width, height, pixel_density = nil)
-      return false if width * height == 0
-
-      return false if
-        width         == @image&.width  &&
-        height        == @image&.height &&
-        pixel_density == @painter.pixel_density
-
-      old_image   = @image
-      old_painter = @painter
-      cs          = old_image&.color_space || Rays::RGBA
-      pd          = pixel_density || old_painter.pixel_density
-
-      @image   = Rays::Image.new width, height, cs, pd
-      @painter = @image.painter
-
-      @painter.paint {image old_image} if old_image
-      copy_painter old_painter, @painter
-
-      GC.start
-      return true
-    end
-
-    private
-
-    def copy_painter(from, to)
-      to.fill         = from.fill
-      to.stroke       = from.stroke
-      to.stroke_width = from.stroke_width
-      to.stroke_cap   = from.stroke_cap
-      to.stroke_join  = from.stroke_join
-      to.miter_limit  = from.miter_limit
-      to.font         = from.font
-    end
-
-  end# Window::Canvas
-
-
-end# RubySketch

data/lib/rubysketch-glsl.rb

@@ -1,12 +0,0 @@
-require 'rubysketch'
-
-
-def (RubySketch::GLSL).run(
-    shader_source,
-    title: 'RubySketch',
-    width: 500, height: 500)
-  w = RubySketch::Window.new(title: title, w: width, h: height) {start}
-  c = RubySketch::GLSL::Context.new w
-  c.run shader_source
-  at_exit {RubySketch::App.new {w.show}.start unless $!}
-end

data/lib/rubysketch-processing.rb

@@ -1,25 +0,0 @@
-require 'rubysketch'
-
-
-begin
-  window  = RubySketch::Window.new {start}
-  context = RubySketch::Processing::Context.new window
-
-  (context.methods - Object.instance_methods).each do |method|
-    define_method method do |*args, **kwargs, &block|
-      context.__send__ method, *args, **kwargs, &block
-    end
-  end
-
-  context.class.constants.each do |const|
-    self.class.const_set const, context.class.const_get(const)
-  end
-
-  window.__send__ :begin_draw
-  at_exit do
-    window.__send__ :end_draw
-    RubySketch::App.new {window.show}.start unless $!
-  end
-
-  RUBYSKETCH_WINDOW = window
-end

data/src/RubySketch.mm

@@ -1,55 +0,0 @@
-#import <CRuby.h>
-#import "RubySketch.h"
-#include "../src/ios/view_controller.h"
-
-
-static ReflexViewController* active_reflex_view_controller = nil;
-
-static ReflexViewController*
-ReflexViewController_create()
-{
-	return active_reflex_view_controller;
-}
-
-static void
-ReflexViewController_show (UIViewController*, ReflexViewController*)
-{
-}
-
-
-@implementation RubySketch
-
-	+ (void) setup
-	{
-		static BOOL done = NO;
-		if (done) return;
-		done = YES;
-
-		[CRuby addLibrary:@"RubySketch" bundle:[NSBundle bundleForClass:RubySketch.class]];
-
-		ReflexViewController_set_create_fun(ReflexViewController_create);
-		ReflexViewController_set_show_fun(ReflexViewController_show);
-	}
-
-	+ (void) start: (NSString*) path
-	{
-		[CRuby evaluate:[NSString stringWithFormat:@
-			"raise 'already started' unless require 'rubysketch-processing'\n"
-			"load '%@'\n"
-			"RUBYSKETCH_WINDOW.__send__ :end_draw\n"
-			"RUBYSKETCH_WINDOW.show",
-			path
-		]];
-	}
-
-	+ (void) setActiveReflexViewController: (id) reflexViewController
-	{
-		active_reflex_view_controller = reflexViewController;
-	}
-
-	+ (void) resetActiveReflexViewController
-	{
-		active_reflex_view_controller = nil;
-	}
-
-@end

data/test/processing/helper.rb

@@ -1,11 +0,0 @@
-# -*- coding: utf-8 -*-
-
-
-require_relative '../helper'
-
-
-def graphics(width = 10, height = 10, &block)
-  RubySketch::Processing::Graphics.new(width, height).tap do |g|
-    g.beginDraw {block.call g, g.getInternal__} if block
-  end
-end

data/test/processing/test_graphics.rb

@@ -1,21 +0,0 @@
-# -*- coding: utf-8 -*-
-
-
-require_relative 'helper'
-
-
-class TestProcessingGraphics < Test::Unit::TestCase
-
-  P = RubySketch::Processing
-
-  def graphics(w = 10, h = 10)
-    P::Graphics.new w, h
-  end
-
-  def test_beginDraw()
-    g = graphics
-    g.beginDraw
-    assert_raise {g.beginDraw}
-  end
-
-end# TestProcessingGraphics

data/test/processing/test_shader.rb

@@ -1,47 +0,0 @@
-# -*- coding: utf-8 -*-
-
-
-require_relative 'helper'
-
-
-class TestProcessingShader < Test::Unit::TestCase
-
-  def color(*args)
-    Rays::Color.new(*args)
-  end
-
-  def shader(vs = vshader, fs = fshader)
-    RubySketch::Processing::Shader.new vs, fs
-  end
-
-  def vshader()
-    "void main() {gl_Position = vec4(0.0, 0.0, 0.0, 1.0);}"
-  end
-
-  def fshader()
-    "void main() {gl_FragColor = vec4(1.0, 0.0, 0.0, 1.0);}"
-  end
-
-  def test_initialize()
-    assert shader vshader, fshader
-    assert shader nil,     fshader
-
-    assert_raise(ArgumentError) {shader "", fshader}
-    assert_raise(ArgumentError) {shader vshader, ""}
-    assert_raise(ArgumentError) {shader vshader, nil}
-  end
-
-  def test_uniform()
-    sh = shader(nil, <<~END).tap {|s| s.set :val, 1.0}
-      uniform float val;
-      void main() {gl_FragColor = vec4(val, 0.0, 0.0, 1.0);}
-    END
-
-    graphics do |g, image|
-      g.shader sh
-      g.rect 0, 0, 10, 10
-      assert_equal color(1, 0, 0, 1), image[0, 0]
-    end
-  end
-
-end# TestProcessingShader

data/test/processing/test_utility.rb

@@ -1,41 +0,0 @@
-# -*- coding: utf-8 -*-
-
-
-require_relative 'helper'
-
-
-class TestProcessingUtility < Test::Unit::TestCase
-
-  P = RubySketch::Processing
-
-  include P::GraphicsContext
-
-  def test_random()
-    assert_equal Float,  random(1).class
-    assert_equal Float,  random(1.0).class
-    assert_equal Symbol, random((:a..:z).to_a).class
-
-    assert_not_equal random, random
-
-    10000.times do
-      n = random
-      assert 0 <= n && n < 1
-
-      n = random 1
-      assert 0 <= n && n < 1
-
-      n = random 1, 2
-      assert 1.0 <= n && n < 2.0
-    end
-  end
-
-  def test_createVector()
-    assert_equal P::Vector, createVector(1, 2).class
-  end
-
-  def test_createShader()
-    fs = "void main() {gl_FragColor = vec4(1.0);}"
-    assert_equal P::Shader, createShader(nil, fs).class
-  end
-
-end# TestProcessingUtility