ruby-processing 2.6.3 → 2.6.4

data/samples/processing_app/topics/shaders/data/nebula.glsl

@@ -1,111 +0,0 @@
-#define PROCESSING_COLOR_SHADER
-
-uniform float time;
-uniform vec2 resolution;
-
-// NEBULA - CoffeeBreakStudios.com (CBS)
-// Work in progress...
-//
-// 3148.26: Switched from classic to simplex noise
-// 3148.27: Reduced number of stars
-// 3249.0:  Switched to fast computed 3D noise. Less quality but ~ 2x faster
-// 3249.5:  Removed use of random number generator to gain performance
-// 3265.0:  Added rotation: glsl.heroku.com/e#3005.1
-
-//Utility functions
-
-vec3 fade(vec3 t) {
-  return vec3(1.0,1.0,1.0);//t*t*t*(t*(t*6.0-15.0)+10.0);
-}
-
-vec2 rotate(vec2 point, float rads) {
-	float cs = cos(rads);
-	float sn = sin(rads);
-	return point * mat2(cs, -sn, sn, cs);
-}	
-
-vec4 randomizer4(const vec4 x)
-{
-    vec4 z = mod(x, vec4(5612.0));
-    z = mod(z, vec4(3.1415927 * 2.0));
-    return(fract(cos(z) * vec4(56812.5453)));
-}
-
-// Fast computed noise
-// http://www.gamedev.net/topic/502913-fast-computed-noise/
-
-const float A = 1.0;
-const float B = 57.0;
-const float C = 113.0;
-const vec3 ABC = vec3(A, B, C);
-const vec4 A3 = vec4(0, B, C, C+B);
-const vec4 A4 = vec4(A, A+B, C+A, C+A+B);
-
-float cnoise4(const in vec3 xx)
-{
-    vec3 x = mod(xx + 32768.0, 65536.0);
-    vec3 ix = floor(x);
-    vec3 fx = fract(x);
-    vec3 wx = fx*fx*(3.0-2.0*fx);
-    float nn = dot(ix, ABC);
-
-    vec4 N1 = nn + A3;
-    vec4 N2 = nn + A4;
-    vec4 R1 = randomizer4(N1);
-    vec4 R2 = randomizer4(N2);
-    vec4 R = mix(R1, R2, wx.x);
-    float re = mix(mix(R.x, R.y, wx.y), mix(R.z, R.w, wx.y), wx.z);
-
-    return 1.0 - 2.0 * re;
-}
-float surface3 ( vec3 coord, float frequency ) {
-	
-	float n = 0.0;	
-		
-	n += 1.0	* abs( cnoise4( coord * frequency ) );
-	n += 0.5	* abs( cnoise4( coord * frequency * 2.0 ) );
-	n += 0.25	* abs( cnoise4( coord * frequency * 4.0 ) );
-	n += 0.125	* abs( cnoise4( coord * frequency * 8.0 ) );
-	n += 0.0625	* abs( cnoise4( coord * frequency * 16.0 ) );
-	
-	return n;
-}
-	
-void main( void ) {
-	float rads = radians(time*3.15);
-	vec2 position = gl_FragCoord.xy / resolution.xy;
-	position += rotate(position, rads);
-	float n = surface3(vec3(position*sin(time*0.1), time * 0.05)*mat3(1,0,0,0,.8,.6,0,-.6,.8),0.9);
-	float n2 = surface3(vec3(position*cos(time*0.1), time * 0.04)*mat3(1,0,0,0,.8,.6,0,-.6,.8),0.8);
-    	float lum = length(n);
-    	float lum2 = length(n2);
-
-	vec3 tc = pow(vec3(1.0-lum),vec3(sin(position.x)+cos(time)+4.0,8.0+sin(time)+4.0,8.0));
-	vec3 tc2 = pow(vec3(1.1-lum2),vec3(5.0,position.y+cos(time)+7.0,sin(position.x)+sin(time)+2.0));
-	vec3 curr_color = (tc*0.8) + (tc2*0.5);
-	
-	
-	//Let's draw some stars
-	
-	float scale = sin(0.3 * time) + 5.0;
-	vec2 position2 = (((gl_FragCoord.xy / resolution) - 0.5) * scale);
-	float gradient = 0.0;
-	vec3 color = vec3(0.0);
-	float fade = 0.0;
-	float z = 0.0;
- 	vec2 centered_coord = position2 - vec2(sin(time*0.1),sin(time*0.1));
-	centered_coord = rotate(centered_coord, rads);
-	
-	for (float i=1.0; i<=60.0; i++)
-	{
-		vec2 star_pos = vec2(sin(i) * 250.0, sin(i*i*i) * 250.0);
-		float z = mod(i*i - 10.0*time, 256.0);
-		float fade = (256.0 - z) /256.0;
-		vec2 blob_coord = star_pos / z;
-		gradient += ((fade / 384.0) / pow(length(centered_coord - blob_coord), 1.5)) * ( fade);
-	}
-
-	curr_color += gradient;
-	
-	gl_FragColor = vec4(curr_color, 1.0);
-}

data/samples/processing_app/topics/shaders/data/sep_blur.glsl

@@ -1,59 +0,0 @@
-// Adapted from:
-// http://callumhay.blogspot.com/2010/09/gaussian-blur-shader-glsl.html
-
-#ifdef GL_ES
-precision mediump float;
-precision mediump int;
-#endif
-
-#define PROCESSING_TEXTURE_SHADER
-
-uniform sampler2D texture;
-
-// The inverse of the texture dimensions along X and Y
-uniform vec2 texOffset;
-
-varying vec4 vertColor;
-varying vec4 vertTexCoord;
-
-uniform int blurSize;       
-uniform int horizontalPass; // 0 or 1 to indicate vertical or horizontal pass
-uniform float sigma;        // The sigma value for the gaussian function: higher value means more blur
-                            // A good value for 9x9 is around 3 to 5
-                            // A good value for 7x7 is around 2.5 to 4
-                            // A good value for 5x5 is around 2 to 3.5
-                            // ... play around with this based on what you need :)
-
-const float pi = 3.14159265;
-
-void main() {  
-  float numBlurPixelsPerSide = float(blurSize / 2); 
-  
-  vec2 blurMultiplyVec = 0 < horizontalPass ? vec2(1.0, 0.0) : vec2(0.0, 1.0);
-
-  // Incremental Gaussian Coefficent Calculation (See GPU Gems 3 pp. 877 - 889)
-  vec3 incrementalGaussian;
-  incrementalGaussian.x = 1.0 / (sqrt(2.0 * pi) * sigma);
-  incrementalGaussian.y = exp(-0.5 / (sigma * sigma));
-  incrementalGaussian.z = incrementalGaussian.y * incrementalGaussian.y;
-
-  vec4 avgValue = vec4(0.0, 0.0, 0.0, 0.0);
-  float coefficientSum = 0.0;
-
-  // Take the central sample first...
-  avgValue += texture2D(texture, vertTexCoord.st) * incrementalGaussian.x;
-  coefficientSum += incrementalGaussian.x;
-  incrementalGaussian.xy *= incrementalGaussian.yz;
-
-  // Go through the remaining 8 vertical samples (4 on each side of the center)
-  for (float i = 1.0; i <= numBlurPixelsPerSide; i++) { 
-    avgValue += texture2D(texture, vertTexCoord.st - i * texOffset * 
-                          blurMultiplyVec) * incrementalGaussian.x;         
-    avgValue += texture2D(texture, vertTexCoord.st + i * texOffset * 
-                          blurMultiplyVec) * incrementalGaussian.x;         
-    coefficientSum += 2.0 * incrementalGaussian.x;
-    incrementalGaussian.xy *= incrementalGaussian.yz;
-  }
-
-  gl_FragColor = avgValue / coefficientSum;
-}

data/samples/processing_app/topics/shaders/deform.rb

@@ -1,28 +0,0 @@
-#
-# Deform. 
-# 
-# A GLSL version of the oldschool 2D deformation effect, by Inigo Quilez.
-# Ported from the webGL version available in ShaderToy:
-# http://www.iquilezles.org/apps/shadertoy/
-# (Look for Deform under the Plane Deformations Presets)
-# 
-#
- 
-attr_reader :tex, :deform
-
-def setup
-  size(640, 360, P2D)
-  
-  textureWrap(REPEAT)
-  @tex = loadImage('tex1.jpg')
- 
-  @deform = loadShader('deform.glsl')
-  deform.set('resolution', width.to_f, height.to_f)
-end
-
-def draw
-  deform.set('time', millis / 1000.0)
-  deform.set('mouse', mouse_x.to_f, mouse_y.to_f)
-  shader(deform)
-  image(tex, 0, 0, width, height)
-end

data/samples/processing_app/topics/shaders/edge_detect.rb

@@ -1,28 +0,0 @@
-#
-# Edge Detection
-# 
-# Change the default shader to apply a simple, custom edge detection filter.
-# 
-# Press the mouse to switch between the custom and default shader.
-#
-attr_reader :edges, :img , :enabled
-
-
-def setup
-  size(640, 360, P2D)
-  @enabled = true
-  @img = load_image('leaves.jpg');      
-  @edges = load_shader('edges.glsl')
-end
-
-def draw
-  shader(edges) if enabled
-  image(img, 0, 0)
-end
-
-def mousePressed
-  @enabled = !enabled
-  if (!enabled == true)
-    resetShader
-  end
-end

data/samples/processing_app/topics/shaders/glossy_fish_eye.rb

@@ -1,57 +0,0 @@
-#
-# Glossy Fish Eye
-# 
-# A fish-eye shader is used on the main surface and 
-# a glossy specular reflection shader is used on the
-# offscreen canvas. 
-#
-
-attr_reader :ball, :canvas, :glossy, :fisheye, :img, :use_fish_eye
-
-def setup
-  size(640, 640, P3D)
-  @canvas = create_graphics(width, height, P3D)
-  @use_fish_eye = true
-  @fisheye = load_shader('FishEye.glsl')
-  fisheye.set('aperture', 180.0)
-  @glossy = load_shader('GlossyFrag.glsl', 'GlossyVert.glsl')  
-  glossy.set('AmbientColour', 0.0, 0.0, 0.0)
-  glossy.set('DiffuseColour', 0.9, 0.2, 0.2)
-  glossy.set('SpecularColour', 1.0, 1.0, 1.0)
-  glossy.set('AmbientIntensity', 1.0)
-  glossy.set('DiffuseIntensity', 1.0)
-  glossy.set('SpecularIntensity', 0.7)
-  glossy.set('Roughness', 0.7)
-  glossy.set('Sharpness', 0.0)
-  @ball = create_shape(SPHERE, 50)
-  ball.set_stroke(false)
-end
-
-def draw
-  canvas.begin_draw
-  canvas.shader(glossy)
-  canvas.no_stroke
-  canvas.background(0)
-  canvas.push_matrix
-  canvas.rotate_y(frame_count * 0.01)
-  canvas.point_light(204, 204, 204, 1000, 1000, 1000)
-  canvas.pop_matrix  
-  (0 ... canvas.width + 100).step(100) do |x|
-    (0 ... canvas.width + 100).step(100) do |y|
-      (0 ... canvas.width + 100).step(100) do |z|
-        canvas.push_matrix
-        canvas.translate(x, y, -z)
-        canvas.shape(ball)
-        canvas.pop_matrix
-      end
-    end
-  end
-  canvas.end_draw   
-  shader(fisheye) if use_fish_eye  
-  image(canvas, 0, 0, width, height)
-end
-
-def mouse_pressed
-  @use_fish_eye = !use_fish_eye
-  reset_shader    
-end

data/samples/processing_app/topics/shaders/glsl_heightmap_noise.rb

@@ -1,125 +0,0 @@
-#
-# 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 ruby-procesing 2.5.0
-# 
-# Photographs by Folkert Gorter (@folkertgorter / http://superfamous.com/) made available under a CC Attribution 3.0 license.
-#
-load_library :vecmath
-
-DIM = 300 # the grid dimensions of the heightmap
-attr_reader :blur_factor # the blur for the displacement map (to make it smoother)
-attr_reader :resize_factor # the resize factor for the displacement map (to make it smoother)
-attr_reader :displace_strength 
-attr_reader :positions 
-attr_reader :tex_coords 
-attr_reader :height_map # PShape to hold the geometry, textures, texture coordinates etc.
-attr_reader :displace # GLSL shader
-
-attr_reader :images # array to hold 2 input images
-attr_reader :current_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)
-  @images = []  
-  images << load_image(data_path('Texture01.jpg'))
-  images << load_image(data_path('Texture02.jpg'))
-  @current_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[current_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
-
-  # write the fps and the current colorMap in the top-left of the window
-  frame.set_title('FrameRate: #{frame_rate.to_i} | colorMap: #{current_color_map + 1}')
-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 = load_image(data_path 'Texture01.jpg')
-  
-  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 { |p, i|
-    t = tex_coords[i]
-    p.to_vertex_uv(renderer, t.x, t.y)
-  }
-  mesh.end_shape
-
-  return mesh # our work is done here, return DA MESH! -)
-end
-
-def key_pressed
-  case key
-  when '1', '2'
-    @current_color_map = key.to_i % 2 #images.size
-    displace.set('colorMap', images[current_color_map]) 
-  else
-    puts 'key pressed: #{key}'
-  end # cycle through colorMaps (set variable and set colorMap in PShader)
-end
-

data/samples/processing_app/topics/shaders/image_mask.rb

@@ -1,31 +0,0 @@
-#
-# Image Mask
-# 
-# Move the mouse to reveal the image through the dynamic mask.
-#
- 
-attr_reader :mask_shader, :src_image, :mask_image
-
-def setup
-  size(640, 360, P2D)
-  @src_image = load_image('leaves.jpg')
-  @mask_image = create_graphics(src_image.width, src_image.height, P2D)
-  mask_image.no_smooth
-  @mask_shader = load_shader('mask.glsl')
-  mask_shader.set('mask', mask_image)
-  background(255)
-end
-
-def draw
-  mask_image.begin_draw
-  mask_image.background(0)
-  if (mouse_x != 0) && (mouse_y != 0)
-    mask_image.no_stroke
-    mask_image.fill(255, 0, 0)
-    mask_image.ellipse(mouse_x, mouse_y, 50, 50)
-  end
-  mask_image.end_draw
-  shader(mask_shader)
-  image(src_image, 0, 0, width, height)
-end
-