new examples

Author: monkstone

contributed/ball_of_confusion.rb

@@ -0,0 +1,232 @@
+# Ball of Confusion Sketch see original by Ben Notiaranni
+# http://lazydog-bookfragments.blogspot.com/2008/12/orb-code.html
+NUMBER_OF_HAIRS = 10_000
+BODY_R = 25.0
+MIN_HAIR_LENGTH = 24.0
+SHORT_HAIR_LENGTH = 30.0
+LONG_HAIR_LENGTH = 10.0
+LONG_HAIR_MAX_LENGTH = 30.0
+LONG_DENDRITE_LENGTH = 20.0
+LONG_DENDRITE_MAX_LENGTH = 60.0
+
+attr_reader :rotation_history, :g_frame, :g_lights, :ball_theta, :ball_phi
+attr_reader :camera_r, :camera_theta, :camera_phi, :graphics, :cr
+
+def key_pressed
+  return unless key == 'l'
+  @g_lights = !g_lights
+end
+
+def settings
+  size(800, 600, P3D)
+  smooth
+end
+
+def setup
+  sketch_title 'Ball of Confusion'
+  colorMode(RGB, 1.0)
+  background(0.0)
+  @rotation_history = RotationHistory.new(200)
+  @g_lights = true
+  @g_frame = 0
+  @camera_r = 130.0
+  @camera_phi = PI / 4
+  @camera_theta = 0.0
+  @ball_theta = 0
+  @ball_phi = 0
+  @graphics = self.g
+  # blend_mode(DIFFERENCE)
+end
+
+def draw
+  @camera_r = 180.0 + (sin(g_frame/50.0) + cos(g_frame / 57)) * 25
+  @g_frame += 1.0
+  @ball_theta += 2.0 * sin(g_frame/53.0)
+  @ball_phi += 2.0 * sin(g_frame/83.0)
+  rotation_history.push(ball_theta, ball_phi)
+  background(0.0)
+  camera_spherical(camera_r, camera_phi, -camera_theta)
+  random_seed(6)
+  @cr = 0.0
+  if (g_lights)
+    @cr = 1.0
+    lights
+    x = sin(g_frame / 30.0)
+    y = sin(g_frame / 37.0)
+    z = sin(g_frame / 43.0)
+    directional_light(1.0, 1.0, 1.0, x, y, z)
+    directional_light(0.3, 0.3, 0.3, -x, -y, -z)
+  else
+    @cr = 0.0
+    no_lights
+  end
+  draw_body(BODY_R, cr * 1.0, cr * 0.4, cr * 0.1, 1.0)
+  begin_shape
+  draw_spikes(30, BODY_R, LONG_HAIR_LENGTH, LONG_HAIR_MAX_LENGTH)
+  draw_dendrites(15, BODY_R, LONG_DENDRITE_LENGTH, LONG_DENDRITE_MAX_LENGTH)
+  draw_fuzz(10_000, MIN_HAIR_LENGTH, SHORT_HAIR_LENGTH)
+  end_shape
+  save_frame(data_path'####.png') if frame_count > 100
+end
+
+def draw_dendrites(count, br, l1, l2)
+  count.times do
+    length = rand(l1..l2)
+    theta = rand(0.0..360.0)
+    phi = rand(0.0..180.0)
+    push_matrix
+    rotation_history.record(0).draw(graphics)
+    draw_patch(br + 0.1, theta, phi, 4.radians, 16)
+    pop_matrix
+    c1 = color(sin(g_frame / 100.0).abs, sin(g_frame / 123.0).abs, sin(g_frame / 176.0).abs, 1.0)
+    c2 = color(sin(g_frame / 57.0).abs, sin(g_frame / 23.0).abs, sin(g_frame / 67.0).abs, 0.0)
+    hair = Hair.new(length*2, br, theta + rand, phi + rand, c1, c2, 1.0)
+    hair.draw
+  end
+end
+
+def draw_spikes(count, br, l1, l2)
+  count.times do
+    theta = rand(0.0..360.0)
+    phi = rand(0.0..180.0)
+    push_matrix
+    rotation_history.record(0).draw(graphics)
+    draw_patch(br + 0.1, theta, phi, 4.radians, 16)
+    pop_matrix
+    length = rand(l1..l2)
+    (0..10).each do |j|
+      l = (j == 9) ? length : rand(l1..length)
+      hair = Hair.new(l, br, theta + rand, phi + rand, color(1.0, 1.0, 1.0, 1.0), color(1.0, 0.4, 0.1, 0.1), 1.0)
+      hair.draw
+    end
+  end
+end
+
+def draw_fuzz(count, r1, r2)
+  push_matrix
+  rotation_history.record(0).draw(graphics)
+  begin_shape(LINES)
+  count.times do
+    theta = rand(0..TWO_PI)
+    phi = rand(0..PI)
+    x1 = cos(theta) * sin(phi)
+    y1 = sin(theta) * sin(phi)
+    z1 = cos(phi)
+    r = rand(r1..r2)
+    c1 = 1.0
+    c2 = 1.0 * 0.4
+    stroke(c1, c1, c1, 0.5)
+    vertex(x1 * r1, y1 * r1, z1 * r1)
+    stroke(c2, c2, c2, 0.0)
+    vertex(x1 * r, y1 * r, z1 * r)
+  end
+  end_shape
+  pop_matrix
+end
+
+def draw_body(r, red, green, blue, alpha)
+  no_stroke
+  fill(red, green, blue, alpha)
+  sphere(r)
+end
+
+def camera_spherical(r, phi, theta)
+  x = r * cos(theta) * sin(phi)
+  y = r * sin(theta) * sin(phi)
+  z = r * cos(phi)
+  nx = cos(theta) * cos(phi)
+  ny = sin(theta) * cos(phi)
+  nz = -sin(phi)
+  camera(x, y, z, 0.0, 0.0, 0.0, nx, ny, nz)
+end
+
+def draw_patch(r, theta, phi, ar, smoothness)
+  push_matrix
+  rotate(theta, 0.0, 0.0, 1.0)
+  rotate(phi, 0.0, 1.0, 0.0)
+  begin_shape(TRIANGLE_FAN)
+  x = r * sin(ar)
+  z = r * cos(ar)
+  fill(1.0, 1.0, 1.0, 1.0)
+  vertex(0.0, 0.0, r)
+  fill(1.0, 0.0, 0.0, 0.0)
+  smoothness.times do |i|
+    vertex(x * cos(TWO_PI * i / smoothness), x * sin(TWO_PI * i / smoothness), z)
+  end
+  end_shape
+
+  pop_matrix
+end
+
+class Hair
+  attr_reader :length, :r, :theta, :phi, :sections
+  attr_reader :r1, :g1, :b1, :a1, :r2, :g2, :b2, :a2
+
+  def initialize(length, r, theta, phi, c1, c2, smoothness)
+    @length = length
+    @r = r
+    @theta = theta.radians
+    @phi = phi.radians
+    @r1 = red(c1)
+    @g1 = green(c1)
+    @b1 = blue(c1)
+    @a1 = alpha(c1)
+    @r2 = red(c2)
+    @g2 = green(c2)
+    @b2 = blue(c2)
+    @a2 = alpha(c2)
+    @sections = (length / smoothness).round
+  end
+
+  def draw
+    push_matrix
+    begin_shape(LINE_STRIP)
+    sections.times do |i|
+      dh = i.to_f / sections
+      h = r + length * dh
+      x = h * cos(@theta) * sin(@phi)
+      y = h * sin(@theta) * sin(@phi)
+      z = h * cos(@phi)
+      theta = rotation_history.record(-i).theta.radians
+      phi = rotation_history.record(-i).phi.radians
+      x1= x * cos(phi) + z * sin(phi)
+      y1 = y
+      z1 = -x * sin(phi) + z * cos(phi)
+      x = x1 * cos(theta) - y1 * sin(theta)
+      y = x1 * sin(theta) + y1 * cos(theta)
+      z = z1
+      stroke(r1 + (r2 - r1) * dh, g1 + (g2 - g1) * dh, b1 + (b2 - b1) * dh, a1 + (a2 - a1) * dh)
+      vertex(x, y, z)
+    end
+    end_shape
+    pop_matrix
+  end
+end
+
+# Struct to store rotations, with draw(graphics) method to return rotations
+Record = Struct.new(:theta, :phi) do
+  def draw(gfx)
+    gfx.rotate_z(theta)
+    gfx.rotate_y(phi)
+  end
+end
+
+class RotationHistory
+  attr_reader :history, :size, :frame
+
+  def initialize(size = 100)
+    @history = (0..size).map { Record.new(0, 0) }
+    @size = size
+    @frame = 0
+  end
+
+  def push(theta, phi)
+    @frame += 1
+    history[frame % size].theta = theta
+    history[frame % size].phi = phi
+  end
+
+  def record(idx)
+    history[(frame + idx).abs % size]
+  end
+end

external_library/java/gicentreUtils/color_table.rb

@@ -0,0 +1,55 @@
+# Sketch to demonstrate the use of colour tables. A ColourTable object
+# consists of a set of ColourRules. Each rule maps a numeric value to
+# a colour. The colour to be associated with any value can be found by
+# calling the find_colour method of a colour table. If the rules are
+# continuous, the returned colour is interpolated between the two
+# colour rules closest to the given value. If rules are discrete, only
+# exact matches are mapped to a colour.
+# Version 1.2, 4th November, 2013.
+# Author Jo Wood. Adapted for JRubyArt by Martin Prout 2019
+load_library 'gicentreUtils'
+java_import 'org.gicentre.utils.colour.ColourTable'
+
+attr_reader :table1, :table2, :table3 # Colour tables to use.
+
+def settings
+  size(500, 250)
+end
+
+def setup
+  sketch_title('GiCentre ColourTable Example in JRubyArt')
+  # Create a continuous Brewer colour table (YlOrBr6).
+  @table1 = ColourTable.new
+  table1.add_continuous_colour_rule(0.5 / 6, 255, 255, 212)
+  table1.add_continuous_colour_rule(1.5 / 6, 254, 227, 145)
+  table1.add_continuous_colour_rule(2.5 / 6, 254, 196, 79)
+  table1.add_continuous_colour_rule(3.5 / 6, 254, 153, 41)
+  table1.add_continuous_colour_rule(4.5 / 6, 217, 95, 14)
+  table1.add_continuous_colour_rule(5.5 / 6, 153, 52, 4)
+  # Create a preset colour table and save it as a file
+  @table2 = ColourTable.get_preset_colour_table(ColourTable::IMHOF_L3, 0, 1)
+  ColourTable.write_file(table2, create_output(data_path('imhofLand3.ctb')))
+  # Read in a colour table from a ctb file.
+  @table3 = ColourTable.read_file(create_input(data_path('imhofLand3.ctb')))
+end
+
+def draw
+  background(255)
+  # Draw the continuous Brewer colour table.
+  draw_color_table(table1, 0.001, 10)
+  # Draw the discrete version of the Brewer colour table.
+  draw_color_table(table1, 1 / 6.0, 70, true)
+  # Draw the preset colour table.
+  draw_color_table(table2, 0.001, 130)
+  # Draw the colour table loaded from a file.
+  draw_color_table(table3, 1 / 6.0, 190)
+end
+
+def draw_color_table(table, increment, height, outline = false)
+  (0..1.0).step(increment) do |i|
+    fill(table.find_colour(i))
+    outline ? stroke(0, 150) : stroke(table.find_colour(i))
+    rect(width * i, height, width * increment, 50) unless outline
+    rect(width * i, height, width * increment, 50, 2) if outline
+  end
+end