propane 0.3.0.pre-java

data/examples/complete/glsl_heightmap_noise.rb

@@ -0,0 +1,121 @@
+# encoding: utf-8
+# 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.3.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
+  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)
+    @images = textures.map { |texture| load_image(data_path(texture)) }
+    @color_map = 0
+    # load the PShader with a fragment and a vertex shader
+    @displace = load_shader('displaceFrag.glsl', 'displaceVert.glsl')
+    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/complete/kinetic_type.rb

@@ -0,0 +1,79 @@
+# encoding: utf-8
+# 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(data_path('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/regular/Rakefile

@@ -0,0 +1,30 @@
+# 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

@@ -0,0 +1,36 @@
+require 'arcball'
+
+############################
+# Use mouse drag to rotate
+# the arcball. Use mousewheel
+# to zoom. Hold down x, y, z
+# to constrain rotation axis.
+############################
+
+require_relative '../../lib/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.init(self, 300, 300)
+  fill 180
+end
+
+def draw
+  background(50)  
+  box(300, 300, 300)
+end
+
+end
+
+ArcballBox.new title: 'ArcBall Box'
+
+
+

data/examples/regular/creating_colors.rb

@@ -0,0 +1,57 @@
+# encoding: utf-8
+# 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
+
+  def setup
+    size 640, 360
+    @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 = 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/elegant_ball.rb

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