rubysketch 0.3.21 → 0.3.22

data/lib/rubysketch/window.rb

@@ -21,32 +21,42 @@ module RubySketch
       end
     end
 
-    attr_accessor :setup, :update, :draw, :before_draw, :after_draw, :resize,
+    attr_accessor :setup, :update, :draw, :resize,
       :key_down, :key_up,
       :pointer_down, :pointer_up, :pointer_move, :pointer_drag,
-      :motion
+      :motion,
+      :before_draw, :after_draw, :update_canvas
 
     attr_accessor :auto_resize
 
-    attr_reader :canvas_image, :canvas_painter
-
     def initialize(width = 500, height = 500, *args, **kwargs, &block)
       RubySketch.instance_variable_set :@window, self
 
-      @canvas_image   =
-      @canvas_painter = nil
-      @events         = []
-      @auto_resize    = true
-      @error          = nil
-
-      painter.miter_limit = 10
-      resize_canvas 1, 1
-
+      @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
@@ -54,8 +64,11 @@ module RubySketch
       end
     end
 
-    def event()
-      @events.last
+    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()
@@ -67,6 +80,9 @@ module RubySketch
     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
 
@@ -89,7 +105,7 @@ module RubySketch
 
     def on_canvas_draw(e)
       draw_canvas {call_block @draw, e} if @draw
-      e.painter.image @canvas_image
+      draw_screen e.painter
     end
 
     def on_canvas_pointer(e)
@@ -102,55 +118,12 @@ module RubySketch
     end
 
     def on_canvas_resize(e)
-      resize_canvas e.width, e.height if @auto_resize
+      resize_canvas e.width, e.height, window_painter.pixel_density if @auto_resize
       draw_canvas {call_block @resize, e} if @resize
     end
 
     private
 
-    def resize_canvas(width, height, pixel_density = nil)
-      return nil if width * height == 0
-
-      unless width    == @canvas_image&.width  &&
-        height        == @canvas_image&.height &&
-        pixel_density == @canvas_painter&.pixel_density
-
-        old_image   = @canvas_image
-        old_painter = @canvas_painter
-        cs          = old_image&.color_space || Rays::RGBA
-        pd          =  pixel_density ||
-          old_painter&.pixel_density ||
-          painter     .pixel_density
-
-        @canvas_image   = Rays::Image.new width, height, cs, pd
-        @canvas_painter = @canvas_image.painter
-
-        if old_image
-          @canvas_painter.paint {image old_image}
-          copy_painter_attributes old_painter, @canvas_painter
-        end
-
-        resize_window width, height
-        GC.start
-      end
-
-      @canvas_painter
-    end
-
-    def copy_painter_attributes(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
-
-    def resize_window(width, height)
-      size width, height
-    end
-
     def update_canvas_view()
       scrollx, scrolly, zoom = get_scroll_and_zoom
       @canvas_view.scroll_to scrollx, scrolly
@@ -158,8 +131,8 @@ module RubySketch
     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
+      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
@@ -180,13 +153,17 @@ module RubySketch
     end
 
     def begin_draw()
-      @canvas_painter.__send__ :begin_paint
+      canvas_painter.__send__ :begin_paint
       @before_draw&.call
     end
 
     def end_draw()
       @after_draw&.call
-      @canvas_painter.__send__ :end_paint
+      canvas_painter.__send__ :end_paint
+    end
+
+    def draw_screen(painter)
+      window_painter.image canvas_image
     end
 
     def call_block(block, event, *args)
@@ -202,4 +179,54 @@ module RubySketch
   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

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

data/rubysketch.gemspec

@@ -28,7 +28,7 @@ Gem::Specification.new do |s|
   s.platform              = Gem::Platform::RUBY
   s.required_ruby_version = '>= 2.6.0'
 
-  s.add_runtime_dependency 'reflexion', '~> 0.1.28'
+  s.add_runtime_dependency 'reflexion', '~> 0.1.29'
 
   s.add_development_dependency 'yard'
 

data/test/processing/helper.rb

@@ -0,0 +1,11 @@
+# -*- 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

@@ -0,0 +1,21 @@
+# -*- 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

@@ -0,0 +1,47 @@
+# -*- 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,34 +1,41 @@
 # -*- coding: utf-8 -*-
 
 
-require_relative '../helper'
+require_relative 'helper'
 
 
 class TestProcessingUtility < Test::Unit::TestCase
 
-  def context()
-    RubySketch::Processing::Context.new RubySketch::Window.new
-  end
+  P = RubySketch::Processing
 
-  def test_random()
-    c = context
+  include P::GraphicsContext
 
-    assert_equal Float,  c.random(1).class
-    assert_equal Float,  c.random(1.0).class
-    assert_equal Symbol, c.random((:a..:z).to_a).class
+  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 c.random, c.random
+    assert_not_equal random, random
 
     10000.times do
-      n = c.random
+      n = random
       assert 0 <= n && n < 1
 
-      n = c.random 1
+      n = random 1
       assert 0 <= n && n < 1
 
-      n = c.random 1, 2
+      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

data/test/processing/test_vector.rb

@@ -1,7 +1,7 @@
 # -*- coding: utf-8 -*-
 
 
-require_relative '../helper'
+require_relative 'helper'
 
 
 class TestProcessingVector < Test::Unit::TestCase

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rubysketch
 version: !ruby/object:Gem::Version
-  version: 0.3.21
+  version: 0.3.22
 platform: ruby
 authors:
 - xordog
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-09-04 00:00:00.000000000 Z
+date: 2022-11-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: reflexion
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.1.28
+        version: 0.1.29
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.1.28
+        version: 0.1.29
 - !ruby/object:Gem::Dependency
   name: yard
   requirement: !ruby/object:Gem::Requirement
@@ -75,6 +75,9 @@ files:
 - src/RubySketch.h
 - src/RubySketch.mm
 - test/helper.rb
+- test/processing/helper.rb
+- test/processing/test_graphics.rb
+- test/processing/test_shader.rb
 - test/processing/test_utility.rb
 - test/processing/test_vector.rb
 homepage: https://github.com/xord/rubysketch
@@ -101,5 +104,8 @@ specification_version: 4
 summary: Processing like Creative Coding Framework.
 test_files:
 - test/helper.rb
+- test/processing/helper.rb
+- test/processing/test_graphics.rb
+- test/processing/test_shader.rb
 - test/processing/test_utility.rb
 - test/processing/test_vector.rb