propane 0.8.0-java → 0.9.0-java

data/examples/data_path/data/monjori.glsl

@@ -1,30 +0,0 @@
-#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/data_path/edge_detection.rb

@@ -1,49 +0,0 @@
-#!/usr/bin/env jruby -v -W2
-# 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(File.expand_path('./data/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/data_path/glsl_heightmap_noise.rb

@@ -1,125 +0,0 @@
-#!/usr/bin/env jruby -v -W2
-# frozen_string_literal: true
-# Noise-Based GLSL Heightmap by Amnon Owed (May 2013)
-# https://github.com/AmnonOwed
-# http://vimeo.com/amnon
-#
-# Creating a GLSL heightmap running on shader-based procedural noise.
-#
-# c = cycle through the color maps
-#
-# Tested with propane-0.8.0
-#
-# Photographs by Folkert Gorter (@folkertgorter / http://superfamous.com/) made available under a CC Attribution 3.0 license.
-
-require 'propane'
-
-class HeightMap < Propane::App
-  include Propane::Render
-  SHADERS = %w(displaceFrag.glsl displaceVert.glsl).freeze
-  SHADER_NAME = %i(frag vert).freeze
-  DIM = 300 # the grid dimensions of the heightmap
-  attr_reader :blur_factor # the blur for the displacement map
-  attr_reader :resize_factor # the resize factor for the displacement map
-  attr_reader :displace_strength
-  attr_reader :positions
-  attr_reader :tex_coords
-  attr_reader :height_map # PShape holds the geometry, textures etc.
-  attr_reader :displace # GLSL shader
-  attr_reader :images # array to hold 2 input images
-  attr_reader :color_map # variable to keep track of the current colorMap
-
-  def setup
-    size(1280, 720, P3D) # use the P3D OpenGL renderer
-    @blur_factor = 3
-    @resize_factor = 0.25
-    displace_strength = 0.25 # the displace strength of the GLSL shader displacement effect
-    # load the images from the _Images folder (relative path from this sketch's folder)
-    textures = %w(Texture01.jpg Texture02.jpg)
-    glsl_files = SHADERS.map { |shade| File.expand_path("./data/#{shade}") }
-    shaders = SHADER_NAME.zip(glsl_files.to_java(:string)).to_h
-    @images = textures.map { |texture| load_image(File.expand_path("./data/#{texture}")) }
-    @color_map = 0
-    # load the PShader with a fragment and a vertex shader
-    @displace = load_shader(shaders[:frag], shaders[:vert])
-    displace.set('displaceStrength', displace_strength) # set the displace_strength
-    displace.set('colorMap', images[color_map]) # set the initial colorMap
-    # create the heightmap PShape (see custom creation method) and put it in the global height_map reference
-    @height_map = create_plane(DIM, DIM)
-  end
-
-  def draw
-    # required for texLight shader
-    pointLight(255, 255, 255, 2 * (mouse_x - width / 2), 2 * (mouse_y - height / 2), 500)
-    translate(width / 2, height / 2) # translate to center of the screen
-    rotate_x(60.radians) # fixed rotation of 60 degrees over the X axis
-    rotate_z(frame_count * 0.005) # dynamic frameCount-based rotation over the Z axis
-    background(0) # black background
-    perspective(PI/3.0, width.to_f / height, 0.1, 1_000_000) # perspective for close shapes
-    scale(750) # scale by 750 (the model itself is unit length
-    displace.set('time', millis / 5_000.0) # feed time to the GLSL shader
-    shader(displace) # use shader
-    shape(height_map) # display the PShape
-  end
-
-  # custom method to create a PShape plane with certain xy DIMensions
-  def create_plane(xsegs, ysegs)
-    # STEP 1: create all the relevant data
-
-    @positions = [] # arrayList to hold positions
-    @tex_coords = [] # arrayList to hold texture coordinates
-
-    usegsize = 1 / xsegs.to_f # horizontal stepsize
-    vsegsize = 1 / ysegs.to_f # vertical stepsize
-
-    xsegs.times do |x|
-      ysegs.times do |y|
-        u = x / xsegs.to_f
-        v = y / ysegs.to_f
-
-        # generate positions for the vertices of each cell
-        # (-0.5 to center the shape around the origin)
-        positions << Vec3D.new(u - 0.5, v - 0.5, 0)
-        positions << Vec3D.new(u + usegsize - 0.5, v - 0.5, 0)
-        positions << Vec3D.new(u + usegsize - 0.5, v + vsegsize - 0.5, 0)
-        positions << Vec3D.new(u - 0.5, v + vsegsize - 0.5, 0)
-
-        # generate texture coordinates for the vertices of each cell
-        tex_coords << Vec2D.new(u, v)
-        tex_coords << Vec2D.new(u + usegsize, v)
-        tex_coords << Vec2D.new(u + usegsize, v + vsegsize)
-        tex_coords << Vec2D.new(u, v + vsegsize)
-      end
-    end
-
-    # STEP 2: put all the relevant data into the PShape
-
-    texture_mode(NORMAL) # set texture_mode to normalized (range 0 to 1)
-    tex = images[0]
-
-    mesh = create_shape # create the initial PShape
-    renderer = ShapeRender.new(mesh) # initialize the shape renderer
-    mesh.begin_shape(QUADS) # define the PShape type: QUADS
-    mesh.no_stroke
-    mesh.texture(tex) # set a texture to make a textured PShape
-    # put all the vertices, uv texture coordinates and normals into the PShape
-    positions.each_with_index do |p, i|
-      p.to_vertex_uv(renderer, tex_coords[i]) # NB: tex_coords as Vec2D
-      # p.to_vertex_uv(renderer, u, v) # u, v as floats is the alternate form
-    end
-    mesh.end_shape
-    mesh # our work is done here, return DA MESH! -)
-  end
-
-  def key_released
-    case key
-    when '1', '2'
-    @color_map = key.to_i - 1 # images.size for more than two
-      displace.set('colorMap', images[color_map])
-    else
-      puts format('key pressed: %s', key)
-    end # cycle through colorMaps (set variable and set colorMap in PShader)
-  end
-end
-
-HeightMap.new title: 'Height Map'

data/examples/data_path/kinetic_type.rb

@@ -1,79 +0,0 @@
-#!/usr/bin/env jruby -v -W2
-# frozen_string_literal: true
-# From the Processing Examples
-# by Zach Lieberman
-
-WORDS = %w(sometimes\ it's\ like the\ lines\ of\ text are\ so\ happy
-           that\ they\ want\ to\ dance or\ leave\ the\ page\ or\ jump
-           can\ you\ blame\ them? living\ on\ the\ page\ like\ that
-           waiting\ to\ be\ read...)
-
-require 'propane' # temporary local
-
-# dispay them 'words'
-class KineticType < Propane::App
-
-  def setup
-    size(200, 200, P3D)
-    frame_rate 30
-    # Load the font from the sketch's data directory.
-    text_font load_font(File.expand_path('./data/Univers45.vlw')), 1.0
-    fill 255
-    # Creating the line objects
-    @lines = WORDS.map.with_index { |word, i| Line.new(self, word, 0, i * 70) }
-  end
-
-  def draw
-    background 0
-    translate(-240, -120, -450)
-    rotate_y 0.3
-    # Now animate every line object & draw it...
-    @lines.each_with_index do |line, i|
-      push_matrix
-      translate 0.0, line.ypos, 0.0
-      line.draw(i)
-      pop_matrix
-    end
-  end
-end
-
-
-class Line
-  attr_accessor :app, :string, :xpos, :ypos, :letters
-
-  def initialize(app, string, x, y)
-    @app, @string, @xpos, @ypos = app, string, x, y
-    spacing = 0.0
-    @letters = string.split('').map do |c|
-      spacing += app.text_width(c)
-      Letter.new(c, spacing, 0.0)
-    end
-  end
-
-  def compute_curve(line_num)
-    base = app.millis / 10_000.0 * Math::PI * 2
-    Math.sin((line_num + 1.0) * base) * Math.sin((8.0 - line_num) * base)
-  end
-
-  def draw(line_num)
-    curve = compute_curve(line_num)
-    letters.each_with_index do |letter, i|
-      return if i < 0
-      app.translate(app.text_width(letters[i - 1].char) * 75, 0.0, 0.0)
-      app.rotate_y(curve * 0.035)
-      app.push_matrix
-      app.scale(75.0, 75.0, 75.0)
-      app.text(letter.char, 0.0, 0.0)
-      app.pop_matrix
-    end
-  end
-end
-
-class Letter
-  attr_accessor :char, :x, :y
-  def initialize(c, x, y)
-    @char, @x, @y = c, x, y
-  end
-end
-
-KineticType.new title: 'Kinetic Type'

data/examples/data_path/landscape.rb

@@ -1,34 +0,0 @@
-#!/usr/bin/env jruby -v -W2
-# frozen_string_literal: true
-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(File.expand_path('./data/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/data_path/linear_image.rb

@@ -1,51 +0,0 @@
-#!/usr/bin/env jruby -v -W2
-# 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 = load_image(File.expand_path('./data/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/data_path/monjori.rb

@@ -1,35 +0,0 @@
-#!/usr/bin/env jruby -v -W2
-# frozen_string_literal: true
-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(File.expand_path('./data/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/Rakefile

@@ -1,30 +0,0 @@
-# Simple demo Rakefile to autorun samples in current directory
-# adjust path to rp5 executable, and or opts as required
-
-SAMPLES_DIR = './'
-
-desc 'run demo'
-task default: [:demo]
-
-desc 'demo'
-task :demo do
-  samples_list.shuffle.each { |sample| run_sample sample }
-end
-
-def samples_list
-  files = []
-  Dir.chdir(SAMPLES_DIR)
-  Dir.glob('*.rb').each do |file|
-    files << File.join(SAMPLES_DIR, file)
-  end
-  return files
-end
-
-def run_sample(sample_name)
-  puts "Running #{sample_name}...quit to run next sample"
-  open("|jruby #{sample_name}", 'r') do |io|
-    while l = io.gets
-      puts(l.chop)
-    end
-  end
-end

data/examples/regular/arcball_box.rb

@@ -1,28 +0,0 @@
-#!/usr/bin/env jruby -v -w
-require 'arcball'
-require 'propane'
-
-############################
-# Use mouse drag to rotate
-# The arcball. Use mousewheel
-# to zoom. Hold down x, y, z
-# to constrain rotation axis.
-############################
-
-class ArcballBox < Propane::App
-
-def setup
-  size(600, 600, P3D)
-  smooth(8)
-  Processing::ArcBall.init(self, 300, 300)
-  fill 180
-end
-
-def draw
-  background(50)
-  box(300, 300, 300)
-end
-
-end
-
-ArcballBox.new title: 'ArcBall Box'