mainly new sketches

Author: monkstone

contributed/circle_growth.rb

@@ -0,0 +1,58 @@
+require 'toxiclibs'
+
+W = 1000
+H = 600
+
+attr_reader :axiom, :z, :physics
+
+def settings
+  size(W, H)
+end
+
+def setup
+  sketch_title 'Wolfram Circle Growth'
+  @axiom = [[0, 1], [0, 2], [1, 2]]
+  @z = axiom.flatten.max + 1
+  @physics = Physics::VerletPhysics2D.new
+  physics.set_drag(0.2)
+  # Get id of each node
+  uniques = axiom.flatten.uniq
+  uniques.each do
+    p = Physics::VerletParticle2D.new(TVec2D.randomVector.add(TVec2D.new(W >> 1, H >> 1)))
+    physics.addParticle(p)
+    physics.addBehavior(Physics::AttractionBehavior2D.new(p, 10, -0.5))
+  end
+  axiom.each do |node|
+    p1 = physics.particles.get(node[0])
+    p2 = physics.particles.get(node[1])
+    s = Physics::VerletSpring2D.new(p1, p2, 4, 0.5)
+    physics.add_spring(s)
+  end
+end
+
+def draw
+  background(color('#FFFFFF'))
+  physics.update
+  idx = rand(z)
+  x, y = *axiom[idx]
+  axiom.delete_at(idx)
+  axiom << [y, z]
+  axiom << [z, x]
+  # Manage physics accordingly
+  px = physics.particles.get(x) # coordinate of node x
+  py = physics.particles.get(y) # coordinate of node y
+  pz = Physics::VerletParticle2D.new(px.add(py).scale(0.5)) # create a new particle in between
+  s = physics.get_spring(px, py) # find spring between the deleted edge
+  physics.remove_spring(s) # remove that spring
+  physics.add_particle(pz) # add particle
+  physics.add_behavior(Physics::AttractionBehavior2D.new(pz, 10, -0.5)) # attach a repulsion behavior to it
+  s1 = Physics::VerletSpring2D.new(py, pz, 4, 0.5) # create spring between 1st new edge
+  s2 = Physics::VerletSpring2D.new(pz, px, 4, 0.5) # create spring between 2nd new edge
+  physics.add_spring(s1) # add them to physics
+  physics.add_spring(s2)
+  @z += 1 # increment 'z'
+  # Draw springs
+  physics.springs.each do |spring|
+    line(spring.a.x, spring.a.y, spring.b.x, spring.b.y)
+  end
+end

contributed/sierpinski_carpet.rb

@@ -0,0 +1,30 @@
+attr_reader :limit
+
+def setup
+  sketch_title 'Sierpinski Carpet'
+  n = 4
+  @limit = width / 3**n
+  fill 0
+  background 255
+  no_stroke
+  holes(0, 0, width / 3)
+end
+
+def in_carpet?(xpos, ypos)
+  !(xpos == 1 && ypos == 1)
+end
+
+def holes(xpos, ypos, dim)
+  return if dim < limit
+
+  grid(3, 3) do |row, col|
+    offset_x = xpos + row * dim
+    offset_y = ypos + col * dim
+    rect(offset_x, offset_y, dim, dim) unless in_carpet?(row, col)
+    holes(offset_x, offset_y, dim / 3)
+  end
+end
+
+def settings
+  size(729, 729)
+end

contributed/truchet_tiling.rb

@@ -0,0 +1,102 @@
+# After a sketch by Jim Bumgardner
+# http://joyofprocessing.com/blog/tag/tilings/page/2/
+# Here we create an array of offscreen images
+# Create a grid using the ruby-processing :grid method
+# Then randomly render tile images from the array
+DIM = 24
+TYPE = %i[corner alt_corner alt_oval oval alt_line line].freeze
+attr_reader :tiles, :images
+
+def make_image(dim, alternate = :line)
+  create_graphics(dim, dim).tap do |g|
+    g.smooth(4)
+    g.begin_draw
+    g.background(255)
+    g.stroke(0)
+    g.stroke_weight(4)
+    g.no_fill
+    g.ellipse_mode(RADIUS)
+    case alternate
+    when :corner
+      g.line(dim / 2, 0, dim / 2, dim / 2)
+      g.line(0, dim / 2, dim / 2, dim / 2)
+      g.line(dim / 2, dim, dim, dim / 2)
+    when :alt_corner
+      g.line(dim / 2, 0, dim / 2, dim / 2)
+      g.line(dim / 2, dim / 2, dim, dim /  2)
+      g.line(0, dim / 2, dim / 2, dim)
+    when :line
+      g.line(dim / 2, 0, dim, dim / 2)
+      g.line(0, dim / 2, dim / 2, dim)
+    when :alt_line
+      g.line(0, dim / 2, dim / 2, 0)
+      g.line(dim / 2, dim, dim, dim / 2)
+    when :alt_oval
+      g.ellipse(0, dim, dim / 2, dim / 2)
+      g.ellipse(dim, 0, dim / 2, dim / 2)
+    when :oval
+      g.ellipse(0, 0, dim / 2, dim / 2)
+      g.ellipse(dim, dim, dim / 2, dim / 2)
+    end
+    g.end_draw
+  end
+end
+
+def create_image_array(except = [])
+  @images = TYPE.reject do |type|
+    except.include?(type)
+  end.map { |type| make_image(DIM, type) }
+  @tiles = []
+end
+
+def create_grid
+  @tiles = []
+  grid(width, height, DIM, DIM) do |posx, posy|
+    tiles << Tile.new(Vec2D.new(posx, posy))
+  end
+end
+
+def setup
+  sketch_title 'Mixed Truchet Tiling'
+  create_image_array
+  create_grid
+  no_loop
+end
+
+def key_pressed
+  case key
+  when 'o', 'O'
+    create_image_array(%i[alt_line line corner alt_corner])
+  when 'c', 'C'
+    create_image_array(%i[alt_line line oval alt_oval])
+  when 'l', 'L'
+    create_image_array(%i[alt_oval oval])
+  end
+  create_grid
+  redraw
+end
+
+def draw
+  background(255)
+  tiles.each(&:render)
+end
+
+def settings
+  size(576, 576)
+  smooth(4)
+end
+
+# encapsulate Tile as a class
+class Tile
+  include Processing::Proxy
+  attr_reader :vec, :img
+
+  def initialize(vec)
+    @vec = vec
+    @img = images.sample
+  end
+
+  def render
+    image(img, vec.x, vec.y, img.width, img.height)
+  end
+end

processing_app/library/video/capture/data/droste.glsl

@@ -0,0 +1,62 @@
+// This implementation is based on GLSL code by ArKano22:
+// http://www.gamedev.net/topic/590070-glsl-droste/
+uniform float time;
+uniform sampler2D texture; // iChannel0 in Shadertoy
+uniform vec2 resolution; // iResolution in Shadertoy
+uniform int mode;
+
+const float TWO_PI = 3.141592*2.0;
+//ADJUSTABLE PARAMETERS:
+const float Branches = 1.0;
+const float scale = 0.4;
+const float off = 0.6;
+//Complex Math:
+vec2 complexExp(in vec2 z){
+	return vec2(exp(z.x)*cos(z.y),exp(z.x)*sin(z.y));
+}
+vec2 complexLog(in vec2 z){
+	return vec2(log(length(z)), atan(z.y, z.x));
+}
+vec2 complexMult(in vec2 a,in vec2 b){
+	return vec2(a.x*b.x - a.y*b.y, a.x*b.y + a.y*b.x);
+}
+float complexMag(in vec2 z){
+	return length(z);
+}
+vec2 complexReciprocal(in vec2 a){ return vec2(a.x, -a.y) / dot(a, a); }
+vec2 complexDiv(in vec2 a,in vec2 b){
+	return complexMult(a, complexReciprocal(b));
+}
+vec2 complexPower(in vec2 a, in vec2 b){
+	return complexExp( complexMult(b,complexLog(a))  );
+}
+//Misc Functions:
+float nearestPower(in float a, in float base){
+	return pow(base,  ceil(  log(abs(a))/log(base)  )-1.0 );
+}
+float map(float value, float istart, float istop, float ostart, float ostop) {
+	   return ostart + (ostop - ostart) * ((value - istart) / (istop - istart));
+}
+
+void main( void ){
+
+	//SHIFT AND SCALE COORDINATES
+	vec2 uv=gl_FragCoord.xy/resolution.xy - off;
+
+	//ESCHER GRID TRANSFORM:
+	float factor = pow(1.0/scale,Branches);
+	uv= complexPower(uv, complexDiv(vec2( log(factor) ,TWO_PI), vec2(0.0,TWO_PI) ) );
+
+	//RECTANGULAR DROSTE EFFECT:
+	float FT = fract(time);
+	FT = log(FT+1.)/log(2.);
+	uv *= 1.0+FT*(scale-1.0);
+
+  float npower = max(nearestPower(uv.x,scale),nearestPower(uv.y,scale));
+//	uv.x = map(uv.x,-npower,npower,-1.0,1.0);
+//	uv.y = map(uv.y,-npower,npower,-1.0,1.0);
+   uv = normalize(uv) * 2;
+
+	//UNDO SHIFT AND SCALE:
+	gl_FragColor =  texture(texture,uv*off+vec2(off));
+}

processing_app/library/video/capture/droste.rb

@@ -0,0 +1,37 @@
+load_library :video, :video_event
+include_package 'processing.video'
+attr_reader :cam, :my_filter, :origin
+
+def settings
+  size(1280, 960, P2D)
+end
+
+def setup
+  sketch_title 'Droste'
+  @origin = Time.now
+  @my_filter = load_shader(data_path('droste.glsl'))
+  my_filter.set('resolution', width.to_f, height.to_f)
+  start_capture
+end
+
+def time
+  (Time.now - origin)
+end
+
+def start_capture
+  @cam = Java::ProcessingVideo::Capture.new(self, "UVC Camera (046d:0825)")
+  cam.start
+end
+
+# using snake case to match java reflect method
+def captureEvent(cam)
+  cam.read
+end
+
+def draw
+  background 0
+  image(cam, 0, 0, width, height)
+  my_filter.set('time', time)
+  return if mouse_pressed?
+  filter(my_filter)
+end