propane 0.8.0-java → 0.9.0-java

data/examples/regular/flight_patterns.rb

@@ -1,64 +0,0 @@
-#!/usr/bin/env jruby -v -w
-# Description:
-# Flight Patterns is that ol' Euruko 2008 demo.
-# Reworked version for Propane
-# Usage:
-# Drag mouse to steer 'invisible' flock attractor, use 'f' key to toggle flee
-# Mouse 'click' to toggle 'sphere' or 'circle' display
-require 'propane'
-
-class FlightPatterns < Propane::App
-  load_library :boids
-
-  attr_reader :flee, :radius
-
-  def setup
-    size 1024, 768, P3D
-    sphere_detail 8
-    color_mode RGB, 1.0
-    no_stroke
-    shininess 1.0
-    specular 0.3, 0.1, 0.1
-    emissive 0.03, 0.03, 0.1
-    @radius = 0.02 * height
-    @click = false
-    @flee = false
-    @flocks = (0..3).map { Boids.flock(n: 20, x: 0, y: 0, w: width, h: height) }
-  end
-
-  def mouse_pressed
-    @click = !@click
-  end
-
-  def key_pressed
-    return unless key == 'f'
-    @flee = !@flee
-  end
-
-  def draw
-    background 0.05
-    ambient_light 0.01, 0.01, 0.01
-    light_specular 0.4, 0.2, 0.2
-    point_light 1.0, 1.0, 1.0, mouse_x, mouse_y, 190
-    @flocks.each_with_index do |flock, i|
-      flock.goal(target: Vec3D.new(mouse_x, mouse_y, 0), flee: @flee)
-      flock.update(goal: 185, limit: 13.5)
-      flock.each do |boid|
-        r = (0.15 * boid.pos.z) + radius
-        case i
-        when 0 then fill 0.85, 0.65, 0.65
-        when 1 then fill 0.65, 0.85, 0.65
-        when 2 then fill 0.65, 0.65, 0.85
-        end
-        push_matrix
-        point_array = (boid.pos.to_a).map { |p| p - (r / 2.0) }
-        translate(*point_array)
-        @click ? sphere(r / 2) : ellipse(0, 0, r, r)
-        @click ? hint(ENABLE_DEPTH_TEST) : hint(DISABLE_DEPTH_TEST)
-        pop_matrix
-      end
-    end
-  end
-end
-
-FlightPatterns.new title: 'Flight Patterns'

data/examples/regular/fractions.rb

@@ -1,32 +0,0 @@
-#!/usr/bin/env jruby -v -w
-# fractions.rb, by Martin Prout
-require 'propane'
-
-class Fractions < Propane::App
-  attr_reader :f, :add, :subtract, :multiply
-
-  def setup
-    size 640, 250
-    @f = createFont('Arial', 24, true)
-    third = 1 / 3r     # since ruby 2.1.0 (and jruby-9.0.0.0)
-    quarter = 1 / 4r
-    format_add = '%s + %s = %s'
-    format_sub = format_add.gsub('+', '-')
-    format_mult = format_add.gsub('+', '*')
-    @add = format(format_add, third, quarter, third + quarter)
-    @subtract = format(format_sub, third, quarter, third - quarter)
-    @multiply = format(format_mult, third, quarter, third * quarter)
-  end
-
-  def draw
-    background 10
-    text_font(f, 24)
-    fill(220)
-    text('Math Blackboard Propane', 80, 50)
-    text(add, 110, 100)
-    text(subtract, 110, 150)
-    text(multiply, 110, 200)
-  end
-end
-
-Fractions.new(title: 'Fraction Sums')

data/examples/regular/grapher.rb

@@ -1,40 +0,0 @@
-#!/usr/bin/env jruby -v -w
-require 'propane'
-
-class Grapher < Propane::App
-  # Grapher is based on a context free art design
-  # by ColorMeImpressed (takes a bit of time to run)
-  # http://www.contextfreeart.org/gallery/view.php?id=2844
-  #
-  CMIN = -2.0 # Important to specify float else get random int from range?
-  CMAX = 2.0
-  FUZZ = 0.04
-  SZ = 5
-
-  def setup
-    size 600, 600
-    no_stroke
-    color_mode(HSB, 1.0)
-    background(0)
-    frame_rate(4_000)
-  end
-
-  def draw
-    translate(width / 2, height / 2)
-    dot(rand(-180..180), rand(-180..180), rand(CMIN..CMAX)) unless frame_count > 200_000
-  end
-
-  def dot(px, py, c)
-    func = DegLut.sin(px) + DegLut.sin(py) + c
-    # change function to change the graph eg.
-    # func = DegLut.cos(px) + DegLut.sin(py) + c
-    if func.abs <= FUZZ
-      fill(((CMIN - c) / (CMIN - CMAX)), 1, 1)
-      ellipse px * width / 360, py * height / 360, SZ, SZ
-    else
-      dot(rand(-180..180), rand(-180..180), rand(CMIN..CMAX))
-    end
-  end
-end
-
-Grapher.new title: 'Grapher'

data/examples/regular/gravity.rb

@@ -1,120 +0,0 @@
-#!/usr/bin/env jruby -v -w
-# After Gravity by Christian Hahn
-# mouse click on window
-require 'propane'
-
-class Gravity < Propane::App
-  attr_reader :particles, :grabbed
-
-  def setup
-    size 600, 500
-    @particles  = []
-    @grabbed    = nil
-    background 0
-    smooth 4
-    stroke_weight 4
-    ellipse_mode CENTER
-    color_mode RGB, 255
-  end
-
-  def draw
-    no_stroke
-    fill 0, 60
-    rect 0, 0, width, height
-    particles.each(&:run)
-  end
-
-  def mouse_pressed
-    return if mouse_x == 0 || mouse_y == 0
-    return if particle_grab
-    particles << Particle.new(mouse_x, mouse_y, rand(0.1..8))
-  end
-
-  def mouse_released
-    @grabbed = nil
-  end
-
-  def particle_grab
-    @grabbed = particles.detect { |p| dist(mouse_x, mouse_y, p.x1, p.y1) < p.diameter/2 }
-  end
-end
-
-class Particle
-  include Math, Propane::Proxy
-  GRAVITY = 1.0
-  attr_reader :x0, :y0, :x1, :y1, :diameter, :mass_amount
-
-  def initialize(x, y, mass)
-    @x0, @y0, @x1, @y1  = x, y, x, y
-    @x_speed, @y_speed  = 0, 0
-    @x_accel, @y_accel  = 0, 0
-    @mass_amount        = mass
-    @diameter           = sqrt(mass_amount) * 20
-  end
-
-  def collect_force
-    @x_accel, @y_accel = 0, 0
-    @min_dist = 1000
-    $app.particles.each do |p|
-      next if p == self
-      g_dist  = hypot(x0 - p.x0, y0 - p.y0)
-      g_theta = -angle_of(x0, y0, p.x0, p.y0)
-      @min_dist = g_dist if g_dist < @min_dist
-      force = (GRAVITY * mass_amount * p.mass_amount) / g_dist
-      if g_dist.abs > diameter
-        @x_accel += force / mass_amount * cos(g_theta)
-        @y_accel += force / mass_amount * sin(g_theta)
-      end
-    end
-  end
-
-  def move
-    @x_speed, @y_speed = 0, 0 if grabbed?
-    @x_speed += @x_accel
-    @y_speed += @y_accel
-    @x1, @y1 = x0 + @x_speed, y0 + @y_speed
-  end
-
-  def grabbed?
-    $app.grabbed == self
-  end
-
-  def run
-    collect_force
-    move
-    render
-  end
-
-  def render
-    no_stroke
-    grabbed? ? render_grabbed : render_free
-  end
-
-  def render_free
-    charge_col  = 1000.0 / @min_dist / 50.0
-    tot_col_1   = 100 + charge_col * 6
-    tot_col_2   = 150 + charge_col * charge_col
-    tot_col_3   = diameter + 8 + charge_col
-    fill(tot_col_1, tot_col_1, 255, charge_col * 150 + 3)
-    ellipse(x1, y1, tot_col_3, tot_col_3)
-    fill 0, 255
-    stroke tot_col_2, tot_col_2, 255, charge_col * 255 + 3
-    ellipse x1, y1, diameter, diameter
-    @x0, @y0 = x1, y1
-  end
-
-  def render_grabbed
-    fill 150, 150, 255, 100
-    ellipse mouse_x, mouse_y, diameter + 8, diameter + 8
-    fill 0, 255
-    stroke 150, 150, 255, 255
-    ellipse mouse_x, mouse_y, diameter, diameter
-    @x0, @y0 = mouse_x, mouse_y
-  end
-
-  def angle_of(x1, y1, x2, y2)
-    Math::PI - atan2(y1 - y2, x1 - x2)
-  end
-end
-
-Gravity.new title: 'Gravity'

data/examples/regular/grey_circles.rb

@@ -1,28 +0,0 @@
-#!/usr/bin/env jruby -v -w
-# frozen_string_literal: true
-# grey circles : borrowed from https://github.com/quil/quil
-require 'propane'
-
-class GreyCircles < Propane::App
-
-  def setup
-    size(323, 200)
-    smooth
-    frame_rate(1)
-    background(200)
-  end
-
-  def draw
-    stroke_setup
-    diameter = rand(100)
-    ellipse(rand(width), rand(height), diameter, diameter)
-  end
-
-  def stroke_setup
-    [:stroke, :stroke_weight, :fill].each do |method|
-      send(method, rand(255))
-    end
-  end
-end
-
-GreyCircles.new title: 'Oh so many circles'

data/examples/regular/jwishy.rb

@@ -1,99 +0,0 @@
-#!/usr/bin/env jruby -v -W2
-# frozen_string_literal: true
-require 'propane'
-# Iconic ruby-processing example for Propane
-class JWishy < Propane::App
-  load_library :control_panel
-
-  attr_reader :alpha, :back_color, :bluish, :hide, :magnitude, :panel
-  attr_reader :x_wiggle, :y_wiggle, :go_big, :shape
-
-  def setup
-    size 600, 600
-    control_panel do |c|
-      c.title = 'Control Panel'
-      c.look_feel 'Nimbus'
-      c.slider :bluish, 0.0..1.0, 0.5
-      c.slider :alpha,  0.0..1.0, 0.5
-      c.checkbox :go_big, false
-      c.button :reset
-      c.menu :shape, %w(oval square triangle), 'oval'
-      @panel = c
-    end
-    @hide = false
-    @x_wiggle, @y_wiggle = 10.0, 0
-    @magnitude = 8.15
-    @back_color = [0.06, 0.03, 0.18]
-    color_mode RGB, 1
-    ellipse_mode CORNER
-    smooth
-  end
-
-  def draw_background
-    back_color[3] = alpha
-    fill(*back_color.to_java(:float))
-    rect 0, 0, width, height
-  end
-
-  def reset
-    @y_wiggle = 0
-  end
-
-  def draw
-    # only make control_panel visible once, or again when hide is false
-    unless hide
-      @hide = true
-      panel.set_visible(hide)
-    end
-    draw_background
-    # Seed the random numbers for consistent placement from frame to frame
-    srand(0)
-    horiz, vert, mag = x_wiggle, y_wiggle, magnitude
-    if go_big
-      mag *= 2
-      vert /= 2
-    end
-    blu = bluish
-    x, y = (width / 2), -27
-    c = 0.0
-    64.times do
-      x += cos(horiz) * mag
-      y += log10(vert) * mag + sin(vert) * 2
-      fill(sin(y_wiggle + c), rand * 0.2, rand * blu, 0.5)
-      s = 42 + cos(vert) * 17
-      args = [@shape, x - s / 2, y - s / 2, s, s]
-      draw_shape(args)
-      vert += rand * 0.25
-      horiz += rand * 0.25
-      c += 0.1
-    end
-    @x_wiggle += 0.05
-    @y_wiggle += 0.1
-  end
-
-  def mouse_pressed
-    return unless hide
-    @hide = false
-  end
-
-  def draw_shape(args)
-    case args[0]
-    when 'triangle'
-      draw_triangle(args)
-    when 'square'
-      rect(args[1], args[2], args[3], args[4])
-    else
-      ellipse(args[1], args[2], args[3], args[4]) # oval for Shoes
-    end
-  end
-
-  def draw_triangle(args)
-    x2 = args[1] + (args[3] * 0.6)
-    y0 = args[2] + (args[4] * 0.396)
-    y1 = args[2] - (args[4] * 0.792)
-    y2 = args[2] + (args[4] * 0.396)
-    triangle(args[1] - (args[3] * 0.6), y0, args[1], y1, x2, y2)
-  end
-end
-
-JWishy.new title: 'Wishy Worm'

data/examples/regular/letters.rb

@@ -1,42 +0,0 @@
-#!/usr/bin/env jruby -v -W2
-# frozen_string_literal: true
-# Letters. Hit any key.
-#
-require 'propane'
-
-LETTERS = ('A'..'Z').to_a + ('0'..'9').to_a  + ('a'..'z').to_a
-
-# Draws letters to the screen. This requires loading a font,
-# setting the font, and then drawing the letters.
-class Letters < Propane::App
-  def setup
-    size 640, 360
-    @font = create_font 'Georgia', 24
-    text_font @font
-    text_align CENTER, CENTER
-  end
-
-  def draw
-    background 0
-    translate 24, 32
-    x, y = 0.0, 0.0
-    gap = 30
-    # ranges -> arrays -> joined!
-    LETTERS.each do |letter|
-      fill 255
-      fill 204, 204, 0 if letter =~ /[AEIOU]/
-      fill 0, 204, 204 if letter =~ /[aeiou]/
-      fill 153 if letter =~ /[0-9]/
-      fill 255, 100, 0 if key_pressed? && (letter.downcase.eql? key)
-      fill 0, 100, 255 if key_pressed? && (letter.upcase.eql? key)
-      text letter, x, y
-      x += gap
-      if x > width - 30
-        x = 0
-        y += gap
-      end
-    end
-  end
-end
-
-Letters.new title: 'Letters'

data/examples/regular/lib/boundary.rb

@@ -1,38 +0,0 @@
-# Re-usable Boundary class
-class Boundary
-  include Propane::Proxy
-  attr_reader :box2d, :b, :pos, :size, :a
-
-  def initialize(b2d, pos, sz, a = 0)
-    @box2d, @pos, @size, @a = b2d, pos, sz, a
-    # Define the polygon
-    sd = PolygonShape.new
-    # Figure out the box2d coordinates
-    box2d_w = box2d.scale_to_world(size.x / 2)
-    box2d_h = box2d.scale_to_world(size.y / 2)
-    # We're just a box
-    sd.set_as_box(box2d_w, box2d_h)
-    # Create the body
-    bd = BodyDef.new
-    bd.type = BodyType::STATIC
-    bd.angle = a
-    bd.position.set(box2d.processing_to_world(pos.x, pos.y))
-    @b = box2d.create_body(bd)
-    # Attached the shape to the body using a Fixture
-    b.create_fixture(sd, 1)
-  end
-
-  # Draw the boundary, it doesn't move so we don't ask for location
-  def display
-    fill(0)
-    stroke(0)
-    stroke_weight(1)
-    rect_mode(PConstants::CENTER)
-    a = b.get_angle
-    push_matrix
-    translate(pos.x, pos.y)
-    rotate(-a)
-    rect(0, 0, size.x, size.y)
-    pop_matrix
-  end
-end