propane 3.4.2-java → 3.5.0-java

data/src/main/java/processing/opengl/VertexBuffer.java

@@ -1,3 +1,5 @@
+/* -*- mode: java; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+
 /*
   Part of the Processing project - http://processing.org
 
@@ -18,69 +20,69 @@
   Public License along with this library; if not, write to the
   Free Software Foundation, Inc., 59 Temple Place, Suite 330,
   Boston, MA  02111-1307  USA
- */
+*/
+
 package processing.opengl;
 
 import processing.opengl.PGraphicsOpenGL.GLResourceVertexBuffer;
 
 // TODO: need to combine with PGraphicsOpenGL.VertexAttribute
 public class VertexBuffer {
-
-    static protected final int INIT_VERTEX_BUFFER_SIZE = 256;
-    static protected final int INIT_INDEX_BUFFER_SIZE = 512;
-
-    public int glId;
-    int target;
-    int elementSize;
-    int ncoords;
-    boolean index;
-
-    protected PGL pgl;                // The interface between Processing and OpenGL.
-    protected int context;            // The context that created this texture.
-    private GLResourceVertexBuffer glres;
-
-    VertexBuffer(PGraphicsOpenGL pg, int target, int ncoords, int esize) {
-        this(pg, target, ncoords, esize, false);
-    }
-
-    VertexBuffer(PGraphicsOpenGL pg, int target, int ncoords, int esize, boolean index) {
-        pgl = pg.pgl;
-        context = pgl.createEmptyContext();
-
-        this.target = target;
-        this.ncoords = ncoords;
-        this.elementSize = esize;
-        this.index = index;
-        create();
-        init();
-    }
-
-    protected void create() {
-        context = pgl.getCurrentContext();
-        glres = new GLResourceVertexBuffer(this);
-    }
-
-    protected void init() {
-        int size = index ? ncoords * INIT_INDEX_BUFFER_SIZE * elementSize
-                : ncoords * INIT_VERTEX_BUFFER_SIZE * elementSize;
-        pgl.bindBuffer(target, glId);
-        pgl.bufferData(target, size, null, PGL.STATIC_DRAW);
-    }
-
-    protected void dispose() {
-        if (glres != null) {
-            glres.dispose();
-            glId = 0;
-            glres = null;
-        }
+  static protected final int INIT_VERTEX_BUFFER_SIZE  = 256;
+  static protected final int INIT_INDEX_BUFFER_SIZE   = 512;
+
+  public int glId;
+  int target;
+  int elementSize;
+  int ncoords;
+  boolean index;
+
+  protected PGL pgl;                // The interface between Processing and OpenGL.
+  protected int context;            // The context that created this texture.
+  private GLResourceVertexBuffer glres;
+
+  VertexBuffer(PGraphicsOpenGL pg, int target, int ncoords, int esize) {
+    this(pg, target, ncoords, esize, false);
+  }
+
+  VertexBuffer(PGraphicsOpenGL pg, int target, int ncoords, int esize, boolean index) {
+    pgl = pg.pgl;
+    context = pgl.createEmptyContext();
+
+    this.target = target;
+    this.ncoords = ncoords;
+    this.elementSize = esize;
+    this.index = index;
+    create();
+    init();
+  }
+
+  protected void create() {
+    context = pgl.getCurrentContext();
+    glres = new GLResourceVertexBuffer(this);
+  }
+
+  protected void init() {
+    int size = index ? ncoords * INIT_INDEX_BUFFER_SIZE * elementSize :
+                       ncoords * INIT_VERTEX_BUFFER_SIZE * elementSize;
+    pgl.bindBuffer(target, glId);
+    pgl.bufferData(target, size, null, PGL.STATIC_DRAW);
+  }
+
+  protected void dispose() {
+    if (glres != null) {
+      glres.dispose();
+      glId = 0;
+      glres = null;
     }
+  }
 
-    protected boolean contextIsOutdated() {
-        boolean outdated = !pgl.contextIsCurrent(context);
-        if (outdated) {
-            dispose();
-        }
-        return outdated;
+  protected boolean contextIsOutdated() {
+    boolean outdated = !pgl.contextIsCurrent(context);
+    if (outdated) {
+      dispose();
     }
+    return outdated;
+  }
 
 }

data/test/create_test.rb

@@ -1,33 +1,34 @@
+# frozen_string_literal: true
+
 require_relative 'test_helper'
 require_relative '../lib/propane/creators/sketch_class'
 require_relative '../lib/propane/creators/sketch_writer'
 
 CLASS_SKETCH = <<~CODE
+  #!/usr/bin/env jruby
+  # frozen_string_literal: false
 
-#!/usr/bin/env jruby
-# frozen_string_literal: false
-require 'propane'
+  require 'propane'
 
-class FredSketch < Propane::App
-  def settings
-    size 200, 200
-  end
+  class FredSketch < Propane::App
+    def settings
+      size 200, 200
+    end
 
-  def setup
-    sketch_title 'Fred Sketch'
-  end
+    def setup
+      sketch_title 'Fred Sketch'
+    end
 
-  def draw
+    def draw
 
+    end
   end
-end
 
-FredSketch.new
+  FredSketch.new
 
 CODE
-
+# Create sketch test
 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')
@@ -35,7 +36,7 @@ class SketchClassTest < Minitest::Test
 
   def test_class
     result = CLASS_SKETCH.split(/\n/, -1)
-    class_lines = @sketch.lines
+    class_lines = @basic.lines
     class_lines.each_with_index do |line, i|
       assert_equal result[i], line
     end
@@ -54,15 +55,15 @@ class SketchClassTest < Minitest::Test
     assert_equal "    sketch_title 'Fred Sketch'", @sketch.sketch_title
   end
 
-  def test_class
-    assert_equal "FredSketch", @sketch.sketch_class
+  def test_class_class
+    assert_equal 'FredSketch', @sketch.sketch_class
   end
 
   def test_class_new
-    assert_equal "FredSketch.new", @sketch.sketch_new
+    assert_equal 'FredSketch.new', @sketch.sketch_new
   end
 
   def test_sketch_class
-    assert_equal "class FredSketch < Propane::App", @basic.class_sketch
+    assert_equal 'class FredSketch < Propane::App', @basic.class_sketch
   end
 end

data/test/deglut_spec_test.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'test_helper'
 require 'java'
 require_relative '../lib/propane'
@@ -15,10 +17,10 @@ class DeglutTest < Minitest::Test
     (-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)
+      assert_in_delta(sine, deg_sin, 0.000001)
       cosine = DegLut.cos(deg)
       deg_cos = Math.cos(deg * to_radian)
-      assert_in_delta(cosine, deg_cos, delta = 0.000001)
+      assert_in_delta(cosine, deg_cos, 0.000001)
     end
   end
 end

data/test/helper_methods_test.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require_relative 'test_helper'
 require 'java'
 require_relative '../lib/propane'
@@ -11,41 +12,69 @@ include MathTool
 Dir.chdir(File.dirname(__FILE__))
 
 class HelperMethodsTest < Minitest::Test
-
- ARRAY = %w(albatross dog horse)
- def test_hex_color
+  ARRAY = %w[albatross dog horse].freeze
+  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 hex_color(hexcolor) == -3_381_760, 'hexadecimal fixnum color'
+    assert hex_color(hexstring) == -3_381_760, '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
+   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')
+    ax = 0
+    ay = 0
+    bx = 1.0
+    by = 1.0
+    assert_in_epsilon(dist(ax, ay, bx, by), Math.sqrt(2), 0.0001, '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), 1.0, 0.0001, 'when y dimension is zero')
+    ax = 0
+    ay = 0
+    bx = 0.0
+    by = 0.0
+    assert_in_epsilon(dist(ax, ay, bx, by), 0.0, 0.0001, 'when x and y dimension are zero')
+    ax = 1
+    ay = 1
+    bx = -2.0
+    by = -3.0
+    assert_in_epsilon(dist(ax, ay, bx, by), 5.0, 0.0001, 'classic triangle dimensions')
+    ax = -1
+    ay = -1
+    bx = 100
+    by = 2.0
+    cx = 3.0
+    cy = 100
+    assert_in_epsilon(dist(ax, ay, bx, by, cx, cy), 5.0, 0.0001, 'classic triangle dimensions')
+    ax = 0
+    ay = 0
+    bx = -1.0
+    by = -1.0
+    cx = 0
+    cy = 0
+    assert_in_epsilon(dist(ax, ay, bx, by, cx, cy), Math.sqrt(2), 0.0001, '2D distance')
+    ax = 0
+    ay = 0
+    bx = 0.0
+    by = 0.0
+    cx = 0
+    cy = 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')
+    ax = 0
+    ay = 0
+    bx = 1.0
+    by = 0.0
+    cx = 0
+    cy = 0
+    assert_in_epsilon(dist(ax, ay, bx, by, cx, cy), 1.0, 0.0001, 'when x and z dimension are zero')
   end
 
   def test_min

data/test/math_tool_test.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'test_helper'
 require 'java'
 require_relative '../lib/propane'
@@ -6,21 +8,20 @@ Java::Monkstone::PropaneLibrary.new.load(JRuby.runtime, false)
 
 # include Processing::HelperMethods
 
-
 Dir.chdir(File.dirname(__FILE__))
 
 class MathToolTest < Minitest::Test
- include MathTool
- def test_map1d
+  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')
+    assert_in_delta(map1d(x[0], range1, range2), 100, 0.00001, 'map to first')
+    assert_in_delta(map1d(x[1], range1, range2), 50.5, 0.00001, 'map to reversed intermediate')
+    assert_in_delta(map1d(x[2], range3, range4), 80.0, 0.00001, 'map to intermediate')
+    assert_in_delta(map1d(x[3], range1, range2), 1, 0.00001, 'map to last')
   end
 
   def test_p5map # as map1d except not using range input
@@ -29,47 +30,53 @@ class MathToolTest < Minitest::Test
     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)
+    assert_in_delta(p5map(x[0], range1.first, range1.last, range2.first, range2.last), 100, 0.00001)
+    assert_in_delta(p5map(x[1], range1.first, range1.last, range2.first, range2.last), 50.5, 0.00001)
+    assert_in_delta(p5map(x[2], range3.first, range3.last, range4.first, range4.last), 80.0, 0.00001)
+    assert_in_delta(p5map(x[3], range1.first, range1.last, range2.first, range2.last), 1, 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')
+    start0 = 30
+    last0 = 200
+    start_int = 0
+    last_int = 200
+    assert_in_delta(norm(x[0], start0, last0), -0.11764705882352941, 0.00001, 'unclamped map')
+    assert_in_delta(norm(x[1], start_int, last_int), 0.7, 0.00001, 'map to intermediate')
+    assert_in_delta(norm(x[2], start_int, last_int), 1.05, 0.00001, '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')
+    assert_in_delta(norm_strict(x[2], x[0], x[1]), 1.0, 0.00001, 'clamped map to 0..1.0')
+    assert_in_delta(norm_strict(x[2], x[1], x[0]), 0.0, 0.00001, 'clamped map to 0..1.0')
+    assert_in_delta(norm_strict(x[1], x[0], x[2]), 0.65, 0.00001, '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')
+    start0 = 300
+    last0 = 200
+    start_int = 0
+    last_int = 200
+    assert_in_delta(lerp(start0, last0, x[0]), 250, 0.00001, 'produces a intermediate value of a reversed range')
+    assert_in_delta(lerp(start_int, last_int, x[1]), 160, 0.00001, 'lerps to an intermediate value')
+    assert_in_delta(lerp(start_int, last_int, x[2]), 200, 0.00001, '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)
+    start_int = 0
+    last_int = 200
+    assert_in_delta(constrain(x_int[0], start_int, last_int), 15, 0.00001)
+    assert_in_delta(constrain(x_int[1], start_int, last_int), 200, 0.00001)
+    assert_in_delta(constrain(x_int[2], start_int, last_int), 0, 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')
+    startf = 0
+    lastf = 200.0
+    assert_in_delta(constrain(xf[0], startf, lastf), 15.0, 0.00001, 'constrain to 0..200')
+    assert_in_delta(constrain(xf[1], startf, lastf), 200.0, 0.00001, 'constrain to 0..200')
+    assert_in_delta(constrain(xf[2], startf, lastf), 0.0, 0.00001, 'constrain to 0..200')
   end
 end

data/test/native_folder.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require_relative 'test_helper'
+require 'java'
+require_relative '../lib/propane'
+# Mock class
+class WindowsNativeFolder < NativeFolder
+  def initialize
+    @os = 'mswin'
+    @bit = 64
+  end
+end
+
+class MacNativeFolder < NativeFolder
+  def initialize
+    @os = 'mac'
+    @bit = 64
+  end
+end
+
+# Test class
+class NativeFolderTest < Minitest::Test
+  def test_windows_native_folder
+    obj = WindowsNativeFolder.new
+    assert_kind_of NativeFolder, obj, 'Constructor Failed'
+    assert(/windows/.match?(obj.name))
+    assert(/\*.dll/.match?(obj.extension))
+  end
+
+  class NativeFolderTest < Minitest::Test
+    def test_windows_native_folder
+      obj = MacNativeFolder.new
+      assert_kind_of NativeFolder, obj, 'Constructor Failed'
+      assert(/macos/.match?(obj.name))
+      assert(/\*.dylib/.match?(obj.extension))
+    end
+  end
+
+  if /linux/.match?(RbConfig::CONFIG['host_os'].downcase)
+    def test_native_folder
+      obj = NativeFolder.new
+      assert_instance_of NativeFolder, obj, 'Constructor Failed'
+      assert(/linux/.match?(obj.name))
+      assert(/\*.so/.match?(obj.extension))
+    end
+  end
+end