Why doesn't reflection sketch work?

Author: monkstone

demo/blend_mode.rb

@@ -1,3 +1,5 @@
+#!/usr/bin/env jruby -w
+
 # frozen_string_literal: true
 
 require 'picrate'

demo/elegant_ball.rb

@@ -1,3 +1,4 @@
+#!/usr/bin/env jruby -w
 require 'picrate'
 # After a vanilla processing sketch by
 # Ben Notorianni aka lazydog

demo/reflection.rb

@@ -1,6 +1,7 @@
+#!/usr/bin/env jruby -w
 require 'picrate'
 # Taken from the Processing Examples.
-class Reflection < Processing::App
+class ReflectionSketch < Processing::App
 
   def setup
     sketch_title 'Reflection'
@@ -10,18 +11,18 @@ def setup
   end
 
   def draw
-    background          0
-    translate           width / 2, height / 2
+    background 0
+    translate width / 2, height / 2
     lights
-    light_specular      1, 1, 1
-    directional_light   0.8, 0.8, 0.8, 0, 0, -1
-    specular            mouse_x.to_f / width.to_f
-    sphere              50
+    light_specular  1, 1, 1
+    directional_light 0.8, 0.8, 0.8, 0, 0, -1
+    specular mouse_x.to_f / width.to_f
+    sphere 50
   end
 
   def settings
     size 200, 200, P3D
   end
 end
 
-Reflection.new
+ReflectionSketch.new

demo/ribbon_doodle.rb

@@ -1,9 +1,10 @@
+#!/usr/bin/env jruby -w
 # frozen_string_literal: true
+require 'picrate'
 # Adapted to use Processing Vec2D and Vec3D classes by Martin Prout
 
 # Use Face Struct triangle 'mesh'.
 Face = Struct.new(:a, :b, :c) # triangle mesh face
-require 'picrate'
 
 # Monkey patch the Vec3D class to support rotations
 Vec3D.class_eval do # re-open the Vec3D class to add the rotate methods

shaders/data/metaballs.glsl

@@ -0,0 +1,49 @@
+#ifdef GL_ES
+precision mediump float;
+precision mediump int;
+#endif
+
+/** ----------------------
+After a sketch on shadertoy https://www.shadertoy.com/user/atomek
+**/
+
+uniform vec3      iResolution;           // viewport resolution (in pixels)
+uniform float     iTime;                 // shader playback time (in seconds)
+uniform vec4      iMouse;                // mouse pixel coords. xy: current (if MLB down), zw: click
+
+void main()
+{
+	// Hold the mouse and drag to adjust
+
+	float ratio = iResolution.y / iResolution.x;
+	float divider = float(iMouse.x / iResolution.x * 10.0) + 1.0;
+	float intensity = float(iMouse.y / iResolution.y * 10.0) + 1.0;
+
+	float coordX = gl_FragCoord.x / iResolution.x;
+	float coordY = gl_FragCoord.y / iResolution.x;
+
+	float ball1x = sin(iTime * 2.1) * 0.5 + 0.5;
+	float ball1y = cos(iTime * 1.0) * 0.5 + 0.5;
+	float ball1z = sin(iTime * 2.0) * 0.1 + 0.2;
+
+	float ball2x = sin(iTime * 1.0) * 0.5 + 0.5;
+	float ball2y = cos(iTime * 1.8) * 0.5 + 0.5;
+	float ball2z = cos(iTime * 2.0) * 0.1 + 0.2;
+
+	float ball3x = sin(iTime * 0.7) * 0.5 + 0.5;
+	float ball3y = cos(iTime * 1.5) * 0.5 + 0.5;
+	float ball3z = cos(iTime * 1.0) * 0.1 + 0.2;
+
+	vec3 ball1 = vec3(ball1x, ball1y * ratio, ball1z);
+	vec3 ball2 = vec3(ball2x, ball2y * ratio, ball2z);
+	vec3 ball3 = vec3(ball3x, ball3y * ratio, ball3z);
+
+	float sum = 0.0;
+	sum += ball1.z / distance(ball1.xy, vec2(coordX, coordY));
+	sum += ball2.z / distance(ball2.xy, vec2(coordX, coordY));
+	sum += ball3.z / distance(ball3.xy, vec2(coordX, coordY));
+
+    sum = pow(sum / intensity, divider);
+
+	gl_FragColor = vec4(sum * 0.2, sum * 0.2, sum * 0.4, 1.0);
+}

shaders/metaballs.rb

@@ -0,0 +1,41 @@
+require 'picrate'
+
+class Metaballs < Processing::App
+  attr_reader :last_mouse_position, :mouse_click_state, :mouse_dragged, :shader_t, :start
+
+  def settings
+    size(640, 360, P2D)
+  end
+
+  def setup
+    sketch_title 'Shadertoy Metaballs'
+    @previous_time = 0.0
+    @mouse_dragged = false
+    @mouse_click_state = 0.0
+    # Load the shader file from the "data" folder
+    @shader_t = load_shader(data_path('metaballs.glsl'))
+    # Assume the dimension of the window will not change over time
+    shader_t.set('iResolution', width.to_f, height.to_f, 0.0)
+    @last_mouse_position = Vec2D.new(mouse_x, mouse_y)
+    @start = java.lang.System.current_time_millis
+  end
+
+  def draw
+    # shader playback time (in seconds)
+    current_time = (java.lang.System.current_time_millis - start) / 1000.0
+    shader_t.set('iTime', current_time)
+    if mouse_pressed?
+      @last_mouse_position = Vec2D.new(mouse_x, mouse_y)
+      @mouse_click_state = 1.0
+    else
+      @mouse_click_state = 0.0
+    end
+    shader_t.set('iMouse', last_mouse_position.x, last_mouse_position.y, mouse_click_state, mouse_click_state)
+    # Apply the specified shader to any geometry drawn from this point
+    shader(shader_t)
+    # Draw the output of the shader onto a rectangle that covers the whole viewport.
+    rect(0, 0, width, height)
+  end
+end
+
+Metaballs.new