propane 0.5.0-java → 0.6.0-java

data/examples/complete/data/monjori.glsl

@@ -0,0 +1,30 @@
+#define PROCESSING_COLOR_SHADER
+
+uniform vec2 resolution;
+uniform float time;
+
+void main(void) {
+  vec2 p = -1.0 + 2.0 * gl_FragCoord.xy / resolution.xy;
+  float a = time*40.0;
+  float d,e,f,g=1.0/40.0,h,i,r,q;
+  e=400.0*(p.x*0.5+0.5);
+  f=400.0*(p.y*0.5+0.5);
+  i=200.0+sin(e*g+a/150.0)*20.0;
+  d=200.0+cos(f*g/2.0)*18.0+cos(e*g)*7.0;
+  r=sqrt(pow(i-e,2.0)+pow(d-f,2.0));
+  q=f/r;
+  e=(r*cos(q))-a/2.0;f=(r*sin(q))-a/2.0;
+  d=sin(e*g)*176.0+sin(e*g)*164.0+r;
+  h=((f+d)+a/2.0)*g;
+  i=cos(h+r*p.x/1.3)*(e+e+a)+cos(q*g*6.0)*(r+h/3.0);
+  h=sin(f*g)*144.0-sin(e*g)*212.0*p.x;
+  h=(h+(f-e)*q+sin(r-(a+h)/7.0)*10.0+i/4.0)*g;
+  i+=cos(h*2.3*sin(a/350.0-q))*184.0*sin(q-(r*4.3+a/12.0)*g)+tan(r*g+h)*184.0*cos(r*g+h);
+  i=mod(i/5.6,256.0)/64.0;
+  if(i<0.0) i+=4.0;
+  if(i>=2.0) i=4.0-i;
+  d=r/350.0;
+  d+=sin(d*d*8.0)*0.52;
+  f=(sin(a*g)+1.0)/2.0;
+  gl_FragColor=vec4(vec3(f*i/1.6,i/2.0+d/13.0,i)*d*p.x+vec3(i/1.3+d/8.0,i/2.0+d/18.0,i)*d*(1.0-p.x),1.0);
+}

data/examples/complete/edge_detection.rb

@@ -0,0 +1,49 @@
+# encoding: utf-8
+# frozen_string_literal: true
+require 'propane'
+# Edge Detection.
+#
+# A high-pass filter sharpens an image. This program analyzes every
+# pixel in an image in relation to the neighboring pixels to sharpen
+# the image.
+class EdgeDetection < Propane::App
+  KERNEL = [[-1, -1, -1], [-1, 9, -1], [-1, -1, -1]].freeze
+  attr_reader :img
+
+  def setup
+    size(640, 360)
+    @img = load_image('moon.jpg') # Load the original image
+    no_loop
+  end
+
+  def draw
+    image(img, 0, 0) # Displays the image from point (0,0)
+    img.load_pixels
+    # Create an opaque image of the same size as the original
+    edge_img = create_image(img.width, img.height, RGB)
+    # Loop through every pixel in the image
+    (1...img.height - 1).each do |y|
+      (1...img.width - 1).each do |x|
+        sum = 0 # Kernel sum for this pixel
+        (-1..1).each do |ky|
+          (-1..1).each do |kx|
+            # Calculate the adjacent pixel for this kernel point
+            pos = (y + ky) * img.width + (x + kx)
+            # Image is grayscale, red/green/blue are identical
+            val = red(img.pixels[pos])
+            # Multiply adjacent pixels based on the kernel values
+            sum += KERNEL[ky + 1][kx + 1] * val
+          end
+        end
+        # For this pixel in the new image, set the gray value
+        # based on the sum from the kernel
+        edge_img.pixels[y * img.width + x] = color(sum, sum, sum)
+      end
+    end
+    # State that there are changes to edge_img.pixels[]
+    edge_img.update_pixels
+    image(edge_img, width / 2, 0) # Draw the new image
+  end
+end
+
+EdgeDetection.new title: 'Edge Detection'

data/examples/complete/landscape.rb

@@ -0,0 +1,32 @@
+require 'propane'
+
+class Landscape < Propane::App
+  #
+  # Elevated
+  # https://www.shadertoy.com/view/MdX3Rr by inigo quilez
+  # Created by inigo quilez - iq/2013
+  # License Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported License.
+  # Processing port by Raphaël de Courville.
+  #  
+  attr_reader :landscape  
+  java_alias :background_int, :background, [Java::int]
+  
+  def setup
+    size(640, 360, P2D)
+    no_stroke    
+    # The code of this shader shows how to integrate shaders from shadertoy
+    # into Processing with minimal changes.
+    @landscape = load_shader('landscape.glsl')
+    landscape.set('resolution', width.to_f, height.to_f)
+  end
+  
+  def draw
+    background_int 0    
+    landscape.set('time', (millis/1000.0).to_f)
+    shader(landscape)
+    rect(0, 0, width, height)    
+    frame.set_title("frame: #{frame_count} - fps: #{format('%0.2f', frame_rate)}")
+  end  
+end
+
+Landscape.new title: 'Landscape'

data/examples/complete/linear_image.rb

@@ -0,0 +1,51 @@
+# encoding: utf-8
+# frozen_string_literal: true
+require 'propane'
+# Linear Image.
+#
+# Click and drag mouse up and down to control the signal.
+#
+# Note in ruby-processing to access booleans use
+#       mouse_pressed? and key_pressed?
+#
+# Press and hold any key to view the image scanning
+class LinearImage < Propane::App
+  attr_reader :signal, :img, :direction
+
+  def setup
+    size(640, 360)
+    stroke(255)
+    @img = loadImage('sea.jpg')
+    @direction = 1
+    @signal = 0
+    img.load_pixels
+    load_pixels
+  end
+
+  def draw
+    @direction = direction * -1 if signal > img.height - 1 || signal < 0
+    if mouse_pressed?
+      @signal = (mouse_y % img.height).abs
+    else
+      @signal += (0.3 * direction)
+    end
+    if key_pressed?
+      set(0, 0, img)
+      line(0, signal, img.width, signal)
+    else
+      signal_offset = signal.to_i * img.width
+      (0...img.height).each do |y|
+        java.lang.System.arraycopy(
+          img.pixels.to_java,
+          signal_offset,
+          pixels,
+          y * width,
+          img.width
+        )
+      end
+      update_pixels
+    end
+  end
+end
+
+LinearImage.new title: 'Linear Image'

data/examples/complete/monjori.rb

@@ -0,0 +1,33 @@
+require 'propane'
+
+class Monjori < Propane::App
+  ##
+  # Monjori.
+  #
+  # GLSL version of the 1k intro Monjori from the demoscene
+  # (http://www.pouet.net/prod.php?which=52761)
+  # Ported from the webGL version available in ShaderToy:
+  # http://www.iquilezles.org/apps/shadertoy/
+  # (Look for Monjori under the Plane Deformations Presets)
+   
+  attr_reader :monjori
+  
+  def setup
+    size(640, 360, P2D)
+    no_stroke
+    @monjori = load_shader('monjori.glsl')
+    monjori.set('resolution', width.to_f, height.to_f)
+  end
+  
+  def draw
+    monjori.set('time', millis / 1000.0)
+    shader(monjori)
+    # This kind of effects are entirely implemented in the
+    # fragment shader, they only need a quad covering the
+    # entire view area so every pixel is pushed through the
+    # shader.
+    rect(0, 0, width, height)
+  end  
+end
+
+Monjori.new title: 'Monjori'

data/examples/regular/arcball_box.rb

@@ -1,8 +1,10 @@
+!#/usr/bin/env jruby
+
 require 'arcball'
 
 ############################
 # Use mouse drag to rotate
-# the arcball. Use mousewheel
+# The arcball. Use mousewheel
 # to zoom. Hold down x, y, z
 # to constrain rotation axis.
 ############################

data/examples/regular/arcball_constrain.rb

@@ -0,0 +1,38 @@
+!#/usr/bin/env jruby
+
+require 'arcball'
+
+############################
+# Use mouse drag to rotate
+# the arcball. Use mousewheel
+# to zoom. Custom constrain
+# default is yaxis.
+############################
+
+require 'propane' # temporary local
+
+# Include processing opengl classes that we'd like to use:
+%w(PGL PGraphics3D PGraphicsOpenGL PShapeOpenGL Texture).each do |klass|
+  java_import "processing.opengl.#{klass}"
+end
+
+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

@@ -0,0 +1,205 @@
+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'