mandelbub

Author: monkstone

contributed/data/java_args.txt

@@ -0,0 +1,53 @@
+# Example of a grid of decagons with perlin noise after Lenny Herzog
+
+load_library :pdf
+NOISE_STRENGTH = 80.0
+THETA = 36
+attr_reader :version, :save, :noise_generator
+
+def setup
+ sketch_title 'Decagon Grid'
+ frame_rate 24
+ @version = 0
+ @save = false
+ @noise_generator = lambda do |x, y, seed|
+ NOISE_STRENGTH * noise(
+ x / 150.0,
+ y / 150.0 + seed * 2,
+ seed
+ ) - 100
+ end
+ end
+
+ def draw
+ begin_record(PDF, data_path("Line_#{version}.pdf")) if save
+ background(255)
+ no_fill
+ stroke(0)
+ stroke_weight(1)
+ grid(height + 100, width + 100, 50, 50) do |cy, cx|
+ begin_shape
+ (0..360).step(THETA) do |angle|
+ x = (DegLut.cos(angle) * 60) + cx
+ y = (DegLut.sin(angle) * 60) + cy
+ noise_value = noise_generator.call(x, y, millis / 5_000.0)
+ x += noise_value
+ y += noise_value
+ vertex(x, y)
+ end
+ end_shape(CLOSE)
+ end
+ return unless save
+
+ end_record
+ @version += 1
+ @save = false
+ end
+
+ def mouse_pressed
+ @save = true
+ end
+
+ def settings
+ size(1000, 1000)
+ end

contributed/decagon_grid.rb

@@ -0,0 +1,207 @@
+#ifdef GL_ES
+precision mediump float;
+precision mediump int;
+#endif
+
+// ----------------------
+// SHADERTOY UNIFORMS -
+// ----------------------
+
+uniform vec3 iResolution; // viewport resolution (in pixels)
+uniform float iTime; // shader playback time (in seconds)
+
+float stime, ctime;
+void ry(inout vec3 p, float a){
+ float c,s;vec3 q=p;
+ c = cos(a); s = sin(a);
+ p.x = c * q.x + s * q.z;
+ p.z = -s * q.x + c * q.z;
+}
+
+float pixel_size = 0.0;
+
+/*
+
+z = r*(sin(theta)cos(phi) + i cos(theta) + j sin(theta)sin(phi)
+
+zn+1 = zn^8 +c
+
+z^8 = r^8 * (sin(8*theta)*cos(8*phi) + i cos(8*theta) + j sin(8*theta)*sin(8*theta)
+
+zn+1' = 8 * zn^7 * zn' + 1
+
+*/
+
+vec3 mb(vec3 p) {
+ p.xyz = p.xzy;
+ vec3 z = p;
+ vec3 dz=vec3(0.0);
+ float power = 8.0;
+ float r, theta, phi;
+ float dr = 1.0;
+
+ float t0 = 1.0;
+ for(int i = 0; i < 7; ++i) {
+ r = length(z);
+ if(r > 2.0) continue;
+ theta = atan(z.y / z.x);
+ #ifdef phase_shift_on
+ phi = asin(z.z / r) + iTime*0.1;
+ #else
+ phi = asin(z.z / r);
+ #endif
+
+ dr = pow(r, power - 1.0) * dr * power + 1.0;
+
+ r = pow(r, power);
+ theta = theta * power;
+ phi = phi * power;
+
+ z = r * vec3(cos(theta)*cos(phi), sin(theta)*cos(phi), sin(phi)) + p;
+
+ t0 = min(t0, r);
+ }
+ return vec3(0.5 * log(r) * r / dr, t0, 0.0);
+}
+
+vec3 f(vec3 p){
+ ry(p, iTime*0.2);
+ return mb(p);
+}
+
+
+float softshadow(vec3 ro, vec3 rd, float k ){
+ float akuma=1.0,h=0.0;
+ float t = 0.01;
+ for(int i=0; i < 50; ++i){
+ h=f(ro+rd*t).x;
+ if(h<0.001)return 0.02;
+ akuma=min(akuma, k*h/t);
+ t+=clamp(h,0.01,2.0);
+ }
+ return akuma;
+}
+
+vec3 nor( in vec3 pos )
+{
+ vec3 eps = vec3(0.001,0.0,0.0);
+ return normalize( vec3(
+ f(pos+eps.xyy).x - f(pos-eps.xyy).x,
+ f(pos+eps.yxy).x - f(pos-eps.yxy).x,
+ f(pos+eps.yyx).x - f(pos-eps.yyx).x ) );
+ }
+
+ vec3 intersect( in vec3 ro, in vec3 rd )
+ {
+ float t = 1.0;
+ float res_t = 0.0;
+ float res_d = 1000.0;
+ vec3 c, res_c;
+ float max_error = 1000.0;
+ float d = 1.0;
+ float pd = 100.0;
+ float os = 0.0;
+ float step = 0.0;
+ float error = 1000.0;
+
+ for( int i=0; i<48; i++ )
+ {
+ if( error < pixel_size*0.5 || t > 20.0 )
+ {
+ }
+ else{ // avoid broken shader on windows
+
+ c = f(ro + rd*t);
+ d = c.x;
+
+ if(d > os)
+ {
+ os = 0.4 * d*d/pd;
+ step = d + os;
+ pd = d;
+ }
+ else
+ {
+ step =-os; os = 0.0; pd = 100.0; d = 1.0;
+ }
+
+ error = d / t;
+
+ if(error < max_error)
+ {
+ max_error = error;
+ res_t = t;
+ res_c = c;
+ }
+
+ t += step;
+ }
+
+ }
+ if( t>20.0/* || max_error > pixel_size*/ ) res_t=-1.0;
+ return vec3(res_t, res_c.y, res_c.z);
+ }
+
+
+
+ void main() {
+ vec2 q=gl_FragCoord.xy/iResolution.xy;
+ vec2 uv = -1.0 + 2.0*q;
+ uv.x*=iResolution.x/iResolution.y;
+
+ pixel_size = 1.0/(iResolution.x * 3.0);
+ // camera
+ stime=0.7+0.3*sin(iTime*0.4);
+ ctime=0.7+0.3*cos(iTime*0.4);
+
+ vec3 ta=vec3(0.0,0.0,0.0);
+ vec3 ro = vec3(0.0, 3.*stime*ctime, 3.*(1.-stime*ctime));
+
+ vec3 cf = normalize(ta-ro);
+ vec3 cs = normalize(cross(cf,vec3(0.0,1.0,0.0)));
+ vec3 cu = normalize(cross(cs,cf));
+ vec3 rd = normalize(uv.x*cs + uv.y*cu + 3.0*cf); // transform from view to world
+
+ vec3 sundir = normalize(vec3(0.1, 0.8, 0.6));
+ vec3 sun = vec3(1.64, 1.27, 0.99);
+ vec3 skycolor = vec3(0.6, 1.5, 1.0);
+
+ vec3 bg = exp(uv.y-2.0)*vec3(0.4, 1.6, 1.0);
+
+ float halo=clamp(dot(normalize(vec3(-ro.x, -ro.y, -ro.z)), rd), 0.0, 1.0);
+ vec3 col=bg+vec3(1.0,0.8,0.4)*pow(halo,17.0);
+
+
+ float t=0.0;
+ vec3 p=ro;
+
+ vec3 res = intersect(ro, rd);
+ if(res.x > 0.0){
+ p = ro + res.x * rd;
+ vec3 n=nor(p);
+ float shadow = softshadow(p, sundir, 10.0 );
+
+ float dif = max(0.0, dot(n, sundir));
+ float sky = 0.6 + 0.4 * max(0.0, dot(n, vec3(0.0, 1.0, 0.0)));
+ float bac = max(0.3 + 0.7 * dot(vec3(-sundir.x, -1.0, -sundir.z), n), 0.0);
+ float spe = max(0.0, pow(clamp(dot(sundir, reflect(rd, n)), 0.0, 1.0), 10.0));
+
+ vec3 lin = 4.5 * sun * dif * shadow;
+ lin += 0.8 * bac * sun;
+ lin += 0.6 * sky * skycolor*shadow;
+ lin += 3.0 * spe * shadow;
+
+ res.y = pow(clamp(res.y, 0.0, 1.0), 0.55);
+ vec3 tc0 = 0.5 + 0.5 * sin(3.0 + 4.2 * res.y + vec3(0.0, 0.5, 1.0));
+ col = lin *vec3(0.9, 0.8, 0.6) * 0.2 * tc0;
+ col=mix(col,bg, 1.0-exp(-0.001*res.x*res.x));
+ }
+
+ // post
+ col=pow(clamp(col,0.0,1.0),vec3(0.45));
+ col=col*0.6+0.4*col*col*(3.0-2.0*col); // contrast
+ col=mix(col, vec3(dot(col, vec3(0.33))), -0.5); // satuation
+ col*=0.5+0.5*pow(16.0*q.x*q.y*(1.0-q.x)*(1.0-q.y),0.7); // vigneting
+ gl_FragColor = vec4(col.xyz, smoothstep(0.55, .76, 1.-res.x/5.));
+ }
+ 

processing_app/topics/shaders/data/mandelbub.glsl

@@ -0,0 +1,25 @@
+
+# Animated Mandelbub Using Shadertoy shader created by evilryu
+# https://www.shadertoy.com/view/MdXSWn
+# License Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported
+# License. Adapted for JRubyArt by Martin Prout
+
+attr_reader :mandelbub
+
+def setup
+ sketch_title 'Mandelbub'
+ no_stroke
+ @mandelbub = load_shader(data_path('mandelbub.glsl'))
+ mandelbub.set('iResolution', width.to_f, height.to_f, 0.0)
+end
+
+def draw
+ puts frame_rate if (frame_count % 300).zero?
+ mandelbub.set('iTime', millis / 1000.0)
+ shader(mandelbub)
+ rect(0, 0, width, height)
+end
+
+def settings
+ size(640, 360, P2D)
+end