tested samples

Author: monkstone

lib/color_group.rb

@@ -1,4 +1,4 @@
-java_import Java::Monkstone::ColorUtil
+java_import 'monkstone.ColorUtil'
 
 # class wraps a java color array, supports shuffle!, last and ruby_string
 # as well as ability to initialize with an array of "web" color string

lib/vecmath.rb

@@ -1,11 +1,10 @@
 require 'java'
 require 'vecmath/version'
 require 'vecmath.jar'
-require 'core.jar'
+require 'color_group'
 module Vecmath
   Java::Monkstone::JRLibrary.load(JRuby.runtime)
 end
 
 java_import 'monkstone.vecmath.GfxRender'
 java_import 'monkstone.vecmath.ShapeRender'
-java_import 'monkstone.ColorUtil'

samples/25_squares.rb

@@ -2,7 +2,8 @@
 GEM_HOME = '/home/tux/.gem/ruby/2.6.0'
 require 'vecmath'
 PALETTE = %w[#a11220 #884444].freeze
-@colors = ColorUtil.webArray(PALETTE.to_java(:string))
+@group = ColorGroup.from_web_array(PALETTE)
+@colors = @group.colors
 rect_mode(CORNER)
 no_stroke
 frame_rate(1) # set the frame rate to 1 draw call per second

samples/arc_tesselation.rb

@@ -7,23 +7,24 @@
 
   # create a java primitive array of signed int
   #  @cols = web_array(PALETTE)
-  @group = ColorUtil.web_array(PALETTE.to_java(:string))
-  stroke_weight 1.5
+  @group = ColorGroup.from_web_array(PALETTE)
+  @colors = @group.colors
   stroke_cap SQUARE
   stroke(0, 200)
   @coloured = true
 
 
 def draw
   arc_pattern
+  no_loop
 end
 
 def sep_index(idx, length)
   (idx - (length - 1) * 0.5).abs.floor
 end
 
 def sep_color(idx, number)
-  @group[sep_index(idx - 1, number + 1)]
+  @colors[sep_index(idx - 1, number + 1)]
 end
 
 def arc_pattern
@@ -49,10 +50,13 @@ def arc_pattern
   end
 end
 
-# def mouse_pressed
-#  @group.shuffle if @coloured
-#  loop
-# end
+# Use midi controls attached to replace these methods?
+
+def mouse_pressed
+  @group.shuffle! if @coloured
+  @cols = @group.colors
+  loop
+end
 
 # def key_typed
 #  case key

samples/elegant_ball.rb

@@ -0,0 +1,142 @@
+# ===== Default : Default
+GEM_HOME = '/home/tux/.gem/ruby/2.6.0'
+require 'vecmath'
+
+color_mode(RGB, 1)
+
+def draw
+  background(0)
+  @renderer ||= GfxRender.new(graphics)
+  # Move the origin so that the scene is centered on the screen.
+  translate(width / 2, height / 2, 0.0)
+  # Set up the lighting.
+  setup_lights
+  # Rotate the local coordinate system.
+  smooth_rotation(5.0, 6.7, 7.3)
+  # Draw the inner object.
+  no_stroke
+  fill(smooth_colour(10.0, 12.0, 7.0))
+  draw_icosahedron(5, 60.0, false)
+  # Rotate the local coordinate system again.
+  smooth_rotation(4.5, 3.7, 7.3)
+  # Draw the outer object.
+  stroke(0.2)
+  fill(smooth_colour(6.0, 9.2, 0.7))
+  draw_icosahedron(5, 200.0, true)
+end
+
+def setup_lights
+  ambient_light(0.025, 0.025, 0.025)
+  directional_light(0.2, 0.2, 0.2, -1, -1, -1)
+  spot_light(1.0, 1.0, 1.0, -200, 0, 300, 1, 0, -1, PI / 4, 20)
+end
+
+# Generate a vector whose components change smoothly over time in the range
+# (0..1). Each component uses a Math.sin function to map the current time in
+# milliseconds in the range (0..1).A 'speed' factor is specified for each
+# component.
+def smooth_vector(s1, s2, s3)
+  mills = millis * 0.00003 ## Lazydogs factor
+  # mills = millis * 0.0000001 ## worked for me a bit slower!!
+  x = 0.5 * sin(mills * s1) + 0.5
+  y = 0.5 * sin(mills * s2) + 0.5
+  z = 0.5 * sin(mills * s3) + 0.5
+  Vec3D.new(x, y, z)
+end
+
+# Generate a colour which smoothly changes over time.
+# The speed of each component is controlled by the parameters s1, s2 and s3.
+def smooth_colour(s1, s2, s3)
+  v = smooth_vector(s1, s2, s3)
+  color(v.x, v.y, v.z)
+end
+
+# Rotate the current coordinate system.
+# Uses smooth_vector to smoothly animate the rotation.
+def smooth_rotation(s1, s2, s3)
+  r1 = smooth_vector(s1, s2, s3)
+  rotate_x(2.0 * Math::PI * r1.x)
+  rotate_y(2.0 * Math::PI * r1.y)
+  rotate_x(2.0 * Math::PI * r1.z)
+end
+
+# Draw an icosahedron defined by a radius r and recursive depth d.
+# Geometry data will be saved into dst. If spherical is true then the
+# icosahedron is projected onto the sphere with radius r.
+def draw_icosahedron(depth, r, spherical)
+  # Calculate the vertex data for an icosahedron inscribed by a sphere radius
+  # 'r'. Use 4 Golden Ratio rectangles as the basis.
+  gr = (1.0 + Math.sqrt(5.0)) / 2.0
+  h = r / Math.sqrt(1.0 + gr * gr)
+  v = [
+    Vec3D.new(0, -h, h * gr),
+    Vec3D.new(0, -h, -h * gr),
+    Vec3D.new(0, h, -h * gr),
+    Vec3D.new(0, h, h * gr),
+    Vec3D.new(h, -h * gr, 0),
+    Vec3D.new(h, h * gr, 0),
+    Vec3D.new(-h, h * gr, 0),
+    Vec3D.new(-h, -h * gr, 0),
+    Vec3D.new(-h * gr, 0, h),
+    Vec3D.new(-h * gr, 0, -h),
+    Vec3D.new(h * gr, 0, -h),
+    Vec3D.new(h * gr, 0, h)
+  ]
+  # Draw the 20 triangular faces of the icosahedron.
+  r = 0.0 unless spherical
+  begin_shape(TRIANGLES)
+  draw_triangle(depth, r, v[0], v[7], v[4])
+  draw_triangle(depth, r, v[0], v[4], v[11])
+  draw_triangle(depth, r, v[0], v[11], v[3])
+  draw_triangle(depth, r, v[0], v[3], v[8])
+  draw_triangle(depth, r, v[0], v[8], v[7])
+  draw_triangle(depth, r, v[1], v[4], v[7])
+  draw_triangle(depth, r, v[1], v[10], v[4])
+  draw_triangle(depth, r, v[10], v[11], v[4])
+  draw_triangle(depth, r, v[11], v[5], v[10])
+  draw_triangle(depth, r, v[5], v[3], v[11])
+  draw_triangle(depth, r, v[3], v[6], v[5])
+  draw_triangle(depth, r, v[6], v[8], v[3])
+  draw_triangle(depth, r, v[8], v[9], v[6])
+  draw_triangle(depth, r, v[9], v[7], v[8])
+  draw_triangle(depth, r, v[7], v[1], v[9])
+  draw_triangle(depth, r, v[2], v[1], v[9])
+  draw_triangle(depth, r, v[2], v[10], v[1])
+  draw_triangle(depth, r, v[2], v[5], v[10])
+  draw_triangle(depth, r, v[2], v[6], v[5])
+  draw_triangle(depth, r, v[2], v[9], v[6])
+  end_shape
+end
+
+##
+# Draw a triangle either immediately or subdivide it first.
+# If depth is 1 then draw the triangle otherwise subdivide first.
+#
+def draw_triangle(depth, r, p1, p2, p3)
+  if depth == 1
+    p1.to_vertex(@renderer)
+    p2.to_vertex(@renderer)
+    p3.to_vertex(@renderer)
+  else
+    # Calculate the mid points of this triangle.
+    v1 = (p1 + p2) * 0.5
+    v2 = (p2 + p3) * 0.5
+    v3 = (p3 + p1) * 0.5
+    unless r == 0.0
+      # Project the vertices out onto the sphere with radius r.
+      v1.normalize!
+      v1 *= r
+      v2.normalize!
+      v2 *= r
+      v3.normalize!
+      v3 *= r
+    end
+    ## Generate the next level of detail
+    depth -= 1
+    draw_triangle(depth, r, p1, v1, v3)
+    draw_triangle(depth, r, v1, p2, v2)
+    draw_triangle(depth, r, v2, p3, v3)
+    # Uncomment out the next line to include the central part of the triangle.
+    # draw_triangle(depth, r, v1, v2, v3)
+  end
+end