picrate 0.0.2-java

data/test/create_test.rb

@@ -0,0 +1,68 @@
+require_relative 'test_helper'
+require_relative '../lib/picrate/creators/sketch_class'
+require_relative '../lib/picrate/creators/sketch_writer'
+
+CLASS_SKETCH = <<~CODE
+
+#!/usr/bin/env jruby
+# frozen_string_literal: false
+require 'picrate'
+
+class FredSketch < Processing::App
+  def settings
+    size 200, 200
+  end
+
+  def setup
+    sketch_title 'Fred Sketch'
+  end
+
+  def draw
+
+  end
+end
+
+FredSketch.new
+
+CODE
+
+class SketchClassTest < Minitest::Test
+
+  def setup
+    @basic = SketchClass.new(name: 'fred_sketch', width: 200, height: 200)
+    @sketch = SketchClass.new(name: 'fred_sketch', width: 200, height: 200, mode: 'p2d')
+  end
+
+  def test_class
+    result = CLASS_SKETCH.split(/\n/, -1)
+    class_lines = @sketch.lines
+    class_lines.each_with_index do |line, i|
+      assert_equal result[i], line
+    end
+  end
+
+  def test_indent
+    assert_equal '  indent', @sketch.indent('indent')
+  end
+
+  def test_size
+    assert_equal '    size 200, 200, P2D', @sketch.size
+    assert_equal '    size 200, 200', @basic.size
+  end
+
+  def test_sketch_title
+    assert_equal "    sketch_title 'Fred Sketch'", @sketch.sketch_title
+  end
+
+  def test_class
+    assert_equal "FredSketch", @sketch.sketch_class
+  end
+
+  def test_class_new
+    assert_equal "FredSketch.new", @sketch.sketch_new
+  end
+
+  def test_sketch_class
+    assert_equal "class FredSketch < Processing::App", @basic.class_sketch
+  end
+end

data/test/deglut_spec_test.rb

@@ -0,0 +1,24 @@
+require_relative 'test_helper'
+require 'java'
+require_relative '../lib/picrate'
+
+Dir.chdir(File.dirname(__FILE__))
+
+class DeglutTest < Minitest::Test
+  attr_reader :to_radian
+
+  def setup
+    @to_radian = Math::PI / 180
+  end
+
+  def test_cos_sin
+    (-720..720).step(1) do |deg|
+      sine = DegLut.sin(deg)
+      deg_sin = Math.sin(deg * to_radian)
+      assert_in_delta(sine, deg_sin, delta = 0.000001)
+      cosine = DegLut.cos(deg)
+      deg_cos = Math.cos(deg * to_radian)
+      assert_in_delta(cosine, deg_cos, delta = 0.000001)
+    end
+  end
+end

data/test/helper_methods_test.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+require_relative 'test_helper'
+require 'java'
+require_relative '../lib/picrate'
+
+Java::Monkstone::PicrateLibrary.new.load(JRuby.runtime, false)
+
+include Processing::HelperMethods
+include MathTool
+
+Dir.chdir(File.dirname(__FILE__))
+
+class HelperMethodsTest < Minitest::Test
+
+ ARRAY = %w(albatross dog horse)
+ def test_hex_color
+    col_double = 0.5
+    hexcolor = 0xFFCC6600
+    dodgy_hexstring = '*56666'
+    hexstring = '#CC6600'
+    assert hex_color(col_double) == 0.5, 'double as a color'
+    assert hex_color(hexcolor) == -3381760, 'hexadecimal fixnum color'
+    assert hex_color(hexstring) == -3381760, 'hexadecimal string color'
+    assert_raises(StandardError, 'Dodgy Hexstring') do
+      hex_color(dodgy_hexstring)
+    end
+    assert_raises(StandardError, 'Dodgy Color Conversion') do
+      hex_color([])
+    end
+  end
+
+  def test_dist
+    ax, ay, bx, by = 0, 0, 1.0, 1.0
+    assert_in_epsilon(dist(ax, ay, bx, by), Math.sqrt(2), epsilon = 0.0001, msg = '2D distance')
+    by = 0.0
+    assert_in_epsilon(dist(ax, ay, bx, by), 1.0, epsilon = 0.0001, msg = 'when y dimension is zero')
+    ax, ay, bx, by = 0, 0, 0.0, 0.0
+    assert_in_epsilon(dist(ax, ay, bx, by), 0.0, epsilon = 0.0001, msg = 'when x and y dimension are zero')
+    ax, ay, bx, by = 1, 1, -2.0, -3.0
+    assert_in_epsilon(dist(ax, ay, bx, by), 5.0, epsilon = 0.0001, msg = 'classic triangle dimensions')
+    ax, ay, bx, by, cx, cy = -1, -1, 100, 2.0, 3.0, 100
+    assert_in_epsilon(dist(ax, ay, bx, by, cx, cy), 5.0, epsilon = 0.0001, msg = 'classic triangle dimensions')
+    ax, ay, bx, by, cx, cy = 0, 0, -1.0, -1.0, 0, 0
+    assert_in_epsilon(dist(ax, ay, bx, by, cx, cy), Math.sqrt(2), epsilon = 0.0001, msg = '2D distance')
+    ax, ay, bx, by, cx, cy = 0, 0, 0.0, 0.0, 0, 0
+    assert_in_epsilon(dist(ax, ay, bx, by, cx, cy), 0.0)
+    ax, ay, bx, by, cx, cy = 0, 0, 1.0, 0.0, 0, 0
+    assert_in_epsilon(dist(ax, ay, bx, by, cx, cy), 1.0, epsilon = 0.0001, msg = 'when x and z dimension are zero')
+  end
+
+  def test_min
+    assert_equal(min(*ARRAY), 'albatross')
+  end
+
+  def test_max
+    assert_equal(max(*ARRAY), 'horse')
+  end
+end

data/test/math_tool_test.rb

@@ -0,0 +1,75 @@
+require_relative 'test_helper'
+require 'java'
+require_relative '../lib/picrate'
+
+Java::Monkstone::PicrateLibrary.new.load(JRuby.runtime, false)
+
+# include Processing::HelperMethods
+
+
+Dir.chdir(File.dirname(__FILE__))
+
+class MathToolTest < Minitest::Test
+ include MathTool
+ def test_map1d
+    x = [0, 5, 7.5, 10]
+    range1 = (0..10)
+    range2 = (100..1)
+    range3 = (0..10)
+    range4 = (5..105)
+    assert_in_delta(map1d(x[0], range1, range2), 100, delta = 0.00001, msg = 'map to first')
+    assert_in_delta(map1d(x[1], range1, range2), 50.5, delta = 0.00001, msg = 'map to reversed intermediate')
+    assert_in_delta(map1d(x[2], range3, range4), 80.0, delta = 0.00001, msg = 'map to intermediate')
+    assert_in_delta(map1d(x[3], range1, range2), 1, delta = 0.00001, msg = 'map to last')
+  end
+
+  def test_p5map # as map1d except not using range input
+    x = [0, 5, 7.5, 10]
+    range1 = (0..10)
+    range2 = (100..1)
+    range3 = (0..10)
+    range4 = (5..105)
+    assert_in_delta(p5map(x[0], range1.first, range1.last, range2.first, range2.last), 100, delta = 0.00001)
+    assert_in_delta(p5map(x[1], range1.first, range1.last, range2.first, range2.last), 50.5, delta = 0.00001)
+    assert_in_delta(p5map(x[2], range3.first, range3.last, range4.first, range4.last), 80.0, delta = 0.00001)
+    assert_in_delta(p5map(x[3], range1.first, range1.last, range2.first, range2.last), 1, delta = 0.00001)
+  end
+
+  def test_norm
+    x = [10, 140, 210]
+    start0, last0 = 30, 200
+    start_int, last_int = 0, 200
+    assert_in_delta(norm(x[0], start0, last0), -0.11764705882352941, delta = 0.00001, msg = 'unclamped map')
+    assert_in_delta(norm(x[1], start_int, last_int), 0.7, delta = 0.00001, msg = 'map to intermediate')
+    assert_in_delta(norm(x[2], start_int, last_int), 1.05, delta = 0.00001, msg = 'unclamped map')
+  end
+
+  def test_norm_strict
+    x = [10, 140, 210]
+    assert_in_delta(norm_strict(x[2], x[0], x[1]), 1.0, delta = 0.00001, msg = 'clamped map to 0..1.0')
+    assert_in_delta(norm_strict(x[2], x[1], x[0]), 0.0, delta = 0.00001, msg = 'clamped map to 0..1.0')
+    assert_in_delta(norm_strict(x[1], x[0], x[2]), 0.65, delta = 0.00001, msg = 'clamped map to 0..1.0')
+  end
+
+  def test_lerp # behaviour is deliberately different to processing which is unclamped
+    x = [0.5, 0.8, 2.0]
+    start0, last0 = 300, 200
+    start_int, last_int = 0, 200
+    assert_in_delta(lerp(start0, last0, x[0]), 250, delta = 0.00001, msg = 'produces a intermediate value of a reversed range')
+    assert_in_delta(lerp(start_int, last_int, x[1]), 160, delta = 0.00001, msg = 'lerps to an intermediate value')
+    assert_in_delta(lerp(start_int, last_int, x[2]), 200, delta = 0.00001, msg = 'lerps to the last value of a range')
+  end
+
+  def test_constrain
+    x_int = [15, 2_500, -2_500]
+    start_int, last_int = 0, 200
+    assert_in_delta(constrain(x_int[0], start_int, last_int), 15, delta = 0.00001)
+    assert_in_delta(constrain(x_int[1], start_int, last_int), 200, delta = 0.00001)
+    assert_in_delta(constrain(x_int[2], start_int, last_int), 0, delta = 0.00001)
+    xf = [15.0, 2_500.0, -2_500.0]
+    startf, lastf = 0, 200.0
+    assert_in_delta(constrain(xf[0], startf, lastf), 15.0, delta = 0.00001, msg = 'constrain to 0..200')
+    assert_in_delta(constrain(xf[1], startf, lastf), 200.0, delta = 0.00001, msg = 'constrain to 0..200')
+    assert_in_delta(constrain(xf[2], startf, lastf), 0.0, delta = 0.00001, msg = 'constrain to 0..200')
+  end
+end

data/test/respond_to_test.rb

@@ -0,0 +1,215 @@
+# frozen_string_literal: true
+require 'java'
+require_relative 'test_helper'
+require_relative '../lib/picrate'
+
+METHODS = %i(
+  alpha
+  ambient
+  ambient_light
+  apply_matrix
+  arc
+  background
+  begin_camera
+  begin_contour
+  begin_raw
+  begin_record
+  begin_shape
+  bezier
+  bezier_detail
+  bezier_point
+  bezier_tangent
+  bezier_vertex
+  blend
+  blend_mode
+  blue
+  box
+  brightness
+  camera
+  color
+  color_mode
+  copy
+  create_font
+  create_graphics
+  create_image
+  create_input
+  create_output
+  create_reader
+  create_shape
+  create_writer
+  cursor
+  curve
+  curve_detail
+  curve_point
+  curve_tangent
+  curve_tightness
+  curve_vertex
+  directional_light
+  ellipse
+  ellipse_mode
+  emissive
+  end_camera
+  end_contour
+  end_raw
+  end_record
+  end_shape
+  fill
+  filter
+  focused
+  frame_count
+  frame_rate
+  frame_rate
+  frustum
+  get
+  green
+  height
+  hue
+  image
+  image_mode
+  key
+  key_code
+  key_pressed
+  key_pressed?
+  key_released
+  key_typed
+  lerp_color
+  light_falloff
+  light_specular
+  lights
+  line
+  load_bytes
+  load_font
+  load_image
+  load_pixels
+  load_shader
+  load_shape
+  load_strings
+  load_table
+  load_xml
+  model_x
+  model_y
+  model_z
+  mouse_button
+  mouse_clicked
+  mouse_dragged
+  mouse_moved
+  mouse_pressed
+  mouse_pressed?
+  mouse_released
+  mouse_x
+  mouse_y
+  no_cursor
+  no_fill
+  no_lights
+  no_smooth
+  no_stroke
+  no_tint
+  noise
+  noise_detail
+  noise_seed
+  normal
+  ortho
+  perspective
+  pixels
+  pmouse_x
+  pmouse_y
+  point
+  point_light
+  pop_matrix
+  print_camera
+  print_matrix
+  print_projection
+  push_matrix
+  quad
+  quadratic_vertex
+  random
+  random_seed
+  rect
+  rect_mode
+  red
+  request_image
+  reset_matrix
+  reset_shader
+  rotate
+  rotate_x
+  rotate_y
+  rotate_z
+  saturation
+  save
+  save_bytes
+  save_frame
+  save_stream
+  save_strings
+  scale
+  screen_x
+  screen_y
+  screen_z
+  select_folder
+  select_input
+  select_output
+  set
+  shader
+  shape
+  shape_mode
+  shear_x
+  shear_y
+  shininess
+  sketch_title
+  size
+  smooth
+  specular
+  sphere
+  sphere_detail
+  spot_light
+  stroke
+  stroke_cap
+  stroke_join
+  stroke_weight
+  text_align
+  text_ascent
+  text_descent
+  text_font
+  text_leading
+  text_mode
+  text_size
+  text_width
+  texture
+  texture_mode
+  texture_wrap
+  tint
+  translate
+  triangle
+  update_pixels
+  vertex
+  width
+)
+
+class TestSketch < Propane::App
+  def settings
+    size 100, 100
+  end
+
+  def setup
+    sketch_title 'Sketch Test'
+  end
+
+  def draw
+    exit if frame_count > 30
+  end
+end
+
+class SpecTest < Minitest::Test
+  def setup
+    @propane_sketch = TestSketch.new
+  end
+
+  def test_respond
+    METHODS.each do |method_string|
+      assert_respond_to @propane_sketch, method_string
+    end
+  end
+
+  def tear_down
+    @propane_sketch = nil?
+  end
+end

data/test/sketches/key_event.rb

@@ -0,0 +1,37 @@
+#!/usr/bin/env jruby
+require 'propane'
+
+
+class CustomProxySketch < Propane::App
+
+  # A simple demonstration of vanilla processing 'reflection' methods using
+  # propane :library_proxy. See my_library.rb code for the guts.
+  load_libraries :library_proxy, :my_library
+
+  attr_reader :visible
+
+  def settings
+    size 300, 200
+    @visible = false
+  end
+
+  def setup
+    sketch_title 'Reflection Voodoo Proxy'
+    MyLibrary.new self
+  end
+
+  def hide(val)
+    @visible = !val
+  end
+
+  def draw
+    if visible
+      fill(0, 0, 200)
+      ellipse(170, 115, 70, 100)
+    else
+      background 0
+    end
+  end
+end
+
+CustomProxySketch.new