propane 0.8.0-java → 0.9.0-java

data/examples/regular/arcball_constrain.rb

@@ -1,29 +0,0 @@
-#!/usr/bin//env jruby -v -w
-
-require 'propane'
-require 'arcball'
-
-############################
-# Use mouse drag to rotate
-# the arcball. Use mousewheel
-# to zoom. Custom constrain
-# default is yaxis.
-############################
-
-class ArcballBox < Propane::App
-
-  def setup
-    size(600, 600, P3D)
-    smooth(8)
-    Processing::ArcBall.constrain(self, :xaxis)
-    fill 180
-  end
-
-  def draw
-    background(50)
-    box(300, 300, 300)
-  end
-
-end
-
-ArcballBox.new title: 'ArcBall Box'

data/examples/regular/bezier_playground.rb

@@ -1,206 +0,0 @@
-#!/usr/bin/env jruby -v -w
-require 'propane'
-
-X1, Y1, X2, Y2 = 50.0, 50.0, 250.0, 250.0
-REDDISH = [250, 100, 100]
-RADIUS = 7
-
-module Olap
-  def self.overlaps(x, y, point_x, point_y)
-    Math.hypot(x - point_x, y - point_y) < RADIUS
-  end
-end
-
-class Curve
-  include Olap, Propane::Proxy
-  attr_accessor :x1, :y1, :c1x, :c1y, :c2x, :c2y, :x2, :y2
-
-  def initialize
-    @x1, @y1, @x2, @y2 = X1, Y1, X2, Y2
-    set_control_points(X1 + 30, Y1, X2 - 30, Y2)
-  end
-
-  def contains(x, y)
-    return :one if Olap.overlaps(x1, y1, x, y)
-    return :two if Olap.overlaps(x2, y2, x, y)
-  end
-
-  def all_points
-    return x1, y1, c1x, c1y, c2x, c2y, x2, y2
-  end
-
-  def control_points
-    return c1x, c1y, c2x, c2y
-  end
-
-  def set_control_points(*points)
-    @c1x, @c1y, @c2x, @c2y = *points
-  end
-
-  def draw
-    bezier(*all_points)
-    ellipse x1, y1, 3, 3
-    ellipse x2, y2, 3, 3
-  end
-
-  def print_equation(id)
-    pt = all_points.map(&:to_i)
-    puts ''
-    puts format('*** line #%s ***', id)
-    xformat = 'x = (1-t)^3 %s + 3(1-t)^2 t%s + 3(1-t)t^2 %s + t^3 %s'
-    yformat = 'y = -1 * ((1-t)^3 %s + 3(1-t)^2 t%s + 3(1-t)t^2 %s + t^3 %s'
-    puts format(xformat, pt[0], pt[2], pt[4], pt[6])
-    puts format(yformat, pt[1], pt[3], pt[5], pt[7])
-    puts ''
-  end
-end
-
-class BezierPlayground < Propane::App
-  # A Bezier playground. Click to shape the curve. Drag to move it.
-  # Arrows toggle between curves, delete removes them.
-  # You can print out the parametric equations for t = 0..1
-
-  attr_accessor :curves, :c1x, :c1y, :c2x, :c2y
-  attr_reader :panel, :hide
-
-  load_library :control_panel
-  include Olap
-
-  def setup
-    size 300, 300
-    @curves = []
-    @hide = false
-    control_panel do |c|
-      c.look_feel 'Nimbus'
-      c.button :new_curve
-      c.button :print_equations
-      @panel = c
-    end
-    generate_curve
-  end
-
-  def draw
-    unless hide
-      panel.visible = visible
-      @hide = true
-    end
-    background 50
-    draw_control_tangent_lines
-    draw_curves
-    draw_current_control_points
-  end
-
-  def print_equations
-    curves.each_with_index { |c, i| c.print_equation(i + 1) }
-  end
-
-  def control_points
-    return c1x, c1y, c2x, c2y
-  end
-
-  def set_control_points(*points)
-    @c1x, @c1y, @c2x, @c2y = points.any? ? points : [X1, Y1, X2, Y2]
-  end
-
-  def generate_curve
-    curves << current_curve = Curve.new
-    @current = curves.length - 1
-    set_control_points(*current_curve.control_points)
-  end
-
-  def current_curve
-    curves[@current]
-  end
-
-  def new_curve
-    current_curve.set_control_points(c1x, c1y, c2x, c2y)
-    generate_curve
-  end
-
-  def clicked_control_point?
-    x, y = mouse_x, mouse_y
-    return :one if Olap.overlaps(c1x, c1y, x, y)
-    return :two if Olap.overlaps(c2x, c2y, x, y)
-  end
-
-  def mouse_pressed
-    switch_curve_if_endpoint_clicked
-    @control = clicked_control_point?
-    return if @control
-    curve = curves.detect { |c| c.contains(mouse_x, mouse_y) }
-    @end_point = curve.contains(mouse_x, mouse_y) if curve
-  end
-
-  def mouse_released
-    @control, @end_point = nil, nil
-    @hide = false
-  end
-
-  def mouse_dragged
-    offs = compute_offsets
-    return if offs.map(&:abs).max > 100
-    return move_control_point(*offs) if @control
-    return move_end_point(*offs) && move_control_point(*offs) if @end_point
-    move_current_curve(*offs)
-  end
-
-  def switch_curve_if_endpoint_clicked
-    become = curves.detect { |c| c.contains(mouse_x, mouse_y) }
-    return unless become && become != current_curve
-    current_curve.set_control_points(*control_points)
-    self.set_control_points(*become.control_points)
-    @current = curves.index(become)
-  end
-
-  def move_current_curve(x_off, y_off)
-    @c1x += x_off; @c2x += x_off
-    @c1y += y_off; @c2y += y_off
-    current_curve.set_control_points(*control_points)
-    current_curve.x1 += x_off; current_curve.x2 += x_off
-    current_curve.y1 += y_off; current_curve.y2 += y_off
-  end
-
-  def move_control_point(x_off, y_off)
-    case @control || @end_point
-    when :one then @c1x += x_off and @c1y += y_off
-    when :two then @c2x += x_off and @c2y += y_off
-    end
-    current_curve.set_control_points(*control_points)
-  end
-
-  def move_end_point(x_off, y_off)
-    c = current_curve
-    case @end_point
-    when :one then c.x1 += x_off and c.y1 += y_off
-    when :two then c.x2 += x_off and c.y2 += y_off
-    end
-  end
-
-  def compute_offsets
-    return mouse_x - pmouse_x, mouse_y - pmouse_y
-  end
-
-  def draw_curves
-    stroke 255
-    no_fill
-    stroke_width 2
-    curves.each(&:draw)
-  end
-
-  def draw_current_control_points
-    fill color(*REDDISH)
-    no_stroke
-    ellipse c1x, c1y, 5, 5
-    ellipse c2x, c2y, 5, 5
-  end
-
-  def draw_control_tangent_lines
-    c = current_curve
-    stroke color(*REDDISH)
-    stroke_width 1
-    line c1x, c1y, c.x1, c.y1
-    line c2x, c2y, c.x2, c.y2
-  end
-end
-
-BezierPlayground.new title: 'Bezier Playground'

data/examples/regular/circle_collision.rb

@@ -1,118 +0,0 @@
-#!/usr/bin/env jruby -v -w
-require 'propane'
-
-# Based on http://processing.org/learning/topics/circlecollision.html
-class CircleCollision < Propane::App
-  attr_reader :balls
-
-  def setup
-    size 640, 360
-    @balls = [Ball.new(100, 40, 20), Ball.new(200, 100, 80)]
-  end
-
-  def draw
-    background(51)
-    balls.each do |b|
-      b.update
-      b.display
-      b.check_boundary width, height
-    end
-    balls[0].check_collision(balls[1])
-  end
-end
-
-# The Ball class knows how to behave, their is a case for a separate boundary class
-class Ball
-  include Propane::Proxy, Math
-  attr_accessor :position, :r, :m, :velocity
-
-  def initialize(x = 0.0, y = 0.0, r = 0.0)
-    @position = Vec2D.new(x, y)
-    @r = r
-    @m = r * 0.1
-    @velocity = Vec2D.new(rand(-3.0..3), rand(-3.0..3))
-  end
-
-  def update
-    @position += velocity
-  end
-
-  def check_boundary(width, height)
-    unless (r..width - r).include?(position.x)
-      (position.x > width - r) ? position.x = width - r : position.x = r
-      velocity.x *= -1
-    end
-    return if (r..height - r).include?(position.y)
-    (position.y > height - r) ? position.y = height - r : position.y = r
-    velocity.y *= -1
-  end
-
-  def check_collision(other_ball)
-    # get distances between the balls components
-    difference = other_ball.position - position
-    # calculate magnitude of the vector separating the balls
-    return unless difference.mag < (r + other_ball.r)
-    # get angle of difference
-    theta  = difference.heading
-    # precalculate trig values
-    sine = sin(theta)
-    cosine = cos(theta)
-    # ball_array will hold rotated ball positions. You just
-    # need to worry about ball_array[1] position
-    ball_array = [Ball.new, Ball.new]
-    # other_ball's position is relative to ball's
-    # so you can use the vector between them (difference) as the
-    # reference point in the rotation expressions.
-    # ball_array[0].x and ball_array[0].y will initialize
-    # automatically to 0.0, which is what you want
-    # since other_ball will rotate around ball
-    ball_array[1].position.x  = cosine * difference.x + sine * difference.y
-    ball_array[1].position.y  = cosine * difference.y - sine * difference.x
-    # rotate Temporary velocities
-    velocity_array = [Vec2D.new, Vec2D.new]
-    velocity_array[0].x  = cosine * velocity.x + sine * velocity.y
-    velocity_array[0].y  = cosine * velocity.y - sine * velocity.x
-    velocity_array[1].x  = cosine * other_ball.velocity.x + sine * other_ball.velocity.y
-    velocity_array[1].y  = cosine * other_ball.velocity.y - sine * other_ball.velocity.x
-    # Now that velocities are rotated, you can use 1D
-    # conservation of momentum equations to calculate
-    # the final velocity along the x-axis.
-    final_velocities = [Vec2D.new, Vec2D.new]
-    # final rotated velocity for ball
-    final_velocities[0].x = ((m - other_ball.m) * velocity_array[0].x + 2 * other_ball.m * velocity_array[1].x) / (m + other_ball.m)
-    final_velocities[0].y = velocity_array[0].y
-    # final rotated velocity for ball
-    final_velocities[1].x = ((other_ball.m - m) * velocity_array[1].x + 2 * m * velocity_array[0].x) / (m + other_ball.m)
-    final_velocities[1].y = velocity_array[1].y
-    # HACK: to avoid clumping
-    # ball_array[0].position.x += final_velocities[0].x
-    # ball_array[1].position.x += final_velocities[1].x
-    # Rotate ball positions and velocities back
-    # Reverse signs in trig expressions to rotate
-    # in the opposite direction
-    # rotate balls
-    final_positions = [Vec2D.new, Vec2D.new]
-    final_positions[0].x = cosine * ball_array[0].position.x - sine * ball_array[0].position.y
-    final_positions[0].y = cosine * ball_array[0].position.y + sine * ball_array[0].position.x
-    final_positions[1].x = cosine * ball_array[1].position.x - sine * ball_array[1].position.y
-    final_positions[1].y = cosine * ball_array[1].position.y + sine * ball_array[1].position.x
-    # update balls to screen position
-    other_ball.position = position + final_positions[1]
-    @position += final_positions[0]
-    # update velocities
-    velocity.x = cosine * final_velocities[0].x - sine * final_velocities[0].y
-    velocity.y = cosine * final_velocities[0].y + sine * final_velocities[0].x
-    other_ball.velocity.x = cosine * final_velocities[1].x - sine * final_velocities[1].y
-    other_ball.velocity.y = cosine * final_velocities[1].y + sine * final_velocities[1].x
-  end
-
-  def display
-    no_stroke
-    fill(204)
-    ellipse(position.x, position.y, r * 2, r * 2)
-  end
-end
-
-
-
-CircleCollision.new title: 'Circle Collision'

data/examples/regular/colors_two.rb

@@ -1,60 +0,0 @@
-#!/usr/bin/env jruby -v -w
-# Creating Colors (Homage to Albers).
-#
-require 'propane'
-
-# Creating variables for colors that may be referred to
-# in the program by their name, rather than a number.
-class CreatingColors < Propane::App
-  attr_reader :redder, :yellower, :orangish
-  def setup
-    size 640, 360
-    # palette = web_to_color_array(['#CC6600', '#CC9900', '#993300'].to_java(:string))
-    palette = web_to_color_array(['#CC6600', '#CC9900', '#993300'])
-    # @redder = color 204, 102, 0
-    # @yellower = color 204, 153, 0
-    # @orangish = color 153, 51, 0
-    # These statements are equivalent to the statements above.
-    # Programmers may use the format they prefer.
-
-    # hex color as a String (NB quotes are required)
-    @redder = palette[0]
-    @yellower = palette[1]
-    @orangish = palette[2]
-
-    # @redder = color '#CC6600'
-    # @yellower = color '#CC9900'
-    # @orangish = color '#993300'
-
-    # or alternatively as a hexadecimal
-
-    # @redder = color 0xFFCC6600
-    # @yellower = color 0xFFCC9900
-    # @orangish = color 0xFF993300
-  end
-
-  def draw
-    no_stroke
-    background 51, 0, 0
-    push_matrix
-    translate 80, 80
-    fill orangish
-    rect 0, 0, 200, 200
-    fill yellower
-    rect 40, 60, 120, 120
-    fill redder
-    rect 60, 90, 80, 80
-    pop_matrix
-    push_matrix
-    translate 360, 80
-    fill redder
-    rect 0, 0, 200, 200
-    fill orangish
-    rect 40, 60, 120, 120
-    fill yellower
-    rect 60, 90, 80, 80
-    pop_matrix
-  end
-end
-
-CreatingColors.new title: 'Homage to Albers'

data/examples/regular/creating_colors.rb

@@ -1,64 +0,0 @@
-#!/usr/bin/env jruby -v -w
-# frozen_string_literal: true
-# Creating Colors (Homage to Albers).
-#
-require 'propane'
-
-# Creating variables for colors that may be referred to
-# in the program by their name, rather than a number.
-class CreatingColors < Propane::App
-  attr_reader :redder, :yellower, :orangish
-
-  WEB = %w(#CC6600 #CC9900 #993300)
-
-  def setup
-    size 640, 360
-    palette = web_to_color_array(WEB)
-    @redder = palette[0]
-    @yellower = palette[1]
-    @orangish = palette[2]
-    # These statements are equivalent to the statements above.
-    # Programmers may use the format they prefer.
-
-    # hex color as a String (NB quotes are required)
-    @redder = palette[0]
-    @yellower = palette[1]
-    @orangish = palette[2]
-
-    # @redder = color '#CC6600'
-    # @yellower = color '#CC9900'
-    # @orangish = color '#993300'
-
-    # or alternatively as a hexadecimal
-
-    # @redder = color 0xFFCC6600
-    # @yellower = color 0xFFCC9900
-    # @orangish = color 0xFF993300
-    puts int_to_ruby_colors(palette)
-  end
-
-  def draw
-    no_stroke
-    background 51, 0, 0
-    push_matrix
-    translate 80, 80
-    fill orangish
-    rect 0, 0, 200, 200
-    fill yellower
-    rect 40, 60, 120, 120
-    fill redder
-    rect 60, 90, 80, 80
-    pop_matrix
-    push_matrix
-    translate 360, 80
-    fill redder
-    rect 0, 0, 200, 200
-    fill orangish
-    rect 40, 60, 120, 120
-    fill yellower
-    rect 60, 90, 80, 80
-    pop_matrix
-  end
-end
-
-CreatingColors.new title: 'Homage to Albers'