propane 0.8.0-java → 0.9.0-java

data/examples/regular/drawolver.rb

@@ -1,93 +0,0 @@
-#!/usr/bin/env jruby -v -w
-require 'propane'
-
-# Example to show how to use the VecMath library.
-# ruby replacement for PVector. Also features
-# the use each_cons, possibly a rare use for this
-# ruby Enumerable method?
-# 2010-03-22 - fjenett (last revised by monkstone 2016-03-26)
-# now uses 'zip' and 'each', in place of a custom Array object
-# with a 'one_of_each' method
-# Drawolver: draw 2D & revolve 3D
-class Drawolver < Propane::App
-  attr_reader :drawing_mode, :points, :rot_x, :rot_y, :vertices
-
-  def setup
-    size 1024, 768, P3D
-    frame_rate 30
-    reset_scene
-  end
-
-  def draw
-    background 0
-    unless drawing_mode
-      translate(width / 2, height / 2)
-      rotate_x rot_x
-      rotate_y rot_y
-      @rot_x += 0.01
-      @rot_y += 0.02
-      translate(-width / 2, -height / 2)
-    end
-    no_fill
-    stroke 255
-    points.each_cons(2) { |ps, pe| line ps.x, ps.y, pe.x, pe.y }
-    return if drawing_mode
-    stroke 125
-    fill 120
-    lights
-    ambient_light 120, 120, 120
-    vertices.each_cons(2) do |r1, r2|
-      begin_shape(TRIANGLE_STRIP)
-      r1.zip(r2).each do |v1, v2|
-        vertex v1.x, v1.y, v1.z
-        vertex v2.x, v2.y, v2.z
-      end
-      end_shape
-    end
-  end
-
-  def reset_scene
-    @drawing_mode = true
-    @points = []
-    @rot_x = 0.0
-    @rot_y = 0.0
-  end
-
-  def mouse_pressed
-    reset_scene
-    points << Vec3D.new(mouse_x, mouse_y)
-  end
-
-  def mouse_dragged
-    points << Vec3D.new(mouse_x, mouse_y)
-  end
-
-  def mouse_released
-    points << Vec3D.new(mouse_x, mouse_y)
-    recalculate_shape
-  end
-
-  def recalculate_shape
-    @vertices = []
-    points.each_cons(2) do |ps, _pe|
-      b = points.last - points.first
-      # len = b.mag
-      b.normalize!
-      a = ps - points.first
-      dot = a.dot b
-      b *= dot
-      normal = points.first + b
-      c = ps - normal
-      # nlen = c.mag
-      vertices << []
-      (0..TAU).step(PI / 15) do |ang|
-        e = normal + c * cos(ang)
-        e.z = c.mag * sin(ang)
-        vertices.last << e
-      end
-    end
-    @drawing_mode = false
-  end
-end
-
-Drawolver.new title: 'Drawolver'

data/examples/regular/elegant_ball.rb

@@ -1,159 +0,0 @@
-#!/usr/bin/env jruby -v -w
-# elegant_ball.rb
-# After a vanilla processing sketch by
-# Ben Notorianni aka lazydog
-#
-# elegant_ball.rb
-require 'propane'
-
-class ElegantBall < Propane::App
-
-  attr_reader :start_t
-
-  def setup
-    size(800, 800, P3D)
-    color_mode(RGB, 1)
-  end
-
-  def draw
-    background(0)
-    # 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 renderer
-    @renderer ||= Propane::Render::AppRender.new(self)
-  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, Math::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 * Math.sin(mills * s1) + 0.5
-    y = 0.5 * Math.sin(mills * s2) + 0.5
-    z = 0.5 * Math.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
-end
-
-ElegantBall.new title: 'Elegant Ball'

data/examples/regular/empathy.rb

@@ -1,80 +0,0 @@
-#!/usr/bin/env jruby -v -W2
-# Empathy
-# original by Kyle McDonald
-# http://www.openprocessing.org/visuals/?visualID=1182
-
-# This sketch takes advantage of multiple processors by running calculations
-# in a separate thread.
-require 'propane'
-
-CELL_COUNT      = 5_000
-SLOW_DOWN       = 0.97
-ROTATION        = 0.004
-LINE_LENGTH     = 37
-
-class Empathy < Propane::App
-
-  attr_reader :cells
-
-  def setup
-    size(500, 500)
-    stroke(0, 0, 0, 25)
-    @cells = create_cells(CELL_COUNT)
-    start_cell_updates
-  end
-
-  def create_cells(n)
-    (0..n).map do |i|
-      a = i + rand(PI / 9.0)
-      r = ((i / n.to_f) * (width / 2) * (((n - i) / n.to_f) * 3.3)) + rand(6.0)
-      Cell.new((r * cos(a) + width / 2).to_i, (r * sin(a) + height / 2).to_i)
-    end
-  end
-
-  def start_cell_updates
-    Thread.new { Kernel.loop { cells.each(&:update) } }
-  end
-
-  def draw
-    background 255
-    cells.each(&:draw_line) if started?
-  end
-
-  def started?
-    pmouse_x != 0 || pmouse_y != 0
-  end
-
-  def mouse_pressed
-    cells.each(&:reset)
-  end
-end
-
-##
-# The cell responds to mouse movement
-##
-class Cell
-  include Propane::Proxy, Math
-  attr_reader :x, :y, :spin, :angle
-  def initialize(x, y)
-    @x, @y  = x, y
-    reset
-  end
-
-  def reset
-    @spin, @angle = 0, 0
-  end
-
-  def update
-    det = ((pmouse_x - x) * (mouse_y - y) - (mouse_x - x) * (pmouse_y - y))
-    @spin += ROTATION * det.to_f / dist(x, y, mouse_x, mouse_y)
-    @spin *= SLOW_DOWN
-    @angle += spin
-  end
-
-  def draw_line
-    d = LINE_LENGTH * spin + 0.001
-    line(x, y, x + d * cos(angle), y + d * sin(angle))
-  end
-end
-
-Empathy.new(title: 'Empathy')

data/examples/regular/fern.rb

@@ -1,57 +0,0 @@
-#!/usr/bin/env jruby -v -w
-require 'propane'
-
-class Fern < Propane::App
-  # The Fern Fractal
-# by Luis Correia
-
-attr_reader :bnds
-
-def setup
-  size 500, 500
-  @bnds = Boundary.new(0, width)
-  no_loop
-  puts 'Be patient. This takes about 10 seconds to render.'
-end
-
-def draw
-  background 0
-  load_pixels
-  x0, y0 = 0.0, 0.0
-  x, y, r = 0.0, 0.0, 0.0
-  i, j = 0, 0
-  max_iterations = 200_000
-  max_iterations.times do
-    r = rand(0..100.0)
-    if r <= 1
-      x = 0.0
-      y = 0.16 * y0
-    elsif r <= 7
-      x = 0.2 * x0 - 0.26 * y0
-      y = 0.23 * x0 + 0.22 * y0
-    elsif r <= 14
-      x = -0.15 * x0 + 0.28 * y0
-      y = 0.26 * x0 + 0.24 * y0
-    else
-      x = 0.85 * x0 + 0.04 * y0
-      y = -0.004 * x0 + 0.85 * y0 + 1.6
-    end
-    i = height - (y * 45).to_i
-    j = width / 2 + (x * 45).to_i
-    pixels[i * height + j] += 2_560 if bnds.include?(i) && bnds.include?(j)
-    x0, y0 = x, y
-  end
-  update_pixels
-end
-end
-# Abstract bnds checking to this
-# lightweight class
-#
-
-Boundary = Struct.new(:lower, :upper) do
-  def include?(x)
-    (lower...upper).cover? x
-  end
-end
-
-Fern.new title: 'Fern'

data/examples/regular/fibonacci_sphere.rb

@@ -1,91 +0,0 @@
-#!/usr/bin/env jruby -v -W2
-require 'propane'
-require 'arcball'
-
-class FibonacciSphere < Propane::App
-  # fibonacci_sphere.rb
-  # After a vanilla processing sketch by Jim Bumgardner
-  # http://www.openprocessing.org/sketch/41142
-  #
-  # Controls:
-  # 1. drag mouse to rotate sphere (uses builtin arcball library)
-  # 2. click mouse to toggle add box to sphere surface
-  # 3. press x, y, or z to constrain arcball rotation to that axis
-  #
-
-  PHI = (sqrt(5) + 1) / 2 - 1   # golden ratio
-  GA = PHI * TAU           # golden angle
-
-  KMAX_POINTS = 100_000
-
-  attr_reader :pts, :rotation_x, :rotation_y, :nbr_points, :radius, :add_points
-
-
-  def setup
-    size(1024, 768, P3D)
-    Processing::ArcBall.init(self, width / 2.0, height / 2.0)
-    @rotation_x = 0
-    @rotation_y = 0
-    @nbr_points = 2000
-    @radius = 0.8 * height / 2
-    @add_points = true
-    @pts = Array.new(KMAX_POINTS)
-    init_sphere(nbr_points)
-    background(0)
-  end
-
-  def draw
-    if add_points
-      @nbr_points += 1
-      @nbr_points = [nbr_points, KMAX_POINTS].min
-      init_sphere(nbr_points)
-    end
-
-    background 0
-    lights
-    ambient(200, 10, 10)
-    ambient_light(150, 150, 150)
-    render_globe
-  end
-
-  ###########################################
-  # For Fibonacci Sphere
-  ##################################
-
-  def render_globe
-    push_matrix
-    (0..[nbr_points, pts.length].min).each do |i|
-      lat = pts[i].lat
-      lon = pts[i].lon
-      push_matrix
-      rotate_y(lon)
-      rotate_z(-lat)
-      fill(200, 10, 10)
-      translate(radius, 0, 0)
-      box(4, 7, 7)
-      pop_matrix
-    end
-    pop_matrix
-  end
-
-  def mouse_clicked
-    @add_points = !add_points
-  end
-
-  SpherePoint = Struct.new(:lat, :lon)
-
-  def init_sphere(num)
-    (0..num).each do |i|
-      lon = GA * i
-      lon /= TAU
-      lon -= lon.floor
-      lon *= TAU
-      lon -= TAU if lon > PI
-      # Convert dome height (which is proportional to surface area) to latitude
-      # lat = asin(-1 + 2 * i / num.to_f)
-      pts[i] = SpherePoint.new(asin(-1 + 2 * i / num.to_f), lon)
-    end
-  end
-end
-
-FibonacciSphere.new title: 'Fibonacci Sphere'