├── LICENSE ├── README.md ├── blackbox ├── black_box.glsl ├── black_box.png └── blackbox.pde ├── blocks_color_bright ├── blocks_bright.glsl ├── blocks_bright.png └── blocks_color_bright.pde ├── blocks_color_dark ├── blocks_color_dark.pde ├── blocks_dark.glsl └── blocks_dark.png ├── chladni ├── chladni.glsl ├── chladni.pde └── chladni.png ├── gooey ├── gooey.glsl ├── gooey.pde └── gooey.png ├── index.html ├── klimt ├── klimt.glsl ├── klimt.pde └── klimt.png ├── logo.png ├── monolith ├── monolith.glsl ├── monolith.pde └── monolith.png ├── noisy_cone ├── noisy_cone.glsl ├── noisy_cone.pde └── noisy_cone.png ├── panopitcon ├── panopitcon.glsl ├── panopitcon.pde └── panopitcon.png ├── polygons ├── polygons.glsl ├── polygons.pde └── polygons.png ├── vorogrid ├── vorogrid.glsl ├── vorogrid.pde └── vorogrid.png └── waves ├── waves.glsl ├── waves.pde └── waves.png /LICENSE: -------------------------------------------------------------------------------- 1 | The MIT License (MIT) 2 | 3 | Copyright (c) 2016 nicolas barradeau 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | 2 | ### BUMP visuals 3 | 4 | the following is my contribution to a gig performed by [No computer](http://nocomputer.be/). it's a series of 2D shaders that will potentially be displayed on a big screen during the [Bump festival in Kortrijk on the 24th of june 2016](http://bump-festival.be/). 5 | it is mostly hacked from the following shaders: 6 | 7 | [https://www.shadertoy.com/view/MlXGDf](https://www.shadertoy.com/view/MlXGDf), [https://www.shadertoy.com/view/Xds3zN](https://www.shadertoy.com/view/Xds3zN) & [http://thebookofshaders.com/](http://thebookofshaders.com/) 8 | 9 | the basic setup is a [Processing 3](https://processing.org/download/?processing) sketch with the following code: 10 | 11 | PShader shader; 12 | String name = "shader_name"; 13 | 14 | void setup() { 15 | size( 1200, 500, P3D ); 16 | noStroke(); 17 | shader = loadShader( name + ".glsl"); 18 | } 19 | 20 | void draw() { 21 | 22 | shader.set("u_resolution", float(width), float(height)); 23 | shader.set("u_time", 1000 + millis() / 1000.0); 24 | 25 | shader(shader); 26 | rect(0,0,width,height); 27 | 28 | } 29 | 30 | void keyPressed(){ 31 | shader = loadShader( name + ".glsl"); 32 | saveFrame( name + ".png" ); 33 | } 34 | 35 | pressing any key will reload the shader an take a snapshot. 36 | you can copy paste any of the following snippets (click editor to open the code) 37 | click on the preview link to watch a live version. 38 | 39 | 125 | 126 | the code is not commented and not optimised at all, just putting it here for the sake of sharing. 127 | not sure if any of those will make it to the big screen but it was fun to make :) 128 | -------------------------------------------------------------------------------- /blackbox/black_box.glsl: -------------------------------------------------------------------------------- 1 | // Author: Nicolas Barradeau 2 | // Title: black box 3 | 4 | #ifdef GL_ES 5 | precision mediump float; 6 | #endif 7 | 8 | #define PI 3.14159265359 9 | 10 | #define PROCESSING_COLOR_SHADER 11 | 12 | const vec3 blue = vec3( 0.4453125, 0.890625, 0.890625 ); 13 | const vec3 yellow_bright = vec3( 0.9296875, 0.8671875, 0.18359375 ); 14 | const vec3 yellow_dark = vec3( 0.921875, 0.80078125, 0.); 15 | const vec3 orange = vec3( 0.88671875, 0.625, 0.1171875); 16 | const vec3 pink = vec3( 0.92578125, 0.46484375, 0.89453125); 17 | 18 | uniform vec2 u_resolution; 19 | uniform vec2 u_mouse; 20 | uniform float u_time; 21 | 22 | const float MAX_TRACE_DIST = 5.0; 23 | const float MIN_HIT_DIST = 0.001; 24 | const int MAX_NUM_STEPS = 20; 25 | 26 | float roundBox( vec3 p, vec3 b, float r ){ return length(max(abs(p)-b,0.0)); } 27 | 28 | vec3 mod289(vec3 x) { return x - floor(x * (1.0 / 289.0)) * 289.0; } 29 | vec2 mod289(vec2 x) { return x - floor(x * (1.0 / 289.0)) * 289.0; } 30 | vec3 permute(vec3 x) { return mod289(((x*34.0)+1.0)*x); } 31 | 32 | float snoise(vec2 v){ 33 | const vec4 C = vec4(0.211324865405187, 34 | 0.366025403784439, 35 | -0.577350269189626, 36 | 0.024390243902439); 37 | vec2 i = floor(v + dot(v, C.yy) ); 38 | vec2 x0 = v - i + dot(i, C.xx); 39 | vec2 i1; 40 | i1 = (x0.x > x0.y) ? vec2(1.0, 0.0) : vec2(0.0, 1.0); 41 | vec4 x12 = x0.xyxy + C.xxzz; 42 | x12.xy -= i1; 43 | i = mod289(i); 44 | vec3 p = permute( permute( i.y + vec3(0.0, i1.y, 1.0 )) 45 | + i.x + vec3(0.0, i1.x, 1.0 )); 46 | vec3 m = max(0.5 - vec3(dot(x0,x0), dot(x12.xy,x12.xy), dot(x12.zw,x12.zw)), 0.0); 47 | m = m*m ; 48 | m = m*m ; 49 | vec3 x = 2.0 * fract(p * C.www) - 1.0; 50 | vec3 h = abs(x) - 0.5; 51 | vec3 ox = floor(x + 0.5); 52 | vec3 a0 = x - ox; 53 | m *= 1.79284291400159 - 0.85373472095314 * ( a0*a0 + h*h ); 54 | vec3 g; 55 | g.x = a0.x * x0.x + h.x * x0.y; 56 | g.yz = a0.yz * x12.xz + h.yz * x12.yw; 57 | return 130.0 * dot(m, g); 58 | } 59 | 60 | float getColor( in vec2 uv ) 61 | { 62 | float m = 1.25; 63 | float t = u_time * .1; 64 | float noise = snoise( vec2( m*uv.x+t, m * uv.y -t )); 65 | noise += abs(snoise( uv)); 66 | return abs( noise * 2.); 67 | } 68 | 69 | mat3 rotationMatrix(vec3 axis, float angle) 70 | { 71 | axis = normalize(axis); 72 | float s = sin(angle); 73 | float c = cos(angle); 74 | float oc = 1.0 - c; 75 | return mat3(oc * axis.x * axis.x + c, oc * axis.x * axis.y - axis.z * s, oc * axis.z * axis.x + axis.y * s, 76 | oc * axis.x * axis.y + axis.z * s, oc * axis.y * axis.y + c, oc * axis.y * axis.z - axis.x * s, 77 | oc * axis.z * axis.x - axis.y * s, oc * axis.y * axis.z + axis.x * s, oc * axis.z * axis.z + c ); 78 | } 79 | 80 | vec2 map(in vec3 pos, in vec2 uv){ 81 | 82 | float freq = getColor( uv ); 83 | float box = max( roundBox( pos+vec3( .0,0.,0. ), vec3( 0.5,.5,.5), .1500), -( length( pos ) - .65 ) ); 84 | float n = 0.05 * sin(freq * pos.x ) * sin(freq * pos.y * .8) * sin(freq * pos.z); 85 | return vec2( box - n, 1. ); 86 | } 87 | 88 | float softshadow( in vec3 ro, in vec3 rd, in float mint, in float tmax, in vec2 uv ){ 89 | float res = 1.0; 90 | float t = mint; 91 | for(int i = 0; i < 16; ++i) 92 | { 93 | float h = map(ro + rd * t, uv).x; 94 | res = min(res, 8. * h / t); 95 | t += clamp(h, 0.02, 0.10); 96 | if(h < 0.001 || t > tmax) break; 97 | } 98 | return clamp( res, 0.0, 1.0 ); 99 | } 100 | 101 | vec3 calcNormal(in vec3 pos, in vec2 uv ) 102 | { 103 | vec3 eps = vec3(0.001, 0.0, 0.0); 104 | vec3 nor = vec3( 105 | map(pos+eps.xyy, uv).x - map(pos-eps.xyy, uv).x, 106 | map(pos+eps.yxy, uv).x - map(pos-eps.yxy, uv).x, 107 | map(pos+eps.yyx, uv).x - map(pos-eps.yyx, uv).x); 108 | return normalize(nor); 109 | } 110 | 111 | 112 | float calcIntersection(in vec3 ro, in vec3 rd, in vec2 uv ){ 113 | 114 | float h = MIN_HIT_DIST * 2.0; 115 | float t = 0.0; 116 | float finalDist = -1.0; 117 | for(int i = 0; i < MAX_NUM_STEPS; ++i){ 118 | if(h < MIN_HIT_DIST || t > MAX_TRACE_DIST) break; 119 | 120 | vec2 distToClosest = map(ro + rd * t, uv); 121 | h = distToClosest.x; 122 | t += h; 123 | } 124 | if(t < MAX_TRACE_DIST) finalDist = t; 125 | return finalDist; 126 | } 127 | 128 | vec3 render(in vec3 ro, in vec3 rd, in vec2 uv) { 129 | 130 | float ssDistToCenter = length(uv); 131 | vec3 bgColor1 = vec3(0.6, 0.2, 0.9); 132 | vec3 bgColor2 = vec3(0.0, 0.2, 0.8); 133 | vec3 surfaceColor = vec3(1.); 134 | 135 | float results = calcIntersection(ro, rd, uv); 136 | float t = results; 137 | 138 | vec3 lightPos = ( vec3( 0.,0.700,0.0) ); 139 | if( t > -.5 ){ 140 | vec3 pos = ro + rd * t; 141 | vec3 n = calcNormal(pos, uv); 142 | vec3 diffColor = orange; 143 | vec3 l = normalize(pos-lightPos ); 144 | float diffStrength = max( pow( dot(n, l), 9. ), 0.0 ); 145 | float ambientStrength = clamp(0.05 + .5 * n.y, 0.0, 1.0); 146 | vec3 ambientColor = blue; 147 | 148 | diffColor *= softshadow( pos, lightPos, 0.02, 2.5, uv ); 149 | ambientColor *= ambientStrength*.9; 150 | surfaceColor = ( diffStrength * diffColor + ambientColor ); 151 | } 152 | 153 | return surfaceColor; 154 | } 155 | 156 | mat3 setCamMatrix(in vec3 ro, in vec3 ta, float roll) 157 | { 158 | vec3 ww = normalize(ta - ro); 159 | vec3 uu = normalize(cross(ww, vec3(sin(roll), cos(roll), 0.0))); 160 | vec3 vv = normalize(cross(uu, ww)); 161 | return mat3(uu, vv, ww); 162 | } 163 | 164 | void main(){ 165 | 166 | vec2 p = 2.*gl_FragCoord.xy/u_resolution.xy-1.; 167 | p.x *= u_resolution.x/u_resolution.y; 168 | 169 | float radius = 1.35; 170 | float camX = radius * cos(u_time * 0.1); 171 | float camY = radius; 172 | float camZ = radius * sin(u_time * 0.1); 173 | 174 | vec3 ro = vec3( camX, camY, camZ); 175 | vec3 ta = vec3(0.0); 176 | mat3 cameraMatrix = setCamMatrix(ro, ta, 0.0); 177 | 178 | float lensLength = 2.; 179 | vec3 rd = normalize(cameraMatrix * vec3(p.xy, lensLength)); 180 | 181 | vec3 color = render(ro, rd, p); 182 | gl_FragColor = vec4(color, 1.0); 183 | } -------------------------------------------------------------------------------- /blackbox/black_box.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nicoptere/BUMP/55f0489c583cc1bd951db49f5df4275f7415b769/blackbox/black_box.png -------------------------------------------------------------------------------- /blackbox/blackbox.pde: -------------------------------------------------------------------------------- 1 | PShader shader; 2 | String name = "black_box"; 3 | 4 | void setup() { 5 | size( 1200, 500, P3D ); 6 | noStroke(); 7 | shader = loadShader( name + ".glsl"); 8 | } 9 | 10 | void draw() { 11 | 12 | shader.set("u_resolution", float(width), float(height)); 13 | shader.set("u_time", 1000 + millis() / 1000.0); 14 | 15 | shader(shader); 16 | rect(0,0,width,height); 17 | 18 | } 19 | void keyPressed(){ 20 | shader = loadShader( name + ".glsl"); 21 | saveFrame( name + ".png" ); 22 | } -------------------------------------------------------------------------------- /blocks_color_bright/blocks_bright.glsl: -------------------------------------------------------------------------------- 1 | // Author: Nicolas Barradeau 2 | // Title: blocks color blright 3 | 4 | #define PROCESSING_COLOR_SHADER 5 | #ifdef GL_ES 6 | precision mediump float; 7 | #endif 8 | #define PI 3.14159265359 9 | 10 | const vec3 blue = vec3( 0.4453125, 0.890625, 0.890625 ); 11 | const vec3 yellow_bright = vec3( 0.9296875, 0.8671875, 0.18359375 ); 12 | const vec3 yellow_dark = vec3( 0.921875, 0.80078125, 0.); 13 | const vec3 orange = vec3( 0.88671875, 0.625, 0.1171875); 14 | const vec3 pink = vec3( 0.92578125, 0.46484375, 0.89453125); 15 | 16 | uniform vec2 u_resolution; 17 | uniform vec2 u_mouse; 18 | uniform float u_time; 19 | 20 | // Created by inigo quilez - iq/2013 21 | // License Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported License. 22 | // http://iquilezles.org/www/articles/voronoise/voronoise.htm 23 | vec3 hash3( vec2 p ) { 24 | vec3 q = vec3( dot(p,vec2(127.1,311.7)), 25 | dot(p,vec2(269.5,183.3)), 26 | dot(p,vec2(419.2,371.9)) ); 27 | return fract(sin(q)*43758.5453); 28 | } 29 | 30 | float iqnoise( in vec2 x, float u, float v, float s ) { 31 | vec2 p = floor(x); 32 | vec2 f = fract(x); 33 | 34 | float k = 1.0+63.0*pow(1.0-v,4.0); 35 | 36 | float va = 0.0; 37 | float wt = 0.0; 38 | vec4 ret; 39 | for ( float j=-2.; j<=2.; j+=1.) { 40 | for (float i=-2.; i<=2.; i+=1.) { 41 | 42 | vec2 g = vec2(i,j); 43 | vec3 o = hash3(p + g)*vec3(u,u,1.0); 44 | vec2 r = g - f + o.xy; 45 | 46 | float d = dot(r,r); 47 | float ww = pow( 1.0-smoothstep(0.0,s,sqrt(d)), k ); 48 | va += o.z*ww; 49 | wt += ww; 50 | } 51 | } 52 | return va/wt; 53 | } 54 | float iqnoise( in vec2 x, in float v ) 55 | { 56 | return iqnoise( x, .5, .5, 1.); 57 | } 58 | float iqnoise( in vec2 x ) 59 | { 60 | return iqnoise( x, 1. ); 61 | } 62 | 63 | 64 | void main() { 65 | 66 | vec2 st = 2. * gl_FragCoord.xy/u_resolution.xy - 1.; 67 | st.x *= u_resolution.x/u_resolution.y; 68 | vec2 uv = st; 69 | st += vec2(.0); 70 | 71 | vec3 color = orange; 72 | vec3 colors[4]; 73 | colors[0] = pink; 74 | colors[1] = orange; 75 | colors[2] = yellow_bright; 76 | colors[3] = blue; 77 | 78 | float dir = 1.; 79 | float ot = ( .5 * sin( u_time ) +.5 ); 80 | float mt = ( .5 * sin( u_time * 1.1 ) +.5 )*2.; 81 | float mc = ( .5 * sin( u_time * 0.2 ) +.5 ); 82 | vec3 final = mix( mix( blue, pink, mc )*.8, mix( pink, orange, mc ), st.y );// * ( .15 + ot * .05 ); 83 | const float total = 10.; 84 | for( float i = 1.; i < total; i+= 1. ){ 85 | 86 | const float count = 4.; 87 | float acc = 0.; 88 | 89 | float a = .1 * u_time + i * PI / 180. * ( i * 20. ); 90 | float inv = .25 + ( ( count - i ) * .1 + sin( u_time * i * .01 )); 91 | vec2 p = vec2( 2.*cos( a )*inv, sin( a ) * inv ); 92 | 93 | for( float j = 1.; j < count; j += 1. ){ 94 | 95 | float l = 1.- length( st-p); 96 | 97 | float v = pow( smoothstep( .0,1., l ) * .75, 2. ); 98 | 99 | v *= pow( iqnoise( ( uv * i * 0.5 ), mt * .5 ), 1. ); 100 | acc += v; 101 | 102 | } 103 | final = mix( final, colors[ int( mod( i, 4. ) ) ], acc ); 104 | 105 | } 106 | 107 | gl_FragColor = vec4( final,1.0); 108 | 109 | } -------------------------------------------------------------------------------- /blocks_color_bright/blocks_bright.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nicoptere/BUMP/55f0489c583cc1bd951db49f5df4275f7415b769/blocks_color_bright/blocks_bright.png -------------------------------------------------------------------------------- /blocks_color_bright/blocks_color_bright.pde: -------------------------------------------------------------------------------- 1 | PShader shader; 2 | String name = "blocks_bright"; 3 | 4 | void setup() { 5 | size( 1200, 500, P3D ); 6 | noStroke(); 7 | shader = loadShader( name + ".glsl"); 8 | } 9 | 10 | void draw() { 11 | 12 | shader.set("u_resolution", float(width), float(height)); 13 | shader.set("u_time", 1000 + millis() / 1000.0); 14 | 15 | shader(shader); 16 | rect(0,0,width,height); 17 | 18 | } 19 | void keyPressed(){ 20 | shader = loadShader( name + ".glsl"); 21 | saveFrame( name + ".png" ); 22 | } -------------------------------------------------------------------------------- /blocks_color_dark/blocks_color_dark.pde: -------------------------------------------------------------------------------- 1 | PShader shader; 2 | String name = "blocks_dark"; 3 | 4 | void setup() { 5 | size( 1200, 500, P3D ); 6 | noStroke(); 7 | shader = loadShader( name + ".glsl"); 8 | } 9 | 10 | void draw() { 11 | 12 | shader.set("u_resolution", float(width), float(height)); 13 | shader.set("u_time", 1000 + millis() / 1000.0); 14 | 15 | shader(shader); 16 | rect(0,0,width,height); 17 | 18 | } 19 | void keyPressed(){ 20 | shader = loadShader( name + ".glsl"); 21 | saveFrame( name + ".png" ); 22 | } -------------------------------------------------------------------------------- /blocks_color_dark/blocks_dark.glsl: -------------------------------------------------------------------------------- 1 | // Author: Nicolas Barradeau 2 | // Title: blocks color dark 3 | 4 | #ifdef GL_ES 5 | precision mediump float; 6 | #endif 7 | 8 | #define PI 3.14159265359 9 | 10 | #define PROCESSING_COLOR_SHADER 11 | 12 | const vec3 blue = vec3( 0.4453125, 0.890625, 0.890625 ); 13 | const vec3 yellow_bright = vec3( 0.9296875, 0.8671875, 0.18359375 ); 14 | const vec3 yellow_dark = vec3( 0.921875, 0.80078125, 0.); 15 | const vec3 orange = vec3( 0.88671875, 0.625, 0.1171875); 16 | const vec3 pink = vec3( 0.92578125, 0.46484375, 0.89453125); 17 | 18 | uniform vec2 u_resolution; 19 | uniform vec2 u_mouse; 20 | uniform float u_time; 21 | 22 | float random (in vec2 st) { 23 | return fract(sin(dot(st.xy,vec2(12.9898,78.233))) * 43758.5453123); 24 | } 25 | void main() { 26 | 27 | vec2 st = 2. * gl_FragCoord.xy/u_resolution.xy - 1.; 28 | st.x *= u_resolution.x/u_resolution.y; 29 | vec2 uv = st; 30 | st += vec2(.0); 31 | vec3 color = vec3(1.); 32 | color = vec3(st.x,st.y,abs(sin(u_time))); 33 | color = orange; 34 | 35 | vec3 colors[4]; 36 | colors[0] = pink; 37 | colors[1] = orange; 38 | colors[2] = yellow_bright; 39 | colors[3] = blue; 40 | 41 | float ot = ( .5 * sin( u_time ) +.5 ); 42 | float mt = ( .5 * sin( u_time * 0.1 ) +.5 )*2.; 43 | float mc = ( .5 * sin( u_time * 0.2 ) +.5 ); 44 | vec3 final = blue * ( .15 + ot * .05 ); 45 | const float total = 10.; 46 | for( float i = 1.; i < total; i+= 1. ){ 47 | 48 | const float count = 5.; 49 | float acc = 0.; 50 | for( float j = 1.; j < count; j += 1. ){ 51 | 52 | float a = .1 * u_time + i * PI / 180. * ( j * 40. + i * 20. ); 53 | 54 | float inv = .25 + abs( ( count - i ) * .1 + sin( u_time * i * .01 )); 55 | 56 | vec2 p = vec2( 2.*cos( a )*inv, sin( a ) * inv ); 57 | 58 | float l = 1.- length( st-p); 59 | 60 | float v = pow( smoothstep( .0,1., l ) * 0.85, 4. ); 61 | 62 | v *= pow( random( floor( uv * (mt+j*1.5) + p ) ), 2.+mt*3. ) + smoothstep( .99,1.0, l ); 63 | acc += v; 64 | 65 | } 66 | final = mix( final, colors[ int( mod( i, 4. ) ) ], acc ); 67 | 68 | } 69 | 70 | gl_FragColor = vec4( final,1.0); 71 | 72 | } -------------------------------------------------------------------------------- /blocks_color_dark/blocks_dark.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nicoptere/BUMP/55f0489c583cc1bd951db49f5df4275f7415b769/blocks_color_dark/blocks_dark.png -------------------------------------------------------------------------------- /chladni/chladni.glsl: -------------------------------------------------------------------------------- 1 | // Author: Nicolas Barradeau 2 | // Title: Chladni patterns 3 | 4 | #ifdef GL_ES 5 | precision mediump float; 6 | #endif 7 | #define PROCESSING_COLOR_SHADER 8 | 9 | vec3 blue = vec3( 0.4453125, 0.890625, 0.890625 ); 10 | vec3 yellow_bright = vec3( 0.9296875, 0.8671875, 0.18359375 ); 11 | vec3 yellow_dark = vec3( 0.921875, 0.80078125, 0.); 12 | vec3 orange = vec3( 0.88671875, 0.625, 0.1171875); 13 | vec3 pink = vec3( 0.92578125, 0.46484375, 0.89453125); 14 | 15 | 16 | #define PI 3.1415926535897932384626433832795 17 | const float GR = 1.61803399; 18 | 19 | uniform vec2 u_resolution; 20 | uniform vec2 u_mouse; 21 | uniform float u_time; 22 | 23 | 24 | void main() { 25 | 26 | vec3 colors[5]; 27 | colors[0] = blue; 28 | colors[1] = yellow_bright; 29 | colors[2] = yellow_dark; 30 | colors[3] = orange; 31 | colors[4] = pink; 32 | 33 | vec2 st = ( 2. * gl_FragCoord.xy - u_resolution ) / max( u_resolution.x, u_resolution.y ) ; 34 | float iteration = 20. + smoothstep( -1., 1., sin( PI * 2. * ( u_time * 0.1 ) ) ) * 20.; 35 | 36 | float an = u_time * PI * 2. * .1; 37 | st += vec2( cos( an / GR ), sin( an * GR ) ); 38 | 39 | float sqi = ( abs(sin( u_time * 0.1 * PI * 2. ) ) ); 40 | float a = sqi * sin( u_time * 0.01 ); 41 | float b = sqi * cos( u_time * 0.005 ); 42 | 43 | vec2 t = vec2( cos( an ) * .25, sin( an ) * .25 ); 44 | for( float i = 1.; i < 4.; i+= 1. ){ 45 | 46 | mat2 m = mat2( cos( a * i * PI * st.x ), 47 | cos( b * i * PI * st.y ), 48 | -cos( b * i * PI * st.x ), 49 | cos( a * i * PI * st.y ) ); 50 | st += t * m * i; 51 | } 52 | 53 | float len = length( st ); 54 | 55 | vec3 color = mix( blue, yellow_bright, smoothstep( 0.5, 0.51, len ) ); 56 | color = mix( color, yellow_dark, smoothstep( 0.75, 0.76, len ) ); 57 | color = mix( color, orange, smoothstep( 1.5, 1.51, len ) ); 58 | color = mix( color, pink, smoothstep( 1.75, 1.751, len ) ); 59 | gl_FragColor = vec4(color,1.0); 60 | 61 | } -------------------------------------------------------------------------------- /chladni/chladni.pde: -------------------------------------------------------------------------------- 1 | PShader shader; 2 | String name = "chladni"; 3 | 4 | void setup() { 5 | size( 1200, 500, P3D ); 6 | noStroke(); 7 | shader = loadShader( name + ".glsl"); 8 | } 9 | 10 | void draw() { 11 | 12 | shader.set("u_resolution", float(width), float(height)); 13 | shader.set("u_time", 1000 + millis() / 1000.0); 14 | 15 | shader(shader); 16 | rect(0,0,width,height); 17 | 18 | } 19 | void keyPressed(){ 20 | shader = loadShader( name + ".glsl"); 21 | saveFrame( name + ".png" ); 22 | } -------------------------------------------------------------------------------- /chladni/chladni.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nicoptere/BUMP/55f0489c583cc1bd951db49f5df4275f7415b769/chladni/chladni.png -------------------------------------------------------------------------------- /gooey/gooey.glsl: -------------------------------------------------------------------------------- 1 | // Author: Nicolas Barradeau 2 | // Title: gooey 3 | 4 | #ifdef GL_ES 5 | precision mediump float; 6 | #endif 7 | 8 | #define PI 3.14159 9 | 10 | #define PROCESSING_COLOR_SHADER 11 | const vec3 blue = vec3( 0.4453125, 0.890625, 0.890625 ); 12 | const vec3 yellow_bright = vec3( 0.9296875, 0.8671875, 0.18359375 ); 13 | const vec3 yellow_dark = vec3( 0.921875, 0.80078125, 0.); 14 | const vec3 orange = vec3( 0.88671875, 0.625, 0.1171875); 15 | const vec3 pink = vec3( 0.92578125, 0.46484375, 0.89453125); 16 | 17 | uniform vec2 u_resolution; 18 | uniform float u_time; 19 | 20 | // Created by inigo quilez - iq/2013 21 | // License Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported License. 22 | // http://iquilezles.org/www/articles/voronoise/voronoise.htm 23 | vec3 hash3( vec2 p ) { 24 | vec3 q = vec3( dot(p,vec2(127.1,311.7)), 25 | dot(p,vec2(269.5,183.3)), 26 | dot(p,vec2(419.2,371.9)) ); 27 | return fract(sin(q)*43758.5453); 28 | } 29 | 30 | float iqnoise( in vec2 x, float u, float v, float s ) { 31 | vec2 p = floor(x); 32 | vec2 f = fract(x); 33 | 34 | float k = 1.0+63.0*pow(1.0-v,4.0); 35 | 36 | float va = 0.0; 37 | float wt = 0.0; 38 | vec4 ret; 39 | for ( float j=-2.; j<=2.; j+=1.) { 40 | for (float i=-2.; i<=2.; i+=1.) { 41 | 42 | vec2 g = vec2(i,j); 43 | vec3 o = hash3(p + g)*vec3(u,u,1.0); 44 | vec2 r = g - f + o.xy; 45 | 46 | float d = dot(r,r); 47 | float ww = pow( 1.0-smoothstep(0.0,s,sqrt(d)), k ); 48 | va += o.z*ww; 49 | wt += ww; 50 | } 51 | } 52 | return va/wt; 53 | } 54 | void main(){ 55 | 56 | vec2 st = gl_FragCoord.xy/u_resolution.xy; 57 | st.x *= u_resolution.x/u_resolution.y; 58 | 59 | float time = u_time; 60 | float si = sin( time * .1 ); 61 | float co = cos( time * .1 ); 62 | float n = iqnoise( ( st - vec2( 0., time*.1 ) ) * 3.5, 0.5, 0., 10.1 ); 63 | 64 | vec2 vt = ( st - vec2( 0., time*.1 ) ) + n * ( co+si ); 65 | float v0 = pow( iqnoise( vt * 3., 1., si, max( 0., 0.5 + si * .5 ) ), 3. ); 66 | float v1 = pow( iqnoise( vt * 6., co, min( 1., co*si ),1.1 ), 3. ); 67 | 68 | vec3 c = mix( mix( orange, yellow_bright, v0 ) * 1.2, mix( pink, blue, v1 ), clamp( max( v0, v1 ), 0.,1. ) * 1. ); 69 | gl_FragColor = vec4( c,1. ); 70 | 71 | } -------------------------------------------------------------------------------- /gooey/gooey.pde: -------------------------------------------------------------------------------- 1 | PShader shader; 2 | String name = "gooey"; 3 | 4 | void setup() { 5 | size( 1200, 500, P3D ); 6 | noStroke(); 7 | shader = loadShader( name + ".glsl"); 8 | } 9 | 10 | void draw() { 11 | 12 | shader.set("u_resolution", float(width), float(height)); 13 | shader.set("u_time", 1000 + millis() / 1000.0); 14 | 15 | shader(shader); 16 | rect(0,0,width,height); 17 | 18 | } 19 | void keyPressed(){ 20 | shader = loadShader( name + ".glsl"); 21 | saveFrame( name + ".png" ); 22 | } -------------------------------------------------------------------------------- /gooey/gooey.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nicoptere/BUMP/55f0489c583cc1bd951db49f5df4275f7415b769/gooey/gooey.png -------------------------------------------------------------------------------- /index.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | Title 6 | 44 | 45 | 46 |
47 | 48 |

BUMP visuals

49 | 50 |
a series of visual that will potentially be displayed on a big screen during the Bump festival in Kortrijk on the 24th of june 2016
51 | 52 |
the following is my contribution to a gig performed by No computer.
53 | it's a series of 2D shaders that will potentially be displayed on a big screen during the Bump festival in Kortrijk on the 24th of june 2016. 54 |

it is mostly hacked from the following shaders:https://www.shadertoy.com/view/MlXGDf, https://www.shadertoy.com/view/Xds3zN & http://thebookofshaders.com/

55 | 56 |
the basic setup is a Processing 3 sketch with the following code:
57 | 
 58 |     PShader shader;
 59 |     String name = "shader_name";
 60 | 
 61 |     void setup() {
 62 |       size( 1200, 500, P3D );
 63 |       noStroke();
 64 |       shader = loadShader( name + ".glsl");
 65 |     }
 66 | 
 67 |     void draw() {
 68 | 
 69 |       shader.set("u_resolution", float(width), float(height));
 70 |       shader.set("u_time", millis() / 1000.0);
 71 | 
 72 |       shader(shader);
 73 |       rect(0,0,width,height);
 74 | 
 75 |     }
 76 | 
 77 |     void keyPressed(){
 78 |       shader = loadShader( name + ".glsl");
 79 |       saveFrame( name + ".png" );
 80 |     }
 81 |
82 |

pressing any key will reload the shader an take a snapshot.

83 |

click on the image link to watch a live version.

84 |

you can copy paste any of the following snippets (click editor to open the code) in the above Processing template

85 | 86 | 196 |
197 | 198 |
199 | 200 | 201 | 202 | 203 | -------------------------------------------------------------------------------- /klimt/klimt.glsl: -------------------------------------------------------------------------------- 1 | // Author: Nicolas Barradeau 2 | // Title: klimt 3 | 4 | #ifdef GL_ES 5 | precision mediump float; 6 | #endif 7 | 8 | #define PI 3.14159265359 9 | 10 | #define PROCESSING_COLOR_SHADER 11 | const vec3 blue = vec3( 0.4453125, 0.890625, 0.890625 ); 12 | const vec3 yellow_bright = vec3( 0.9296875, 0.8671875, 0.18359375 ); 13 | const vec3 yellow_dark = vec3( 0.921875, 0.80078125, 0.); 14 | const vec3 orange = vec3( 0.88671875, 0.625, 0.1171875); 15 | const vec3 pink = vec3( 0.92578125, 0.46484375, 0.89453125); 16 | 17 | uniform vec2 u_resolution; 18 | uniform vec2 u_mouse; 19 | uniform float u_time; 20 | 21 | const float MAX_TRACE_DIST = 50.0; 22 | const float MIN_HIT_DIST = 0.001; 23 | const int MAX_NUM_STEPS = 100; 24 | 25 | float hash( float n ) { return fract(sin(n)*753.5453123); } 26 | float noise( in vec3 x ) 27 | { 28 | vec3 p = floor(x); 29 | vec3 f = fract(x); 30 | f = f*f*(3.0-2.0*f); 31 | 32 | float n = p.x + p.y*157.0 + 113.0*p.z; 33 | return mix(mix(mix( hash(n+ 0.0), hash(n+ 1.0),f.x), 34 | mix( hash(n+157.0), hash(n+158.0),f.x),f.y), 35 | mix(mix( hash(n+113.0), hash(n+114.0),f.x), 36 | mix( hash(n+270.0), hash(n+271.0),f.x),f.y),f.z); 37 | } 38 | 39 | vec2 opU( vec2 a, vec2 b ) { return (a.x < b.x) ? a : b; } 40 | float sdPlane(in vec3 p) { return p.y; } 41 | float sdSphere(in vec3 p, float s){ 42 | float d1 = length(p) - s; 43 | return d1; 44 | } 45 | 46 | vec3 mod289(vec3 x) { 47 | return x - floor(x * (1.0 / 289.0)) * 289.0; 48 | } 49 | 50 | vec2 mod289(vec2 x) { 51 | return x - floor(x * (1.0 / 289.0)) * 289.0; 52 | } 53 | 54 | vec3 permute(vec3 x) { 55 | return mod289(((x*34.0)+1.0)*x); 56 | } 57 | 58 | float snoise(vec2 v){ 59 | const vec4 C = vec4(0.211324865405187, 60 | 0.366025403784439, 61 | -0.577350269189626, 62 | 0.024390243902439); 63 | vec2 i = floor(v + dot(v, C.yy) ); 64 | vec2 x0 = v - i + dot(i, C.xx); 65 | vec2 i1; 66 | i1 = (x0.x > x0.y) ? vec2(1.0, 0.0) : vec2(0.0, 1.0); 67 | vec4 x12 = x0.xyxy + C.xxzz; 68 | x12.xy -= i1; 69 | i = mod289(i); 70 | vec3 p = permute( permute( i.y + vec3(0.0, i1.y, 1.0 )) 71 | + i.x + vec3(0.0, i1.x, 1.0 )); 72 | vec3 m = max(0.5 - vec3(dot(x0,x0), dot(x12.xy,x12.xy), dot(x12.zw,x12.zw)), 0.0); 73 | m = m*m ; 74 | m = m*m ; 75 | vec3 x = 2.0 * fract(p * C.www) - 1.0; 76 | vec3 h = abs(x) - 0.5; 77 | vec3 ox = floor(x + 0.5); 78 | vec3 a0 = x - ox; 79 | m *= 1.79284291400159 - 0.85373472095314 * ( a0*a0 + h*h ); 80 | vec3 g; 81 | g.x = a0.x * x0.x + h.x * x0.y; 82 | g.yz = a0.yz * x12.xz + h.yz * x12.yw; 83 | return 130.0 * dot(m, g); 84 | } 85 | 86 | float getColor( in vec2 uv ) 87 | { 88 | float m = 4.5; 89 | float t = u_time * .01; 90 | float noise = snoise( vec2( m * uv.x + t, m * uv.y - t )); 91 | noise += snoise( uv); 92 | return noise * 12.; 93 | } 94 | 95 | vec2 map(in vec3 pos, in vec2 uv){ 96 | 97 | vec2 res = vec2( sdPlane(pos - vec3(0.0, -2.0, 0.0)), 1.0 ); 98 | res = opU( res, vec2(sdSphere(pos-vec3( 2.5,0.,0.), 1.5+ sin( u_time*.1)*.25),2.) ); 99 | 100 | float freq = getColor( uv ); 101 | float d1 = 0.1*sin(freq * pos.x) * sin(freq * pos.y + 0.8) * sin(freq * pos.z + 0.3); 102 | float d2 = 0.1*sin(freq * pos.x) * sin(freq * pos.y + 0.8) * sin(freq * pos.z + 0.3); 103 | return vec2( res.x - d2, 1. ); 104 | } 105 | 106 | float softshadow( in vec3 ro, in vec3 rd, in float mint, in float tmax ){ 107 | float res = 1.0; 108 | float t = mint; 109 | for(int i = 0; i < 16; ++i) 110 | { 111 | float h = map(ro + rd * t, vec2(1.)).x; 112 | res = min(res, 8.0 * h / t); 113 | t += clamp(h, 0.02, 0.10); 114 | if(h < 0.001 || t > tmax) break; 115 | } 116 | return clamp( res, 0.0, 1.0 ); 117 | } 118 | 119 | vec3 calcNormal(in vec3 pos, in vec2 uv ){ 120 | vec3 eps = vec3(0.001, 0.0, 0.0); 121 | vec3 nor = vec3( 122 | map(pos+eps.xyy, uv).x - map(pos-eps.xyy, uv).x, 123 | map(pos+eps.yxy, uv).x - map(pos-eps.yxy, uv).x, 124 | map(pos+eps.yyx, uv).x - map(pos-eps.yyx, uv).x); 125 | return normalize(nor); 126 | } 127 | 128 | vec2 calcIntersection(in vec3 ro, in vec3 rd, in vec2 uv ){ 129 | float h = MIN_HIT_DIST * 2.0; 130 | float t = 0.0; 131 | float finalDist = -1.0; 132 | float id = -1.0; 133 | for(int i = 0; i < MAX_NUM_STEPS; ++i){ 134 | if(h < MIN_HIT_DIST || t > MAX_TRACE_DIST) break; 135 | 136 | vec2 distToClosest = map(ro + rd * t, uv); 137 | h = distToClosest.x; 138 | id = distToClosest.y; 139 | t += h; 140 | } 141 | 142 | if(t < MAX_TRACE_DIST) finalDist = t; 143 | if(t > MAX_TRACE_DIST) id = -1.0; 144 | return vec2(finalDist, id); 145 | } 146 | 147 | vec3 render(in vec3 ro, in vec3 rd, in vec2 uv) { 148 | 149 | float ssDistToCenter = length(uv); 150 | vec3 bgColor1 = vec3(0.6, 0.2, 0.9); 151 | vec3 bgColor2 = vec3(0.0, 0.2, 0.8); 152 | vec3 surfaceColor = vec3(1.); 153 | 154 | vec2 results = calcIntersection(ro, rd, uv); 155 | float t = results.x; 156 | float id = results.y; 157 | 158 | vec3 lightPos = vec3(0.0,10.000,0.0); 159 | vec3 pos = ro + rd * t; 160 | vec3 n = calcNormal(pos, uv); 161 | vec3 diffColor = orange; 162 | n += noise( n + getColor( uv ) ); 163 | vec3 l = normalize(lightPos - pos); 164 | float diffStrength = max( pow( dot(n, l), 2. ), 0.0 ); 165 | float ambientStrength = clamp(0.5 + .5 * n.y, 0.0, 1.0); 166 | vec3 ambientColor = vec3( 0. ); 167 | surfaceColor = diffStrength * diffColor + ambientColor; 168 | 169 | return surfaceColor; 170 | } 171 | 172 | mat3 setCamMatrix(in vec3 ro, in vec3 ta, float roll) 173 | { 174 | vec3 ww = normalize(ta - ro); 175 | vec3 uu = normalize(cross(ww, vec3(sin(roll), cos(roll), 0.0))); 176 | vec3 vv = normalize(cross(uu, ww)); 177 | return mat3(uu, vv, ww); 178 | } 179 | 180 | void main() 181 | { 182 | 183 | vec2 p = (-u_resolution.xy + 2.0 * gl_FragCoord.xy) / u_resolution.y; 184 | 185 | float radius = 5.0; 186 | float camX = 7.; 187 | float camZ = 0.; 188 | 189 | vec3 ro = vec3( camX, 00.0, camZ); 190 | vec3 ta = vec3(0.0); 191 | mat3 cameraMatrix = setCamMatrix(ro, ta, 0.0); 192 | 193 | float lensLength = 2.0; 194 | vec3 rd = normalize(cameraMatrix * vec3(p.xy, lensLength)); 195 | 196 | vec3 color = render(ro, rd, p); 197 | gl_FragColor = vec4(color, 1.0); 198 | } -------------------------------------------------------------------------------- /klimt/klimt.pde: -------------------------------------------------------------------------------- 1 | PShader shader; 2 | String name = "klimt"; 3 | 4 | void setup() { 5 | size( 1200, 500, P3D ); 6 | noStroke(); 7 | shader = loadShader( name + ".glsl"); 8 | } 9 | 10 | void draw() { 11 | 12 | shader.set("u_resolution", float(width), float(height)); 13 | shader.set("u_time", 1000 + millis() / 1000.0); 14 | 15 | shader(shader); 16 | rect(0,0,width,height); 17 | 18 | } 19 | void keyPressed(){ 20 | shader = loadShader( name + ".glsl"); 21 | saveFrame( name + ".png" ); 22 | } -------------------------------------------------------------------------------- /klimt/klimt.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nicoptere/BUMP/55f0489c583cc1bd951db49f5df4275f7415b769/klimt/klimt.png -------------------------------------------------------------------------------- /logo.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nicoptere/BUMP/55f0489c583cc1bd951db49f5df4275f7415b769/logo.png -------------------------------------------------------------------------------- /monolith/monolith.glsl: -------------------------------------------------------------------------------- 1 | // Author: Nicolas Barradeau 2 | // Title: monolith 3 | 4 | #ifdef GL_ES 5 | precision mediump float; 6 | #endif 7 | 8 | #define PI 3.14159265359 9 | 10 | #define PROCESSING_COLOR_SHADER 11 | const vec3 blue = vec3( 0.4453125, 0.890625, 0.890625 ); 12 | const vec3 yellow_bright = vec3( 0.9296875, 0.8671875, 0.18359375 ); 13 | const vec3 yellow_dark = vec3( 0.921875, 0.80078125, 0.); 14 | const vec3 orange = vec3( 0.88671875, 0.625, 0.1171875); 15 | const vec3 pink = vec3( 0.92578125, 0.46484375, 0.89453125); 16 | 17 | uniform vec2 u_resolution; 18 | uniform vec2 u_mouse; 19 | uniform float u_time; 20 | 21 | 22 | const float MAX_TRACE_DIST = 50.0; 23 | const float MIN_HIT_DIST = 0.001; 24 | const int MAX_NUM_STEPS = 100; 25 | 26 | float hash( float n ) { return fract(sin(n)*753.5453123); } 27 | float noise( in vec3 x ) 28 | { 29 | vec3 p = floor(x); 30 | vec3 f = fract(x); 31 | f = f*f*(3.0-2.0*f); 32 | 33 | float n = p.x + p.y*157.0 + 113.0*p.z; 34 | return mix(mix(mix( hash(n+ 0.0), hash(n+ 1.0),f.x), 35 | mix( hash(n+157.0), hash(n+158.0),f.x),f.y), 36 | mix(mix( hash(n+113.0), hash(n+114.0),f.x), 37 | mix( hash(n+270.0), hash(n+271.0),f.x),f.y),f.z); 38 | } 39 | float roundBox( vec3 p, vec3 b, float r ){ return length(max(abs(p)-b,0.0))-r; } 40 | 41 | 42 | vec3 mod289(vec3 x) { 43 | return x - floor(x * (1.0 / 289.0)) * 289.0; 44 | } 45 | 46 | vec2 mod289(vec2 x) { 47 | return x - floor(x * (1.0 / 289.0)) * 289.0; 48 | } 49 | 50 | vec3 permute(vec3 x) { 51 | return mod289(((x*34.0)+1.0)*x); 52 | } 53 | 54 | float snoise(vec2 v){ 55 | const vec4 C = vec4(0.211324865405187, 56 | 0.366025403784439, 57 | -0.577350269189626, 58 | 0.024390243902439); 59 | vec2 i = floor(v + dot(v, C.yy) ); 60 | vec2 x0 = v - i + dot(i, C.xx); 61 | vec2 i1; 62 | i1 = (x0.x > x0.y) ? vec2(1.0, 0.0) : vec2(0.0, 1.0); 63 | vec4 x12 = x0.xyxy + C.xxzz; 64 | x12.xy -= i1; 65 | i = mod289(i); 66 | vec3 p = permute( permute( i.y + vec3(0.0, i1.y, 1.0 )) 67 | + i.x + vec3(0.0, i1.x, 1.0 )); 68 | vec3 m = max(0.5 - vec3(dot(x0,x0), dot(x12.xy,x12.xy), dot(x12.zw,x12.zw)), 0.0); 69 | m = m*m ; 70 | m = m*m ; 71 | vec3 x = 2.0 * fract(p * C.www) - 1.0; 72 | vec3 h = abs(x) - 0.5; 73 | vec3 ox = floor(x + 0.5); 74 | vec3 a0 = x - ox; 75 | m *= 1.79284291400159 - 0.85373472095314 * ( a0*a0 + h*h ); 76 | vec3 g; 77 | g.x = a0.x * x0.x + h.x * x0.y; 78 | g.yz = a0.yz * x12.xz + h.yz * x12.yw; 79 | return 130.0 * dot(m, g); 80 | } 81 | 82 | float getColor( in vec2 uv ) 83 | { 84 | float m = 4.5; 85 | float t = u_time * .1; 86 | float noise = snoise( vec2( m*uv.x, m * uv.y -t )); 87 | noise += abs(snoise( uv)); 88 | return noise * 12.; 89 | } 90 | mat3 rotationMatrix(vec3 axis, float angle) 91 | { 92 | axis = normalize(axis); 93 | float s = sin(angle); 94 | float c = cos(angle); 95 | float oc = 1.0 - c; 96 | return mat3(oc * axis.x * axis.x + c, oc * axis.x * axis.y - axis.z * s, oc * axis.z * axis.x + axis.y * s, 97 | oc * axis.x * axis.y + axis.z * s, oc * axis.y * axis.y + c, oc * axis.y * axis.z - axis.x * s, 98 | oc * axis.z * axis.x - axis.y * s, oc * axis.y * axis.z + axis.x * s, oc * axis.z * axis.z + c ); 99 | } 100 | 101 | vec2 map(in vec3 pos, in vec2 uv){ 102 | 103 | 104 | float box = roundBox( pos+vec3(0.,.75,0. ), vec3( .5, 1.5,.5), .1500); 105 | float freq = getColor( uv ); 106 | float n = 0.05 * sin(freq * pos.x ) * sin(freq * pos.y) * sin(freq * pos.z); 107 | return vec2( box - n, 1. ); 108 | } 109 | 110 | float softshadow( in vec3 ro, in vec3 rd, in float mint, in float tmax, in vec2 uv ){ 111 | float res = 1.0; 112 | float t = mint; 113 | for(int i = 0; i < 16; ++i) 114 | { 115 | float h = map(ro + rd * t, uv).x; 116 | res = min(res, 8.0 * h / t); 117 | t += clamp(h, 0.02, 0.10); 118 | if(h < 0.001 || t > tmax) break; 119 | } 120 | return clamp( res, 0.0, 1.0 ); 121 | 122 | } 123 | 124 | 125 | vec3 calcNormal(in vec3 pos, in vec2 uv ) 126 | { 127 | vec3 eps = vec3(0.001, 0.0, 0.0); 128 | vec3 nor = vec3( 129 | map(pos+eps.xyy, uv).x - map(pos-eps.xyy, uv).x, 130 | map(pos+eps.yxy, uv).x - map(pos-eps.yxy, uv).x, 131 | map(pos+eps.yyx, uv).x - map(pos-eps.yyx, uv).x); 132 | return normalize(nor); 133 | } 134 | 135 | 136 | float calcIntersection(in vec3 ro, in vec3 rd, in vec2 uv ){ 137 | 138 | float h = MIN_HIT_DIST * 2.0; 139 | float t = 0.0; 140 | float finalDist = -1.0; 141 | 142 | for(int i = 0; i < MAX_NUM_STEPS; ++i){ 143 | if(h < MIN_HIT_DIST || t > MAX_TRACE_DIST) break; 144 | 145 | vec2 distToClosest = map(ro + rd * t, uv); 146 | h = distToClosest.x; 147 | t += h; 148 | } 149 | 150 | if(t < MAX_TRACE_DIST) finalDist = t; 151 | return finalDist; 152 | } 153 | 154 | 155 | 156 | vec3 render(in vec3 ro, in vec3 rd, in vec2 uv) 157 | { 158 | 159 | float ssDistToCenter = length(uv); 160 | vec3 bgColor1 = vec3(0.6, 0.2, 0.9); 161 | vec3 bgColor2 = vec3(0.0, 0.2, 0.8); 162 | vec3 surfaceColor = .25*mix( .1*blue, orange*2., ( uv.y+.5 ) * getColor(uv*0.1)*.05 * noise( vec3( getColor( fract( uv *10.15 )*u_time*.1 ) ) ) ); 163 | 164 | float results = calcIntersection(ro, rd, uv); 165 | float t = results; 166 | 167 | vec3 lightPos = ( vec3( 0., .35 + sin( u_time * .1 ) * 0.500,0.0) ); 168 | if( t > -.5 ){ 169 | 170 | 171 | vec3 pos = ro + rd * t; 172 | vec3 n = calcNormal(pos, uv); 173 | vec3 r = reflect(pos, n ); 174 | vec3 diffColor = orange * 1.5; 175 | 176 | r *= rotationMatrix( vec3( uv.x,uv.y,uv.x), u_time *.1* PI * 2. ); 177 | n += noise( vec3( getColor( fract( uv * 0.3 )*u_time*.1 ) ) ); 178 | 179 | vec3 l = normalize(pos-lightPos ); 180 | float diffStrength = max( pow( dot( r, l), 2. ), 0.0 ) * max( pow( dot( n, l), 1. ), 0.0 ); 181 | float ambientStrength = clamp(0.05 + .5 * n.y, 0.0, 1.0); 182 | vec3 ambientColor = blue*.2; 183 | 184 | diffColor *= softshadow( pos, lightPos, 0.02, 12.5, uv ); 185 | ambientColor *= ambientStrength*.9; 186 | 187 | surfaceColor = ( diffStrength * diffColor + ambientColor ); 188 | } 189 | 190 | return surfaceColor; 191 | } 192 | 193 | mat3 setCamMatrix(in vec3 ro, in vec3 ta, float roll) 194 | { 195 | vec3 ww = normalize(ta - ro); 196 | vec3 uu = normalize(cross(ww, vec3(sin(roll), cos(roll), 0.0))); 197 | vec3 vv = normalize(cross(uu, ww)); 198 | return mat3(uu, vv, ww); 199 | } 200 | 201 | void main() 202 | { 203 | vec2 p = (-u_resolution.xy + 2.0 * gl_FragCoord.xy) / u_resolution.y; 204 | 205 | float radius = 2.35; 206 | float camX = radius; 207 | float camZ = radius; 208 | 209 | vec3 ro = vec3( camX, -radius, camZ); 210 | vec3 ta = vec3(0.0); 211 | mat3 cameraMatrix = setCamMatrix(ro, ta, 0.0); 212 | 213 | float lensLength = 3.; 214 | vec3 rd = normalize(cameraMatrix * vec3(p.xy, lensLength)); 215 | 216 | vec3 color = render(ro, rd, p); 217 | gl_FragColor = vec4(color, 1.0); 218 | } -------------------------------------------------------------------------------- /monolith/monolith.pde: -------------------------------------------------------------------------------- 1 | PShader shader; 2 | String name = "monolith"; 3 | 4 | void setup() { 5 | size( 1200, 500, P3D ); 6 | noStroke(); 7 | shader = loadShader( name + ".glsl"); 8 | } 9 | 10 | void draw() { 11 | 12 | shader.set("u_resolution", float(width), float(height)); 13 | shader.set("u_time", 1000 + millis() / 1000.0); 14 | 15 | shader(shader); 16 | rect(0,0,width,height); 17 | 18 | } 19 | void keyPressed(){ 20 | shader = loadShader( name + ".glsl"); 21 | saveFrame( name + ".png" ); 22 | } -------------------------------------------------------------------------------- /monolith/monolith.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nicoptere/BUMP/55f0489c583cc1bd951db49f5df4275f7415b769/monolith/monolith.png -------------------------------------------------------------------------------- /noisy_cone/noisy_cone.glsl: -------------------------------------------------------------------------------- 1 | // Author: Nicolas Barradeau 2 | // Title: noisy cone 3 | 4 | #ifdef GL_ES 5 | precision mediump float; 6 | #endif 7 | 8 | #define PI 3.14159265359 9 | 10 | #define PROCESSING_COLOR_SHADER 11 | const vec3 blue = vec3( 0.4453125, 0.890625, 0.890625 ); 12 | const vec3 yellow_bright = vec3( 0.9296875, 0.8671875, 0.18359375 ); 13 | const vec3 yellow_dark = vec3( 0.921875, 0.80078125, 0.); 14 | const vec3 orange = vec3( 0.88671875, 0.625, 0.1171875); 15 | const vec3 pink = vec3( 0.92578125, 0.46484375, 0.89453125); 16 | 17 | uniform vec2 u_resolution; 18 | uniform vec2 u_mouse; 19 | uniform float u_time; 20 | 21 | const float MAX_TRACE_DIST = 10.0; 22 | const float MIN_HIT_DIST = 0.0001; 23 | const int MAX_NUM_STEPS = 200; 24 | 25 | float hash( float n ) { return fract(sin(n)*753.5453123); } 26 | float noise( in vec3 x ) 27 | { 28 | vec3 p = floor(x); 29 | vec3 f = fract(x); 30 | f = f*f*(3.0-2.0*f); 31 | 32 | float n = p.x + p.y*157.0 + 113.0*p.z; 33 | return mix(mix(mix( hash(n+ 0.0), hash(n+ 1.0),f.x), 34 | mix( hash(n+157.0), hash(n+158.0),f.x),f.y), 35 | mix(mix( hash(n+113.0), hash(n+114.0),f.x), 36 | mix( hash(n+270.0), hash(n+271.0),f.x),f.y),f.z); 37 | } 38 | 39 | 40 | vec2 opU( vec2 a, vec2 b ) 41 | { 42 | return (a.x < b.x) ? a : b; 43 | } 44 | 45 | float sdPlane(in vec3 p) 46 | { 47 | return p.y; 48 | } 49 | 50 | float sdSphere(in vec3 p, float s) 51 | { 52 | float d1 = length(p) - s; 53 | return d1; 54 | } 55 | float sdCone( in vec3 p, in vec3 c ) 56 | { 57 | vec2 q = vec2( length(p.xz), p.y ); 58 | float d1 = -q.y-c.z; 59 | float d2 = max( dot(q,c.xy), q.y); 60 | return length(max(vec2(d1,d2),0.0)) + min(max(d1,d2), 0.); 61 | } 62 | vec3 mod289(vec3 x) { 63 | return x - floor(x * (1.0 / 289.0)) * 289.0; 64 | } 65 | 66 | vec2 mod289(vec2 x) { 67 | return x - floor(x * (1.0 / 289.0)) * 289.0; 68 | } 69 | 70 | vec3 permute(vec3 x) { 71 | return mod289(((x*34.0)+1.0)*x); 72 | } 73 | 74 | float snoise(vec2 v){ 75 | const vec4 C = vec4(0.211324865405187, 76 | 0.366025403784439, 77 | -0.577350269189626, 78 | 0.024390243902439); 79 | vec2 i = floor(v + dot(v, C.yy) ); 80 | vec2 x0 = v - i + dot(i, C.xx); 81 | vec2 i1; 82 | i1 = (x0.x > x0.y) ? vec2(1.0, 0.0) : vec2(0.0, 1.0); 83 | vec4 x12 = x0.xyxy + C.xxzz; 84 | x12.xy -= i1; 85 | i = mod289(i); 86 | vec3 p = permute( permute( i.y + vec3(0.0, i1.y, 1.0 )) 87 | + i.x + vec3(0.0, i1.x, 1.0 )); 88 | vec3 m = max(0.5 - vec3(dot(x0,x0), dot(x12.xy,x12.xy), dot(x12.zw,x12.zw)), 0.0); 89 | m = m*m ; 90 | m = m*m ; 91 | vec3 x = 2.0 * fract(p * C.www) - 1.0; 92 | vec3 h = abs(x) - 0.5; 93 | vec3 ox = floor(x + 0.5); 94 | vec3 a0 = x - ox; 95 | m *= 1.79284291400159 - 0.85373472095314 * ( a0*a0 + h*h ); 96 | vec3 g; 97 | g.x = a0.x * x0.x + h.x * x0.y; 98 | g.yz = a0.yz * x12.xz + h.yz * x12.yw; 99 | return 130.0 * dot(m, g); 100 | } 101 | 102 | float getColor( in vec2 uv ) 103 | { 104 | float m = 4.5; 105 | float t = u_time * .1; 106 | float noise = snoise( vec2( m*uv.x, m * uv.y -t )); 107 | noise += abs(snoise( uv)); 108 | return noise * 12.; 109 | } 110 | 111 | mat3 rotationMatrix(vec3 axis, float angle) 112 | { 113 | axis = normalize(axis); 114 | float s = sin(angle); 115 | float c = cos(angle); 116 | float oc = 1.0 - c; 117 | 118 | return mat3(oc * axis.x * axis.x + c, oc * axis.x * axis.y - axis.z * s, oc * axis.z * axis.x + axis.y * s, 119 | oc * axis.x * axis.y + axis.z * s, oc * axis.y * axis.y + c, oc * axis.y * axis.z - axis.x * s, 120 | oc * axis.z * axis.x - axis.y * s, oc * axis.y * axis.z + axis.x * s, oc * axis.z * axis.z + c ); 121 | } 122 | vec2 map(in vec3 pos, in vec2 uv) 123 | { 124 | pos *= rotationMatrix( vec3(0.,0., 1. ), PI ); 125 | float sphere1 = sdCone( pos - vec3( 0.,2.,0. ), vec3( 0.5,0.3,3.) ) ; 126 | float freq = getColor( uv ); 127 | float d1 = 0.1*sin(freq * pos.x) * sin(freq * pos.y + 0.8) * sin(freq * pos.z + 0.3); 128 | float d2 = 0.1*sin(freq * pos.x) * sin(freq * pos.y + 0.8) * sin(freq * pos.z + 0.3); 129 | return vec2( sphere1 - d2, 1. ); 130 | } 131 | 132 | float softshadow( in vec3 ro, in vec3 rd, in float mint, in float tmax, in vec2 uv ) 133 | { 134 | float res = 1.0; 135 | float t = mint; 136 | for(int i = 0; i < 16; ++i) 137 | { 138 | float h = map(ro + rd * t, uv).x; 139 | res = min(res, 8.0 * h / t); 140 | t += clamp(h, 0.02, 0.10); 141 | if(h < 0.001 || t > tmax) break; 142 | } 143 | return clamp( res, 0.0, 1.0 ); 144 | } 145 | 146 | 147 | vec3 calcNormal(in vec3 pos, in vec2 uv ) 148 | { 149 | vec3 eps = vec3(0.001, 0.0, 0.0); 150 | vec3 nor = vec3( 151 | map(pos+eps.xyy, uv).x - map(pos-eps.xyy, uv).x, 152 | map(pos+eps.yxy, uv).x - map(pos-eps.yxy, uv).x, 153 | map(pos+eps.yyx, uv).x - map(pos-eps.yyx, uv).x); 154 | return normalize(nor); 155 | } 156 | 157 | 158 | vec2 calcIntersection(in vec3 ro, in vec3 rd, in vec2 uv ) 159 | { 160 | float h = MIN_HIT_DIST * 2.0; 161 | float t = 0.0; 162 | float finalDist = -1.0; 163 | float id = -1.0; 164 | 165 | for(int i = 0; i < MAX_NUM_STEPS; ++i){ 166 | if(h < MIN_HIT_DIST || t > MAX_TRACE_DIST) break; 167 | vec2 distToClosest = map(ro + rd * t, uv); 168 | h = distToClosest.x; 169 | id = distToClosest.y; 170 | t += h; 171 | } 172 | 173 | if(t < MAX_TRACE_DIST) finalDist = t; 174 | 175 | return vec2(finalDist, id); 176 | } 177 | vec3 render(in vec3 ro, in vec3 rd, in vec2 uv) 178 | { 179 | 180 | float ssDistToCenter = length(uv); 181 | vec3 bgColor1 = vec3(0.6, 0.2, 0.9); 182 | vec3 bgColor2 = vec3(0.0, 0.2, 0.8); 183 | vec3 surfaceColor = .25*mix( .2*blue, orange, rd.y*3.9); 184 | 185 | vec2 results = calcIntersection(ro, rd, uv); 186 | float t = results.x; 187 | float id = results.y; 188 | 189 | if( t > -.50 ){ 190 | 191 | vec3 lightPos = normalize( vec3( 3.-abs( cos( u_time * 1.1 )), -0.000, - .5) ); 192 | 193 | vec3 pos = ro + rd * t; 194 | 195 | vec3 n = calcNormal(pos, uv); 196 | vec3 r = reflect( rd, n ); 197 | vec3 diffColor = orange; 198 | vec3 l = normalize(pos-lightPos ); 199 | 200 | float diffStrength = max( pow( dot(r, l), 2.5 ), 0.0 ) * .5 + max( pow( dot(n, l), 1. ), 0.0 ) * .5; 201 | float ambientStrength = clamp(0.05 + .5 * n.y, 0.0, 1.0); 202 | vec3 ambientColor = blue; 203 | 204 | ambientColor *= ambientStrength*.5; 205 | 206 | surfaceColor = ( diffStrength * diffColor + ambientColor ); 207 | } 208 | 209 | return surfaceColor; 210 | } 211 | 212 | mat3 setCamMatrix(in vec3 ro, in vec3 ta, float roll) 213 | { 214 | vec3 ww = normalize(ta - ro); 215 | vec3 uu = normalize(cross(ww, vec3(sin(roll), cos(roll), 0.0))); 216 | vec3 vv = normalize(cross(uu, ww)); 217 | return mat3(uu, vv, ww); 218 | } 219 | 220 | void main() 221 | { 222 | 223 | vec2 p = (-u_resolution.xy + 2.0 * gl_FragCoord.xy) / u_resolution.y; 224 | 225 | float radius = 5.0; 226 | float camX = 5.; 227 | float camZ = 0.; 228 | 229 | vec3 ro = vec3( camX, 0., camZ); 230 | vec3 ta = vec3(0.0); 231 | mat3 cameraMatrix = setCamMatrix(ro, ta, 0.0); 232 | 233 | float lensLength = 2.0; 234 | vec3 rd = normalize(cameraMatrix * vec3(p.xy, lensLength)); 235 | 236 | vec3 color = render(ro, rd, p); 237 | gl_FragColor = vec4(color, 1.0); 238 | } -------------------------------------------------------------------------------- /noisy_cone/noisy_cone.pde: -------------------------------------------------------------------------------- 1 | PShader shader; 2 | String name = "noisy_cone"; 3 | 4 | void setup() { 5 | size( 1200, 500, P3D ); 6 | noStroke(); 7 | shader = loadShader( name + ".glsl"); 8 | } 9 | 10 | void draw() { 11 | 12 | shader.set("u_resolution", float(width), float(height)); 13 | shader.set("u_time", 1000 + millis() / 1000.0); 14 | 15 | shader(shader); 16 | rect(0,0,width,height); 17 | 18 | } 19 | void keyPressed(){ 20 | shader = loadShader( name + ".glsl"); 21 | saveFrame( name + ".png" ); 22 | } -------------------------------------------------------------------------------- /noisy_cone/noisy_cone.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nicoptere/BUMP/55f0489c583cc1bd951db49f5df4275f7415b769/noisy_cone/noisy_cone.png -------------------------------------------------------------------------------- /panopitcon/panopitcon.glsl: -------------------------------------------------------------------------------- 1 | // Author: Nicolas Barradeau 2 | // Title: panopitcon ( dark future ) 3 | 4 | #ifdef GL_ES 5 | precision mediump float; 6 | #endif 7 | 8 | #define PI 3.14159 9 | 10 | #define PROCESSING_COLOR_SHADER 11 | const vec3 blue = vec3( 0.4453125, 0.890625, 0.890625 ); 12 | const vec3 yellow_bright = vec3( 0.9296875, 0.8671875, 0.18359375 ); 13 | const vec3 yellow_dark = vec3( 0.921875, 0.80078125, 0.); 14 | const vec3 orange = vec3( 0.88671875, 0.625, 0.1171875); 15 | const vec3 pink = vec3( 0.92578125, 0.46484375, 0.89453125); 16 | 17 | uniform vec2 u_resolution; 18 | uniform vec2 u_mouse; 19 | uniform float u_time; 20 | 21 | 22 | float rand(float n){ 23 | return fract( ( sin( n ) * 43758.5453123 ) ); 24 | } 25 | float noise(float p) 26 | { 27 | float fl = floor(p); 28 | float fc = fract(p); 29 | return mix(rand(fl), rand(fl + 1.0), fc); 30 | } 31 | 32 | float f( vec2 p, float a, float b){ 33 | return ( atan(p.y+a,p.x+b) ); 34 | } 35 | 36 | void main() { 37 | 38 | float scale = 10.; 39 | vec2 sc = 2. * ( gl_FragCoord.xy / u_resolution ); 40 | vec2 st = sc * u_resolution.xy / max(u_resolution.x, u_resolution.y); 41 | st *= 6.; 42 | vec2 uv = 1. + sc * u_resolution.xy / max(u_resolution.x, u_resolution.y); 43 | uv *= scale; 44 | 45 | float t = ( u_time *.1 ) - 10.; 46 | vec2 id = floor( uv ); 47 | vec2 fr = fract( uv); 48 | 49 | float acc = 0.; 50 | for( float i = 1.; i < 20.; i+=1. ){ 51 | vec2 id = floor( uv * scale / i ) + t; 52 | vec2 fr = fract( uv * scale / i ) + ( ( t ) - floor( uv.x * t ) ); 53 | fr.y += fract( fr.y ); 54 | acc += .205 * sin( f( sc * floor( sc ).x + floor( sc ).y, fr.x / cos( id.x ), fr.y / sin( id.y ) ) ); 55 | } 56 | 57 | float w = sc.y + ( sin( ( sc.y - t ) * rand( floor(st+t).x ) * 10. ) ); 58 | w *= ( cos( ( sc.x - t * sc.y * 50.) * 1. ) ); 59 | 60 | float v = acc * pow( length( sc-vec2( 1., 0. ) ), 2. ); 61 | 62 | vec3 color = mix( blue * v, orange * v, smoothstep( 0.,1., w ) ); 63 | 64 | color *= smoothstep( .65,.751,1.-sin( distance( fract( st ), vec2(0.5) ) ) ); 65 | 66 | gl_FragColor = vec4(color,1.0); 67 | 68 | } -------------------------------------------------------------------------------- /panopitcon/panopitcon.pde: -------------------------------------------------------------------------------- 1 | PShader shader; 2 | String name = "panopitcon"; 3 | 4 | void setup() { 5 | size( 1200, 500, P3D ); 6 | noStroke(); 7 | shader = loadShader( name + ".glsl"); 8 | } 9 | 10 | void draw() { 11 | 12 | shader.set("u_resolution", float(width), float(height)); 13 | shader.set("u_time", 1000 + millis() / 1000.0); 14 | 15 | shader(shader); 16 | rect(0,0,width,height); 17 | 18 | } 19 | void keyPressed(){ 20 | shader = loadShader( name + ".glsl"); 21 | saveFrame( name + ".png" ); 22 | } -------------------------------------------------------------------------------- /panopitcon/panopitcon.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nicoptere/BUMP/55f0489c583cc1bd951db49f5df4275f7415b769/panopitcon/panopitcon.png -------------------------------------------------------------------------------- /polygons/polygons.glsl: -------------------------------------------------------------------------------- 1 | // Author: Nicolas Barradeau 2 | // Title: polygons 3 | 4 | #ifdef GL_ES 5 | precision mediump float; 6 | #endif 7 | #define PI 3.14159265359 8 | #define PROCESSING_COLOR_SHADER 9 | 10 | const vec3 blue = vec3( 0.4453125, 0.890625, 0.890625 ); 11 | const vec3 yellow_bright = vec3( 0.9296875, 0.8671875, 0.18359375 ); 12 | const vec3 yellow_dark = vec3( 0.921875, 0.80078125, 0.); 13 | const vec3 orange = vec3( 0.88671875, 0.625, 0.1171875); 14 | const vec3 pink = vec3( 0.92578125, 0.46484375, 0.89453125); 15 | 16 | uniform vec2 u_resolution; 17 | uniform float u_time; 18 | 19 | float poly( vec2 c, float sides, float scale, float thickness ){ 20 | 21 | float a=atan(c.x,c.y); 22 | float b=6.28319/float(sides); 23 | return smoothstep( .5-thickness, .5, cos(floor(.5+a/b)*b-a)*length(c.xy) * ( 1. / scale ) ) - smoothstep( .5, .5 + thickness, cos(floor(.5+a/b)*b-a)*length(c.xy) * ( 1. / scale ) ); 24 | 25 | } 26 | float rand( vec2 c ){ 27 | return fract(sin(dot(c.xy,vec2(12.9898,78.233)))*43758.5453123); 28 | } 29 | 30 | //#define biunit 31 | void main() { 32 | 33 | vec2 ratio = u_resolution.xy / max(u_resolution.x, u_resolution.y); 34 | #ifdef biunit 35 | vec2 uv = ( 2. * ( gl_FragCoord.xy / u_resolution ) - 1. ) * ratio; 36 | #else 37 | vec2 uv = ( gl_FragCoord.xy / u_resolution ) * ratio; 38 | #endif 39 | 40 | vec3 col = vec3(0.); 41 | 42 | float scale = 1.; 43 | vec2 f = fract( uv ); 44 | 45 | float a = u_time * .001 * PI; 46 | float ca = cos( a * 2. ); 47 | float sa = sin( a * 1.5 ); 48 | mat2 t = mat2( ca, -sa, sa, ca ); 49 | 50 | vec2 i = floor( uv * 100. ); 51 | vec2 motion = vec2( sa, ca )*100.; 52 | 53 | float acc = 0.; 54 | const float count = 10.; 55 | for( float k = 0.; k < count; k+= 1. ){ 56 | acc += rand( floor( t * ( motion + uv * k - vec2( k *.5 ) * ratio ) ) ) * ( k / count ) * .25; 57 | } 58 | col = vec3( acc ); 59 | 60 | a = 0.; 61 | ca = cos( a ); 62 | sa = sin( a ); 63 | t = mat2( ca, -sa, sa, ca ); 64 | f -= vec2(0.5) * ratio; 65 | f *= t; 66 | 67 | float s = 0.; 68 | float pscale = 0.; 69 | 70 | a = u_time * 1.1; 71 | ca = cos( a ); 72 | sa = sin( a ); 73 | s = 6.; 74 | pscale = min( ratio.x, ratio.y ) * .25 ; 75 | col += vec3( poly( f, s, pscale, 0.1 ) + poly( f, s,pscale,.15 ) * ( .25 + sa * .05 ) ); 76 | s /= 2.; 77 | col += vec3( poly( f, s, pscale, 0.1 ) + poly( f, s,pscale,.15 ) * ( .25 + sa * .05 ) ); 78 | s *= 40.; 79 | col += vec3( poly( f, s, pscale * 2., 0.1 ) + poly( f, s,pscale * 2.,.5 )* ( .5 + sa * .35 ) ); 80 | s = 4.; 81 | col += vec3( poly( f, s, pscale * 2., 0.1 ) + poly( f, s,pscale * 1.,.25 ) );// * ( .5 + sa * .75 ) ); 82 | 83 | f += vec2(.5); 84 | col *= vec3( f.x, f.y, 1. ); 85 | gl_FragColor = vec4( col, 1. ); 86 | 87 | } -------------------------------------------------------------------------------- /polygons/polygons.pde: -------------------------------------------------------------------------------- 1 | PShader shader; 2 | String name = "polygons"; 3 | 4 | void setup() { 5 | size( 1200, 500, P3D ); 6 | noStroke(); 7 | shader = loadShader( name + ".glsl"); 8 | } 9 | 10 | void draw() { 11 | 12 | shader.set("u_resolution", float(width), float(height)); 13 | shader.set("u_time", 1000 + millis() / 1000.0); 14 | 15 | shader(shader); 16 | rect(0,0,width,height); 17 | 18 | } 19 | void keyPressed(){ 20 | shader = loadShader( name + ".glsl"); 21 | saveFrame( name + ".png" ); 22 | } -------------------------------------------------------------------------------- /polygons/polygons.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nicoptere/BUMP/55f0489c583cc1bd951db49f5df4275f7415b769/polygons/polygons.png -------------------------------------------------------------------------------- /vorogrid/vorogrid.glsl: -------------------------------------------------------------------------------- 1 | // Author: Nicolas Barradeau 2 | // Title: vorogrid 3 | 4 | #ifdef GL_ES 5 | precision mediump float; 6 | #endif 7 | 8 | #define PI 3.14159265359 9 | 10 | #define PROCESSING_COLOR_SHADER 11 | const vec3 blue = vec3( 0.4453125, 0.890625, 0.890625 ); 12 | const vec3 yellow_bright = vec3( 0.9296875, 0.8671875, 0.18359375 ); 13 | const vec3 yellow_dark = vec3( 0.921875, 0.80078125, 0.); 14 | const vec3 orange = vec3( 0.88671875, 0.625, 0.1171875); 15 | const vec3 pink = vec3( 0.92578125, 0.46484375, 0.89453125); 16 | 17 | uniform vec2 u_resolution; 18 | uniform vec2 u_mouse; 19 | uniform float u_time; 20 | 21 | float sdPlane( vec3 p ) { return p.y; } 22 | 23 | float sdSphere( vec3 p, float s ) { return length(p)-s; } 24 | 25 | float sdBox( vec3 p, vec3 b ) { vec3 d = abs(p) - b; return min(max(d.x,max(d.y,d.z)),0.0) + length(max(d,0.0)); } 26 | 27 | float opS( float d1, float d2 ) { return max(-d2,d1); } 28 | 29 | vec2 opU( vec2 d1, vec2 d2 ) { return (d1.x x0.y) ? vec2(1.0, 0.0) : vec2(0.0, 1.0); 43 | vec4 x12 = x0.xyxy + C.xxzz; 44 | x12.xy -= i1; 45 | i = mod289(i); 46 | vec3 p = permute( permute( i.y + vec3(0.0, i1.y, 1.0 )) + i.x + vec3(0.0, i1.x, 1.0 )); 47 | vec3 m = max(0.5 - vec3(dot(x0,x0), dot(x12.xy,x12.xy), dot(x12.zw,x12.zw)), 0.0); 48 | m = m*m ; 49 | m = m*m ; 50 | vec3 x = 2.0 * fract(p * C.www) - 1.0; 51 | vec3 h = abs(x) - 0.5; 52 | vec3 ox = floor(x + 0.5); 53 | vec3 a0 = x - ox; 54 | m *= 1.79284291400159 - 0.85373472095314 * ( a0*a0 + h*h ); 55 | vec3 g; 56 | g.x = a0.x * x0.x + h.x * x0.y; 57 | g.yz = a0.yz * x12.xz + h.yz * x12.yw; 58 | return 130.0 * dot(m, g); 59 | } 60 | 61 | mat3 rotationMatrix(vec3 axis, float angle) 62 | { 63 | axis = normalize(axis); 64 | float s = sin(angle); 65 | float c = cos(angle); 66 | float oc = 1.0 - c; 67 | return mat3(oc * axis.x * axis.x + c, oc * axis.x * axis.y - axis.z * s, oc * axis.z * axis.x + axis.y * s, 68 | oc * axis.x * axis.y + axis.z * s, oc * axis.y * axis.y + c, oc * axis.y * axis.z - axis.x * s, 69 | oc * axis.z * axis.x - axis.y * s, oc * axis.y * axis.z + axis.x * s, oc * axis.z * axis.z + c ); 70 | } 71 | float seed = 0.; 72 | float rand(float n){ 73 | 74 | return fract( sin( seed + n * 43758.5453123 ) ); 75 | } 76 | vec2 rand2(in vec2 p){ 77 | return fract(vec2(sin(p.x * 591.32 + p.y * 154.077), cos(p.x * 391.32 + p.y * 49.077))); 78 | } 79 | 80 | float seednoise(float p) 81 | { 82 | float fl = floor(p); 83 | float fc = fract(p ); 84 | return mix(rand( fl + seed ), rand(fl + seed+ 1.0), fc); 85 | } 86 | 87 | float noise(float p) 88 | { 89 | float fl = floor(p); 90 | float fc = fract(p ); 91 | return mix(rand( fl ), rand(fl + 1.0), fc); 92 | } 93 | 94 | float cube( in vec3 p, in vec3 b, in float t ) { 95 | return opS( opS( opS( sdBox( p, b ), sdBox( p, vec3(b.x*2., b.y*t, b.z*t) ) ), sdBox( p, vec3(b.x*t, b.y*2., b.z*t) ) ), sdBox( p, vec3(b.x*t, b.y*t, b.z *2. ) ) ); 96 | } 97 | float hollowSphere( in vec3 p, in float outerRadius, in float thickness ) { 98 | return opS( sdSphere( p, outerRadius ), sdSphere( p, outerRadius * ( 1. - thickness ) ) ); 99 | } 100 | 101 | vec2 map( in vec3 pos ){ 102 | vec2 res = vec2( 0.); 103 | 104 | const float count_i = 2., count_j = 2. , count_k = 2.; 105 | float noise_i = 2., noise_j = 2. , noise_k = 2.; 106 | float multi = 1.; 107 | vec3 pfloor = floor( pos * multi ); 108 | vec3 pfract = fract( pos * multi ); 109 | float dist = 0.; 110 | 111 | seed = abs( snoise( vec2( u_time * .01 ) ) ) * .0001; 112 | pos *= rotationMatrix( vec3( 1.,0.,0. ), u_time * .1 ); 113 | 114 | vec3 c = vec3(.0); 115 | vec3 tg = pos; 116 | vec3 origin = tg; 117 | float sq = .75; 118 | res = vec2( sdSphere( pos, .75) , 2.) ; 119 | for( float i = -1.; i < count_i; i += 1. ){ 120 | 121 | for( float j = -1.; j < count_j; j += 1. ){ 122 | 123 | for( float k = -1.; k < count_k; k += 1. ){ 124 | vec3 cell = pos - vec3( i, j, k ); 125 | vec3 tg = cell + normalize( vec3( seednoise( i+j ), seednoise( j+k ), seednoise( k+i ) ) )-.5; 126 | dist = distance( pos, tg ); 127 | res = vec2( opS( res.x, sdSphere( tg, dist * sq ) ), sqrt( dist ) ); 128 | } 129 | } 130 | } 131 | return res; 132 | } 133 | 134 | vec2 castRay( in vec3 ro, in vec3 rd ) 135 | { 136 | float tmin = 0.1; 137 | float tmax = 50.0; 138 | float precis = 0.0001; 139 | float t = tmin; 140 | float m = -1.0; 141 | for( int i=0; i<100; i++ ) 142 | { 143 | vec2 res = map( ro+rd*t ); 144 | if( res.xtmax ) break; 145 | t += res.x; 146 | m = res.y; 147 | } 148 | if( t>tmax ) m=-1.0; 149 | return vec2( t, m ); 150 | } 151 | 152 | vec3 calcNormal( in vec3 pos ) 153 | { 154 | vec3 eps = vec3( 0.001, 0.0, 0.0 ); 155 | vec3 nor = vec3( 156 | map(pos+eps.xyy).x - map(pos-eps.xyy).x, 157 | map(pos+eps.yxy).x - map(pos-eps.yxy).x, 158 | map(pos+eps.yyx).x - map(pos-eps.yyx).x ); 159 | return normalize(nor); 160 | } 161 | 162 | vec3 render( in vec3 ro, in vec3 rd, in vec2 uv ) 163 | { 164 | float n = snoise( vec2( uv.x * .2 + sin( u_time * 0.01 ), uv.y * .2 + sin(u_time * 0.01) ) ); 165 | vec3 col = blue * .35 + rd.y + ( pow( n, 2. ) ) * .8; 166 | vec2 res = castRay(ro,rd); 167 | float t = res.x; 168 | float m = res.y; 169 | if( m>-0.5 ) 170 | { 171 | vec3 pos = ro + rd * t; 172 | vec3 n = calcNormal(pos); 173 | vec3 ref = reflect( rd, n ); 174 | vec3 diffColor = orange; 175 | 176 | vec3 lightPos = ( vec3( -1., -.700, 3.0) ); 177 | vec3 l = normalize(pos-lightPos ); 178 | float diffStrength = max( pow( dot(n, l), 32. ), 0.0 ); 179 | vec3 ambientColor = blue * clamp( 0.005 + .35 * ref.y, 0.0, 1.0); 180 | col = ( diffStrength * diffColor + ambientColor ); 181 | 182 | } 183 | return vec3( clamp(col,0.0,1.0) ); 184 | } 185 | 186 | mat3 setCamera( in vec3 ro, in vec3 ta, float cr ) 187 | { 188 | vec3 cw = normalize(ta-ro); 189 | vec3 cp = vec3(sin(cr), cos(cr),0.0); 190 | vec3 cu = normalize( cross(cw,cp) ); 191 | vec3 cv = normalize( cross(cu,cw) ); 192 | return mat3( cu, cv, cw ); 193 | } 194 | 195 | void main() 196 | { 197 | vec2 q = gl_FragCoord.xy/u_resolution.xy; 198 | vec2 p = 2.0*q-1.; 199 | p.x *= u_resolution.x/u_resolution.y; 200 | 201 | vec3 ro = vec3( 0.,0.,-2. ); 202 | vec3 ta = vec3( 2./3., 0., 0.); 203 | mat3 ca = setCamera( ro, ta, 0.0 ); 204 | vec3 rd = ca * normalize( vec3(p.xy, 2.5 ) ); 205 | vec3 col = render( ro, rd, q ); 206 | 207 | gl_FragColor=vec4( col, 1.0 ); 208 | } -------------------------------------------------------------------------------- /vorogrid/vorogrid.pde: -------------------------------------------------------------------------------- 1 | PShader shader; 2 | String name = "vorogrid"; 3 | 4 | void setup() { 5 | size( 1200, 500, P3D ); 6 | noStroke(); 7 | shader = loadShader( name + ".glsl"); 8 | } 9 | 10 | void draw() { 11 | 12 | shader.set("u_resolution", float(width), float(height)); 13 | shader.set("u_time", 1000 + millis() / 1000.0); 14 | 15 | shader(shader); 16 | rect(0,0,width,height); 17 | 18 | } 19 | void keyPressed(){ 20 | shader = loadShader( name + ".glsl"); 21 | saveFrame( name + ".png" ); 22 | } -------------------------------------------------------------------------------- /vorogrid/vorogrid.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nicoptere/BUMP/55f0489c583cc1bd951db49f5df4275f7415b769/vorogrid/vorogrid.png -------------------------------------------------------------------------------- /waves/waves.glsl: -------------------------------------------------------------------------------- 1 | // Author: Nicolas Barradeau 2 | // Title: waves 3 | 4 | #ifdef GL_ES 5 | precision mediump float; 6 | #endif 7 | 8 | #define PROCESSING_COLOR_SHADER 9 | const vec3 blue = vec3( 0.4453125, 0.890625, 0.890625 ); 10 | const vec3 yellow_bright = vec3( 0.9296875, 0.8671875, 0.18359375 ); 11 | const vec3 yellow_dark = vec3( 0.921875, 0.80078125, 0.); 12 | const vec3 orange = vec3( 0.88671875, 0.625, 0.1171875); 13 | const vec3 pink = vec3( 0.92578125, 0.46484375, 0.89453125); 14 | 15 | 16 | uniform float u_time; 17 | uniform vec2 u_resolution; 18 | uniform float u_mouse; 19 | 20 | // 1D random numbers 21 | float rand(float n){ 22 | return fract( ( sin( n ) * 43758.5453123 ) ); 23 | } 24 | 25 | // 2D random numbers 26 | vec2 rand2(in vec2 p){ 27 | return fract(vec2(sin(p.x * 591.32 + p.y * 154.077), cos(p.x * 391.32 + p.y * 49.077))); 28 | } 29 | 30 | // 1D noise 31 | float noise(float p) 32 | { 33 | float fl = floor(p); 34 | float fc = fract(p); 35 | return mix(rand(fl), rand(fl + 1.0), fc); 36 | } 37 | 38 | 39 | void main() { 40 | 41 | 42 | float scale = 1.; 43 | vec2 sc = ( gl_FragCoord.xy / u_resolution ); 44 | vec2 uv = sc * u_resolution.xy / max(u_resolution.x, u_resolution.y); 45 | uv *= scale; 46 | 47 | float angle = radians( 45 * sc.y + sin( u_time ) ); 48 | float ca = cos( angle ); 49 | float sa = sin( angle ); 50 | 51 | uv *= mat2( ca, sa, -sa, ca ); 52 | vec2 i = floor( uv ); 53 | vec2 f = fract( uv ); 54 | 55 | float v0 = rand( floor( uv * 20. ).x+ u_time * 0.00001 ); 56 | vec3 color0 = mix( blue, yellow_dark, v0 ); 57 | 58 | float v1 = rand( floor( uv * 40. ).y + u_time * 0.00001 ); 59 | vec3 color1 = mix( yellow_bright, blue, v1 ); 60 | 61 | float v2 = rand( floor( uv * 80. ).y + u_time * 0.00001 ); 62 | vec3 color2 = mix( pink, yellow_bright, v2 ); 63 | 64 | float a = ( sc.y - .15 + sin( u_time * 2.5 + sc.x * 8. ) * .1 ); 65 | float b = ( sc.y + .13 + sin( - u_time * 2.25 + sc.x * 6. ) * .15 ); 66 | float c = ( sc.y - .13 + cos( .25 + u_time * 1.25 + sc.x * 4. ) * .25 ); 67 | 68 | 69 | vec3 color = mix( orange, blue, v0 ) * .75; 70 | color = mix( color, color2 * .95, smoothstep( 0.5,.501, c ) ); 71 | color = mix( color, color0, smoothstep( 0.501,.5, a ) ); 72 | color = mix( color, color1 * 1.25, smoothstep( 0.501,.5, b ) ); 73 | 74 | gl_FragColor = vec4(color,1.0); 75 | 76 | 77 | } -------------------------------------------------------------------------------- /waves/waves.pde: -------------------------------------------------------------------------------- 1 | PShader shader; 2 | String name = "waves"; 3 | 4 | void setup() { 5 | size( 1200, 500, P3D ); 6 | noStroke(); 7 | shader = loadShader( name + ".glsl"); 8 | } 9 | 10 | void draw() { 11 | 12 | shader.set("u_resolution", float(width), float(height)); 13 | shader.set("u_time", 1000 + millis() / 1000.0); 14 | 15 | shader(shader); 16 | rect(0,0,width,height); 17 | 18 | } 19 | void keyPressed(){ 20 | shader = loadShader( name + ".glsl"); 21 | saveFrame( name + ".png" ); 22 | } -------------------------------------------------------------------------------- /waves/waves.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nicoptere/BUMP/55f0489c583cc1bd951db49f5df4275f7415b769/waves/waves.png --------------------------------------------------------------------------------