basics examples

Author: monkstone

basics/arrays/array.rb

@@ -0,0 +1,37 @@
+#!/usr/bin/env jruby
+require 'picrate'
+# An array is a list of data. Each piece of data in an array
+# is identified by an index number representing its position in
+# the array. Arrays are zero based, which means that the first
+# element in the array is [0], the second element is [1], and so on.
+# In this example, an array named "coswave" is created using ruby
+# map with the cosine values. This data is displayed three
+# separate ways on the screen.
+class SimpleArray < Processing::App
+
+  attr_reader :coswave
+
+  def setup
+    sketch_title 'Simple Array'
+    @coswave = (0..width).map do |i|
+      Math.cos(map1d(i, (0..width), (0..PI))).abs
+    end
+  end
+
+  def draw
+    coswave.each_with_index do |val, i|
+      stroke(val * 255)
+      line(i, 0, i, height / 3)
+      stroke(val * 255 / 4)
+      line(i, height / 3, i, height / 3 * 2)
+      stroke(255 - val * 255)
+      line(i, height / 3 * 2, i, height)
+    end
+  end
+
+  def settings
+    size 640, 360
+  end
+end
+
+SimpleArray.new

basics/arrays/array_2d.rb

@@ -0,0 +1,40 @@
+#!/usr/bin/env jruby
+require 'picrate'
+# Demonstrates the use of :grid to create a two-dimensional (2D) array in ruby
+# Values in a 2D array are accessed through two index values.
+# 2D arrays are useful for storing images. In this example, each dot
+# is colored in relation to its distance from the center of the image.
+class Array2d < Processing::App
+  attr_reader :distances
+
+  def setup
+    sketch_title 'Array 2D'
+    @distances = Array.new(width) { Array.new(height) }
+    stroke_weight 2
+    max_distance = dist(width / 2, height / 2, width, height)
+    grid(width, height) do |x, y|
+      distance = dist(width / 2, height / 2, x, y)
+      distances[x][y] = distance / max_distance * 255
+    end
+  end
+
+  def draw
+    background 0
+    x = 0
+    while x < distances.length
+      y = 0
+      while y < distances[x].length
+        stroke distances[x][y]
+        point x, y
+        y += 2
+      end
+      x += 2
+    end
+  end
+
+  def settings
+    size 640, 360
+  end
+end
+
+Array2d.new

basics/arrays/array_objects.rb

@@ -0,0 +1,68 @@
+#!/usr/bin/env jruby
+require 'picrate'
+
+class ArrayObjects < Processing::App
+  # Demonstrates the syntax for creating an array of custom objects.
+
+  UNIT = 40
+  attr_reader :mods
+
+  def setup
+    sketch_title 'Array of Objects'
+    wide_count = width / UNIT
+    height_count = height / UNIT
+    @mods = []
+    grid(wide_count, height_count) do |i, j|
+       mods << CustomObject.new(j * UNIT, i * UNIT, UNIT / 2, UNIT / 2, rand(0.05..0.8))
+    end
+    no_stroke
+  end
+
+  def draw
+    background 0
+    mods.each(&:run)
+  end
+
+  def settings
+    size 640, 360, FX2D
+  end
+
+  module Runnable
+    def run
+      update
+      draw
+    end
+  end
+
+  # the custom object
+  class CustomObject
+    include Processing::Proxy, Runnable
+    attr_reader :x, :y, :mx, :my, :size
+    def initialize(mx, my, x, y, speed)
+      @mx, @my      = my, mx # This is backwards to match original example.
+      @x, @y        = x.to_i, y.to_i
+      @xdir, @ydir  = 1, 1
+      @speed        = speed
+      @size         = UNIT
+    end
+
+    def update
+      @x += @speed * @xdir
+      unless (0..size).cover? x
+        @xdir *= -1
+        @x += @xdir
+        @y += @ydir
+      end
+      return unless @y >= @size || x <= 0
+      @ydir *= -1
+      @y += @ydir
+    end
+
+    def draw
+      fill(255)
+      ellipse(mx + x, my + y, 6, 6)
+    end
+  end
+end
+
+ArrayObjects.new

basics/arrays/custom_array.rb

@@ -0,0 +1,76 @@
+#!/usr/bin/env jruby
+require 'picrate'
+require 'forwardable'
+
+# Demonstrates possible syntax for creating a custom array of objects.
+class CustomArray < Processing::App
+  UNIT = 40
+  attr_reader :custom_array
+
+  def setup
+    sketch_title 'Custom Array'
+    wide_count = width / UNIT
+    height_count = height / UNIT
+    @custom_array = CustomArray.new
+    grid(wide_count, height_count) do |i, j|
+      custom_array.add_object(i * UNIT, j * UNIT, UNIT / 2, UNIT / 2, rand(0.05..0.8))
+    end
+    no_stroke
+  end
+
+  def draw
+    custom_array.update
+    custom_array.draw
+  end
+
+  def settings
+    size 640, 360, FX2D
+  end
+
+  # The Particle object
+  Particle = Struct.new(:x, :y, :mx, :my, :size, :speed, :xdir, :ydir)
+
+  # The custom Array created using Forwardable
+  # Processing::Proxy gives access to PApplet methods
+  class CustomArray
+    extend Forwardable
+    def_delegators(:@objs, :each, :<<)
+    include Enumerable, Processing::Proxy
+
+    def initialize
+      @objs = []
+    end
+
+    def add_object(mx, my, x, y, speed)
+      self << Particle.new(x.to_i, y.to_i, mx, my, UNIT, speed, 1, 1)
+    end
+
+    def update
+      each do |obj|
+        update_x obj
+        next unless obj.y >= UNIT || obj.x <= 0
+        obj.ydir *= -1
+        obj.y += obj.ydir
+      end
+    end
+
+    def update_x(obj)
+      obj.x += obj.speed * obj.xdir
+      return if (0..UNIT).cover? obj.x
+      obj.xdir *= -1
+      obj.x += obj.xdir
+      obj.y += obj.ydir
+    end
+
+    def draw
+      background(0)
+      fill(255)
+      each do |obj|
+        ellipse(obj.mx + obj.x, obj.my + obj.y, 6, 6)
+      end
+    end
+  end
+
+end
+
+CustomArray.new

basics/arrays/parallel_array.rb

@@ -0,0 +1,38 @@
+#!/usr/bin/env jruby
+require 'picrate'
+require 'parallel'
+# An array is a list of data. Each piece of data in an array
+# is identified by an index number representing its position in
+# the array. Arrays are zero based, which means that the first
+# element in the array is [0], the second element is [1], and so on.
+# In this example, an array named "coswave" is created using ruby
+# map with the cosine values. This data is displayed three
+# separate ways on the screen.
+class ParallelArray < Processing::App
+
+  attr_reader :coswave
+
+  def setup
+    sketch_title 'Array'
+    @coswave = Parallel.map(0..width) do |i|
+      Math.cos(map1d(i, (0..width), (0..PI))).abs
+    end
+  end
+
+  def draw
+    coswave.each_with_index do |val, i|
+      stroke(val * 255)
+      line(i, 0, i, height / 3)
+      stroke(val * 255 / 4)
+      line(i, height / 3, i, height / 3 * 2)
+      stroke(255 - val * 255)
+      line(i, height / 3 * 2, i, height)
+    end
+  end
+
+  def settings
+    size 640, 360
+  end
+end
+
+ParallelArray.new

basics/camera/Rakefile

@@ -0,0 +1,30 @@
+# Simple demo Rakefile to autorun samples in current directory
+# adjust path to jruby, 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

basics/camera/arcball_perspektiv.rb

@@ -0,0 +1,56 @@
+#!/usr/bin/env jruby -v -W2
+require 'picrate'
+require 'arcball'
+# Move the mouse left and right to change the field of view (fov).
+# Click to modify the aspect ratio. The perspektiv method
+# sets a perspective projection applying foreshortening, making
+# distant objects appear smaller than closer ones. The parameters
+# define a viewing volume with the shape of truncated pyramid.
+# while farther objects appear smaller. This projection simulates
+# the perspective of the world more accurately than orthographic projection.
+# The version of perspektiv without parameters sets the default
+# perspective and the version with up to four parameters allows the programmer
+# to set the environment more precisely.
+class ArcballPerspektiv < Processing::App
+  attr_reader :aspect
+
+  def setup
+    sketch_title 'Perspektiv Example'
+    Processing::ArcBall.constrain self
+    @aspect = width.to_f / height
+    no_stroke
+  end
+
+  def draw
+    lights
+    background 204
+    camera_y = height / 2.0
+    fov = mouse_x / width.to_f * PI / 2.0
+    camera_z = camera_y / Math.tan(fov / 2.0)
+    perspektiv(
+      fov: fov,
+      aspect_ratio: aspect,
+      near_z: camera_z / 10.0,
+      far_z: camera_z * 10.0
+    )
+    rotate_x -PI / 6
+    box 45
+    translate 0, 0, -50
+    box 30
+  end
+
+  def settings
+    size 640, 360, P3D
+  end
+
+  def key_pressed
+    case key
+    when ' '
+      @aspect = width * 0.5 / height
+    when 'n', 'N'
+      @aspect = width.to_f / height
+    end
+  end
+end
+
+ArcballPerspektiv.new

basics/camera/kmove_eye.rb

@@ -0,0 +1,30 @@
+#!/usr/bin/env jruby -v -W2
+require 'picrate'
+# Move Eye.
+# by Simon Greenwold.
+#
+# The camera lifts up (controlled by mouseY) while looking at the same point.
+class KMoveEye < Processing::App
+  def setup
+    sketch_title 'KMove Eye Kamera'
+    fill 204
+  end
+
+  def draw
+    lights
+    background 0
+    kamera eye: Vec3D.new(30, mouse_y, 220), center: Vec3D.new
+    no_stroke
+    box 90
+    stroke 255
+    line( -100, 0, 0, 100, 0, 0)
+    line( 0, -100, 0, 0, 100, 0)
+    line( 0, 0, -100, 0, 0, 100)
+  end
+
+  def settings
+    size 640, 360, P3D
+  end
+end
+
+KMoveEye.new