├── .gitignore ├── ISF ├── 01_Strobosphere.fs ├── 02_ColorWheel.fs ├── 03_SquareStep.fs ├── 04_SmoothStep.fs ├── 05_PetalBlob.fs ├── 06_GradientCheck.fs ├── 07_GradientEdges.fs ├── 08_TilePattern.fs ├── 09_RotatingCirclePatterns.fs ├── 10_RotatingSquarePatterns.fs ├── 11_Bricked.fs ├── 12_TruchetTiles.fs ├── 13_TiledFractPatterns.fs ├── 14_ControlledChaos.fs ├── 15_GoTo10.fs ├── 16_Zebre.fs ├── 17_HypnoCircles.fs ├── 18_Iteration.fs ├── 19_TruchetIteration.fs ├── 20_FractalDots.fs ├── 21_Cosplay.fs ├── 22_DifferenceStrokes.fs ├── 23_DiscSpin.fs ├── 24_RadialWaves.fs ├── 25_HoopLoop.fs ├── 26_SoftPatterns.fs ├── 27_DistanceFieldMorph.fs ├── 28_TurbulentShapes.fs ├── 29_WaveLines.fs ├── 30_Wisps.fs ├── 31_Twist.fs ├── 32_WaveShapes.fs ├── 33_CrossGrid.fs ├── 34_Kaleidolines.fs ├── 35_Moiree.fs ├── 36_Hypnocone.fs ├── 37_CircleSpiral.fs ├── 38_SimpleShapeFunctions.fs ├── 39_MoreMoire.fs ├── 40_Matrix.fs ├── 41_CB4.fs └── 42_CellularIterations.fs ├── Images ├── SaturdayShader_Week15_Goto10.png ├── SaturdayShader_Week23_DiscSpin.jpg └── SaturdayShader_Week40_Matrix.png ├── README.md └── SaturdayShaders.vdmx5 /.gitignore: -------------------------------------------------------------------------------- 1 | .DS_Store 2 | Unity3D 3 | Exports 4 | Audio 5 | ThreeJS -------------------------------------------------------------------------------- /ISF/01_Strobosphere.fs: -------------------------------------------------------------------------------- 1 | //#SaturdayShader 2 | //2015-01 StroboSphere 3 | //Based on code from http://patriciogonzalezvivo.com/2015/thebookofshaders/07/ 4 | 5 | 6 | /*{ 7 | "CREDIT": "by vjzef", 8 | "DESCRIPTION": "Stroboscopic sphere", 9 | "CATEGORIES": [ 10 | "Generator" 11 | ], 12 | "INPUTS": [ 13 | { 14 | "NAME": "pos", 15 | "TYPE": "point2D", 16 | "DEFAULT": [ 17 | 0.5, 18 | 0.5 19 | ] 20 | }, 21 | { 22 | "NAME": "speed", 23 | "TYPE": "float", 24 | "DEFAULT": 4.0, 25 | "MIN": -3.0, 26 | "MAX": 10.0 27 | }, 28 | { 29 | "NAME": "scale1", 30 | "TYPE": "float", 31 | "DEFAULT": 0.0, 32 | "MIN": 0.0, 33 | "MAX": 2.0 34 | }, 35 | { 36 | "NAME": "scale2", 37 | "TYPE": "float", 38 | "DEFAULT": 1.0, 39 | "MIN": 0.0, 40 | "MAX": 1.0 41 | }, 42 | { 43 | "NAME": "outline", 44 | "TYPE": "float", 45 | "DEFAULT": 0.99, 46 | "MIN": 0.0, 47 | "MAX": 0.99 48 | }, 49 | { 50 | "NAME": "roundness", 51 | "TYPE": "float", 52 | "DEFAULT": 0.0, 53 | "MIN": 0.0, 54 | "MAX": 1.0 55 | } 56 | ] 57 | }*/ 58 | 59 | 60 | 61 | void main(){ 62 | vec2 st = gl_FragCoord.xy/RENDERSIZE.xy; 63 | st.x *= RENDERSIZE.x/RENDERSIZE.y; 64 | 65 | //not sure how to go about centering this to match the point2D XY, (Y is not perfectly centered) 66 | st.y+= 0.5; 67 | st -= pos/RENDERSIZE; 68 | 69 | 70 | //st.x += -0.5; 71 | vec3 color = vec3(0.0); 72 | float d = 0.0; 73 | 74 | // Remap the space to -1. to 1. 75 | st = st * 2.-1.; 76 | 77 | 78 | // Make the distance field 79 | d = length( max(abs(st)-roundness,0.) ); 80 | 81 | d = smoothstep(scale1,scale2,d); 82 | 83 | color = vec3(fract(d*sin(d+TIME*speed))); 84 | 85 | if (outline > 0.0) 86 | color = step(outline, color); 87 | 88 | 89 | // Visualize the distance field 90 | gl_FragColor = vec4(color,1.0); 91 | 92 | } -------------------------------------------------------------------------------- /ISF/02_ColorWheel.fs: -------------------------------------------------------------------------------- 1 | //#SaturdayShader 2 | //2015-02 ColorWheel 3 | //Based on code from http://patriciogonzalezvivo.com/2015/thebookofshaders/06/ 4 | //and from Iñigo Quiles https://www.shadertoy.com/view/MsS3Wc 5 | 6 | 7 | /*{ 8 | "CREDIT": "by vjzef", 9 | "DESCRIPTION": "", 10 | "CATEGORIES": [ 11 | "Generator" 12 | ], 13 | "INPUTS": [ 14 | { 15 | "NAME": "rotate", 16 | "TYPE": "float", 17 | "DEFAULT": 0.0, 18 | "MIN": 0.0, 19 | "MAX": 1.0 20 | }, 21 | { 22 | "NAME": "multiply", 23 | "TYPE": "float", 24 | "DEFAULT": 6.0, 25 | "MIN": 0.0, 26 | "MAX": 2000.0 27 | }, 28 | { 29 | "NAME": "sharpenLines", 30 | "TYPE": "float", 31 | "DEFAULT": 1.0, 32 | "MIN": 1.0, 33 | "MAX": 1000.0 34 | }, 35 | { 36 | "NAME": "invert", 37 | "TYPE": "float", 38 | "DEFAULT": 1.0, 39 | "MIN": -20.0, 40 | "MAX": 20.0 41 | }, 42 | { 43 | "NAME": "warp", 44 | "TYPE": "float", 45 | "DEFAULT": 1.0, 46 | "MIN": -200.0, 47 | "MAX": 200.0 48 | }, 49 | { 50 | "NAME": "mRadius", 51 | "TYPE": "float", 52 | "DEFAULT": 2.0, 53 | "MIN": -50.0, 54 | "MAX": 50.0 55 | }, 56 | { 57 | "NAME": "pos", 58 | "TYPE": "point2D", 59 | "DEFAULT": [ 60 | 0.0, 61 | 0.0 62 | ], 63 | "MIN": [ 64 | -0.5, 65 | -0.5 66 | ], 67 | "MAX": [ 68 | 0.5, 69 | 0.5 70 | ] 71 | } 72 | ] 73 | }*/ 74 | 75 | // multiply 0 - 2000, 6.0 is default 76 | 77 | #ifdef GL_ES 78 | precision mediump float; 79 | #endif 80 | 81 | #define TWO_PI 6.28318530718 82 | 83 | 84 | // Function from Iñigo Quiles 85 | // https://www.shadertoy.com/view/MsS3Wc 86 | vec3 hsb2rgb( in vec3 c ){ 87 | vec3 rgb = clamp(abs(mod(c.x*multiply+vec3(0.0,4.0,2.0), 88 | 6.0)-3.0)-1.0, 89 | 0.0, 90 | 1.0 ); 91 | rgb = rgb*rgb*(3.0-2.0*rgb); 92 | return c.z * mix( vec3(invert), rgb, c.y)*warp; 93 | } 94 | 95 | void main(){ 96 | vec2 st = gl_FragCoord.xy/RENDERSIZE; 97 | vec3 color = vec3(0.0); 98 | st.x -=pos.x; 99 | st.y -=pos.y; 100 | 101 | // Use polar coordinates instead of cartesian 102 | vec2 toCenter = vec2(0.5)-st; 103 | float angle = atan(toCenter.y,toCenter.x); 104 | float radius = length(toCenter)*mRadius; 105 | 106 | // Map the angle (-PI to PI) to the Hue (from 0 to 1) 107 | // and the Saturation to the radius 108 | color = hsb2rgb(vec3((angle/TWO_PI)+rotate,radius*sharpenLines,1.0)); 109 | 110 | gl_FragColor = vec4(color,1.0); 111 | } -------------------------------------------------------------------------------- /ISF/03_SquareStep.fs: -------------------------------------------------------------------------------- 1 | // #SaturdayShader Week 3 : SquareStep 2 | // 2015-09-05 3 | // Based on the "Step" example by Patricio Gonzalez Vivo on http://patriciogonzalezvivo.com/2015/thebookofshaders/05/ 4 | 5 | /*{ 6 | "CREDIT": "Joseph Fiola", 7 | "DESCRIPTION": "", 8 | "CATEGORIES": [ 9 | "Generator", "Geometry" 10 | 11 | ], 12 | "INPUTS": [ 13 | { 14 | "NAME": "left", 15 | "TYPE": "float", 16 | "DEFAULT": 0.1, 17 | "MIN": 0.0, 18 | "MAX": 1.0 19 | }, 20 | { 21 | "NAME": "right", 22 | "TYPE": "float", 23 | "DEFAULT": 0.9, 24 | "MIN": 0.0, 25 | "MAX": 1.0 26 | }, 27 | { 28 | "NAME": "top", 29 | "TYPE": "float", 30 | "DEFAULT": 0.1, 31 | "MIN": 0.0, 32 | "MAX": 1.0 33 | }, 34 | { 35 | "NAME": "bottom", 36 | "TYPE": "float", 37 | "DEFAULT": 0.9, 38 | "MIN": 0.0, 39 | "MAX": 1.0 40 | } 41 | ] 42 | } 43 | */ 44 | 45 | #ifdef GL_ES 46 | precision mediump float; 47 | #endif 48 | 49 | void main() { 50 | vec2 st = gl_FragCoord.xy/RENDERSIZE; 51 | float y; 52 | if(right > left){ 53 | y = step(st.x,right) * step(left, st.x); 54 | } else if(right < left){ 55 | y = step(st.x,left) * step(right, st.x); 56 | } 57 | float x; 58 | if(top>bottom){ 59 | x = step(st.y, top) * step(bottom, st.y); 60 | } else if(top < bottom){ 61 | x = step(st.y, bottom) * step(top, st.y); 62 | 63 | } 64 | 65 | vec3 color = vec3(y * x); 66 | 67 | gl_FragColor = vec4(color,1.0); 68 | } -------------------------------------------------------------------------------- /ISF/04_SmoothStep.fs: -------------------------------------------------------------------------------- 1 | // #SaturdayShader Week 4 : SmoothStep 2 | // by Joseph Fiola (http://www.joefiola.com) 3 | // 2015-09-12 4 | // Based on the "SmoothStep" example by Patricio Gonzalez Vivo on http://patriciogonzalezvivo.com/2015/thebookofshaders/05/ 5 | 6 | /*{ 7 | "CREDIT": "Joseph Fiola", 8 | "DESCRIPTION": "", 9 | "CATEGORIES": [ 10 | "Generator", "Lines", "Gradients" 11 | ], 12 | "INPUTS": [ 13 | { 14 | "NAME": "invertColors", 15 | "TYPE": "float", 16 | "DEFAULT": 0.0, 17 | "MIN": 0.0, 18 | "MAX": 1.0 19 | }, 20 | { 21 | "NAME": "left", 22 | "TYPE": "float", 23 | "DEFAULT": 0.0, 24 | "MIN": 0.0, 25 | "MAX": 1.0 26 | }, 27 | { 28 | "NAME": "right", 29 | "TYPE": "float", 30 | "DEFAULT": 1.0, 31 | "MIN": 0.0, 32 | "MAX": 1.0 33 | }, 34 | { 35 | "NAME": "peak", 36 | "TYPE": "float", 37 | "DEFAULT": 0.5, 38 | "MIN": 0.0, 39 | "MAX": 1.0 40 | }, 41 | { 42 | "NAME": "topGradient", 43 | "TYPE": "float", 44 | "DEFAULT": 0.01, 45 | "MIN": 0.0, 46 | "MAX": 1.0 47 | }, 48 | { 49 | "NAME": "bottomGradient", 50 | "TYPE": "float", 51 | "DEFAULT": 0.1, 52 | "MIN": 0.0, 53 | "MAX": 1.0 54 | } 55 | ] 56 | } 57 | */ 58 | 59 | #ifdef GL_ES 60 | precision mediump float; 61 | #endif 62 | 63 | 64 | float plot(vec2 st, float pct){ 65 | return smoothstep( pct-bottomGradient, pct, st.y) - 66 | smoothstep( pct, pct+topGradient, st.y); 67 | } 68 | 69 | void main() { 70 | 71 | vec2 st = gl_FragCoord.xy/RENDERSIZE; 72 | 73 | // Smooth interpolation between 0.1 and 0.9 74 | float y = smoothstep(left,0.0+peak,st.x) - smoothstep(1.0-peak,right,st.x); 75 | 76 | vec3 color = vec3(0.0 + invertColors); // background color 77 | float pct = plot(st,y); //plot the line 78 | color = (1.0-pct)*color+pct*vec3(1.0-invertColors); 79 | 80 | gl_FragColor = vec4(color,1.0); 81 | } -------------------------------------------------------------------------------- /ISF/05_PetalBlob.fs: -------------------------------------------------------------------------------- 1 | // #SaturdayShader Week 5 : PetalBlob 2 | // by Joseph Fiola (http://www.joefiola.com) 3 | // 2015-09-12 4 | // Based on Polar Shapes example by Patricio Gonzalez Vivo on http://patriciogonzalezvivo.com/2015/thebookofshaders/07/ 5 | 6 | 7 | /*{ 8 | "CREDIT": "Joseph Fiola", 9 | "DESCRIPTION": "", 10 | "CATEGORIES": [ 11 | "Generator", "Blobs", "Shapes" 12 | ], 13 | "INPUTS": [ 14 | 15 | { 16 | "NAME": "radius", 17 | "TYPE": "float", 18 | "DEFAULT": 1.0, 19 | "MIN": 0.0, 20 | "MAX": 20.0 21 | }, 22 | { 23 | "NAME": "speed", 24 | "TYPE": "float", 25 | "DEFAULT": 1.0, 26 | "MIN": 0.0, 27 | "MAX": 20.0 28 | }, 29 | { 30 | "NAME": "inner", 31 | "TYPE": "float", 32 | "DEFAULT": 0.3, 33 | "MIN": 0.0, 34 | "MAX": 1.0 35 | }, 36 | { 37 | "NAME": "outer", 38 | "TYPE": "float", 39 | "DEFAULT": 1.0, 40 | "MIN": 0.0, 41 | "MAX": 1.0 42 | }, 43 | { 44 | "NAME": "sinValue", 45 | "TYPE": "float", 46 | "DEFAULT": -50.0, 47 | "MIN": -50.0, 48 | "MAX": 50.0 49 | }, 50 | { 51 | "NAME": "cosValue", 52 | "TYPE": "float", 53 | "DEFAULT": 50.0, 54 | "MIN": -50.0, 55 | "MAX": 50.0 56 | }, 57 | { 58 | "NAME": "fade", 59 | "TYPE": "float", 60 | "DEFAULT": 0.5, 61 | "MIN": 0.0, 62 | "MAX": 2.0 63 | }, 64 | { 65 | "NAME": "location", 66 | "TYPE": "point2D", 67 | "DEFAULT": [ 68 | 0, 69 | 0 70 | ], 71 | "MIN": [ 72 | 0, 73 | 0 74 | ], 75 | "MAX": [ 76 | 1, 77 | 1 78 | ] 79 | }, 80 | { 81 | "NAME": "pinchPoint", 82 | "TYPE": "point2D", 83 | "DEFAULT": [ 84 | 0, 85 | 0 86 | ], 87 | "MIN": [ 88 | -1, 89 | -1 90 | ], 91 | "MAX": [ 92 | 1, 93 | 1 94 | ] 95 | } 96 | ] 97 | } 98 | */ 99 | 100 | #ifdef GL_ES 101 | precision mediump float; 102 | #endif 103 | 104 | 105 | void main(){ 106 | vec2 st = gl_FragCoord.xy/RENDERSIZE; 107 | vec3 color = vec3(0.0); 108 | 109 | vec2 pos = location - st; ///RENDERSIZE-st; 110 | 111 | float r = length(pos)*(radius); // radius 112 | float a = atan(pos.y+pinchPoint.y,pos.x+pinchPoint.x); 113 | 114 | 115 | float mSpeed = speed * TIME; 116 | 117 | float f = abs(cos(a*cosValue + mSpeed)*sin(a*sinValue+mSpeed)) *outer+inner; 118 | 119 | 120 | color = vec3( 1.-smoothstep(f,f+fade,r) ); 121 | gl_FragColor = vec4(color, 1.0); 122 | } -------------------------------------------------------------------------------- /ISF/06_GradientCheck.fs: -------------------------------------------------------------------------------- 1 | // #SaturdayShader Week 6 : GradientCheck 2 | // by Joseph Fiola (http://www.joefiola.com) 3 | // 2015-09-26 4 | 5 | 6 | 7 | /*{ 8 | "CREDIT": "Joseph Fiola", 9 | "DESCRIPTION": "", 10 | "CATEGORIES": [ 11 | "Generator", "Gradients", "lines", "Shapes" 12 | ], 13 | "INPUTS": [ 14 | { 15 | "NAME": "gradient", 16 | "TYPE": "float", 17 | "DEFAULT": 0.0, 18 | "MIN": -1.0, 19 | "MAX": 1.0 20 | }, 21 | { 22 | "NAME": "gradientPosition", 23 | "TYPE": "point2D", 24 | "DEFAULT": [ 25 | 0.5, 26 | 0.5 27 | ], 28 | "MIN": [ 29 | 0.0, 30 | 0.0 31 | ], 32 | "MAX": [ 33 | 1.0, 34 | 1.0 35 | ] 36 | }, 37 | { 38 | "NAME": "whiteframeTopRight", 39 | "TYPE": "point2D", 40 | "DEFAULT": [ 41 | 0.8, 42 | 0.8 43 | ], 44 | "MIN": [ 45 | 0.0, 46 | 0.0 47 | ], 48 | "MAX": [ 49 | 1.0, 50 | 1.0 51 | ] 52 | }, 53 | { 54 | "NAME": "whiteframeBottomLeft", 55 | "TYPE": "point2D", 56 | "DEFAULT": [ 57 | 0.2, 58 | 0.2 59 | ], 60 | "MIN": [ 61 | 0.0, 62 | 0.0 63 | ], 64 | "MAX": [ 65 | 1.0, 66 | 1.0 67 | ] 68 | }, 69 | { 70 | "NAME": "blackframeTopRight", 71 | "TYPE": "point2D", 72 | "DEFAULT": [ 73 | 0.9, 74 | 0.9 75 | ], 76 | "MIN": [ 77 | 0.0, 78 | 0.0 79 | ], 80 | "MAX": [ 81 | 1.0, 82 | 1.0 83 | ] 84 | }, 85 | { 86 | "NAME": "blackframeBottomLeft", 87 | "TYPE": "point2D", 88 | "DEFAULT": [ 89 | 0.1, 90 | 0.1 91 | ], 92 | "MIN": [ 93 | 0.0, 94 | 0.0 95 | ], 96 | "MAX": [ 97 | 1.0, 98 | 1.0 99 | ] 100 | }, 101 | { 102 | "NAME": "checkerframeTopRight", 103 | "TYPE": "point2D", 104 | "DEFAULT": [ 105 | 0.7, 106 | 0.7 107 | ], 108 | "MIN": [ 109 | 0.0, 110 | 0.0 111 | ], 112 | "MAX": [ 113 | 1.0, 114 | 1.0 115 | ] 116 | }, 117 | { 118 | "NAME": "checkerframeBottomLeft", 119 | "TYPE": "point2D", 120 | "DEFAULT": [ 121 | 0.3, 122 | 0.3 123 | ], 124 | "MIN": [ 125 | 0.0, 126 | 0.0 127 | ], 128 | "MAX": [ 129 | 1.0, 130 | 1.0 131 | ] 132 | }, 133 | { 134 | "NAME": "checkerColorLeft", 135 | "TYPE": "float", 136 | "DEFAULT": 0.8, 137 | "MIN": 0.0, 138 | "MAX": 1.0 139 | }, 140 | { 141 | "NAME": "checkerColorRight", 142 | "TYPE": "float", 143 | "DEFAULT": 0.2, 144 | "MIN": 0.0, 145 | "MAX": 1.0 146 | }, 147 | { 148 | "NAME": "invert", 149 | "TYPE": "bool", 150 | "DEFAULT": 0.0 151 | } 152 | ] 153 | }*/ 154 | 155 | 156 | #ifdef GL_ES 157 | precision mediump float; 158 | #endif 159 | 160 | 161 | 162 | void main(){ 163 | vec2 st = gl_FragCoord.xy/RENDERSIZE; 164 | float pct = 0.0; 165 | 166 | 167 | 168 | // draw gradient based on distance 169 | pct = distance(st,vec2(gradientPosition)) + gradient; 170 | 171 | 172 | 173 | //draw inner white frame 174 | //bottom-left 175 | vec2 bl = step(vec2(whiteframeBottomLeft),st); 176 | pct /= bl.x * bl.y; 177 | // top-right 178 | vec2 tr = step(vec2(whiteframeTopRight * -1.0 + 1.0),1.0-st); 179 | pct /= tr.x * tr.y; 180 | 181 | //draw black frame 182 | //bottom-left 183 | bl = step(vec2(blackframeBottomLeft),st); 184 | pct *= bl.x * bl.y; 185 | // top-right 186 | tr = step(vec2(blackframeTopRight * -1.0 + 1.0),1.0-st); 187 | pct *= tr.x * tr.y; 188 | 189 | 190 | //draw checker frame 191 | //bottom-left 192 | bl = step(vec2(checkerframeBottomLeft),st); 193 | bl += checkerColorLeft; 194 | pct *= bl.x * bl.y; 195 | // top-right 196 | tr = step(vec2(checkerframeTopRight * -1.0 + 1.0),1.0-st); 197 | tr += checkerColorRight; 198 | pct *= tr.x * tr.y; 199 | 200 | 201 | 202 | vec3 color = vec3(pct); 203 | 204 | // invert colors 205 | if (invert) 206 | {color = vec3(pct *-1.0 + 1.0);} 207 | 208 | gl_FragColor = vec4( color, 1.0 ); 209 | } -------------------------------------------------------------------------------- /ISF/07_GradientEdges.fs: -------------------------------------------------------------------------------- 1 | // #SaturdayShader Week 7 : GradientEdges 2 | // by Joseph Fiola (http://www.joefiola.com) 3 | // 2015-10-03 4 | // Based on Combining Powers example by Patricio Gonzalez Vivo on http://patriciogonzalezvivo.com/2015/thebookofshaders/07/ 5 | 6 | 7 | 8 | 9 | /*{ 10 | "CREDIT": "Joseph Fiola", 11 | "DESCRIPTION": "", 12 | "CATEGORIES": [ 13 | "Generator", "Gradients", "lines", "Shapes" 14 | ], 15 | "INPUTS": [ 16 | { 17 | "NAME": "sides", 18 | "TYPE": "float", 19 | "DEFAULT": 3.0, 20 | "MIN": 0.0, 21 | "MAX": 20.0 22 | }, 23 | { 24 | "NAME": "gradient", 25 | "TYPE": "float", 26 | "DEFAULT": 0.0, 27 | "MIN": -1.0, 28 | "MAX": 1.0 29 | }, 30 | { 31 | "NAME": "gradientRadius", 32 | "TYPE": "float", 33 | "DEFAULT": 0.4, 34 | "MIN": -1.0, 35 | "MAX": 1.0 36 | }, 37 | { 38 | "NAME": "teeth", 39 | "TYPE": "float", 40 | "DEFAULT": 0.5, 41 | "MIN": 0.0, 42 | "MAX": 1.0 43 | }, 44 | { 45 | "NAME": "warpX", 46 | "TYPE": "float", 47 | "DEFAULT": 1.0, 48 | "MIN": 0.0, 49 | "MAX": 20.0 50 | }, 51 | { 52 | "NAME": "warpY", 53 | "TYPE": "float", 54 | "DEFAULT": 1.0, 55 | "MIN": 0.0, 56 | "MAX": 20.0 57 | }, 58 | { 59 | "NAME": "warpPosition", 60 | "TYPE": "point2D", 61 | "DEFAULT": [ 62 | 0.0, 63 | 0.0 64 | ], 65 | "MIN": [ 66 | -1.0, 67 | -1.0 68 | ], 69 | "MAX": [ 70 | 1.0, 71 | 1.0 72 | ] 73 | }, 74 | { 75 | "NAME": "pos", 76 | "TYPE": "point2D", 77 | "DEFAULT": [ 78 | 1.0, 79 | 1.0 80 | ], 81 | "MIN": [ 82 | 0.0, 83 | 0.0 84 | ], 85 | "MAX": [ 86 | 2.0, 87 | 2.0 88 | ] 89 | } 90 | ] 91 | }*/ 92 | 93 | #ifdef GL_ES 94 | precision mediump float; 95 | #endif 96 | 97 | #define PI 3.14159265359 98 | #define TWO_PI 6.28318530718 99 | 100 | 101 | // Reference to 102 | // http://thndl.com/square-shaped-shaders.html 103 | 104 | void main(){ 105 | vec2 st = gl_FragCoord.xy/RENDERSIZE.xy; 106 | // st.x *= RENDERSIZE.x/RENDERSIZE.y; 107 | vec3 color = vec3(0.0); 108 | float d = 0.0; 109 | 110 | // Remap the space to -1. to 1. 111 | st = st *2.-pos; 112 | 113 | // Number of sides of your shape 114 | int N = int(sides); 115 | 116 | // Angle and radius from the current pixel 117 | float a = atan(st.x*warpX,st.y*warpY)+PI; 118 | float r = TWO_PI/float(N); 119 | 120 | 121 | // Shaping function that modulate the distance 122 | d = cos(floor(teeth+a/r)*r-a)*length(st+warpPosition *-1.); 123 | 124 | color = vec3(1.0-smoothstep(-gradient+gradientRadius,gradient+gradientRadius,d)); 125 | // color = vec3(d); 126 | 127 | gl_FragColor = vec4(color,1.0); 128 | } -------------------------------------------------------------------------------- /ISF/08_TilePattern.fs: -------------------------------------------------------------------------------- 1 | // #SaturdayShader Week 7 : GradientEdges 2 | // by Joseph Fiola (http://www.joefiola.com) 3 | // 2015-10-03 4 | // Based on Apply Matrices Inside Patterns example by Patricio Gonzalez Vivo on http://patriciogonzalezvivo.com/2015/thebookofshaders/09/ 5 | // Author @patriciogv ( patriciogonzalezvivo.com ) - 2015 6 | 7 | 8 | 9 | /*{ 10 | "CREDIT": "Joseph Fiola", 11 | "DESCRIPTION": "", 12 | "CATEGORIES": [ 13 | "Generator", "Patterns", "Squares" 14 | ], 15 | "INPUTS": [ 16 | { 17 | "NAME": "Rotate", 18 | "TYPE": "float", 19 | "DEFAULT": 0.25, 20 | "MIN": 0.0, 21 | "MAX": 2.0 22 | }, 23 | { 24 | "NAME": "Offset", 25 | "TYPE": "float", 26 | "DEFAULT": 0.5, 27 | "MIN": 0.0, 28 | "MAX": 2.0 29 | }, 30 | { 31 | "NAME": "Tiles", 32 | "TYPE": "float", 33 | "DEFAULT": 4.0, 34 | "MIN": -20.0, 35 | "MAX": 20.0 36 | }, 37 | { 38 | "NAME": "pos", 39 | "TYPE": "point2D", 40 | "DEFAULT": [ 41 | 0.5, 42 | 0.5 43 | ], 44 | "MIN": [ 45 | 0.0, 46 | 0.0 47 | ], 48 | "MAX": [ 49 | 1.0, 50 | 1.0 51 | ] 52 | } 53 | ] 54 | }*/ 55 | 56 | 57 | #ifdef GL_ES 58 | precision mediump float; 59 | #endif 60 | 61 | 62 | 63 | #define PI 3.14159265358979323846 64 | 65 | vec2 rotate2D(vec2 _st, float _angle){ 66 | _st -= pos; 67 | _st = mat2(cos(_angle),-sin(_angle), 68 | sin(_angle),cos(_angle)) * _st; 69 | _st += Offset; 70 | return _st; 71 | } 72 | 73 | vec2 tile(vec2 _st, float _zoom){ 74 | _st *= _zoom; 75 | return fract(_st); 76 | } 77 | 78 | float box(vec2 _st, vec2 _size, float _smoothEdges){ 79 | _size = vec2(0.5)-_size*0.5; 80 | vec2 aa = vec2(_smoothEdges*0.5); 81 | vec2 uv = smoothstep(_size,_size+aa,_st); 82 | uv *= smoothstep(_size,_size+aa,vec2(2.0)-_st); 83 | return uv.x*uv.y; 84 | } 85 | 86 | void main(void){ 87 | vec2 st = gl_FragCoord.xy/RENDERSIZE.xy; 88 | vec3 color = vec3(0.0); 89 | 90 | // Divide the space in 4 91 | st = tile(st,Tiles); 92 | 93 | // Use a matrix to rotate the space 45 degrees 94 | st = rotate2D(st,PI*Rotate); 95 | 96 | // Draw a square 97 | color = vec3(box(st,vec2(0.7),0.01)); 98 | // color = vec3(st,0.0); 99 | 100 | gl_FragColor = vec4(color,1.0); 101 | } -------------------------------------------------------------------------------- /ISF/09_RotatingCirclePatterns.fs: -------------------------------------------------------------------------------- 1 | // SaturdayShader Week 9 : RotatingCirclePatterns 2 | // by Joseph Fiola (http://www.joefiola.com) 3 | // 2015-10-17 4 | // 5 | // Based on a combination of Patricio Gonzalez Vivo's Patterns examples on http://patriciogonzalezvivo.com/2015/thebookofshaders/09/ 6 | // and Matrices examples http://patriciogonzalezvivo.com/2015/thebookofshaders/08/ @patriciogv ( patriciogonzalezvivo.com ) - 2015 7 | 8 | 9 | 10 | /*{ 11 | "CREDIT": "Joseph Fiola", 12 | "DESCRIPTION": "", 13 | "CATEGORIES": [ 14 | "Generator", "Patterns", "Circles" 15 | ], 16 | "INPUTS": [ 17 | 18 | { 19 | "NAME": "invert", 20 | "TYPE": "bool", 21 | "DEFAULT": 0.0 22 | }, 23 | { 24 | "NAME": "rotate", 25 | "TYPE": "float", 26 | "DEFAULT": 0.25, 27 | "MIN": 0.0, 28 | "MAX": 2.0 29 | }, 30 | { 31 | "NAME": "circulateCanvas", 32 | "TYPE": "float", 33 | "DEFAULT": 0.5, 34 | "MIN": 0.0, 35 | "MAX": 2.0 36 | }, 37 | { 38 | "NAME": "circulateCanvasAmplitude", 39 | "TYPE": "float", 40 | "DEFAULT": 0.1, 41 | "MIN": 0.0, 42 | "MAX": 20.0 43 | }, 44 | { 45 | "NAME": "circulateTile", 46 | "TYPE": "float", 47 | "DEFAULT": 0.5, 48 | "MIN": 0.0, 49 | "MAX": 20.0 50 | }, 51 | { 52 | "NAME": "circulateTileAmplitude", 53 | "TYPE": "float", 54 | "DEFAULT": 0.2, 55 | "MIN": 0.0, 56 | "MAX": 2.0 57 | }, 58 | { 59 | "NAME": "tiles", 60 | "TYPE": "float", 61 | "DEFAULT": 3.0, 62 | "MIN": 0.0, 63 | "MAX": 100.0 64 | }, 65 | { 66 | "NAME": "radius", 67 | "TYPE": "float", 68 | "DEFAULT": 4.0, 69 | "MIN": 1.0, 70 | "MAX": 20.0 71 | }, 72 | { 73 | "NAME": "gradient", 74 | "TYPE": "float", 75 | "DEFAULT": 0.03, 76 | "MIN": 0.0, 77 | "MAX": 50.0 78 | }, 79 | { 80 | "NAME": "pos", 81 | "TYPE": "point2D", 82 | "DEFAULT": [ 83 | 0.5, 84 | 0.5 85 | ], 86 | "MIN": [ 87 | 0.0, 88 | 0.0 89 | ], 90 | "MAX": [ 91 | 1.0, 92 | 1.0 93 | ] 94 | } 95 | ] 96 | }*/ 97 | 98 | #ifdef GL_ES 99 | precision mediump float; 100 | #endif 101 | 102 | #define PI 3.14159265359 103 | 104 | uniform vec2 u_resolution; 105 | uniform float u_time; 106 | 107 | float circle(in vec2 _st, in float _radius){ 108 | vec2 l = _st-vec2(0.5); 109 | return 1.-smoothstep(_radius-(_radius*gradient), 110 | _radius+(_radius*gradient), 111 | dot(l,l)*radius); 112 | } 113 | 114 | mat2 rotate2d(float _angle){ 115 | return mat2(cos(_angle),-sin(_angle), 116 | sin(_angle),cos(_angle)); 117 | } 118 | 119 | void main() { 120 | vec2 st = gl_FragCoord.xy/RENDERSIZE; 121 | st -= vec2(pos); // move the origin - vec2(0.5) to center 122 | st.x *= RENDERSIZE.x/RENDERSIZE.y; // make things 1:1 ratio regardless of canvas ratio 123 | 124 | vec3 color = vec3(0.0); // instantiate color variable 125 | 126 | 127 | //translate canvas 128 | vec2 translate = vec2(cos(circulateCanvas*PI),sin(circulateCanvas*PI)); 129 | st += translate*circulateCanvasAmplitude; 130 | 131 | //rotate canvas 132 | st = rotate2d(rotate*PI ) * st; 133 | 134 | //tile pattern 135 | st *= tiles; // Scale up the space by 3 136 | st = fract(st); // Wrap arround 1.0 137 | 138 | // translate within tile 139 | translate = vec2(cos(circulateTile),sin(circulateTile)); 140 | st += translate*circulateTileAmplitude; 141 | 142 | 143 | color = vec3(st,0.0); 144 | color = vec3(circle(st,0.5)); 145 | 146 | // invert colors 147 | if (invert) 148 | color = vec3(color *-1.0 + 1.0); 149 | 150 | 151 | gl_FragColor = vec4(color,1.0); 152 | } -------------------------------------------------------------------------------- /ISF/10_RotatingSquarePatterns.fs: -------------------------------------------------------------------------------- 1 | // SaturdayShader Week 10 : RotatingSquarePatterns 2 | // by Joseph Fiola (http://www.joefiola.com) 3 | // 2015-10-24 4 | 5 | // Based on Patricio Gonzalez Vivo's "Apply Matrices Inside Patterns" example 6 | // on http://patriciogonzalezvivo.com/2015/thebookofshaders/09/ @patriciogv ( patriciogonzalezvivo.com ) - 2015 7 | 8 | 9 | 10 | /*{ 11 | "CREDIT": "Joseph Fiola", 12 | "DESCRIPTION": "", 13 | "CATEGORIES": [ 14 | "Generator", "Patterns", "Boxes" 15 | ], 16 | "INPUTS": [ 17 | 18 | { 19 | "NAME": "invert", 20 | "TYPE": "bool", 21 | "DEFAULT": 0.0 22 | }, 23 | { 24 | "NAME": "blur1", 25 | "TYPE": "float", 26 | "DEFAULT": 0.01, 27 | "MIN": 0.01, 28 | "MAX": 0.75 29 | }, 30 | { 31 | "NAME": "blur2", 32 | "TYPE": "float", 33 | "DEFAULT": 0.01, 34 | "MIN": 0.01, 35 | "MAX": 3.0 36 | }, 37 | { 38 | "NAME": "rotate1", 39 | "TYPE": "float", 40 | "DEFAULT": 0.25, 41 | "MIN": 0.0, 42 | "MAX": 1.0 43 | }, 44 | { 45 | "NAME": "rotate2", 46 | "TYPE": "float", 47 | "DEFAULT": 0.25, 48 | "MIN": 0.0, 49 | "MAX": 1.0 50 | }, 51 | { 52 | "NAME": "tile1", 53 | "TYPE": "float", 54 | "DEFAULT": 3.0, 55 | "MIN": 0.0, 56 | "MAX": 50.0 57 | }, 58 | { 59 | "NAME": "tile2", 60 | "TYPE": "float", 61 | "DEFAULT": 3.0, 62 | "MIN": 0.0, 63 | "MAX": 50.0 64 | }, 65 | { 66 | "NAME": "xScale1", 67 | "TYPE": "float", 68 | "DEFAULT": 0.5, 69 | "MIN": 0.0, 70 | "MAX": 1.0 71 | }, 72 | { 73 | "NAME": "yScale1", 74 | "TYPE": "float", 75 | "DEFAULT": 0.5, 76 | "MIN": 0.0, 77 | "MAX": 1.0 78 | }, 79 | { 80 | "NAME": "xScale2", 81 | "TYPE": "float", 82 | "DEFAULT": 0.5, 83 | "MIN": 0.0, 84 | "MAX": 1.0 85 | }, 86 | { 87 | "NAME": "yScale2", 88 | "TYPE": "float", 89 | "DEFAULT": 0.5, 90 | "MIN": 0.0, 91 | "MAX": 1.0 92 | }, 93 | 94 | 95 | { 96 | "NAME": "pos", 97 | "TYPE": "point2D", 98 | "DEFAULT": [ 99 | 0.5, 100 | 0.5 101 | ], 102 | "MIN": [ 103 | 0.0, 104 | 0.0 105 | ], 106 | "MAX": [ 107 | 1.0, 108 | 1.0 109 | ] 110 | } 111 | ] 112 | }*/ 113 | 114 | #ifdef GL_ES 115 | precision mediump float; 116 | #endif 117 | 118 | 119 | #define PI 3.14159265358979323846 120 | 121 | vec2 rotate2D(vec2 _st, float _angle){ 122 | _st -= 0.5; 123 | _st = mat2(cos(_angle),-sin(_angle), 124 | sin(_angle),cos(_angle)) * _st; 125 | _st += 0.5; 126 | return _st; 127 | } 128 | 129 | vec2 tile(vec2 _st, float _zoom){ 130 | _st *= _zoom; 131 | return fract(_st); 132 | } 133 | 134 | float box(vec2 _st, vec2 _size, float _smoothEdges){ 135 | _size = vec2(0.5)-_size*0.5; 136 | vec2 aa = vec2(_smoothEdges*0.5); 137 | vec2 uv = smoothstep(_size,_size+aa,_st); 138 | uv *= smoothstep(_size,_size+aa,vec2(1.0)-_st); 139 | return uv.x*uv.y; 140 | } 141 | 142 | 143 | void main(void){ 144 | vec2 st = gl_FragCoord.xy/RENDERSIZE.xy; 145 | st -= vec2(pos); // move the origin - vec2(0.5) will center it 146 | st.x *= RENDERSIZE.x/RENDERSIZE.y; // make things 1:1 ratio regardless of canvas ratio 147 | vec3 color = vec3(0.0); // instantiate color variable 148 | 149 | // Divide the space 150 | st = tile(st,tile1); 151 | 152 | // Use a matrix to rotate the space 45 degrees 153 | st = rotate2D(st,PI*rotate1); 154 | 155 | // Draw a square 156 | color = vec3(box(st,vec2(xScale1,yScale1),blur1)); 157 | 158 | //Second set of squares 159 | // Center second set of squares 160 | st -= vec2(0.5); 161 | 162 | st = tile(st,tile2); 163 | 164 | st = rotate2D(st,PI*rotate2); 165 | color += vec3(box(st,vec2(xScale2, yScale2),blur2)); 166 | 167 | 168 | // invert colors 169 | if (invert) 170 | {color = vec3(color *-1.0 + 1.0);} 171 | 172 | gl_FragColor = vec4(color,1.0); 173 | } -------------------------------------------------------------------------------- /ISF/11_Bricked.fs: -------------------------------------------------------------------------------- 1 | // SaturdayShader Week 11 : Bricked 2 | // by Joseph Fiola (http://www.joefiola.com) 3 | // 2015-10-31 4 | 5 | // Based on Patricio Gonzalez Vivo's "Apply Matrices Inside Patterns" example 6 | // on http://patriciogonzalezvivo.com/2015/thebookofshaders/09/ @patriciogv ( patriciogonzalezvivo.com ) - 2015 7 | 8 | 9 | 10 | 11 | /*{ 12 | "CREDIT": "Joseph Fiola", 13 | "DESCRIPTION": "", 14 | "CATEGORIES": [ 15 | "Generator", "Patterns", "Squares", "Warp" 16 | ], 17 | "INPUTS": [ 18 | 19 | { 20 | "NAME": "invert", 21 | "TYPE": "bool", 22 | "DEFAULT": 0.0 23 | }, 24 | { 25 | "NAME": "tile", 26 | "TYPE": "float", 27 | "DEFAULT": 50.0, 28 | "MIN": 0.0, 29 | "MAX": 50.0 30 | }, 31 | { 32 | "NAME": "offset", 33 | "TYPE": "float", 34 | "DEFAULT": 0.5, 35 | "MIN": 0.0, 36 | "MAX": 1.0 37 | }, 38 | { 39 | "NAME": "strokeWidth", 40 | "TYPE": "float", 41 | "DEFAULT": 0.9, 42 | "MIN": 0.0, 43 | "MAX": 0.99 44 | }, 45 | { 46 | "NAME": "gradient", 47 | "TYPE": "float", 48 | "DEFAULT": 1e-4, 49 | "MIN": 1e-4, 50 | "MAX": 0.5 51 | }, 52 | { 53 | "NAME": "evenRows", 54 | "TYPE": "float", 55 | "DEFAULT": 1.0, 56 | "MIN": 0.0, 57 | "MAX": 5.0 58 | }, 59 | { 60 | "NAME": "oddRows", 61 | "TYPE": "float", 62 | "DEFAULT": 2.0, 63 | "MIN": 0.0, 64 | "MAX": 5.0 65 | }, 66 | { 67 | "NAME": "rotate", 68 | "TYPE": "float", 69 | "DEFAULT": 0.5, 70 | "MIN": 0.0, 71 | "MAX": 1.0 72 | }, 73 | { 74 | "NAME": "warp", 75 | "TYPE": "float", 76 | "DEFAULT": 1.0, 77 | "MIN": 0.0, 78 | "MAX": 2.0 79 | }, 80 | { 81 | "NAME": "pos", 82 | "TYPE": "point2D", 83 | "DEFAULT": [ 84 | 0.5, 85 | 0.5 86 | ], 87 | "MIN": [ 88 | 0.0, 89 | 0.0 90 | ], 91 | "MAX": [ 92 | 1.0, 93 | 1.0 94 | ] 95 | } 96 | ] 97 | }*/ 98 | 99 | 100 | 101 | #ifdef GL_ES 102 | precision mediump float; 103 | #endif 104 | 105 | #define PI 3.14159265358979323846 106 | 107 | vec2 rotate2D(vec2 _st, float _angle){ 108 | _st -= 0.5; 109 | _st = mat2(cos(_angle),-sin(_angle), 110 | sin(_angle),cos(_angle)) * _st; 111 | _st += 0.5; 112 | return _st; 113 | } 114 | 115 | 116 | vec2 brickTile(vec2 _st, float _zoom){ 117 | _st *= _zoom; 118 | 119 | // Here is where the offset is happening 120 | _st.x += step(evenRows, mod(_st.y,oddRows)) * offset; 121 | 122 | return fract(_st); 123 | } 124 | 125 | float box(vec2 _st, vec2 _size){ 126 | _size = vec2(0.5)-_size*0.5; 127 | vec2 uv = smoothstep(_size,_size+vec2(gradient),_st); 128 | uv *= smoothstep(_size,_size+vec2(gradient),vec2(1.0)-_st); 129 | return uv.x*uv.y; 130 | } 131 | 132 | void main(void){ 133 | vec2 st = gl_FragCoord.xy/RENDERSIZE; 134 | vec3 color = vec3(0.0); 135 | 136 | st *= rotate2D(st,PI*warp); 137 | 138 | st -= vec2(pos); // move the origin - vec2(0.5) will center it 139 | st.x *= RENDERSIZE.x/RENDERSIZE.y; // make things 1:1 ratio regardless of canvas ratio 140 | 141 | // Apply the brick tiling 142 | st = brickTile(st,tile); 143 | 144 | st = rotate2D(st,PI*rotate); 145 | 146 | color = vec3(box(st,vec2(strokeWidth))); 147 | 148 | // invert colors 149 | if (invert) 150 | {color = vec3(color *-1.0 + 1.0);} 151 | 152 | gl_FragColor = vec4(color,1.0); 153 | } -------------------------------------------------------------------------------- /ISF/12_TruchetTiles.fs: -------------------------------------------------------------------------------- 1 | // SaturdayShader Week 12 : Truchet Tiles 2 | // by Joseph Fiola (http://www.joefiola.com) 3 | // 2015-11-07 4 | 5 | // Based on Patricio Gonzalez Vivo's "Truchet Tiles" example 6 | // on http://patriciogonzalezvivo.com/2015/thebookofshaders/09/ @patriciogv ( patriciogonzalezvivo.com ) - 2015 7 | 8 | /*{ 9 | "CREDIT": "Joseph Fiola", 10 | "DESCRIPTION": "", 11 | "CATEGORIES": [ 12 | "Generator", "Patterns", "Tiles" 13 | ], 14 | "INPUTS": [ 15 | { 16 | "NAME": "pos", 17 | "TYPE": "point2D", 18 | "DEFAULT": [ 19 | 0.5, 20 | 0.5 21 | ], 22 | "MIN": [ 23 | 0.0, 24 | 0.0 25 | ], 26 | "MAX": [ 27 | 1.0, 28 | 1.0 29 | ] 30 | }, 31 | { 32 | "NAME": "scale", 33 | "TYPE": "float", 34 | "DEFAULT": 2.0, 35 | "MIN": 0.0, 36 | "MAX": 20.0 37 | }, 38 | { 39 | "NAME": "rotate", 40 | "TYPE": "float", 41 | "DEFAULT": 0.5, 42 | "MIN": 0.0, 43 | "MAX": 1.0 44 | }, 45 | { 46 | "NAME": "patternZoom", 47 | "TYPE": "float", 48 | "DEFAULT": 0.5, 49 | "MIN": 0.0, 50 | "MAX": 10.0 51 | }, 52 | { 53 | "NAME": "scalePos", 54 | "TYPE": "point2D", 55 | "DEFAULT": [ 56 | 0.5, 57 | 0.5 58 | ], 59 | "MIN": [ 60 | 0.0, 61 | 0.0 62 | ], 63 | "MAX": [ 64 | 1.0, 65 | 1.0 66 | ] 67 | }, 68 | { 69 | "NAME": "tiles", 70 | "TYPE": "float", 71 | "DEFAULT": 2.0, 72 | "MIN": 0.0, 73 | "MAX": 20.0 74 | } 75 | 76 | ] 77 | }*/ 78 | 79 | 80 | #ifdef GL_ES 81 | precision mediump float; 82 | #endif 83 | 84 | #define PI 3.14159265358979323846 85 | 86 | vec2 rotate2D (vec2 _st, float _angle) { 87 | _st -= 0.5; 88 | _st = mat2(cos(_angle),-sin(_angle), 89 | sin(_angle),cos(_angle)) * _st; 90 | _st += 0.5; 91 | return _st; 92 | } 93 | 94 | vec2 tile (vec2 _st, float _zoom) { 95 | _st *= _zoom; 96 | return fract(_st); 97 | } 98 | 99 | vec2 rotateTilePattern(vec2 _st){ 100 | 101 | // Scale the coordinate system by 2x2 102 | _st -=scalePos; 103 | _st *= scale; 104 | _st += scalePos; 105 | 106 | // Give each cell an index number 107 | // according to its position 108 | float index = 0.0; 109 | index += step(1., mod(_st.x,2.0)); 110 | index += step(1., mod(_st.y,2.0))*2.0; 111 | 112 | // Make each cell between 0.0 - 1.0 113 | _st = fract(_st); 114 | 115 | // Rotate each cell according to the index 116 | if(index == 1.0){ 117 | // Rotate cell 1 by 90 degrees 118 | _st = rotate2D(_st,PI*0.5); 119 | } else if(index == 2.0){ 120 | // Rotate cell 2 by -90 degrees 121 | _st = rotate2D(_st,PI*-0.5); 122 | } else if(index == 3.0){ 123 | // Rotate cell 3 by 180 degrees 124 | _st = rotate2D(_st,PI); 125 | } 126 | 127 | return _st; 128 | } 129 | 130 | void main (void) { 131 | vec2 st = gl_FragCoord.xy/RENDERSIZE.xy; 132 | 133 | st -= vec2(pos); 134 | st.x *= RENDERSIZE.x/RENDERSIZE.y; 135 | 136 | st = tile(st,tiles); 137 | st = rotateTilePattern(st); 138 | 139 | // Make more interesting combinations 140 | st = rotate2D(st,-PI*rotate*2.); 141 | st = rotateTilePattern(st*patternZoom); 142 | 143 | gl_FragColor = vec4(vec3(step(st.x,st.y)),1.0); 144 | } -------------------------------------------------------------------------------- /ISF/13_TiledFractPatterns.fs: -------------------------------------------------------------------------------- 1 | // SaturdayShader Week 13 : TiledFractPatterns 2 | // by Joseph Fiola (http://www.joefiola.com) 3 | // 2015-11-14 4 | 5 | // Based on Patricio Gonzalez Vivo's "2D Random" example on http://patriciogonzalezvivo.com/2015/thebookofshaders/10/ @patriciogv ( patriciogonzalezvivo.com ) - 2015 6 | // with elements from last week's "Truchet Tiles" added in for the tiled patterns and rotations. 7 | 8 | /*{ 9 | "CREDIT": "Joseph Fiola", 10 | "DESCRIPTION": "", 11 | "CATEGORIES": [ 12 | "Generator", "Patterns", "Tiles", "Random", "Noise" 13 | ], 14 | "INPUTS": [ 15 | { 16 | "NAME": "pos", 17 | "TYPE": "point2D", 18 | "DEFAULT": [ 19 | 0.5, 20 | 0.5 21 | ], 22 | "MIN": [ 23 | 0.0, 24 | 0.0 25 | ], 26 | "MAX": [ 27 | 1.0, 28 | 1.0 29 | ] 30 | }, 31 | { 32 | "NAME": "ScalePosition", 33 | "TYPE": "point2D", 34 | "DEFAULT": [ 35 | 0.5, 36 | 0.5 37 | ], 38 | "MIN": [ 39 | 0.0, 40 | 0.0 41 | ], 42 | "MAX": [ 43 | 1.0, 44 | 1.0 45 | ] 46 | }, 47 | 48 | { 49 | "NAME": "invert", 50 | "TYPE": "bool", 51 | "DEFAULT": 0.0 52 | }, 53 | { 54 | "NAME": "Random1", 55 | "TYPE": "float", 56 | "DEFAULT": 2.0, 57 | "MIN": -100.0, 58 | "MAX": 100.0 59 | }, 60 | { 61 | "NAME": "TileZoom", 62 | "TYPE": "float", 63 | "DEFAULT": 2.0, 64 | "MIN": 0.5, 65 | "MAX": 10.0 66 | }, 67 | { 68 | "NAME": "Tiles", 69 | "TYPE": "float", 70 | "DEFAULT": 2.0, 71 | "MIN": 0.5, 72 | "MAX": 10.0 73 | }, 74 | { 75 | "NAME": "Random2", 76 | "TYPE": "float", 77 | "DEFAULT": 2.0, 78 | "MIN": -100.0, 79 | "MAX": 100.0 80 | }, 81 | { 82 | "NAME": "Multiplyer", 83 | "TYPE": "float", 84 | "DEFAULT": 2.0, 85 | "MIN": -100.0, 86 | "MAX": 100.0 87 | }, 88 | { 89 | "NAME": "Repeat", 90 | "TYPE": "float", 91 | "DEFAULT": 2.0, 92 | "MIN": -10.0, 93 | "MAX": 10.0 94 | }, 95 | { 96 | "NAME": "Rotate", 97 | "TYPE": "float", 98 | "DEFAULT": 1.0, 99 | "MIN": -1.0, 100 | "MAX": 1.0 101 | } 102 | ] 103 | }*/ 104 | 105 | 106 | #ifdef GL_ES 107 | precision mediump float; 108 | #endif 109 | 110 | #define PI 3.14159265358979323846 111 | 112 | 113 | float random (vec2 st) { 114 | return fract(sin(dot(st.xy*Repeat, 115 | vec2(Random1,Random2)))* 116 | Multiplyer); 117 | } 118 | 119 | vec2 tile (vec2 _st, float _zoom) { 120 | _st *= _zoom; 121 | return fract(_st); 122 | } 123 | 124 | vec2 rotate2D (vec2 _st, float _angle) { 125 | // _st -= 0.5; 126 | _st = mat2(cos(_angle),-sin(_angle), 127 | sin(_angle),cos(_angle)) * _st; 128 | // _st += 0.5; 129 | return _st; 130 | } 131 | 132 | 133 | vec2 rotateTilePattern(vec2 _st){ 134 | 135 | // Scale the coordinate system by 2x2 136 | _st -=ScalePosition; 137 | _st *= TileZoom; 138 | _st += ScalePosition; 139 | 140 | // Give each cell an index number 141 | // according to its position 142 | float index = 0.0; 143 | index += step(1., mod(_st.x,2.0)); 144 | index += step(1., mod(_st.y,2.0))*2.0; 145 | 146 | // Make each cell between 0.0 - 1.0 147 | _st = fract(_st); 148 | 149 | // Rotate each cell according to the index 150 | if(index == 1.0){ 151 | // Rotate cell 1 by 90 degrees 152 | _st = rotate2D(_st,PI*0.5); 153 | } else if(index == 2.0){ 154 | // Rotate cell 2 by -90 degrees 155 | _st = rotate2D(_st,PI*-0.5); 156 | } else if(index == 3.0){ 157 | // Rotate cell 3 by 180 degrees 158 | _st = rotate2D(_st,PI); 159 | } 160 | 161 | return _st; 162 | } 163 | 164 | void main() { 165 | vec2 st = gl_FragCoord.xy/RENDERSIZE.xy; 166 | st -= vec2(pos); 167 | st.x *= RENDERSIZE.x/RENDERSIZE.y; 168 | 169 | 170 | st += tile(st,Tiles); 171 | st = rotateTilePattern(st); 172 | 173 | st = rotate2D(st,-PI*Rotate*2.); 174 | 175 | float rnd = random( st ); 176 | 177 | 178 | 179 | 180 | 181 | // invert colors 182 | if (invert) 183 | {rnd = rnd *-1.0 + 1.0;} 184 | 185 | gl_FragColor = vec4(vec3(rnd),1.0); 186 | } -------------------------------------------------------------------------------- /ISF/14_ControlledChaos.fs: -------------------------------------------------------------------------------- 1 | // SaturdayShader Week 14 : ControlledChaos 2 | // by Joseph Fiola (http://www.joefiola.com) 3 | // 2015-11-21 4 | // Based on Patricio Gonzalez Vivo's "Using the Chaos" example on http://patriciogonzalezvivo.com/2015/thebookofshaders/10/ @patriciogv ( patriciogonzalezvivo.com ) - 2015 5 | 6 | 7 | /*{ 8 | "CREDIT": "Joseph Fiola", 9 | "DESCRIPTION": "", 10 | "CATEGORIES": [ 11 | "Generator", "Patterns", "Random", "Noise" 12 | ], 13 | "INPUTS": [ 14 | { 15 | "NAME": "pos", 16 | "TYPE": "point2D", 17 | "DEFAULT": [ 18 | 0.5, 19 | 0.5 20 | ], 21 | "MIN": [ 22 | 0.0, 23 | 0.0 24 | ], 25 | "MAX": [ 26 | 1.0, 27 | 1.0 28 | ] 29 | }, 30 | { 31 | "NAME": "invert", 32 | "TYPE": "bool" 33 | }, 34 | { 35 | "NAME": "function", 36 | "TYPE": "long", 37 | "VALUES": [ 38 | 0, 39 | 1, 40 | 2, 41 | 3, 42 | 4, 43 | 5, 44 | 6, 45 | 7, 46 | 8 47 | ], 48 | "LABELS": [ 49 | "floor", 50 | "fract", 51 | "abs", 52 | "tan", 53 | "atan", 54 | "sin", 55 | "mod", 56 | "mod grid", 57 | "clamp" 58 | ], 59 | "DEFAULT": 8 60 | }, 61 | { 62 | "NAME": "speed", 63 | "TYPE": "float", 64 | "DEFAULT": 0.1, 65 | "MIN": -2.0, 66 | "MAX": 2.0 67 | }, 68 | { 69 | "NAME": "multiplier", 70 | "TYPE": "float", 71 | "DEFAULT": 0.1, 72 | "MIN": -2.0, 73 | "MAX": 2.0 74 | }, 75 | { 76 | "NAME": "grid", 77 | "TYPE": "float", 78 | "DEFAULT": 10.0, 79 | "MIN": 1e-4, 80 | "MAX": 20.0 81 | }, 82 | { 83 | "NAME": "detail", 84 | "TYPE": "float", 85 | "DEFAULT": 0.05, 86 | "MIN": 1e-4, 87 | "MAX": 0.1 88 | }, 89 | 90 | { 91 | "NAME": "contrast", 92 | "TYPE": "float", 93 | "DEFAULT": 0.0, 94 | "MIN": 0.0, 95 | "MAX": 0.5 96 | }, 97 | { 98 | "NAME": "contrastShift", 99 | "TYPE": "float", 100 | "DEFAULT": 0.0, 101 | "MIN": -0.5, 102 | "MAX": 0.5 103 | }, 104 | { 105 | "NAME": "mode", 106 | "TYPE": "long", 107 | "VALUES": [ 108 | 0, 109 | 1 110 | ], 111 | "LABELS": [ 112 | "clean", 113 | "noisy" 114 | ], 115 | "DEFAULT": 0 116 | } 117 | ] 118 | }*/ 119 | 120 | 121 | 122 | #ifdef GL_ES 123 | precision mediump float; 124 | #endif 125 | 126 | 127 | 128 | float random (vec2 st) { 129 | if (mode == 0) return sin(dot(st.xy + TIME*speed, vec2(12.9898, 78.233 * 2. *multiplier))) * 40.* 1.* detail; 130 | else if (mode == 1) return fract(sin(dot(st.xy + TIME*speed *0.0001, vec2(12.9898,78.233*2.*multiplier)))* 43758.5453123*1.* detail); 131 | } 132 | 133 | 134 | vec3 invertColor(vec3 color) { 135 | return vec3(color *-1.0 + 1.0); 136 | 137 | } 138 | 139 | 140 | void main() { 141 | vec2 st = gl_FragCoord.xy/RENDERSIZE.xy; 142 | st -= vec2(pos); 143 | st.x *= RENDERSIZE.x/RENDERSIZE.y; // 1:1 ratio 144 | 145 | 146 | st *= grid; // Scale the coordinate system 147 | 148 | 149 | vec2 ipos = st; 150 | if (function == 0) ipos = floor(st); 151 | else if (function == 1) ipos = fract(st); 152 | else if (function == 2) ipos = abs(st); 153 | else if (function == 3) ipos = tan(st); 154 | else if (function == 4) ipos = atan(st); 155 | else if (function == 5) ipos = sin(st); 156 | else if (function == 6) ipos = mod(st.xy, st.yx); 157 | else if (function == 7) ipos = mod(st.xy, st.xy); 158 | else if (function == 8) ipos = clamp(st.xy, vec2(-2.0 + multiplier), vec2(2.0 - multiplier)); 159 | 160 | 161 | 162 | vec2 fpos = fract(st); // get the fractional coords 163 | 164 | // Assign a random value based on the integer coord 165 | vec3 color = vec3(random(ipos)); 166 | 167 | 168 | //adjust contrast 169 | color = smoothstep(0.0+contrast+contrastShift,1.0-contrast+contrastShift, color); 170 | 171 | //invert colors 172 | if (invert) color = invertColor(color); 173 | 174 | gl_FragColor = vec4(color,1.0); 175 | } 176 | 177 | -------------------------------------------------------------------------------- /ISF/15_GoTo10.fs: -------------------------------------------------------------------------------- 1 | // SaturdayShader Week 15 : GOTO 10 2 | // by Joseph Fiola (http://www.joefiola.com) 3 | // 2015-11-28 4 | // Based on Patricio Gonzalez Vivo's "GOTO 10 Maze" example on http://patriciogonzalezvivo.com/2015/thebookofshaders/10/ @patriciogv ( patriciogonzalezvivo.com ) - 2015 5 | 6 | 7 | /*{ 8 | "CREDIT": "Joseph Fiola", 9 | "DESCRIPTION": "", 10 | "CATEGORIES": [ "Generator" ], 11 | "INPUTS": [ 12 | { 13 | "NAME": "pos", 14 | "TYPE": "point2D", 15 | "DEFAULT": [ 16 | 0.5, 17 | 0.5 18 | ], 19 | "MIN": [ 20 | 0.0, 21 | 0.0 22 | ], 23 | "MAX": [ 24 | 1.0, 25 | 1.0 26 | ] 27 | }, 28 | { 29 | "NAME": "invert", 30 | "TYPE": "bool" 31 | }, 32 | { 33 | "NAME": "pattern", 34 | "TYPE": "long", 35 | "VALUES": [ 36 | 0, 37 | 1, 38 | 2 39 | 40 | ], 41 | "LABELS": [ 42 | "Maze", 43 | "Circle", 44 | "Both" 45 | 46 | ], 47 | "DEFAULT": 0 48 | }, 49 | { 50 | "NAME": "zoom", 51 | "TYPE": "float", 52 | "DEFAULT": 2.0, 53 | "MIN": 0.5, 54 | "MAX": 100.0 55 | }, 56 | { 57 | "NAME": "gradient", 58 | "TYPE": "float", 59 | "DEFAULT": 0.3, 60 | "MIN": 0.01, 61 | "MAX": 2.0 62 | }, 63 | { 64 | "NAME": "gradientOffset", 65 | "TYPE": "float", 66 | "DEFAULT": 0.0, 67 | "MIN": -1.0, 68 | "MAX": 1.0 69 | }, 70 | { 71 | "NAME": "truchetPositionOffset", 72 | "TYPE": "float", 73 | "DEFAULT": 1.0, 74 | "MIN": 1e-4, 75 | "MAX": 2.0 76 | }, 77 | { 78 | "NAME": "truchetIndex", 79 | "TYPE": "float", 80 | "DEFAULT": 1.0, 81 | "MIN": 0.0, 82 | "MAX": 4.0 83 | }, 84 | { 85 | "NAME": "contrast", 86 | "TYPE": "float", 87 | "DEFAULT": 0.0, 88 | "MIN": 0.0, 89 | "MAX": 0.5 90 | }, 91 | { 92 | "NAME": "contrastShift", 93 | "TYPE": "float", 94 | "DEFAULT": 0.0, 95 | "MIN": -0.5, 96 | "MAX": 0.5 97 | }, 98 | { 99 | "NAME": "randomXspeed", 100 | "TYPE": "float", 101 | "DEFAULT": 0.0, 102 | "MIN": -5.0, 103 | "MAX": 5.0 104 | }, 105 | { 106 | "NAME": "randomYspeed", 107 | "TYPE": "float", 108 | "DEFAULT": 0.0, 109 | "MIN": -5.0, 110 | "MAX": 5.0 111 | } 112 | ] 113 | }*/ 114 | 115 | 116 | #ifdef GL_ES 117 | precision mediump float; 118 | #endif 119 | 120 | #define PI 3.14159265358979323846 121 | 122 | 123 | float random (in vec2 _st) { 124 | return fract(sin(dot(_st.xy, 125 | vec2((TIME*randomXspeed),(TIME*randomYspeed))))); 126 | } 127 | 128 | vec2 truchetPattern(in vec2 _st, in float _index){ 129 | _index = fract(((_index-0.5)*truchetIndex)); 130 | if (_index > 0.75*truchetIndex) { 131 | _st = vec2(truchetPositionOffset) - _st; 132 | } else if (_index > 0.5 * truchetIndex) { 133 | _st = vec2(truchetPositionOffset-_st.x,_st.y); 134 | } else if (_index > 0.25 * truchetIndex) { 135 | _st = 1.-vec2(truchetPositionOffset-_st.x,_st.y); 136 | } else if (_index >= 0.0) { 137 | _st += truchetPositionOffset; 138 | } 139 | return _st; 140 | } 141 | 142 | void main() { 143 | vec2 st = gl_FragCoord.xy/RENDERSIZE.xy; 144 | st -= vec2(pos); 145 | st.x *= RENDERSIZE.x/RENDERSIZE.y; // 1:1 ratio 146 | 147 | st *= zoom; 148 | 149 | vec2 ipos = floor(st); // integer 150 | vec2 fpos = fract(st); // fraction 151 | 152 | vec2 tile = truchetPattern(fpos, random( ipos )); 153 | 154 | float color = 0.0; 155 | 156 | // Maze 157 | if (pattern == 0 || pattern == 2){ 158 | color += smoothstep(tile.x-gradient+gradientOffset,tile.x,tile.y)- 159 | smoothstep(tile.x,tile.x+gradient+gradientOffset,tile.y); 160 | } 161 | 162 | // Circles 163 | if (pattern == 1 || pattern == 2){ 164 | color += (step(length(tile),0.6) - 165 | step(length(tile),0.4) ) + 166 | (step(length(tile-vec2(1.)),0.6) - 167 | step(length(tile-vec2(1.)),0.4) ); 168 | } 169 | 170 | //adjust contrast 171 | color += smoothstep(0.0+contrast+contrastShift,1.0-contrast+contrastShift, color); 172 | 173 | //invert colors 174 | if (invert) color = color *-1.0 + 1.0; 175 | 176 | gl_FragColor = vec4(vec3(color),1.0); 177 | } 178 | 179 | 180 | 181 | -------------------------------------------------------------------------------- /ISF/16_Zebre.fs: -------------------------------------------------------------------------------- 1 | // SaturdayShader Week 16 : Zebre 2 | // by Joseph Fiola (http://www.joefiola.com) 3 | // 2015-12-05 4 | // Based on Patricio Gonzalez Vivo's "Wood Texture" example on http://patriciogonzalezvivo.com/2015/thebookofshaders/edit.html#11/wood.frag @patriciogv ( patriciogonzalezvivo.com ) - 2015 5 | 6 | 7 | /*{ 8 | "CREDIT": "Joseph Fiola", 9 | "DESCRIPTION": "", 10 | "CATEGORIES": [ "Generator","waves", "random" ], 11 | "INPUTS": [ 12 | 13 | { 14 | "NAME": "lineScale", 15 | "TYPE": "float", 16 | "DEFAULT": 0.5, 17 | "MIN": 0.0005, 18 | "MAX": 10.0 19 | }, 20 | { 21 | "NAME": "harmonic", 22 | "TYPE": "float", 23 | "DEFAULT": 1.0, 24 | "MIN": 0.0, 25 | "MAX": 200.0 26 | }, 27 | { 28 | "NAME": "lineOffsetSpeed", 29 | "TYPE": "float", 30 | "DEFAULT": 0.5, 31 | "MIN": 0.0, 32 | "MAX": 100.0 33 | }, 34 | { 35 | "NAME": "brightness", 36 | "TYPE": "float", 37 | "DEFAULT": 0.5, 38 | "MIN": 0.1, 39 | "MAX": 10.0 40 | }, 41 | { 42 | "NAME": "contrast", 43 | "TYPE": "float", 44 | "DEFAULT": 0.0, 45 | "MIN": 0.0, 46 | "MAX": 0.5 47 | }, 48 | { 49 | "NAME": "contrastShift", 50 | "TYPE": "float", 51 | "DEFAULT": 0.0, 52 | "MIN": -0.5, 53 | "MAX": 0.5 54 | }, 55 | { 56 | "NAME": "randomMultiply", 57 | "TYPE": "float", 58 | "DEFAULT": 43758.5453123, 59 | "MIN": 0.0, 60 | "MAX": 50000.0 61 | }, 62 | { 63 | "NAME": "randomAmt", 64 | "TYPE": "point2D", 65 | "DEFAULT": [ 66 | 0.12, 67 | 0.78 68 | ], 69 | "MIN": [ 70 | 0.0, 71 | 0.0 72 | ], 73 | "MAX": [ 74 | 1.0, 75 | 1.0 76 | ] 77 | }, 78 | { 79 | "NAME": "origin", 80 | "TYPE": "point2D", 81 | "DEFAULT": [ 82 | 0.5, 83 | 0.5 84 | ], 85 | "MIN": [ 86 | 0.0, 87 | 0.0 88 | ], 89 | "MAX": [ 90 | 1.0, 91 | 1.0 92 | ] 93 | }, 94 | { 95 | "NAME": "xyStretch", 96 | "TYPE": "point2D", 97 | "DEFAULT": [ 98 | 5.0, 99 | 1.5 100 | ], 101 | "MIN": [ 102 | 0.0, 103 | 0.0 104 | ], 105 | "MAX": [ 106 | 1.0, 107 | 1.0 108 | ] 109 | }, 110 | { 111 | "NAME": "xyNoiseFactor", 112 | "TYPE": "point2D", 113 | "DEFAULT": [ 114 | 0.3, 115 | 0.3 116 | ], 117 | "MIN": [ 118 | 0.0, 119 | 0.0 120 | ], 121 | "MAX": [ 122 | 1.0, 123 | 1.0 124 | ] 125 | } 126 | 127 | ] 128 | }*/ 129 | 130 | 131 | #ifdef GL_ES 132 | precision mediump float; 133 | #endif 134 | 135 | 136 | float random (in vec2 st) { 137 | return fract(sin(dot(st.xy, 138 | vec2(randomAmt.x * 100.,randomAmt.y * 100.))) 139 | * randomMultiply); 140 | } 141 | 142 | // Value noise by Inigo Quilez - iq/2013 143 | // https://www.shadertoy.com/view/lsf3WH 144 | float noise(vec2 st) { 145 | 146 | vec2 i = floor(st); 147 | vec2 f = fract(st); 148 | 149 | 150 | vec2 u = f*f*(3.0-2.0*f); 151 | return mix( mix( random( i + vec2(0.0,0.0) ), 152 | random( i + vec2(1.0,0.0) ), u.x), 153 | mix( random( i + vec2(0.0,1.0) ), 154 | random( i + vec2(1.0,1.0) ), u.x), u.y); 155 | } 156 | 157 | 158 | mat2 rotate2d(float angle){ 159 | return mat2(cos(angle *xyNoiseFactor.x * 100.),-sin(angle), 160 | sin(angle * xyNoiseFactor.y * 100.),cos(angle)); 161 | } 162 | 163 | 164 | float lines(in vec2 pos, float b){ 165 | float scale = lineScale; 166 | pos *= scale; 167 | return smoothstep(0.0, 168 | .5+b*.5, 169 | abs((sin(pos.x*3.1415)+b*2.0))* brightness); 170 | } 171 | 172 | 173 | void main() { 174 | vec2 st = gl_FragCoord.xy/RENDERSIZE.xy; 175 | st -= vec2(origin); 176 | st.y *= RENDERSIZE.y/RENDERSIZE.x; 177 | 178 | vec2 pos = st.yx*vec2(xyStretch * 100.); 179 | 180 | float pattern = pos.x; 181 | 182 | // Add noise 183 | pos = rotate2d( noise(pos) ) * pos * harmonic + (TIME * lineOffsetSpeed); 184 | 185 | // Draw lines 186 | pattern = lines(pos,0.5); 187 | 188 | //adjust contrast 189 | pattern += smoothstep(0.0+contrast+contrastShift,1.0-contrast+contrastShift, pattern); 190 | 191 | gl_FragColor = vec4(vec3(pattern),1.0); 192 | } 193 | -------------------------------------------------------------------------------- /ISF/17_HypnoCircles.fs: -------------------------------------------------------------------------------- 1 | // SaturdayShader Week 17 : HypnoCircles 2 | // by Joseph Fiola (http://www.joefiola.com) 3 | // 2015-12-12 4 | // Based on "Circles" by Michael Feldstein - http://www.interactiveshaderformat.com/sketches/519 5 | 6 | /*{ 7 | "CREDIT": "Joseph Fiola", 8 | "DESCRIPTION": "", 9 | "CATEGORIES": [ 10 | ], 11 | "INPUTS": [ 12 | { 13 | "NAME": "pos", 14 | "TYPE": "point2D", 15 | "DEFAULT": [ 16 | 0.5, 17 | 0.5 18 | ], 19 | "MIN": [ 20 | 0.0, 21 | 0.0 22 | ], 23 | "MAX": [ 24 | 1.0, 25 | 1.0 26 | ] 27 | }, 28 | { 29 | "NAME": "zoom", 30 | "TYPE": "float", 31 | "MIN": 0.1, 32 | "MAX": 25, 33 | "DEFAULT": 6 34 | }, 35 | { 36 | "NAME": "rotate", 37 | "TYPE": "float", 38 | "MIN": 0.0, 39 | "MAX": 2, 40 | "DEFAULT": 0.25 41 | }, 42 | { 43 | "NAME": "lineSpeed", 44 | "TYPE": "float", 45 | "MIN": -50, 46 | "MAX": 50, 47 | "DEFAULT": 1.0 48 | }, 49 | { 50 | "NAME": "lineAmount", 51 | "TYPE": "float", 52 | "MIN": 1.0, 53 | "MAX": 1000, 54 | "DEFAULT": 50.0 55 | }, 56 | { 57 | "NAME": "lineThickness", 58 | "TYPE": "float", 59 | "MIN": 0.01, 60 | "MAX": 1.999, 61 | "DEFAULT": 1.0 62 | } 63 | ] 64 | }*/ 65 | 66 | 67 | 68 | #define PI 3.14159265358979323846 69 | 70 | 71 | 72 | 73 | //rotate function taken from Patricio Gonzalez Vivo on http://patriciogonzalezvivo.com/2015/thebookofshaders/09/ 74 | vec2 rotate2D(vec2 _st, float _angle){ 75 | _st = mat2(cos(_angle),-sin(_angle), 76 | sin(_angle),cos(_angle)) * _st; 77 | return _st; 78 | } 79 | 80 | void main() { 81 | 82 | vec2 st = gl_FragCoord.xy / RENDERSIZE; 83 | st -= vec2(pos); 84 | st.x *= RENDERSIZE.x/RENDERSIZE.y; // 1:1 ratio 85 | 86 | st = rotate2D(st,PI*-rotate); 87 | 88 | 89 | st *= zoom; 90 | st = fract(st); 91 | float v = distance(st, vec2(0.5)); 92 | v = floor(sin(v * lineAmount + TIME * -lineSpeed) + lineThickness); 93 | gl_FragColor = vec4(v); 94 | 95 | 96 | } -------------------------------------------------------------------------------- /ISF/18_Iteration.fs: -------------------------------------------------------------------------------- 1 | // SaturdayShader Week 18 : Iteration 2 | // by Joseph Fiola (http://www.joefiola.com) 3 | // 2015-12-19 4 | 5 | 6 | /*{ 7 | "CREDIT": "Joseph Fiola", 8 | "DESCRIPTION": "", 9 | "CATEGORIES": [ 10 | "Generator" 11 | ], 12 | "INPUTS": [ 13 | { 14 | "NAME": "invert", 15 | "TYPE": "bool" 16 | }, 17 | { 18 | "NAME": "gradient", 19 | "TYPE": "float", 20 | "DEFAULT": 0.03, 21 | "MIN": 0.0, 22 | "MAX": 2.0 23 | }, 24 | { 25 | "NAME": "radius", 26 | "TYPE": "float", 27 | "DEFAULT": 10.0, 28 | "MIN": 1e-4, 29 | "MAX": 50.0 30 | }, 31 | { 32 | "NAME": "pos", 33 | "TYPE": "point2D", 34 | "DEFAULT": [ 35 | 0.5, 36 | 0.5 37 | ], 38 | "MIN": [ 39 | 0.0, 40 | 0.0 41 | ], 42 | "MAX": [ 43 | 1.0, 44 | 1.0 45 | ] 46 | }, 47 | { 48 | "NAME": "offsetPos", 49 | "TYPE": "point2D", 50 | "DEFAULT": [ 51 | 0.0, 52 | 0.0 53 | ], 54 | "MIN": [ 55 | -0.1, 56 | -0.1 57 | ], 58 | "MAX": [ 59 | 0.1, 60 | 0.1 61 | ] 62 | }, 63 | { 64 | "NAME": "offset", 65 | "TYPE": "float", 66 | "DEFAULT": 0.2, 67 | "MIN": 1e-4, 68 | "MAX": 1.0 69 | }, 70 | { 71 | "NAME": "shapeSelect", 72 | "TYPE": "long", 73 | "VALUES": [ 74 | 0, 75 | 1 76 | ], 77 | "LABELS": [ 78 | "circle", 79 | "square" 80 | ], 81 | "DEFAULT": 0 82 | } 83 | ] 84 | }*/ 85 | 86 | float circle(in vec2 _st, in float _radius){ 87 | vec2 l = _st; 88 | return 1.-smoothstep(_radius-(_radius*gradient), 89 | _radius+(_radius*gradient), 90 | dot(l,l)*radius); 91 | } 92 | 93 | float box(vec2 _st, vec2 _size, float _smoothEdges){ 94 | _st += 0.5; 95 | vec2 aa = vec2(_smoothEdges*0.5); 96 | vec2 uv = smoothstep(_size,_size+aa,_st); 97 | uv *= smoothstep(_size,_size+aa,vec2(1.0)-_st); 98 | return uv.x*uv.y; 99 | } 100 | 101 | vec3 invertColor(vec3 color) { 102 | return vec3(color *-1.0 + 1.0); 103 | 104 | } 105 | 106 | void main() { 107 | 108 | vec2 st = gl_FragCoord.xy/RENDERSIZE; 109 | st -= vec2(pos); 110 | st.x *= RENDERSIZE.x/RENDERSIZE.y; 111 | 112 | vec3 color = vec3(0.0); 113 | 114 | for (float i = 0.0; i<50.0; i++){ 115 | vec3 shape = vec3(0.0); 116 | if (shapeSelect == 0) shape = vec3(circle(st-=vec2(offsetPos), (offset * i))); 117 | if (shapeSelect == 1) shape = vec3(box(st-=vec2(offsetPos),vec2(radius*0.009*offset,radius*0.009*offset),gradient*0.05)); 118 | 119 | shape *= invertColor(shape); 120 | color += shape; 121 | } 122 | 123 | float finalColor = 0.0; 124 | 125 | if (invert) { 126 | color = invertColor(color); 127 | finalColor = color.x + color.y - color.z; 128 | } else { 129 | finalColor = color.x + color.y + color.z; 130 | } 131 | 132 | gl_FragColor = vec4(vec3(finalColor),1.0); 133 | } -------------------------------------------------------------------------------- /ISF/19_TruchetIteration.fs: -------------------------------------------------------------------------------- 1 | // SaturdayShader Week 19 : Truchet Iteration 2 | // by Joseph Fiola (http://www.joefiola.com) 3 | // 2015-12-26 4 | 5 | // This shader is a mix of Patricio Gonzalez Vivo's "Truchet Tiles" example 6 | // found at http://patriciogonzalezvivo.com/2015/thebookofshaders/09/ @patriciogv ( patriciogonzalezvivo.com ) - 2015 7 | // as well as last week's "Iteration" shader found at http://www.interactiveshaderformat.com/sketches/746 8 | 9 | /*{ 10 | "CREDIT": "Joseph Fiola", 11 | "DESCRIPTION": "", 12 | "CATEGORIES": [ 13 | "Generator" 14 | ], 15 | "INPUTS": [ 16 | { 17 | "NAME": "invert", 18 | "TYPE": "bool" 19 | }, 20 | { 21 | "NAME": "gradient", 22 | "TYPE": "float", 23 | "DEFAULT": 0.2, 24 | "MIN": 0.0, 25 | "MAX": 2.0 26 | }, 27 | { 28 | "NAME": "xScale", 29 | "TYPE": "float", 30 | "DEFAULT": 0.49, 31 | "MIN": 1e-4, 32 | "MAX": 0.5 33 | }, 34 | { 35 | "NAME": "yScale", 36 | "TYPE": "float", 37 | "DEFAULT": 0.3, 38 | "MIN": 1e-4, 39 | "MAX": 0.5 40 | }, 41 | { 42 | "NAME": "tiles", 43 | "TYPE": "float", 44 | "DEFAULT": 2.0, 45 | "MIN": 0.0, 46 | "MAX": 20.0 47 | }, 48 | { 49 | "NAME": "rotate", 50 | "TYPE": "float", 51 | "DEFAULT": 0.15, 52 | "MIN": 0.0, 53 | "MAX": 1.0 54 | }, 55 | { 56 | "NAME": "pos", 57 | "TYPE": "point2D", 58 | "DEFAULT": [ 59 | 0.5, 60 | 0.5 61 | ], 62 | "MIN": [ 63 | 0.0, 64 | 0.0 65 | ], 66 | "MAX": [ 67 | 1.0, 68 | 1.0 69 | ] 70 | }, 71 | { 72 | "NAME": "offset", 73 | "TYPE": "point2D", 74 | "DEFAULT": [ 75 | 0.05, 76 | 0.05 77 | ], 78 | "MIN": [ 79 | -0.1, 80 | -0.1 81 | ], 82 | "MAX": [ 83 | 0.1, 84 | 0.1 85 | ] 86 | }, 87 | { 88 | "NAME": "scalePos", 89 | "TYPE": "point2D", 90 | "DEFAULT": [ 91 | 0.5, 92 | 0.5 93 | ], 94 | "MIN": [ 95 | 0.0, 96 | 0.0 97 | ], 98 | "MAX": [ 99 | 1.0, 100 | 1.0 101 | ] 102 | } 103 | ] 104 | }*/ 105 | 106 | #define PI 3.14159265358979323846 107 | 108 | vec2 rotate2D (vec2 _st, float _angle) { 109 | _st -= 0.5; 110 | _st = mat2(cos(_angle),-sin(_angle), 111 | sin(_angle),cos(_angle)) * _st; 112 | _st += 0.5; 113 | return _st; 114 | } 115 | 116 | vec2 tile (vec2 _st, float _zoom) { 117 | _st *= _zoom; 118 | return fract(_st); 119 | } 120 | 121 | vec2 rotateTilePattern(vec2 _st){ 122 | 123 | // Scale the coordinate system by 2x2 124 | _st -=scalePos; 125 | _st *= xScale + yScale * 0.5; 126 | //_st += scalePos; 127 | 128 | // Give each cell an index number 129 | // according to its position 130 | float index = 0.0; 131 | index += step(1., mod(_st.x,2.0)); 132 | index += step(1., mod(_st.y,2.0))*2.0; 133 | 134 | // Make each cell between 0.0 - 1.0 135 | _st = fract(_st); 136 | 137 | // Rotate each cell according to the index 138 | if(index == 1.0){ 139 | // Rotate cell 1 by 90 degrees 140 | _st = rotate2D(_st,PI*0.5); 141 | } else if(index == 2.0){ 142 | // Rotate cell 2 by -90 degrees 143 | _st = rotate2D(_st,PI*-0.5); 144 | } else if(index == 3.0){ 145 | // Rotate cell 3 by 180 degrees 146 | _st = rotate2D(_st,PI); 147 | } 148 | 149 | return _st; 150 | } 151 | 152 | 153 | float box(vec2 _st, vec2 _size, float _smoothEdges){ 154 | //_size = vec2(0.0); 155 | _st += 0.5; 156 | vec2 aa = vec2(_smoothEdges*0.5); 157 | vec2 uv = smoothstep(_size,_size+aa,_st); 158 | uv *= smoothstep(_size,_size+aa,vec2(1.0)-_st); 159 | return uv.x*uv.y; 160 | } 161 | 162 | 163 | vec3 invertColor(vec3 color) { 164 | return vec3(color *-1.0 + 1.0); 165 | } 166 | 167 | 168 | void main() { 169 | 170 | vec2 st = gl_FragCoord.xy/RENDERSIZE; 171 | st -= vec2(pos); 172 | st.x *= RENDERSIZE.x/RENDERSIZE.y; 173 | 174 | st = tile(st,tiles); 175 | st = rotateTilePattern(st); 176 | 177 | // Make more interesting combinations 178 | st = rotate2D(st,-PI*rotate*2.); 179 | st = rotateTilePattern(st); 180 | 181 | 182 | 183 | vec3 color = vec3(0.0); 184 | 185 | 186 | for (float i = 0.0; i<50.0; i++){ 187 | vec3 shape = vec3(0.0); 188 | shape = vec3(box(st-=vec2(offset), vec2(xScale, yScale), gradient*0.05)); 189 | shape *= invertColor(shape); 190 | color += shape; 191 | } 192 | 193 | 194 | float finalColor = 0.0; 195 | if (invert) { 196 | color = invertColor(color); 197 | finalColor = color.x + color.y - color.z; 198 | } else { 199 | finalColor = color.x + color.y + color.z; 200 | } 201 | 202 | gl_FragColor = vec4(vec3(finalColor),1.0); 203 | } -------------------------------------------------------------------------------- /ISF/20_FractalDots.fs: -------------------------------------------------------------------------------- 1 | // SaturdayShader Week 20 : Fractal Dots 2 | // by Joseph Fiola (http://www.joefiola.com) 3 | // 2016-01-02 4 | 5 | // Based on "Basic Fractal" by @paulofalcao found at https://www.shadertoy.com/view/Mss3Wf 6 | 7 | 8 | 9 | /*{ 10 | "CREDIT": "Joseph Fiola", 11 | "DESCRIPTION": "", 12 | "CATEGORIES": [ 13 | "Generator" 14 | ], 15 | "INPUTS": [ 16 | 17 | 18 | { 19 | "NAME": "iteration", 20 | "TYPE": "float", 21 | "DEFAULT": 5.0, 22 | "MIN": 0.0, 23 | "MAX": 10.0 24 | }, 25 | { 26 | "NAME": "complexity", 27 | "TYPE": "float", 28 | "DEFAULT": 0.0, 29 | "MIN": 0.0, 30 | "MAX": 4.0 31 | }, 32 | 33 | { 34 | "NAME": "zoom", 35 | "TYPE": "float", 36 | "DEFAULT": 40.0, 37 | "MIN": 0.0, 38 | "MAX": 200.0 39 | }, 40 | { 41 | "NAME": "pattern", 42 | "TYPE": "float", 43 | "DEFAULT": 2.0, 44 | "MIN": 0.0, 45 | "MAX": 10.0 46 | }, 47 | { 48 | "NAME": "spacing", 49 | "TYPE": "float", 50 | "DEFAULT": 15.0, 51 | "MIN": 0.0, 52 | "MAX": 100.0 53 | }, 54 | { 55 | "NAME": "rotate1", 56 | "TYPE": "float", 57 | "DEFAULT": 0.5, 58 | "MIN": 0.0, 59 | "MAX": 1.57079632679 60 | }, 61 | { 62 | "NAME": "rotate2", 63 | "TYPE": "float", 64 | "DEFAULT": 0.5, 65 | "MIN": 0.0, 66 | "MAX": 1.57079632679 67 | }, 68 | { 69 | "NAME": "dotSize", 70 | "TYPE": "float", 71 | "DEFAULT": 500.0, 72 | "MIN": 0.0, 73 | "MAX": 4000.0 74 | }, 75 | { 76 | "NAME": "pos", 77 | "TYPE": "point2D", 78 | "DEFAULT": [ 79 | 0.5, 80 | 0.5 81 | ], 82 | "MIN": [ 83 | 0.0, 84 | 0.0 85 | ], 86 | "MAX": [ 87 | 1.0, 88 | 1.0 89 | ] 90 | } 91 | ] 92 | }*/ 93 | 94 | #define HALF_PI 1.57079632679 95 | 96 | const int maxIterations=10; //a nice value for fullscreen is 8 97 | 98 | float circleSize=dotSize/(3.0*pow(2.0,float(maxIterations))); 99 | 100 | //generic rotation formula 101 | vec2 rot(vec2 uv,float a){ 102 | 103 | return vec2(uv.x*cos(a)-uv.y*sin(a),uv.y*cos(a)+uv.x*sin(a)); 104 | 105 | } 106 | 107 | void main(){ 108 | 109 | vec2 uv = gl_FragCoord.xy/RENDERSIZE; 110 | uv -= vec2(pos); 111 | uv.x *= RENDERSIZE.x/RENDERSIZE.y; 112 | 113 | 114 | //global rotation and zoom 115 | uv=rot(uv,rotate1); 116 | uv *= zoom; 117 | 118 | 119 | //mirror, rotate and scale 6 times... 120 | float s=spacing; 121 | for(int i=0;icircleSize?0.0:1.0; 134 | 135 | gl_FragColor = vec4(c,c,c,1.0); 136 | } -------------------------------------------------------------------------------- /ISF/21_Cosplay.fs: -------------------------------------------------------------------------------- 1 | // SaturdayShader Week 21 : Cosplay 2 | // by Joseph Fiola (http://www.joefiola.com) 3 | // 2016-01-09 4 | 5 | /*{ 6 | "CREDIT": "Joseph Fiola", 7 | "DESCRIPTION": "", 8 | "CATEGORIES": [ 9 | "Generator" 10 | ], 11 | "INPUTS": [ 12 | 13 | { 14 | "NAME": "dotSize", 15 | "TYPE": "float", 16 | "DEFAULT": 0.01, 17 | "MIN": 0.0, 18 | "MAX": 0.1 19 | }, 20 | { 21 | "NAME": "iteration", 22 | "TYPE": "float", 23 | "DEFAULT": 100.0, 24 | "MIN": 0.0, 25 | "MAX": 100.0 26 | }, 27 | { 28 | "NAME": "xAmp", 29 | "TYPE": "float", 30 | "DEFAULT": 0.3, 31 | "MIN": -1.0, 32 | "MAX": 1.0 33 | }, 34 | { 35 | "NAME": "yAmp", 36 | "TYPE": "float", 37 | "DEFAULT": 0.1, 38 | "MIN": -1.0, 39 | "MAX": 1.0 40 | }, 41 | { 42 | "NAME": "xFactor", 43 | "TYPE": "float", 44 | "DEFAULT": 0.2, 45 | "MIN": 0.0, 46 | "MAX": 10.0 47 | }, 48 | { 49 | "NAME": "yFactor", 50 | "TYPE": "float", 51 | "DEFAULT": 0.2, 52 | "MIN": 0.0, 53 | "MAX": 10.0 54 | }, 55 | { 56 | "NAME": "speed", 57 | "TYPE": "float", 58 | "DEFAULT": 0.05, 59 | "MIN": 0.0, 60 | "MAX": 0.1 61 | }, 62 | { 63 | "NAME": "rotateCanvas", 64 | "TYPE": "float", 65 | "DEFAULT": 0.0, 66 | "MIN": -3.14159265358979323846, 67 | "MAX": 3.14159265358979323846 68 | }, 69 | { 70 | "NAME": "rotateParticles", 71 | "TYPE": "float", 72 | "DEFAULT": 1.0, 73 | "MIN": -1.57079632679489661923, 74 | "MAX": 1.57079632679489661923 75 | }, 76 | { 77 | "NAME": "rotateMultiplier", 78 | "TYPE": "float", 79 | "DEFAULT": 10.0, 80 | "MIN": 0.01, 81 | "MAX": 10 82 | }, 83 | { 84 | "NAME": "pos", 85 | "TYPE": "point2D", 86 | "DEFAULT": [ 87 | 0.5, 88 | 0.5 89 | ], 90 | "MIN": [ 91 | 0.0, 92 | 0.0 93 | ], 94 | "MAX": [ 95 | 1.0, 96 | 1.0 97 | ] 98 | } 99 | ] 100 | }*/ 101 | 102 | #define PI 3.14159265358979323846 103 | #define TWOPI 6.28318530717958 104 | 105 | 106 | 107 | //generic rotation formula 108 | vec2 rot(vec2 uv,float a){ 109 | return vec2(uv.x*cos(a)-uv.y*sin(a),uv.y*cos(a)+uv.x*sin(a)); 110 | } 111 | 112 | float circle(vec2 uv, float size){ 113 | return length(uv) > size?0.0:1.0; 114 | } 115 | 116 | 117 | void main(){ 118 | 119 | vec2 uv = gl_FragCoord.xy/RENDERSIZE; 120 | uv -= vec2(pos); 121 | uv.x *= RENDERSIZE.x/RENDERSIZE.y; 122 | vec3 color = vec3(0); 123 | 124 | //rotate canvas 125 | uv=rot(uv,rotateCanvas); 126 | 127 | for (float i = 0.0; i<100.0; i++){ 128 | 129 | // set max number of iterations 130 | if (iteration < i) break; 131 | 132 | // sin() cos() animation 133 | vec2 st = uv - vec2(cos(i * xFactor * (TIME*speed)) * xAmp, sin(i * yFactor * (TIME*speed)) * yAmp); 134 | 135 | // set dotSize 136 | float dots = circle((st), dotSize * (i * 0.01)); 137 | 138 | //rotate particles 139 | uv=rot(uv,rotateParticles*rotateMultiplier); 140 | 141 | color += dots; 142 | } 143 | 144 | gl_FragColor = vec4(vec3(color),1.0); 145 | } -------------------------------------------------------------------------------- /ISF/22_DifferenceStrokes.fs: -------------------------------------------------------------------------------- 1 | // SaturdayShader Week 22 : Difference Strokes 2 | // by Joseph Fiola (http://www.joefiola.com) 3 | // 2016-01-16 4 | 5 | /*{ 6 | "CREDIT": "Joseph Fiola", 7 | "DESCRIPTION": "", 8 | "CATEGORIES": [ 9 | "Generator" 10 | ], 11 | "INPUTS": [ 12 | 13 | { 14 | "NAME": "invert", 15 | "TYPE": "bool" 16 | }, 17 | { 18 | "NAME": "difference", 19 | "TYPE": "bool", 20 | "DEFAULT": true 21 | }, 22 | { 23 | "NAME": "shape", 24 | "TYPE": "long", 25 | "VALUES": [ 26 | 0, 27 | 1, 28 | 2, 29 | 3 30 | ], 31 | "LABELS": [ 32 | "circle solid", 33 | "circle outlines", 34 | "rect solid", 35 | "rect outlines" 36 | ], 37 | "DEFAULT": 0 38 | }, 39 | { 40 | "NAME": "dotSize", 41 | "TYPE": "float", 42 | "DEFAULT": 0.1, 43 | "MIN": 0.0, 44 | "MAX": 0.5 45 | }, 46 | { 47 | "NAME": "zoom", 48 | "TYPE": "float", 49 | "DEFAULT": 1.0, 50 | "MIN": 0.25, 51 | "MAX": 4.0 52 | }, 53 | { 54 | "NAME": "iteration", 55 | "TYPE": "float", 56 | "DEFAULT": 25.0, 57 | "MIN": 0.0, 58 | "MAX": 50.0 59 | }, 60 | { 61 | "NAME": "xAmp", 62 | "TYPE": "float", 63 | "DEFAULT": 0.1, 64 | "MIN": -0.5, 65 | "MAX": 0.5 66 | }, 67 | { 68 | "NAME": "yAmp", 69 | "TYPE": "float", 70 | "DEFAULT": -0.2, 71 | "MIN": -0.5, 72 | "MAX": 0.5 73 | }, 74 | { 75 | "NAME": "xFactor", 76 | "TYPE": "float", 77 | "DEFAULT": 0.2, 78 | "MIN": 0.0, 79 | "MAX": 10.0 80 | }, 81 | { 82 | "NAME": "yFactor", 83 | "TYPE": "float", 84 | "DEFAULT": 0.2, 85 | "MIN": 0.0, 86 | "MAX": 10.0 87 | }, 88 | { 89 | "NAME": "speed", 90 | "TYPE": "float", 91 | "DEFAULT": 0.1, 92 | "MIN": 0.0, 93 | "MAX": 0.1 94 | }, 95 | { 96 | "NAME": "rotateCanvas", 97 | "TYPE": "float", 98 | "DEFAULT": 0.5, 99 | "MIN": -1.0, 100 | "MAX": 1.0 101 | }, 102 | { 103 | "NAME": "rotateParticles", 104 | "TYPE": "float", 105 | "DEFAULT": 1.0, 106 | "MIN": -1.0, 107 | "MAX": 1.0 108 | }, 109 | { 110 | "NAME": "rotateMultiplier", 111 | "TYPE": "float", 112 | "DEFAULT": 10.0, 113 | "MIN": 0.01, 114 | "MAX": 10 115 | }, 116 | { 117 | "NAME": "pos", 118 | "TYPE": "point2D", 119 | "DEFAULT": [ 120 | 0.5, 121 | 0.5 122 | ], 123 | "MIN": [ 124 | 0.0, 125 | 0.0 126 | ], 127 | "MAX": [ 128 | 1.0, 129 | 1.0 130 | ] 131 | } 132 | ] 133 | }*/ 134 | 135 | 136 | #define PI 3.14159265358979323846 137 | #define TWO_PI 6.28318530718 138 | 139 | 140 | 141 | //rotation function 142 | vec2 rot(vec2 uv,float a){ 143 | return vec2(uv.x*cos(a)-uv.y*sin(a),uv.y*cos(a)+uv.x*sin(a)); 144 | } 145 | 146 | // circle function by jonobr1 from https://www.shadertoy.com/view/XsjGDt 147 | vec3 circle(vec2 uv, vec2 pos, float rad) { 148 | float d = length(pos - uv) - rad; 149 | float t = clamp(d, 0.0, 1.0); 150 | return vec3(vec3(1.0-t)); 151 | } 152 | 153 | vec3 rectangle(vec2 uv, vec2 pos, float width, float height) { 154 | float t = 0.0; 155 | if ((uv.x > pos.x - width / 2.0) && (uv.x < pos.x + width / 2.0) 156 | && (uv.y > pos.y - height / 2.0) && (uv.y < pos.y + height / 2.0)) { 157 | t = 1.0; 158 | } 159 | return vec3(t); 160 | } 161 | 162 | vec3 invertColor(vec3 color) { 163 | return vec3(color *-1.0 + 1.0); 164 | } 165 | 166 | 167 | 168 | void main(){ 169 | 170 | vec2 uv = gl_FragCoord.xy; 171 | uv -= vec2(pos * RENDERSIZE); 172 | 173 | uv *= zoom; 174 | 175 | //rotate canvas 176 | uv=rot(uv,rotateCanvas * PI); 177 | 178 | vec3 color = vec3(0.0); 179 | 180 | // prevents background from flashing when +/- iteration value 181 | if (difference) { 182 | if (mod(iteration, 2.0) < 1.0) color = invertColor(color); 183 | } 184 | 185 | 186 | float radius = dotSize * RENDERSIZE.x; 187 | 188 | for (float i = 0.0; i<=50.0; i++){ 189 | 190 | // set max number of iterations 191 | if (iteration < i) break; 192 | 193 | vec2 offset = pos; 194 | offset += vec2( cos( i * xFactor * (TIME * speed)) * (xAmp * RENDERSIZE.x), 195 | sin( i * yFactor * (TIME * speed)) * (yAmp * RENDERSIZE.y)); 196 | 197 | radius += i * 0.002; 198 | 199 | //DRAW SHAPES 200 | //draw circle solid 201 | if (shape == 0 || shape == 1) color += circle(uv, offset, radius); 202 | 203 | //draw circle outline 204 | if (shape == 1){ 205 | if (difference) color -= circle(uv, offset, radius + 2.0); 206 | if (!difference) color -= circle(uv, offset, radius - 2.0); 207 | } 208 | 209 | //draw rectangle solid 210 | if (shape == 2 || shape == 3) color += rectangle(uv, offset, radius*2.0, radius*2.0); 211 | 212 | //draw rect outline 213 | if (shape == 3) { 214 | if (difference) color -= rectangle(uv, offset, radius*2.0 + 4.0, radius*2.0 + 4.0); 215 | if (!difference) color -= rectangle(uv, offset, radius*2.0 - 4.0, radius*2.0 - 4.0); 216 | } 217 | 218 | 219 | if (difference) color = invertColor(color); 220 | 221 | //rotate particles 222 | uv=rot(uv,rotateParticles * PI * rotateMultiplier); 223 | 224 | } 225 | 226 | //invert colors 227 | if (invert) color = invertColor(color); 228 | 229 | gl_FragColor = vec4(color, 1.0); 230 | } -------------------------------------------------------------------------------- /ISF/23_DiscSpin.fs: -------------------------------------------------------------------------------- 1 | // SaturdayShader Week 23 : Discspin 2 | // by Joseph Fiola (http://www.joefiola.com) 3 | // 2016-01-23 4 | 5 | // Based on "The Power of Sin" by antonOTI - https://www.shadertoy.com/view/XdlSzB 6 | 7 | 8 | 9 | /*{ 10 | "CREDIT": "Joseph Fiola", 11 | "DESCRIPTION": "", 12 | "CATEGORIES": [ 13 | "Generator" 14 | ], 15 | "INPUTS": [ 16 | { 17 | "NAME": "mirror", 18 | "TYPE": "bool" 19 | }, 20 | { 21 | "NAME": "pattern", 22 | "TYPE": "bool", 23 | "DEFAULT": true 24 | }, 25 | { 26 | "NAME": "iteration", 27 | "TYPE": "float", 28 | "DEFAULT": 35.0, 29 | "MIN": 0.0, 30 | "MAX": 35.0 31 | }, 32 | { 33 | "NAME": "speed", 34 | "TYPE": "float", 35 | "DEFAULT": 1.0, 36 | "MIN": -10.0, 37 | "MAX": 10.0 38 | }, 39 | { 40 | "NAME": "radius", 41 | "TYPE": "float", 42 | "DEFAULT": 0.8, 43 | "MIN": 0.0, 44 | "MAX": 2.0 45 | }, 46 | { 47 | "NAME": "centerRadius", 48 | "TYPE": "float", 49 | "DEFAULT": 1.0, 50 | "MIN": -1.0, 51 | "MAX": 1.0 52 | }, 53 | { 54 | "NAME": "lineThickness", 55 | "TYPE": "float", 56 | "DEFAULT": 0.07, 57 | "MIN": 0.01, 58 | "MAX": 1.0 59 | }, 60 | { 61 | "NAME": "smoothEdge", 62 | "TYPE": "float", 63 | "DEFAULT": 0.03, 64 | "MIN": 0.01, 65 | "MAX": 1.0 66 | }, 67 | { 68 | "NAME": "yOffset", 69 | "TYPE": "float", 70 | "DEFAULT": 0.0, 71 | "MIN": -1.0, 72 | "MAX": 1.0 73 | }, 74 | { 75 | "NAME": "xOffset", 76 | "TYPE": "float", 77 | "DEFAULT": 0.0, 78 | "MIN": -1.0, 79 | "MAX": 1.0 80 | }, 81 | { 82 | "NAME": "startValue", 83 | "TYPE": "float", 84 | "DEFAULT": -1.5, 85 | "MIN": -2.0, 86 | "MAX": 2.0 87 | }, 88 | { 89 | "NAME": "endValue", 90 | "TYPE": "float", 91 | "DEFAULT": 1.5, 92 | "MIN": -2.0, 93 | "MAX": 2.0 94 | }, 95 | { 96 | "NAME": "rotate", 97 | "TYPE": "float", 98 | "DEFAULT": 0.0, 99 | "MIN": -1.0, 100 | "MAX": 1.0 101 | }, 102 | { 103 | "NAME": "pos", 104 | "TYPE": "point2D", 105 | "DEFAULT": [ 106 | 0.5, 107 | 0.5 108 | ], 109 | "MIN": [ 110 | 0.0, 111 | 0.0 112 | ], 113 | "MAX": [ 114 | 1.0, 115 | 1.0 116 | ] 117 | } 118 | ] 119 | }*/ 120 | 121 | 122 | #define NB 35. 123 | #define MODE1 124 | #define PI 3.14159265358979323846 125 | 126 | float circle(vec2 center , float radius,float thickness,float la,float ha) 127 | { 128 | float f = length(center); 129 | 130 | float a = atan(center.y,center.x) ; 131 | return(smoothstep(f,f+0.01,radius) * smoothstep(radius - thickness,radius - thickness+0.01,f) * step(la,a) *smoothstep(a-smoothEdge,a+smoothEdge,ha)); 132 | } 133 | 134 | float cable(vec2 p,float dx,float dy,float r,float thick,float la,float ha) 135 | { 136 | p.x-= dx; 137 | p.y -= dy; 138 | return (circle(p,r,thick,la,ha)); 139 | } 140 | 141 | //rotation function 142 | vec2 rot(vec2 uv,float a){ 143 | return vec2(uv.x*cos(a)-uv.y*sin(a),uv.y*cos(a)+uv.x*sin(a)); 144 | } 145 | 146 | void main() 147 | { 148 | 149 | vec2 uv = gl_FragCoord.xy / RENDERSIZE.xy; 150 | uv -= vec2(pos - 0.5); 151 | 152 | vec2 p = -1. + 2. * uv; 153 | p.x*=RENDERSIZE.x/RENDERSIZE.y; 154 | 155 | p=rot(p,rotate * PI); 156 | 157 | 158 | 159 | vec2 ap = vec2(0.0); 160 | if (mirror){ 161 | ap = p * vec2(1.,-1.); 162 | } else { 163 | ap = p * vec2(-1.,-1.); 164 | } 165 | 166 | 167 | 168 | float f = 0.; 169 | for(float i = 0.; i < NB; ++i) 170 | { 171 | if (i > iteration) break; 172 | 173 | if (pattern) f *= -1.; // invert values every iteration to create interesting patterns when line thickness overlaps 174 | 175 | float divi = i/iteration * centerRadius; 176 | f += cable(p,xOffset,yOffset,radius - divi,lineThickness,0.,(sin(TIME * speed - divi*5.)*startValue+endValue) * 3.14); 177 | f += cable(ap,xOffset,yOffset,radius - divi,lineThickness,0.,(sin(TIME * speed - divi*5.)*startValue+endValue) * 3.14); 178 | } 179 | vec3 col = mix(vec3(0.,0.,0.),vec3(1.,1.,1.),f); 180 | 181 | gl_FragColor = vec4(col,1.0); 182 | } 183 | 184 | -------------------------------------------------------------------------------- /ISF/24_RadialWaves.fs: -------------------------------------------------------------------------------- 1 | // SaturdayShader Week 24 : RadialWaves 2 | // by Joseph Fiola (http://www.joefiola.com) 3 | // 2016-01-30 4 | 5 | // Based on the animation found at https://media.giphy.com/media/xT9GEDBNxB9PDgicco/giphy.gif 6 | 7 | 8 | 9 | /*{ 10 | "CREDIT": "Joseph Fiola", 11 | "DESCRIPTION": "", 12 | "CATEGORIES": [ 13 | "Generator" 14 | ], 15 | "INPUTS": [ 16 | { 17 | "NAME": "invert", 18 | "TYPE": "bool", 19 | "DEFAULT": true 20 | }, 21 | { 22 | "NAME": "shapes", 23 | "TYPE": "long", 24 | "VALUES": [ 25 | 0, 26 | 1, 27 | 2 28 | 29 | ], 30 | "LABELS": [ 31 | "Circles", 32 | "Dots", 33 | "Both" 34 | 35 | ], 36 | "DEFAULT": 2 37 | }, 38 | { 39 | "NAME": "iteration", 40 | "TYPE": "float", 41 | "DEFAULT": 15.0, 42 | "MIN": 1.0, 43 | "MAX": 20.0 44 | }, 45 | { 46 | "NAME": "dotRadius", 47 | "TYPE": "float", 48 | "DEFAULT": 0.01, 49 | "MIN": 0.0, 50 | "MAX": 0.1 51 | }, 52 | { 53 | "NAME": "dotThickness", 54 | "TYPE": "float", 55 | "DEFAULT": 0.1, 56 | "MIN": 0.0, 57 | "MAX": 0.1 58 | }, 59 | { 60 | "NAME": "orbitDistance", 61 | "TYPE": "float", 62 | "DEFAULT": 0.9, 63 | "MIN": 0.0, 64 | "MAX": 2.0 65 | }, 66 | { 67 | "NAME": "circleRadius", 68 | "TYPE": "float", 69 | "DEFAULT": 0.05, 70 | "MIN": 0.0, 71 | "MAX": 0.1 72 | }, 73 | { 74 | "NAME": "lineThickness", 75 | "TYPE": "float", 76 | "DEFAULT": 0.0, 77 | "MIN": 0.0, 78 | "MAX": 0.05 79 | }, 80 | { 81 | "NAME": "gridDistance", 82 | "TYPE": "float", 83 | "DEFAULT": 0.055, 84 | "MIN": 0.0, 85 | "MAX": 1.0 86 | }, 87 | { 88 | "NAME": "speed", 89 | "TYPE": "float", 90 | "DEFAULT": -3.0, 91 | "MIN": -10.0, 92 | "MAX": 10.0 93 | }, 94 | { 95 | "NAME": "freq", 96 | "TYPE": "float", 97 | "DEFAULT": 0.4, 98 | "MIN": -10.0, 99 | "MAX": 10.0 100 | }, 101 | { 102 | "NAME": "pos", 103 | "TYPE": "point2D", 104 | "DEFAULT": [ 105 | 0.5, 106 | 0.5 107 | ], 108 | "MIN": [ 109 | 0.0, 110 | 0.0 111 | ], 112 | "MAX": [ 113 | 1.0, 114 | 1.0 115 | ] 116 | } 117 | ] 118 | }*/ 119 | 120 | #define PI 3.14159265358979323846 121 | 122 | float circle(vec2 center , float radius,float thickness) 123 | { 124 | float f = length(center); 125 | return(smoothstep(f,f+0.002,radius*1.1) * smoothstep(radius - thickness,radius - thickness+0.002,f)); 126 | } 127 | 128 | float invertColor(float color) { 129 | return float(color *-1.0 + 1.0); 130 | } 131 | 132 | 133 | void main() 134 | { 135 | 136 | vec2 uv = gl_FragCoord.xy / RENDERSIZE.xy; 137 | uv.x*=RENDERSIZE.x/RENDERSIZE.y; 138 | 139 | 140 | float center = gridDistance; 141 | 142 | uv -= vec2(pos - center * ((iteration) * -0.5)); 143 | 144 | 145 | float c = 0.0; 146 | 147 | // offset to keep grid centered 148 | float offset = center * iteration; 149 | 150 | for(int row = 0; row < 20; row++) { 151 | if (row > int(iteration)) break; 152 | 153 | for(int col = 0; col < 20; col++) { 154 | if (col > int(iteration)) break; 155 | 156 | //draw circles 157 | if (shapes == 0 || shapes == 2){ 158 | c += circle(uv+offset -(vec2(row,col)* gridDistance),circleRadius,lineThickness); 159 | } 160 | 161 | //draw oscilating dots 162 | if (shapes == 1 || shapes == 2) { 163 | 164 | c += circle(uv+offset -(vec2( 165 | sin( 166 | (float(-row)*freq) + (float(col)*freq) + TIME*speed) * orbitDistance + float(row), 167 | -cos( 168 | (float(-row)*freq) + (float(col)*freq) + TIME*speed) * orbitDistance + float(col) 169 | ) * gridDistance), 170 | dotRadius, dotThickness); 171 | } 172 | } 173 | } 174 | 175 | if (invert) { 176 | c = invertColor(c); 177 | } 178 | 179 | gl_FragColor = vec4(vec3(c), 1.0); 180 | } 181 | 182 | -------------------------------------------------------------------------------- /ISF/25_HoopLoop.fs: -------------------------------------------------------------------------------- 1 | // SaturdayShader Week 25 : HoopLoop 2 | // by Joseph Fiola (http://www.joefiola.com) 3 | // 2016-02-06 4 | 5 | 6 | /*{ 7 | "CREDIT": "Joseph Fiola", 8 | "DESCRIPTION": "", 9 | "CATEGORIES": [ 10 | "Generator" 11 | ], 12 | "INPUTS": [ 13 | { 14 | "NAME": "invert", 15 | "TYPE": "bool", 16 | "DEFAULT": 0.0 17 | }, 18 | { 19 | "NAME": "zoom", 20 | "TYPE": "float", 21 | "DEFAULT": 2.0, 22 | "MIN": 0.0, 23 | "MAX": 20.0 24 | }, 25 | { 26 | "NAME": "animate", 27 | "TYPE": "float", 28 | "DEFAULT": 0.3, 29 | "MIN": -3.14159265358979323846, 30 | "MAX": 3.14159265358979323846 31 | }, 32 | { 33 | "NAME": "size", 34 | "TYPE": "float", 35 | "DEFAULT": 0.35, 36 | "MIN": 0.0, 37 | "MAX": 1.0 38 | }, 39 | { 40 | "NAME": "thickness", 41 | "TYPE": "float", 42 | "DEFAULT": 0.001, 43 | "MIN": 0.001, 44 | "MAX": 0.5 45 | }, 46 | { 47 | "NAME": "lineEffect", 48 | "TYPE": "float", 49 | "DEFAULT": 0.001, 50 | "MIN": 0.0, 51 | "MAX": 0.2 52 | }, 53 | { 54 | "NAME": "patternOffset", 55 | "TYPE": "float", 56 | "DEFAULT": 0.0, 57 | "MIN": -1.0, 58 | "MAX": 1.0 59 | }, 60 | { 61 | "NAME": "rSin", 62 | "TYPE": "float", 63 | "DEFAULT": 0.0, 64 | "MIN": -5.0, 65 | "MAX": 5.0 66 | }, 67 | { 68 | "NAME": "xCos", 69 | "TYPE": "float", 70 | "DEFAULT": 1.0, 71 | "MIN": -5.0, 72 | "MAX": 5.0 73 | }, 74 | { 75 | "NAME": "ySin", 76 | "TYPE": "float", 77 | "DEFAULT": 1.0, 78 | "MIN": -5.0, 79 | "MAX": 5.0 80 | }, 81 | { 82 | "NAME": "blur", 83 | "TYPE": "float", 84 | "DEFAULT": 0.005, 85 | "MIN": 0.001, 86 | "MAX": 0.5 87 | }, 88 | { 89 | "NAME": "function", 90 | "TYPE": "long", 91 | "VALUES": [ 92 | 0, 93 | 1 94 | ], 95 | "LABELS": [ 96 | "abs", 97 | "fract" 98 | ], 99 | "DEFAULT": 0 100 | }, 101 | { 102 | "NAME": "rotate", 103 | "TYPE": "float", 104 | "DEFAULT": 0.0, 105 | "MIN": -1.0, 106 | "MAX": 1.0 107 | }, 108 | { 109 | "NAME": "pos", 110 | "TYPE": "point2D", 111 | "DEFAULT": [ 112 | 0.5, 113 | 0.5 114 | ], 115 | "MIN": [ 116 | 0.0, 117 | 0.0 118 | ], 119 | "MAX": [ 120 | 1.0, 121 | 1.0 122 | ] 123 | } 124 | ] 125 | }*/ 126 | 127 | 128 | const int NUM_CIRCLES = 50; 129 | 130 | #define PI 3.14159265358979323846 131 | #define TWO_PI 6.28318530718 132 | 133 | vec3 drawCircle(vec2 p, vec2 center, float radius, float edgeWidth, vec3 color) 134 | { 135 | float dist = length(p - center); 136 | vec3 ret; 137 | 138 | float look; 139 | if (function == 0) look = abs(dist -size); 140 | else if (function == 1) look = fract(dist -size); 141 | 142 | ret = color * (1.0 - lineEffect - smoothstep(radius, (radius+edgeWidth), look )); 143 | 144 | return ret; 145 | } 146 | 147 | vec3 invertColor(vec3 color) { 148 | return vec3(color *-1.0 + 1.0); 149 | } 150 | 151 | //rotation function 152 | vec2 rot(vec2 uv,float a){ 153 | return vec2(uv.x*cos(a)-uv.y*sin(a),uv.y*cos(a)+uv.x*sin(a)); 154 | } 155 | 156 | 157 | void main() 158 | { 159 | 160 | vec2 uv = gl_FragCoord.xy / RENDERSIZE.xy; 161 | uv -= vec2(pos); 162 | uv.x*=RENDERSIZE.x/RENDERSIZE.y; 163 | uv *= zoom; 164 | 165 | uv=rot(uv,rotate * PI); 166 | 167 | 168 | vec3 color = vec3(0.0); 169 | float angleIncrement = TWO_PI / float(NUM_CIRCLES); 170 | 171 | 172 | for (int i = 0; i < NUM_CIRCLES; ++i) { 173 | float t = angleIncrement*(float(i)); 174 | float r = sin(rSin * t + animate); 175 | vec2 p = vec2(r*cos(t*xCos), r*sin(t*ySin)); 176 | 177 | uv=rot(uv,patternOffset * PI); 178 | 179 | if (lineEffect >= 0.2) color = invertColor(color); 180 | 181 | color += drawCircle(uv, p, thickness, blur, vec3(1.0)); 182 | } 183 | 184 | if (invert) color = invertColor(color); 185 | 186 | gl_FragColor = vec4(color,1.0); 187 | } -------------------------------------------------------------------------------- /ISF/26_SoftPatterns.fs: -------------------------------------------------------------------------------- 1 | // SaturdayShader Week 26 : Soft Patterns 2 | // by Joseph Fiola (http://www.joefiola.com) 3 | // 2016-02-13 4 | 5 | // Based on Interferance, Color Waves by @gabrieldunne 6 | // https://twitter.com/gabrieldunne/status/671398225593561090 7 | // http://glslsandbox.com/e#29006.1 8 | 9 | 10 | 11 | /*{ 12 | "CREDIT": "Joseph Fiola", 13 | "DESCRIPTION": "", 14 | "CATEGORIES": [ 15 | "Generator" 16 | ], 17 | "INPUTS": [ 18 | { 19 | "NAME": "zoom", 20 | "TYPE": "float", 21 | "DEFAULT": 20.0, 22 | "MIN": 0.0, 23 | "MAX": 50.0 24 | }, 25 | { 26 | "NAME": "iterations", 27 | "TYPE": "float", 28 | "DEFAULT": 20.0, 29 | "MIN": 0.0, 30 | "MAX": 50.0 31 | }, 32 | { 33 | "NAME": "contrast", 34 | "TYPE": "float", 35 | "DEFAULT": 0.0, 36 | "MIN": -20.0, 37 | "MAX": 20.0 38 | }, 39 | { 40 | "NAME": "offset", 41 | "TYPE": "float", 42 | "DEFAULT": 0.0, 43 | "MIN": 0.0, 44 | "MAX": 1.0 45 | }, 46 | { 47 | "NAME": "pattern", 48 | "TYPE": "float", 49 | "DEFAULT": 1.1, 50 | "MIN": 1e-4, 51 | "MAX": 10.0 52 | }, 53 | { 54 | "NAME": "rotate", 55 | "TYPE": "float", 56 | "DEFAULT": 0.0, 57 | "MIN": -1.0, 58 | "MAX": 1.0 59 | }, 60 | { 61 | "NAME": "pos", 62 | "TYPE": "point2D", 63 | "DEFAULT": [0.5,0.5], 64 | "MIN":[0.0,0.0], 65 | "MAX":[1.0,1.0] 66 | } 67 | ] 68 | }*/ 69 | 70 | 71 | 72 | #define PI 3.14159 73 | #define TWO_PI (PI*2.0) 74 | 75 | 76 | vec2 rot(vec2 uv,float a){ 77 | return vec2(uv.x*cos(a) -uv.y*sin(a),uv.y*cos(a)+uv.x*sin(a)); 78 | } 79 | 80 | 81 | void main() 82 | { 83 | vec2 center = (gl_FragCoord.xy); 84 | 85 | vec2 uv = gl_FragCoord.xy / RENDERSIZE.xy; 86 | uv -= vec2(pos); 87 | uv.x *= RENDERSIZE.x/RENDERSIZE.y; 88 | uv *= zoom; 89 | uv=rot(uv,rotate * PI); 90 | 91 | float col = contrast; 92 | 93 | for(float i = 0.0; i < 50.0; i++) 94 | { 95 | float a = i * (TWO_PI / pattern); 96 | col += cos(TWO_PI*(uv.y * cos(a) + uv.x * sin(a) + offset)); 97 | 98 | if (i >= iterations) break; 99 | 100 | } 101 | 102 | gl_FragColor = vec4(col*1.0, col*1.0,col*1.0, 1.0); 103 | } -------------------------------------------------------------------------------- /ISF/27_DistanceFieldMorph.fs: -------------------------------------------------------------------------------- 1 | // SaturdayShader Week 27 : Distance Field Morphs 2 | // by Joseph Fiola (http://www.joefiola.com) 3 | // 2016-02-20 4 | 5 | 6 | // Based on @kyndinfo's Distance Field Shapes Transitions http://thebookofshaders.com/edit.html#examples/07/1454255754461.frag 7 | // http://www.kynd.info 8 | 9 | // Also used tilling techniques found on @patriciogv's Book of Shaders' patterns page 10 | // http://thebookofshaders.com/09/ 11 | 12 | /*{ 13 | "CREDIT": "", 14 | "DESCRIPTION": "", 15 | "CATEGORIES": [ 16 | "Generator" 17 | ], 18 | "INPUTS": [ 19 | { 20 | "NAME": "zoom", 21 | "TYPE": "float", 22 | "DEFAULT": 6.0, 23 | "MIN": 0.5, 24 | "MAX": 20.0 25 | }, 26 | { 27 | "NAME": "centerTile", 28 | "TYPE": "bool", 29 | "DEFAULT": true 30 | }, 31 | { 32 | "NAME": "rotateCanvas", 33 | "TYPE": "float", 34 | "DEFAULT": 0.0, 35 | "MIN": 0.0, 36 | "MAX": 1.0 37 | }, 38 | { 39 | "NAME": "rotateElements", 40 | "TYPE": "float", 41 | "DEFAULT": 0.0, 42 | "MIN": 0.0, 43 | "MAX": 1.0 44 | }, 45 | { 46 | "NAME": "shape1", 47 | "TYPE": "long", 48 | "VALUES": [ 49 | 0, 50 | 1, 51 | 2, 52 | 3, 53 | 4, 54 | 5, 55 | 6, 56 | 7, 57 | 8 58 | ], 59 | "LABELS": [ 60 | "circle", 61 | "ring", 62 | "round rectangle", 63 | "rectangle", 64 | "capsule", 65 | "ellipse", 66 | "triangle", 67 | "polygon", 68 | "hexagon" 69 | ], 70 | "DEFAULT": 1 71 | }, 72 | { 73 | "NAME": "shape2", 74 | "TYPE": "long", 75 | "VALUES": [ 76 | 0, 77 | 1, 78 | 2, 79 | 3, 80 | 4, 81 | 5, 82 | 6, 83 | 7, 84 | 8 85 | ], 86 | "LABELS": [ 87 | "circle", 88 | "ring", 89 | "round rectangle", 90 | "rectangle", 91 | "capsule", 92 | "ellipse", 93 | "triangle", 94 | "polygon", 95 | "hexagon" 96 | ], 97 | "DEFAULT": 8 98 | }, 99 | { 100 | "NAME": "morph", 101 | "TYPE": "float", 102 | "DEFAULT": 1.5, 103 | "MIN": -2.0, 104 | "MAX": 3.0 105 | }, 106 | { 107 | "NAME": "pos", 108 | "TYPE": "point2D", 109 | "DEFAULT": [0.5,0.5], 110 | "MIN":[0.0,0.0], 111 | "MAX":[1.0,1.0] 112 | } 113 | ] 114 | }*/ 115 | 116 | 117 | #ifdef GL_ES 118 | precision mediump float; 119 | #endif 120 | 121 | #define PI 3.14159265359 122 | 123 | mat2 rotate2d(float _angle){ 124 | return mat2(cos(_angle),-sin(_angle), 125 | sin(_angle),cos(_angle)); 126 | } 127 | 128 | 129 | float smoothedge(float v) { 130 | return smoothstep(0.0, zoom * 4.0 / RENDERSIZE.x, v); 131 | } 132 | 133 | float circle(vec2 p, float radius) { 134 | return length(p) - radius; 135 | } 136 | 137 | float rect(vec2 p, vec2 size) { 138 | vec2 d = abs(p) - size; 139 | return min(max(d.x, d.y), 0.0) + length(max(d,0.0)); 140 | } 141 | 142 | float roundRect(vec2 p, vec2 size, float radius) { 143 | vec2 d = abs(p) - size; 144 | return min(max(d.x, d.y), 0.0) + length(max(d,0.0))- radius; 145 | } 146 | 147 | float ring(vec2 p, float radius, float width) { 148 | return abs(length(p) - radius) - width; 149 | } 150 | 151 | float hexagon(vec2 p, float radius) { 152 | vec2 q = abs(p); 153 | return max(abs(q.y), q.x * 0.866025 + q.y * 0.5) - radius; 154 | } 155 | 156 | float triangle(vec2 p, float size) { 157 | vec2 q = abs(p); 158 | return max(q.x * 0.866025 + p.y * 0.5, -p.y * 0.5) - size * 0.5; 159 | } 160 | 161 | float ellipse(vec2 p, vec2 r, float s) { 162 | return (length(p / r) - s); 163 | } 164 | 165 | float capsule(vec2 p, vec2 a, vec2 b, float r) { 166 | vec2 pa = p - a, ba = b - a; 167 | float h = clamp( dot(pa,ba)/dot(ba,ba), 0.0, 1.0 ); 168 | return length( pa - ba*h ) - r; 169 | } 170 | 171 | //http://thndl.com/square-shaped-shaders.html 172 | float polygon(vec2 p, int vertices, float size) { 173 | float a = atan(p.x, p.y) + 0.2; 174 | float b = 6.28319 / float(vertices); 175 | return cos(floor(0.5 + a / b) * b - a) * length(p) - size; 176 | } 177 | 178 | float getShape(vec2 st, int i) { 179 | if (i == 0) { 180 | return circle(st, 0.4); 181 | } else if (i == 1) { 182 | return ring(st, 0.36, 0.08); 183 | } else if (i == 2) { 184 | return roundRect(st, vec2(0.32, 0.24), 0.08); 185 | } else if (i == 3) { 186 | return rect(st, vec2(0.4, 0.4)); 187 | } else if (i == 4) { 188 | return capsule(st, vec2(-0.25, -0.25), vec2(0.25, 0.25), 0.2); 189 | } else if (i == 5) { 190 | return ellipse(st, vec2(0.9, 1.2), 0.4); 191 | } else if (i == 6) { 192 | return triangle(st, 0.4); 193 | } else if (i == 7) { 194 | return polygon(st, 5, 0.4); 195 | } else { 196 | return hexagon(st, 0.4); 197 | } 198 | } 199 | 200 | void main() { 201 | vec2 st = gl_FragCoord.xy/RENDERSIZE; 202 | st -= vec2(pos); 203 | st.x *= RENDERSIZE.x/RENDERSIZE.y; 204 | 205 | st=rotate2d(rotateCanvas * -PI * 2.0) * st; 206 | 207 | st *= zoom; 208 | if (centerTile) st+=0.5; // centers tile 209 | st = fract(st); 210 | st -=0.5; 211 | 212 | st = rotate2d(rotateElements*-PI *2.0 ) * st; 213 | 214 | vec3 color = vec3(smoothedge(mix(getShape(st, shape1), getShape(st, shape2), morph))); 215 | 216 | gl_FragColor = vec4(color, 1.0); 217 | } -------------------------------------------------------------------------------- /ISF/28_TurbulentShapes.fs: -------------------------------------------------------------------------------- 1 | // SaturdayShader Week 28 : Turbulent Shapes 2 | // by Joseph Fiola (http://www.joefiola.com) 3 | // 2016-02-27 4 | 5 | // This is a remix of Patricio Gonzalez Vivo's 6 | // VectorField - http://patriciogonzalezvivo.github.io/glslEditor/?log=160224011512 7 | // and @kyndinfo's Distance Field Transitions http://thebookofshaders.com/edit.html?log=160131053646 8 | 9 | /*{ 10 | "CREDIT": "Joseph Fiola, based on work by Patricio Gonzalez and @kyndinfo", 11 | "DESCRIPTION": "", 12 | "CATEGORIES": [ 13 | "Generator" 14 | ], 15 | "INPUTS": [ 16 | { 17 | "NAME": "zoom", 18 | "TYPE": "float", 19 | "DEFAULT": 20.0, 20 | "MIN": 1.0, 21 | "MAX": 60.0 22 | }, 23 | { 24 | "NAME": "scale", 25 | "TYPE": "float", 26 | "DEFAULT": 0.25, 27 | "MIN": -4.0, 28 | "MAX": 4.0 29 | }, 30 | { 31 | "NAME": "spin", 32 | "TYPE": "float", 33 | "DEFAULT": 0.25, 34 | "MIN": 0.0, 35 | "MAX": 10.0 36 | }, 37 | { 38 | "NAME": "turbulanceSpeed", 39 | "TYPE": "float", 40 | "DEFAULT": 0.3, 41 | "MIN": 0.0, 42 | "MAX": 2.0 43 | }, 44 | { 45 | "NAME": "turbulanceZoom", 46 | "TYPE": "float", 47 | "DEFAULT": 0.1, 48 | "MIN": 0.0, 49 | "MAX": 1.0 50 | }, 51 | { 52 | "NAME": "shape", 53 | "TYPE": "float", 54 | "DEFAULT": 0.0, 55 | "MIN": 0.0, 56 | "MAX": 8.0 57 | }, 58 | { 59 | "NAME": "rotateCanvas", 60 | "TYPE": "float", 61 | "DEFAULT": 0.0, 62 | "MIN": 0.0, 63 | "MAX": 1.0 64 | }, 65 | { 66 | "NAME": "centerTile", 67 | "TYPE": "bool", 68 | "DEFAULT": true 69 | }, 70 | { 71 | "NAME": "pos", 72 | "TYPE": "point2D", 73 | "DEFAULT": [0.5,0.5], 74 | "MIN":[0.0,0.0], 75 | "MAX":[1.0,1.0] 76 | }, 77 | { 78 | "NAME": "posOffset", 79 | "TYPE": "point2D", 80 | "DEFAULT": [0.5,0.5], 81 | "MIN":[0.0,0.0], 82 | "MAX":[1.0,1.0] 83 | } 84 | ] 85 | }*/ 86 | 87 | 88 | 89 | #ifdef GL_ES 90 | precision mediump float; 91 | #endif 92 | 93 | 94 | #define PI 3.14159265359 95 | #define TWO_PI 6.28318530718 96 | 97 | float smoothedge(float v) { 98 | return smoothstep(0.0, 1.0 / RENDERSIZE.x, v) * -1.0 +1.0; 99 | } 100 | 101 | float circle(vec2 p, float radius) { 102 | return length(p) - radius; 103 | } 104 | 105 | float ring(vec2 p, float radius, float width) { 106 | return abs(length(p) - radius) - width; 107 | } 108 | 109 | //http://thndl.com/square-shaped-shaders.html 110 | float polygon(vec2 p, int vertices, float size) { 111 | float a = atan(p.x, p.y) + 0.2; 112 | float b = 6.28319 / float(vertices); 113 | return cos(floor(0.5 + a / b) * b - a) * length(p) - size; 114 | } 115 | 116 | mat2 rotate2d(float _angle){ 117 | return mat2(cos(_angle),-sin(_angle), 118 | sin(_angle),cos(_angle)); 119 | } 120 | 121 | vec3 mod289(vec3 x) { return x - floor(x * (1.0 / 289.0)) * 289.0; } 122 | vec2 mod289(vec2 x) { return x - floor(x * (1.0 / 289.0)) * 289.0; } 123 | vec3 permute(vec3 x) { return mod289(((x*34.0)+1.0)*x); } 124 | 125 | float snoise(vec2 v) { 126 | const vec4 C = vec4(0.211324865405187, // (3.0-sqrt(3.0))/6.0 127 | 0.366025403784439, // 0.5*(sqrt(3.0)-1.0) 128 | -0.577350269189626, // -1.0 + 2.0 * C.x 129 | 0.024390243902439); // 1.0 / 41.0 130 | vec2 i = floor(v + dot(v, C.yy) ); 131 | vec2 x0 = v - i + dot(i, C.xx); 132 | vec2 i1; 133 | i1 = (x0.x > x0.y) ? vec2(1.0, 0.0) : vec2(0.0, 1.0); 134 | vec4 x12 = x0.xyxy + C.xxzz; 135 | x12.xy -= i1; 136 | i = mod289(i); // Avoid truncation effects in permutation 137 | vec3 p = permute( permute( i.y + vec3(0.0, i1.y, 1.0 )) 138 | + i.x + vec3(0.0, i1.x, 1.0 )); 139 | 140 | vec3 m = max(0.5 - vec3(dot(x0,x0), dot(x12.xy,x12.xy), dot(x12.zw,x12.zw)), 0.0); 141 | m = m*m ; 142 | m = m*m ; 143 | vec3 x = 3.0 * fract(p * C.www) - 1.0; 144 | vec3 h = abs(x) - 0.5; 145 | vec3 ox = floor(x + 0.5); 146 | vec3 a0 = x - ox; 147 | m *= 1.79284291400159 - 0.85373472095314 * ( a0*a0 + h*h ); 148 | vec3 g; 149 | g.x = a0.x * x0.x + h.x * x0.y; 150 | g.yz = a0.yz * x12.xz + h.yz * x12.yw; 151 | return 130.0 * dot(m, g); 152 | } 153 | 154 | float getShape(vec2 fpos, int i, float scale) { 155 | if (i == 0) { 156 | return polygon(fpos, 2, scale); //rectangle 157 | } else if (i == 1) { 158 | return polygon(fpos, 1, scale); //line 159 | } else if (i == 2) { 160 | return polygon(fpos, 3, scale); //triangle 161 | } else if (i == 3) { 162 | return polygon(fpos, 4, scale); //square 163 | } else if (i == 4) { 164 | return polygon(fpos, 6, scale); //hexagon 165 | } else if (i == 5) { 166 | return circle(fpos, scale); //circle 167 | } else if (i == 6) { 168 | return ring(fpos, scale,scale*0.25); //ring1 169 | } else if (i ==7) { 170 | return ring(fpos, scale * 2.0 ,scale); //ring2 171 | } else { 172 | return polygon(fpos, 4, scale); //square 173 | } 174 | } 175 | 176 | void main() { 177 | vec2 st = gl_FragCoord.xy/RENDERSIZE.xy; 178 | st -= vec2(pos); 179 | st.x *= RENDERSIZE.x/RENDERSIZE.y; 180 | 181 | st = rotate2d(rotateCanvas*-TWO_PI) * st; 182 | 183 | 184 | st *= zoom; // Scale the coordinate system by 10 185 | 186 | if (centerTile) st+=0.5; // centers tile 187 | 188 | vec2 ipos = floor(st); // get the integer coords 189 | vec2 fpos = fract(st); // get the fractional coords 190 | 191 | float angle = snoise(ipos*turbulanceZoom+TIME*turbulanceSpeed)*spin; 192 | float scale = snoise(ipos*turbulanceZoom+TIME*turbulanceSpeed)*scale; 193 | 194 | fpos -= posOffset; 195 | fpos = rotate2d(angle*PI)* fpos; 196 | 197 | float t0 = mod(shape, 9.0); 198 | float t1 = mod(shape + 1.0, 9.0); 199 | int i0 = int(floor(t0)); 200 | int i1 = int(floor(t1)); 201 | float f = fract(t0); 202 | 203 | vec3 color = vec3(smoothedge(mix(getShape(fpos, i0, scale), getShape(fpos, i1, scale), f))); 204 | 205 | gl_FragColor = vec4(color,1.0); 206 | } -------------------------------------------------------------------------------- /ISF/29_WaveLines.fs: -------------------------------------------------------------------------------- 1 | // SaturdayShader Week 29 : Wave Lines 2 | // by Joseph Fiola (http://www.joefiola.com) 3 | // 2016-03-05 4 | 5 | // Based on "WAVES" Shadertoy by bonniem 6 | // https://www.shadertoy.com/view/4dsGzH 7 | 8 | /*{ 9 | "CREDIT": "Joseph Fiola", 10 | "DESCRIPTION": "", 11 | "CATEGORIES": [ 12 | "Generator" 13 | ], 14 | "INPUTS": [ 15 | { 16 | "NAME": "amp", 17 | "TYPE": "float", 18 | "DEFAULT": 1.0, 19 | "MIN": -20.0, 20 | "MAX": 20.0 21 | }, 22 | { 23 | "NAME": "glow", 24 | "TYPE": "float", 25 | "DEFAULT": -1.0, 26 | "MIN": -20.0, 27 | "MAX": 0.0 28 | }, 29 | { 30 | "NAME": "mod1", 31 | "TYPE": "float", 32 | "DEFAULT": 1.0, 33 | "MIN": 0.0, 34 | "MAX": 100.0 35 | }, 36 | { 37 | "NAME": "mod2", 38 | "TYPE": "float", 39 | "DEFAULT": 0.0, 40 | "MIN": -1.0, 41 | "MAX": 1.0 42 | }, 43 | { 44 | "NAME": "zoom", 45 | "TYPE": "float", 46 | "DEFAULT": 1.0, 47 | "MIN": 0.0, 48 | "MAX": 100.0 49 | }, 50 | { 51 | "NAME": "rotateCanvas", 52 | "TYPE": "float", 53 | "DEFAULT": 0.0, 54 | "MIN": 0.0, 55 | "MAX": 1.0 56 | }, 57 | { 58 | "NAME": "scroll", 59 | "TYPE": "float", 60 | "DEFAULT": 0.0, 61 | "MIN": 0.0, 62 | "MAX": 1.0 63 | }, 64 | { 65 | "NAME": "pos", 66 | "TYPE": "point2D", 67 | "DEFAULT": [0.5,0.5], 68 | "MIN":[0.0,0.0], 69 | "MAX":[1.0,1.0] 70 | }, 71 | { 72 | "NAME": "twisted", 73 | "TYPE": "float", 74 | "DEFAULT": 0.0, 75 | "MIN": -0.5, 76 | "MAX": 0.5 77 | } 78 | ] 79 | }*/ 80 | 81 | 82 | #define PI 3.14159265359 83 | #define TWO_PI 6.28318530718 84 | 85 | mat2 rotate2d(float _angle){ 86 | return mat2(cos(_angle),-sin(_angle), 87 | sin(_angle),cos(_angle)); 88 | } 89 | 90 | void main() 91 | { 92 | vec2 uv = gl_FragCoord.xy / RENDERSIZE.xy; 93 | uv -= vec2(pos); 94 | uv.x *= RENDERSIZE.x/RENDERSIZE.y; 95 | uv *= zoom; // Scale the coordinate system 96 | uv = rotate2d(rotateCanvas*-TWO_PI) * uv; 97 | 98 | 99 | // waves 100 | vec3 wave_color = vec3(0.0); 101 | 102 | float wave_width = 0.01; 103 | //uv = -1.0 + 2.0 * uv; 104 | //uv.y += 0.1; 105 | for(float i = 0.0; i < 10.0; i++) { 106 | 107 | uv = rotate2d(twisted*-TWO_PI) * uv; 108 | 109 | uv.y += sin(sin(uv.x + i*mod1 + (scroll * TWO_PI) ) * amp + (mod2 * PI)); 110 | wave_width = abs(1.0 / (50.0 * uv.y * glow)); 111 | wave_color += vec3(wave_width, wave_width, wave_width); 112 | } 113 | 114 | gl_FragColor = vec4(wave_color, 1.0); 115 | } -------------------------------------------------------------------------------- /ISF/30_Wisps.fs: -------------------------------------------------------------------------------- 1 | // SaturdayShader Week 30 : Wisps 2 | // by Joseph Fiola (http://www.joefiola.com) 3 | // 2016-03-12 4 | 5 | // Based on Week 29 Saturday Shader + "WAVES" Shadertoy by bonniem 6 | // https://www.shadertoy.com/view/4dsGzH 7 | 8 | /*{ 9 | "CREDIT": "Joseph Fiola", 10 | "DESCRIPTION": "", 11 | "CATEGORIES": [ 12 | "Generator" 13 | ], 14 | "INPUTS": [ 15 | { 16 | "NAME": "lines", 17 | "TYPE": "float", 18 | "DEFAULT": 100.0, 19 | "MIN": 1.0, 20 | "MAX": 200.0 21 | }, 22 | { 23 | "NAME": "linesStartOffset", 24 | "TYPE": "float", 25 | "DEFAULT": 0.5, 26 | "MIN": 0.0, 27 | "MAX": 1.0 28 | }, 29 | { 30 | "NAME": "amp", 31 | "TYPE": "float", 32 | "DEFAULT": 0.1, 33 | "MIN": 0.0, 34 | "MAX": 1.0 35 | }, 36 | { 37 | "NAME": "glow", 38 | "TYPE": "float", 39 | "DEFAULT": -6.0, 40 | "MIN": -40.0, 41 | "MAX": 0.0 42 | }, 43 | { 44 | "NAME": "mod1", 45 | "TYPE": "float", 46 | "DEFAULT": 1.0, 47 | "MIN": 0.0, 48 | "MAX": 1.0 49 | }, 50 | { 51 | "NAME": "mod2", 52 | "TYPE": "float", 53 | "DEFAULT": 0.01, 54 | "MIN": -1.0, 55 | "MAX": 1.0 56 | }, 57 | { 58 | "NAME": "zoom", 59 | "TYPE": "float", 60 | "DEFAULT": 11.0, 61 | "MIN": 0.0, 62 | "MAX": 100.0 63 | }, 64 | { 65 | "NAME": "rotateCanvas", 66 | "TYPE": "float", 67 | "DEFAULT": 0.0, 68 | "MIN": 0.0, 69 | "MAX": 1.0 70 | }, 71 | { 72 | "NAME": "scroll", 73 | "TYPE": "float", 74 | "DEFAULT": 0.0, 75 | "MIN": 0.0, 76 | "MAX": 1.0 77 | }, 78 | { 79 | "NAME": "pos", 80 | "TYPE": "point2D", 81 | "DEFAULT": [0.5,0.5], 82 | "MIN":[0.0,0.0], 83 | "MAX":[1.0,1.0] 84 | }, 85 | { 86 | "NAME": "twisted", 87 | "TYPE": "float", 88 | "DEFAULT": 0.01, 89 | "MIN": -0.5, 90 | "MAX": 0.5 91 | } 92 | ] 93 | }*/ 94 | 95 | 96 | #define PI 3.14159265359 97 | #define TWO_PI 6.28318530718 98 | 99 | mat2 rotate2d(float _angle){ 100 | return mat2(cos(_angle),-sin(_angle), 101 | sin(_angle),cos(_angle)); 102 | } 103 | 104 | void main() 105 | { 106 | vec2 uv = gl_FragCoord.xy / RENDERSIZE.xy; 107 | uv -= vec2(pos); 108 | uv.x *= RENDERSIZE.x/RENDERSIZE.y; 109 | uv *= zoom; // Scale the coordinate system 110 | uv = rotate2d(rotateCanvas*-TWO_PI) * uv; 111 | 112 | 113 | // waves 114 | vec3 wave_color = vec3(0.0); 115 | 116 | float wave_width = 0.01; 117 | //uv = -1.0 + 2.0 * uv; 118 | //uv.y += 0.1; 119 | for(float i = 0.0; i < 200.0; i++) { 120 | 121 | uv = rotate2d(twisted*-TWO_PI) * uv; 122 | if (lines <= i) break; 123 | 124 | uv.y += sin(sin(uv.x + i*mod1 + (scroll * TWO_PI) ) * amp + (mod2 * PI)); 125 | 126 | 127 | if(lines * linesStartOffset - 1.0 <= i) { 128 | wave_width = abs(1.0 / (50.0 * uv.y * glow)); 129 | wave_color += vec3(wave_width, wave_width, wave_width); 130 | } 131 | } 132 | 133 | gl_FragColor = vec4(wave_color, 1.0); 134 | } -------------------------------------------------------------------------------- /ISF/31_Twist.fs: -------------------------------------------------------------------------------- 1 | //Based on "Twist" Shadertoy by fb39ca4 - https://www.shadertoy.com/view/XsXXDH 2 | //Inspired by Matthew DiVito's gifs 3 | //http://cargocollective.com/matthewdivito/Animated-Gifs-02 4 | 5 | 6 | /*{ 7 | "CREDIT": "Joseph Fiola, Matthew DiVito, Shadertoy user fb39ca4", 8 | "DESCRIPTION": "", 9 | "CATEGORIES": [ 10 | "Generator" 11 | ], 12 | "INPUTS": [ 13 | { 14 | "NAME": "iterations", 15 | "TYPE": "float", 16 | "DEFAULT": 30.0, 17 | "MIN": 0.0, 18 | "MAX": 60.0 19 | }, 20 | { 21 | "NAME": "zoom", 22 | "TYPE": "float", 23 | "DEFAULT": 3.0, 24 | "MIN": 0.125, 25 | "MAX": 3.0 26 | }, 27 | { 28 | "NAME": "twist", 29 | "TYPE": "float", 30 | "DEFAULT": 0.51, 31 | "MIN": 0.0, 32 | "MAX": 1.0 33 | }, 34 | { 35 | "NAME": "offset", 36 | "TYPE": "float", 37 | "DEFAULT": 1.0, 38 | "MIN": 0.0, 39 | "MAX": 1.0 40 | }, 41 | { 42 | "NAME": "rotation", 43 | "TYPE": "float", 44 | "DEFAULT": 0.0, 45 | "MIN": 0.0, 46 | "MAX": 1.0 47 | }, 48 | { 49 | "NAME": "linesOffset", 50 | "TYPE": "float", 51 | "DEFAULT": 1.0, 52 | "MIN": -10.0, 53 | "MAX": 10.0 54 | }, 55 | { 56 | "NAME": "fade", 57 | "TYPE": "float", 58 | "DEFAULT": 1.0, 59 | "MIN": 0.0, 60 | "MAX": 1.0 61 | }, 62 | { 63 | "NAME": "stripes", 64 | "TYPE": "bool", 65 | "DEFAULT": true 66 | }, 67 | { 68 | "NAME": "invert", 69 | "TYPE": "bool", 70 | "DEFAULT": false 71 | }, 72 | { 73 | "NAME": "pos", 74 | "TYPE": "point2D", 75 | "DEFAULT": [ 76 | 0.5, 77 | 0.5 78 | ], 79 | "MIN": [ 80 | 0.0, 81 | 0.0 82 | ], 83 | "MAX": [ 84 | 1.0, 85 | 1.0 86 | ] 87 | } 88 | 89 | ] 90 | }*/ 91 | 92 | const float PI = 3.14159265; 93 | 94 | vec2 rotate(vec2 v, float a) { 95 | float sinA = sin(a); 96 | float cosA = cos(a); 97 | return vec2(v.x * cosA - v.y * sinA, v.y * cosA + v.x * sinA); 98 | } 99 | 100 | float square(vec2 uv, float d) { 101 | return max(abs(uv.x), abs(uv.y)) - d; 102 | } 103 | 104 | 105 | 106 | void main() 107 | { 108 | vec2 uv = gl_FragCoord.xy / RENDERSIZE.xy; 109 | uv -= vec2(pos); 110 | 111 | uv.x *= RENDERSIZE.x / RENDERSIZE.y; 112 | uv *= zoom; 113 | 114 | uv = rotate(uv, rotation * PI); 115 | 116 | float blurAmount = -5.0 / RENDERSIZE.y * (zoom * 0.5); 117 | 118 | float time = twist; 119 | 120 | gl_FragColor = vec4(0.0, 0.0, 0.0, 1.0); 121 | for (int i = 0; i < 60; i++) { 122 | 123 | float n = float(i); 124 | float size = 1.0 - n / iterations; 125 | float rotateAmount = (n * 0.5 + 0.25) * PI * 2.0; 126 | gl_FragColor.rgb = mix(gl_FragColor.rgb, vec3(1.0), smoothstep(0.0, blurAmount, square(rotate(uv, -rotateAmount * time), size))); 127 | 128 | float blackOffset = mix(linesOffset / 4.0, linesOffset / 2.0, n / (iterations * offset)) / (iterations * offset); 129 | gl_FragColor.rgb = mix(gl_FragColor.rgb, vec3(0.0), smoothstep(0.0, blurAmount, square(rotate(uv, -(rotateAmount + PI / 2.0) * time), size - blackOffset))); 130 | 131 | 132 | 133 | if (stripes) { 134 | gl_FragColor.rgb = vec3(gl_FragColor.rgb * -1.0 + 1.0) * fade; 135 | } else { 136 | gl_FragColor.rgb = gl_FragColor.rgb * fade; 137 | } 138 | } 139 | 140 | if (invert) gl_FragColor.rgb = vec3(gl_FragColor.rgb *-1.0 + 1.0); 141 | 142 | } -------------------------------------------------------------------------------- /ISF/32_WaveShapes.fs: -------------------------------------------------------------------------------- 1 | // SaturdayShader Week 31 : WaveShapes 2 | // by Joseph Fiola (http://www.joefiola.com) 3 | // 2016-03-26 4 | 5 | // Based on shader by Shadertoy user smb02dunnal entitiled "Electro-Prim's" - https://www.shadertoy.com/view/Mll3WS 6 | // https://twitter.com/AlexWDunn 7 | 8 | 9 | 10 | /*{ 11 | "CREDIT": "Joseph Fiola", 12 | "DESCRIPTION": "", 13 | "CATEGORIES": [ 14 | "Generator" 15 | ], 16 | "INPUTS": [ 17 | { 18 | "NAME": "shape", 19 | "TYPE": "long", 20 | "VALUES": [ 21 | 0, 22 | 1 23 | 24 | ], 25 | "LABELS": [ 26 | "triangle", 27 | "square" 28 | 29 | ], 30 | "DEFAULT": 0 31 | }, 32 | { 33 | "NAME": "zoom", 34 | "TYPE": "float", 35 | "DEFAULT": 1.0, 36 | "MIN": 0.0, 37 | "MAX": 10.0 38 | }, 39 | { 40 | "NAME": "rotate", 41 | "TYPE": "float", 42 | "DEFAULT": 0.0, 43 | "MIN": 0.0, 44 | "MAX": 1.0 45 | }, 46 | { 47 | "NAME": "twist", 48 | "TYPE": "float", 49 | "DEFAULT": 0.02, 50 | "MIN": 0.0, 51 | "MAX": 1.0 52 | }, 53 | { 54 | "NAME": "tunnel", 55 | "TYPE": "float", 56 | "DEFAULT": 1.1, 57 | "MIN": 0.25, 58 | "MAX": 1.75 59 | }, 60 | { 61 | "NAME": "thickness", 62 | "TYPE": "float", 63 | "DEFAULT": 0.003, 64 | "MIN": 0.0, 65 | "MAX": 0.2 66 | }, 67 | { 68 | "NAME": "amplitude", 69 | "TYPE": "float", 70 | "DEFAULT": 2.0, 71 | "MIN": 0.0, 72 | "MAX": 100.0 73 | }, 74 | { 75 | "NAME": "frequency", 76 | "TYPE": "float", 77 | "DEFAULT": 2.0, 78 | "MIN": 0.0, 79 | "MAX": 50.0 80 | }, 81 | { 82 | "NAME": "band", 83 | "TYPE": "float", 84 | "DEFAULT": 0.0, 85 | "MIN": -0.5, 86 | "MAX": 1.0 87 | }, 88 | { 89 | "NAME": "motion", 90 | "TYPE": "float", 91 | "DEFAULT": 0.0, 92 | "MIN": 0.0, 93 | "MAX": 1.0 94 | }, 95 | { 96 | "NAME": "pos", 97 | "TYPE": "point2D", 98 | "DEFAULT": [0.5,0.5], 99 | "MIN":[0.0,0.0], 100 | "MAX":[1.0,1.0] 101 | } 102 | ] 103 | }*/ 104 | 105 | 106 | 107 | #define PI 3.14159265359 108 | #define TWO_PI 6.28318530718 109 | 110 | float electro(vec2 uv, float d, float f, float o, float a, float b) 111 | { 112 | 113 | float theta = atan(uv.y,uv.x); 114 | 115 | float amp = smoothstep(0.0, 1.0, (sin(theta+motion * 2.0 * PI)*0.5+0.5)-b)*a; 116 | float phase = d + sin(theta * f + o + motion * PI * 2.0) * amp; 117 | 118 | return sin(clamp(phase, 0.0, PI*2.0) + PI/2.0) + 1.0005; 119 | } 120 | 121 | mat2 rotate2d(float _angle){ 122 | return mat2(cos(_angle),-sin(_angle), 123 | sin(_angle),cos(_angle)); 124 | } 125 | 126 | void main() 127 | { 128 | const float radius = 0.1; 129 | 130 | vec2 uv = gl_FragCoord.xy / RENDERSIZE.xy; 131 | uv -= vec2(pos); 132 | uv.x *= RENDERSIZE.x/RENDERSIZE.y; 133 | 134 | uv = rotate2d(rotate*-TWO_PI) * uv; 135 | uv *= zoom; 136 | 137 | float grey = 0.0; 138 | float alpha = 1.0; 139 | 140 | for(int i = 0; i < 20; i++) { 141 | 142 | float d = 0.0; 143 | 144 | //triangle 145 | if (shape == 0){ 146 | float root2 = sqrt(2.0); 147 | d = dot(uv, vec2(0.0,-1.0)); 148 | d = max(d, dot(uv, vec2(-root2,1.0))); 149 | d = max(d, dot(uv, vec2( root2,1.0))); 150 | } 151 | 152 | //square 153 | if (shape == 1){ 154 | d = max(abs(uv).x, abs(uv).y); 155 | } 156 | 157 | grey += 1.0 - smoothstep(0.0, thickness, electro(uv, d/radius, frequency, 0.0 * PI, amplitude, band)); 158 | grey += 1.0 - smoothstep(0.0, thickness, electro(uv, d/radius, frequency, 0.5 * PI, amplitude, band)); 159 | grey += 1.0 - smoothstep(0.0, thickness, electro(uv, d/radius, frequency, 1.0 * PI, amplitude, band)); 160 | 161 | 162 | //tunnel 163 | uv *= tunnel; 164 | 165 | //twist 166 | uv = rotate2d(twist*-TWO_PI) * uv; 167 | } 168 | 169 | 170 | gl_FragColor = vec4(vec3(grey),1.0); 171 | } -------------------------------------------------------------------------------- /ISF/33_CrossGrid.fs: -------------------------------------------------------------------------------- 1 | // SaturdayShader Week 33 : CrossGrid 2 | // Joseph Fiola (http://www.joefiola.com) 3 | // 2016-04-02 4 | 5 | // Based on http://thebookofshaders.com/edit.html#09/cross.frag 6 | // by Patricio Gonzalez Vivo - www.patriciogonzalezvivo.com 7 | 8 | /*{ 9 | "CREDIT": "", 10 | "DESCRIPTION": "", 11 | "CATEGORIES": [ 12 | "Generator" 13 | ], 14 | "INPUTS": [ 15 | { 16 | "NAME": "zoom", 17 | "TYPE": "float", 18 | "DEFAULT": 8.0, 19 | "MIN": 0.0, 20 | "MAX": 100.0 21 | }, 22 | { 23 | "NAME": "scale", 24 | "TYPE": "float", 25 | "DEFAULT": 0.5, 26 | "MIN": 0.0, 27 | "MAX": 15.0 28 | }, 29 | { 30 | "NAME": "rotate", 31 | "TYPE": "float", 32 | "DEFAULT": 0.0, 33 | "MIN": 0.0, 34 | "MAX": 1.0 35 | }, 36 | { 37 | "NAME": "spin", 38 | "TYPE": "float", 39 | "DEFAULT": 0.0, 40 | "MIN": 0.0, 41 | "MAX": 1.0 42 | }, 43 | { 44 | "NAME": "centerOffset", 45 | "TYPE": "float", 46 | "DEFAULT": 0.0, 47 | "MIN": 0.0, 48 | "MAX": 1.0 49 | }, 50 | { 51 | "NAME": "verticalHeight", 52 | "TYPE": "float", 53 | "DEFAULT": 0.125, 54 | "MIN": -0.1, 55 | "MAX": 0.5 56 | }, 57 | { 58 | "NAME": "verticalWidth", 59 | "TYPE": "float", 60 | "DEFAULT": 0.5, 61 | "MIN": -0.1, 62 | "MAX": 0.5 63 | }, 64 | { 65 | "NAME": "horizontalHeight", 66 | "TYPE": "float", 67 | "DEFAULT": 0.5, 68 | "MIN": -0.1, 69 | "MAX": 0.5 70 | }, 71 | { 72 | "NAME": "horizontalWidth", 73 | "TYPE": "float", 74 | "DEFAULT": 0.125, 75 | "MIN": -0.1, 76 | "MAX": 0.5 77 | }, 78 | { 79 | "NAME": "grid", 80 | "TYPE": "float", 81 | "DEFAULT": 5.0, 82 | "MIN": 0.0, 83 | "MAX": 100.0 84 | }, 85 | { 86 | "NAME": "gridRotate", 87 | "TYPE": "float", 88 | "DEFAULT": 0.0, 89 | "MIN": 0.0, 90 | "MAX": 1.0 91 | }, 92 | { 93 | "NAME": "linesThickness", 94 | "TYPE": "float", 95 | "DEFAULT": 0.99, 96 | "MIN": 0.25, 97 | "MAX": 1.0 98 | }, 99 | { 100 | "NAME": "invert", 101 | "TYPE": "bool" 102 | }, 103 | { 104 | "NAME": "pos", 105 | "TYPE": "point2D", 106 | "DEFAULT": [0.5,0.5], 107 | "MIN":[0.0,0.0], 108 | "MAX":[1.0,1.0] 109 | } 110 | ] 111 | }*/ 112 | 113 | #ifdef GL_ES 114 | precision mediump float; 115 | #endif 116 | 117 | #define TWO_PI 6.28318530718 118 | 119 | 120 | mat2 rotate2d(float _angle){ 121 | return mat2(cos(_angle),-sin(_angle), 122 | sin(_angle),cos(_angle)); 123 | } 124 | 125 | vec2 tile(vec2 _st, float _zoom){ 126 | _st *= _zoom; 127 | return fract(_st); 128 | } 129 | 130 | float box(in vec2 _st, in vec2 _size){ 131 | _size = vec2(0.5) - _size * 0.5; 132 | vec2 uv = smoothstep(_size, 133 | _size+vec2(0.001), 134 | _st); 135 | uv *= smoothstep(_size, 136 | _size+vec2(0.001), 137 | vec2(1.0)-_st); 138 | return uv.x*uv.y; 139 | } 140 | 141 | float cross(in vec2 _st, float _size){ 142 | return box(_st, vec2(_size*verticalWidth,_size*verticalHeight)) + 143 | box(_st, vec2(_size*horizontalWidth,_size*horizontalHeight)); 144 | } 145 | 146 | 147 | 148 | void main(){ 149 | 150 | //crosses 151 | vec2 st = gl_FragCoord.xy / RENDERSIZE.xy; 152 | st -= vec2(pos); 153 | st.x *= RENDERSIZE.x/RENDERSIZE.y; 154 | st = rotate2d(rotate*-TWO_PI) * st; 155 | st = tile(st,zoom); 156 | st -= 0.5; 157 | st = rotate2d(spin*-TWO_PI) * st; 158 | st += centerOffset; 159 | vec3 color = vec3( clamp(cross(fract(st),scale),0.0,1.0) ); 160 | 161 | //square grids 162 | st = gl_FragCoord.xy / RENDERSIZE.xy; 163 | st -= vec2(pos); 164 | st.x *= RENDERSIZE.x/RENDERSIZE.y; 165 | st = rotate2d(gridRotate*-TWO_PI/2.0) * st; 166 | st += centerOffset; 167 | st = tile(st,grid); 168 | 169 | color += vec3(box(st,vec2(linesThickness))) * -1.0 + 1.0; 170 | 171 | if (invert) color = color *-1.0 + 1.0; 172 | 173 | 174 | gl_FragColor = vec4(color,1.0); 175 | } 176 | -------------------------------------------------------------------------------- /ISF/34_Kaleidolines.fs: -------------------------------------------------------------------------------- 1 | // SaturdayShader Week 34 : Kaleidolines 2 | // Joseph Fiola (http://www.joefiola.com) 3 | // 2016-04-09 4 | 5 | // Based on Shadertoy created by Vinicius Graciano Santos - vgs/2014 6 | // https://www.shadertoy.com/view/lsBSDz 7 | 8 | 9 | /*{ 10 | "CREDIT": "", 11 | "DESCRIPTION": "", 12 | "CATEGORIES": [ 13 | "Generator" 14 | ], 15 | "INPUTS": [ 16 | { 17 | "NAME": "invert", 18 | "TYPE": "bool", 19 | "DEFAULT" : "1" 20 | }, 21 | { 22 | "NAME": "zoom", 23 | "TYPE": "float", 24 | "DEFAULT": 2.0, 25 | "MIN": 0.25, 26 | "MAX": 20.0 27 | }, 28 | { 29 | "NAME": "rotateCanvas", 30 | "TYPE": "float", 31 | "DEFAULT": 0.0, 32 | "MIN": 0.0, 33 | "MAX": 1.0 34 | }, 35 | { 36 | "NAME": "rotateLines", 37 | "TYPE": "float", 38 | "DEFAULT": 0.0, 39 | "MIN": 0.0, 40 | "MAX": 1.0 41 | }, 42 | { 43 | "NAME": "lineThickness", 44 | "TYPE": "float", 45 | "DEFAULT": 1.0, 46 | "MIN": 0.1, 47 | "MAX": 20.0 48 | }, 49 | 50 | { 51 | "NAME": "lineLength", 52 | "TYPE": "float", 53 | "DEFAULT": 1.25, 54 | "MIN": 0.05, 55 | "MAX": 10.0 56 | }, 57 | { 58 | "NAME": "lines1", 59 | "TYPE": "float", 60 | "DEFAULT": 10.0, 61 | "MIN": 1.0, 62 | "MAX": 10.0 63 | }, 64 | { 65 | "NAME": "lines2", 66 | "TYPE": "float", 67 | "DEFAULT": 10.0, 68 | "MIN": 1.0, 69 | "MAX": 10.0 70 | }, 71 | { 72 | "NAME": "offset", 73 | "TYPE": "float", 74 | "DEFAULT": 0.0, 75 | "MIN": -2.0, 76 | "MAX": 2.0 77 | }, 78 | { 79 | "NAME": "motion", 80 | "TYPE": "float", 81 | "DEFAULT": 0.25, 82 | "MIN": 0.0, 83 | "MAX": 1.0 84 | }, 85 | { 86 | "NAME": "pos", 87 | "TYPE": "point2D", 88 | "DEFAULT": [0.5,0.5], 89 | "MIN":[0.0,0.0], 90 | "MAX":[1.0,1.0] 91 | } 92 | ] 93 | }*/ 94 | 95 | 96 | #define TAU 6.28318530718 97 | 98 | mat2 rotate2d(float _angle){ 99 | return mat2(cos(_angle),-sin(_angle), 100 | sin(_angle),cos(_angle)); 101 | } 102 | 103 | vec2 tile(vec2 _st, float _zoom){ 104 | _st *= _zoom; 105 | return fract(_st); 106 | } 107 | 108 | float segment(vec2 p, vec2 a, vec2 b) { 109 | vec2 ab = b - a; 110 | vec2 ap = p - a; 111 | float k = clamp(dot(ap, ab)/dot(ab, ab), 0.0, lineLength); 112 | return smoothstep(0.0, 0.003 + lineThickness/RENDERSIZE.y, length(ap - k*ab) - (0.001 * lineThickness * 5. )); 113 | } 114 | 115 | float shape(vec2 p, float angle) { 116 | float d = 100.0; 117 | vec2 a = vec2(1.0, 0.0), b; 118 | vec2 rot = vec2(cos(angle), sin(angle)); 119 | 120 | for (int i = 0; i < 10; ++i) { 121 | a = a + offset; 122 | if (i >= int(lines1)) break; 123 | b = a; 124 | for (int j = 0; j < 10; ++j) { 125 | if (j >= int(lines2)) break; 126 | b = vec2(b.x*rot.x - b.y*rot.y, b.x*rot.y + b.y*rot.x); 127 | p = rotate2d(rotateLines* -TAU) * p; 128 | d = min(d, segment(p, a, b)); 129 | } 130 | a = vec2(a.x*rot.x - a.y*rot.y, a.x*rot.y + a.y*rot.x); 131 | 132 | } 133 | return d; 134 | } 135 | 136 | void main() { 137 | 138 | vec2 uv = gl_FragCoord.xy / RENDERSIZE.xy; 139 | uv -= vec2(pos); 140 | uv.x *= RENDERSIZE.x/RENDERSIZE.y; 141 | uv = rotate2d(rotateCanvas *-TAU) * uv; 142 | uv *= zoom; 143 | 144 | float col = shape(abs(uv), cos((motion * TAU))); 145 | 146 | if (invert) col = col *-1.0 + 1.0; 147 | 148 | gl_FragColor = vec4(vec3(col), 1.0); 149 | } -------------------------------------------------------------------------------- /ISF/35_Moiree.fs: -------------------------------------------------------------------------------- 1 | // SaturdayShader Week 35 : Moirée 2 | // by Joseph Fiola (http://www.joefiola.com) 3 | // 2016-04-16 4 | 5 | //Based on "Hyper-lightweight2 XOR ..." Shadertoy https://www.shadertoy.com/view/4slXWn by Fabrice NEYRET @FabriceNEYRET 6 | 7 | /*{ 8 | "CREDIT": "", 9 | "DESCRIPTION": "", 10 | "CATEGORIES": [ 11 | "Generator" 12 | ], 13 | "INPUTS": [ 14 | { 15 | "NAME": "invert", 16 | "TYPE": "bool", 17 | "DEFAULT" : "0" 18 | }, 19 | { 20 | "NAME": "zoom", 21 | "TYPE": "float", 22 | "DEFAULT": 4.0, 23 | "MIN": 0.25, 24 | "MAX": 10.0 25 | }, 26 | { 27 | "NAME": "rotate", 28 | "TYPE": "float", 29 | "DEFAULT": 0.0, 30 | "MIN": 0.0, 31 | "MAX": 1.0 32 | }, 33 | { 34 | "NAME": "speed", 35 | "TYPE": "float", 36 | "DEFAULT": 1.0, 37 | "MIN": 0.0, 38 | "MAX": 4.0 39 | }, 40 | { 41 | "NAME": "details", 42 | "TYPE": "float", 43 | "DEFAULT": 50.0, 44 | "MIN": 1.0, 45 | "MAX": 500.0 46 | }, 47 | { 48 | "NAME": "amp", 49 | "TYPE": "float", 50 | "DEFAULT": 1.0, 51 | "MIN": 0.0, 52 | "MAX": 4.0 53 | }, 54 | { 55 | "NAME": "frequency", 56 | "TYPE": "float", 57 | "DEFAULT": 1.0, 58 | "MIN": 0.02, 59 | "MAX": 50.0 60 | }, 61 | { 62 | "NAME": "sharpen", 63 | "TYPE": "float", 64 | "DEFAULT": 1.0, 65 | "MIN": 0.0, 66 | "MAX": 4.0 67 | }, 68 | { 69 | "NAME": "pos", 70 | "TYPE": "point2D", 71 | "DEFAULT": [0.5,0.5], 72 | "MIN":[0.0,0.0], 73 | "MAX":[1.0,1.0] 74 | } 75 | ] 76 | }*/ 77 | 78 | #define TWO_PI 6.28318530718 79 | 80 | mat2 rotate2d(float _angle){ 81 | return mat2(cos(_angle),-sin(_angle), 82 | sin(_angle),cos(_angle)); 83 | } 84 | 85 | float f(float a, float b, vec2 uv) { 86 | return sin(length( uv -vec2(cos(a) * amp,sin(b) *amp) * frequency) *details) *sharpen; 87 | } 88 | 89 | void main() { 90 | 91 | float t= TIME * speed; 92 | 93 | vec2 uv = gl_FragCoord.xy / RENDERSIZE.xy; 94 | uv -= vec2(pos); 95 | uv.x *= RENDERSIZE.x/RENDERSIZE.y; 96 | 97 | uv = rotate2d(rotate*-TWO_PI) * uv; 98 | uv *= zoom; 99 | 100 | 101 | float offset = 0.7; 102 | vec4 color = vec4(f(t,t,uv)*f(t * (offset * 2.0),t * offset, uv)); 103 | 104 | if (invert) color = color *-1.0 + 1.0; 105 | 106 | gl_FragColor = vec4(color); 107 | } -------------------------------------------------------------------------------- /ISF/36_Hypnocone.fs: -------------------------------------------------------------------------------- 1 | // SaturdayShader Week 36 : SpiralCone 2 | // by Joseph Fiola (http://www.joefiola.com) 3 | // 2016-04-23 4 | 5 | // Based on "Flailing" Shadertoy by okro 6 | //https://www.shadertoy.com/view/MsjSWw 7 | 8 | /*{ 9 | "CREDIT": "", 10 | "DESCRIPTION": "", 11 | "CATEGORIES": [ 12 | "Generator" 13 | ], 14 | "INPUTS": [ 15 | { 16 | "NAME": "invert", 17 | "TYPE": "bool" 18 | }, 19 | { 20 | "NAME": "zoom", 21 | "TYPE": "float", 22 | "DEFAULT": 2.0, 23 | "MIN": 0.25, 24 | "MAX": 10.0 25 | }, 26 | { 27 | "NAME": "rings", 28 | "TYPE": "float", 29 | "DEFAULT": 0.01, 30 | "MIN": 0.01, 31 | "MAX": 1.0 32 | }, 33 | { 34 | "NAME": "radius", 35 | "TYPE": "float", 36 | "DEFAULT": 1.0, 37 | "MIN": 0.001, 38 | "MAX": 2.0 39 | }, 40 | { 41 | "NAME": "xAmp", 42 | "TYPE": "float", 43 | "DEFAULT": 0.0, 44 | "MIN": -0.1, 45 | "MAX": 0.1 46 | }, 47 | { 48 | "NAME": "xOffset", 49 | "TYPE": "float", 50 | "DEFAULT": 0.0, 51 | "MIN": -1.0, 52 | "MAX": 1.0 53 | }, 54 | { 55 | "NAME": "xOffsetSpeed", 56 | "TYPE": "float", 57 | "DEFAULT": 0.0, 58 | "MIN": 0.0, 59 | "MAX": 0.1 60 | }, 61 | { 62 | "NAME": "yAmp", 63 | "TYPE": "float", 64 | "DEFAULT": 0.0, 65 | "MIN": -0.1, 66 | "MAX": 0.1 67 | }, 68 | { 69 | "NAME": "yOffset", 70 | "TYPE": "float", 71 | "DEFAULT": 0.0, 72 | "MIN": -1.0, 73 | "MAX": 1.0 74 | }, 75 | { 76 | "NAME": "yOffsetSpeed", 77 | "TYPE": "float", 78 | "DEFAULT": 0.0, 79 | "MIN": 0.0, 80 | "MAX": 0.1 81 | }, 82 | { 83 | "NAME": "startPoint", 84 | "TYPE": "float", 85 | "DEFAULT": 0.0, 86 | "MIN": 0.0, 87 | "MAX": 300.0 88 | }, 89 | { 90 | "NAME": "rotate", 91 | "TYPE": "float", 92 | "DEFAULT": 0.0, 93 | "MIN": 0.0, 94 | "MAX": 1.0 95 | }, 96 | { 97 | "NAME": "pos", 98 | "TYPE": "point2D", 99 | "DEFAULT": [0.5,0.5], 100 | "MIN":[0.0,0.0], 101 | "MAX":[1.0,1.0] 102 | } 103 | ] 104 | }*/ 105 | 106 | 107 | #define TWO_PI 6.28318530718 108 | 109 | mat2 rotate2d(float _angle){ 110 | return mat2(cos(_angle),-sin(_angle), 111 | sin(_angle),cos(_angle)); 112 | } 113 | 114 | void main() 115 | { 116 | vec2 uv = gl_FragCoord.xy / RENDERSIZE.xy; 117 | uv -= vec2(pos); 118 | uv.x *= RENDERSIZE.x/RENDERSIZE.y; 119 | uv = rotate2d(rotate*-TWO_PI) * uv; 120 | uv *= zoom; 121 | 122 | vec3 col = vec3(0.); 123 | vec2 loc = uv * 0.0; 124 | 125 | float radius = radius+rings; 126 | 127 | 128 | for (int i = 0; i < 100; ++i) { 129 | float r = smoothstep(radius, radius+.004, distance(uv,loc)); 130 | 131 | col = 1.0 - col * r; 132 | 133 | //move circles 134 | float dx = xAmp; 135 | dx += cos((startPoint + TIME) * xOffsetSpeed * float(i)) * xOffset; 136 | 137 | float dy = yAmp; 138 | dy += sin((startPoint + TIME) * yOffsetSpeed * float(i)) * yOffset; 139 | 140 | loc += vec2(dx, dy); 141 | 142 | 143 | //make smaller 144 | radius -= rings; 145 | } 146 | 147 | if (invert) col = col *-1.0 + 1.0; 148 | gl_FragColor = vec4(col, 1.0); 149 | } -------------------------------------------------------------------------------- /ISF/37_CircleSpiral.fs: -------------------------------------------------------------------------------- 1 | // SaturdayShader Week 37 : CircleSpiral 2 | // by Joseph Fiola (http://www.joefiola.com) 3 | // 2016-04-30 4 | 5 | // Based on "CircleSpiral" Shadertoy by mmalex 6 | // https://www.shadertoy.com/view/4sBGRh 7 | 8 | /*{ 9 | "CREDIT": "", 10 | "DESCRIPTION": "", 11 | "CATEGORIES": [ 12 | "Generator" 13 | ], 14 | "INPUTS": [ 15 | { 16 | "NAME": "invert", 17 | "TYPE": "bool" 18 | }, 19 | { 20 | "NAME": "zoom", 21 | "TYPE": "float", 22 | "DEFAULT": 0.5, 23 | "MIN": 0.25, 24 | "MAX": 10.0 25 | }, 26 | { 27 | "NAME": "rotate", 28 | "TYPE": "float", 29 | "DEFAULT": 0.0, 30 | "MIN": 0.0, 31 | "MAX": 1.0 32 | }, 33 | { 34 | "NAME": "offset", 35 | "TYPE": "float", 36 | "DEFAULT": 15.0, 37 | "MIN": -50.0, 38 | "MAX": 50.0 39 | }, 40 | { 41 | "NAME": "speed", 42 | "TYPE": "float", 43 | "DEFAULT": 0.1, 44 | "MIN": 0.0, 45 | "MAX": 3.0 46 | }, 47 | { 48 | "NAME": "lineThickness", 49 | "TYPE": "float", 50 | "DEFAULT": 1.5, 51 | "MIN": 0.0, 52 | "MAX": 50.0 53 | }, 54 | { 55 | "NAME": "radius", 56 | "TYPE": "float", 57 | "DEFAULT": 1.5, 58 | "MIN": 0.0, 59 | "MAX": 50.0 60 | }, 61 | { 62 | "NAME": "pos", 63 | "TYPE": "point2D", 64 | "DEFAULT": [0.5,0.5], 65 | "MIN":[0.0,0.0], 66 | "MAX":[1.0,1.0] 67 | }, 68 | { 69 | "NAME": "mode", 70 | "TYPE": "long", 71 | "VALUES": [ 72 | 0, 73 | 1 74 | ], 75 | "LABELS": [ 76 | "spiral", 77 | "wave" 78 | ], 79 | "DEFAULT": 0 80 | } 81 | ] 82 | }*/ 83 | 84 | 85 | #define TWO_PI 6.28318530718 86 | 87 | mat2 rotate2d(float _angle){ 88 | return mat2(cos(_angle),-sin(_angle), 89 | sin(_angle),cos(_angle)); 90 | } 91 | 92 | void main() 93 | { 94 | float res=min(RENDERSIZE.x,RENDERSIZE.y); 95 | float pixel=1.0/res; 96 | vec2 p = (gl_FragCoord.xy-RENDERSIZE.xy * vec2(pos)) * pixel; 97 | p = rotate2d(rotate* -TWO_PI) * p; 98 | p *=zoom; 99 | 100 | float ink=0.0,theta=0.0; 101 | float rr=res; 102 | float ofs=0.0001*(TIME + 10.) * offset + pixel * 0.25; 103 | 104 | for (int iter=0;iter<100;++iter) { 105 | ink += max(0.0, lineThickness - abs(length(p) - radius) * rr); 106 | rr /= 1.1; // center glow 107 | p *= 1.1; 108 | p.x += ofs * sin(theta); 109 | if (mode == 0) p.y += ofs * cos(theta); 110 | if (mode == 1) p.y += ofs * sin(theta); 111 | 112 | theta += TIME * speed; 113 | } 114 | 115 | ink=sqrt(ink)*0.5; // line blur 116 | 117 | if (invert) ink = ink *-1.0 + 1.0; 118 | 119 | gl_FragColor = vec4(vec3(ink),1.0); 120 | 121 | } -------------------------------------------------------------------------------- /ISF/38_SimpleShapeFunctions.fs: -------------------------------------------------------------------------------- 1 | // SaturdayShader Week 38 : SimpleShapeFunctions 2 | // by Joseph Fiola (http://www.joefiola.com) 3 | // 2016-05-07 4 | 5 | // Simple shape function based on the first examples in the Book of Shaders by Patricio Gonzalez Vivo 6 | // http://thebookofshaders.com/05/ 7 | 8 | 9 | 10 | 11 | /*{ 12 | "CREDIT": "Joseph Fiola", 13 | "DESCRIPTION": "", 14 | "CATEGORIES": [ 15 | "Generator" 16 | ], 17 | "INPUTS": [ 18 | { 19 | "NAME": "function", 20 | "TYPE": "long", 21 | "VALUES": [ 22 | 0,1,2,3,4 23 | 24 | ], 25 | "LABELS": [ 26 | "tan", 27 | "atan", 28 | "sin", 29 | "asin", 30 | "mod" 31 | 32 | ], 33 | "DEFAULT": 0 34 | }, 35 | { 36 | "NAME": "invert", 37 | "TYPE": "bool" 38 | }, 39 | { 40 | "NAME" : "zoom", 41 | "TYPE" : "float", 42 | "DEFAULT": 10.0, 43 | "MIN": 1e-4, 44 | "MAX": 20.0 45 | }, 46 | { 47 | "NAME" : "thickness", 48 | "TYPE" : "float", 49 | "DEFAULT": 2.0, 50 | "MIN": 0.0, 51 | "MAX": 10.0 52 | }, 53 | { 54 | "NAME" : "compress", 55 | "TYPE" : "float", 56 | "DEFAULT": 1.0, 57 | "MIN": 1e-4, 58 | "MAX": 10.0 59 | }, 60 | { 61 | "NAME": "rotate", 62 | "TYPE": "float", 63 | "DEFAULT": 0.0, 64 | "MIN": 0.0, 65 | "MAX": 1.0 66 | }, 67 | { 68 | "NAME": "pos", 69 | "TYPE": "point2D", 70 | "DEFAULT": [0.5,0.5], 71 | "MIN":[0.0,0.0], 72 | "MAX":[1.0,1.0] 73 | } 74 | ] 75 | }*/ 76 | 77 | 78 | #ifdef GL_ES 79 | precision mediump float; 80 | #endif 81 | 82 | #define TWO_PI 6.28318530718 83 | 84 | 85 | 86 | 87 | // Plot a line on Y using a value between 0.0-1.0 88 | float plot(vec2 st, float pct){ 89 | return smoothstep( pct-thickness, pct, st.y) - 90 | smoothstep( pct, pct+thickness, st.y); 91 | } 92 | 93 | // Rotate 94 | mat2 rotate2d(float _angle){ 95 | return mat2(cos(_angle),-sin(_angle), 96 | sin(_angle),cos(_angle)); 97 | } 98 | 99 | void main() { 100 | vec2 st = gl_FragCoord.xy/RENDERSIZE; 101 | st -= vec2(pos); 102 | st.x *= RENDERSIZE.x/RENDERSIZE.y; 103 | st *= zoom; 104 | st = rotate2d(rotate*-TWO_PI) * st; 105 | 106 | float p = 0.0; 107 | 108 | if(function == 0) p = tan(st.x); 109 | if(function == 1) p = atan(st.x); 110 | if(function == 2) p = sin(st.x); 111 | if(function == 3) p = asin(st.x); 112 | if(function == 4) p = mod(st.x, 1.0); 113 | 114 | 115 | // Plot line 116 | float pct = plot(st,p*compress); 117 | 118 | if (invert) pct = pct *-1.0 + 1.0; 119 | 120 | gl_FragColor = vec4(vec3(pct),1.0); 121 | } -------------------------------------------------------------------------------- /ISF/39_MoreMoire.fs: -------------------------------------------------------------------------------- 1 | // SaturdayShader Week 39 : More Moiré 2 | // by Joseph Fiola (http://www.joefiola.com) 3 | // 2016-05-14 4 | 5 | // Based on "Moiré Bounce" Shadertoy by echophon 6 | // https://www.shadertoy.com/view/XlfGDB 7 | 8 | 9 | 10 | 11 | /*{ 12 | "CREDIT": "Joseph Fiola", 13 | "DESCRIPTION": "", 14 | "CATEGORIES": [ 15 | "Generator" 16 | ], 17 | "INPUTS": [ 18 | { 19 | "NAME": "invert", 20 | "TYPE": "bool" 21 | }, 22 | { 23 | "NAME" : "zoom", 24 | "TYPE" : "float", 25 | "DEFAULT": 10.0, 26 | "MIN": 1e-4, 27 | "MAX": 20.0 28 | }, 29 | { 30 | "NAME" : "moire_x", 31 | "TYPE" : "float", 32 | "DEFAULT": 10.0, 33 | "MIN": 1e-4, 34 | "MAX": 10.0 35 | }, 36 | { 37 | "NAME" : "moire_y", 38 | "TYPE" : "float", 39 | "DEFAULT": 4.0, 40 | "MIN": 1e-4, 41 | "MAX": 10.0 42 | }, 43 | { 44 | "NAME" : "shape_x", 45 | "TYPE" : "float", 46 | "DEFAULT": 1.005, 47 | "MIN": 0.0, 48 | "MAX": 1.0 49 | }, 50 | { 51 | "NAME" : "shape_y", 52 | "TYPE" : "float", 53 | "DEFAULT": 0.5, 54 | "MIN": 0.0, 55 | "MAX": 1.0 56 | }, 57 | { 58 | "NAME" : "mult_x", 59 | "TYPE" : "float", 60 | "DEFAULT": 1.0, 61 | "MIN": 0.0, 62 | "MAX": 10.0 63 | }, 64 | { 65 | "NAME" : "mult_y", 66 | "TYPE" : "float", 67 | "DEFAULT": 2.0, 68 | "MIN": 0.0, 69 | "MAX": 10.0 70 | }, 71 | { 72 | "NAME": "speed", 73 | "TYPE": "float", 74 | "DEFAULT": 0.0, 75 | "MIN": 0.0, 76 | "MAX": 1000.0 77 | }, 78 | { 79 | "NAME": "timeOffset", 80 | "TYPE": "float", 81 | "DEFAULT": 80.0, 82 | "MIN": 0.0, 83 | "MAX": 1000.0 84 | }, 85 | { 86 | "NAME": "rotate", 87 | "TYPE": "float", 88 | "DEFAULT": 0.0, 89 | "MIN": 0.0, 90 | "MAX": 1.0 91 | }, 92 | { 93 | "NAME": "pos", 94 | "TYPE": "point2D", 95 | "DEFAULT": [0.5,0.5], 96 | "MIN":[0.0,0.0], 97 | "MAX":[1.0,1.0] 98 | } 99 | ] 100 | }*/ 101 | 102 | #ifdef GL_ES 103 | precision mediump float; 104 | #endif 105 | 106 | #define TWO_PI 6.28318530718 107 | 108 | 109 | // Rotate 110 | mat2 rotate2d(float _angle){ 111 | return mat2(cos(_angle),-sin(_angle), 112 | sin(_angle),cos(_angle)); 113 | } 114 | 115 | void main() { 116 | vec2 uv = gl_FragCoord.xy / RENDERSIZE.xy; 117 | uv -= vec2(pos); 118 | uv.x *= RENDERSIZE.x/RENDERSIZE.y; 119 | uv *= zoom; 120 | uv = rotate2d(rotate*-TWO_PI) * uv; 121 | 122 | float _time = TIME + timeOffset; 123 | 124 | float distance = sqrt( pow(abs(uv[0]), shape_x * mult_x) + pow(abs(uv[1]), shape_y * mult_y) + speed); 125 | float color = sin(distance * _time * moire_x) * cos(distance * _time * moire_y); 126 | 127 | if (invert) color = color *-1.0 + 1.0; 128 | gl_FragColor = vec4(color, color, color,1.0);} -------------------------------------------------------------------------------- /ISF/40_Matrix.fs: -------------------------------------------------------------------------------- 1 | // SaturdayShader Week 40 : Matrix 2 | // by Joseph Fiola (http://www.joefiola.com) 3 | // 2016-07-09 4 | 5 | // Based on "Matrix" Patricio Gonzalez Vivo from the Book of Shaders' Generative Designs Examples 6 | // https://thebookofshaders.com/examples/?chapter=10 7 | 8 | 9 | 10 | /*{ 11 | "CREDIT": "", 12 | "DESCRIPTION": "", 13 | "CATEGORIES": [ 14 | "Generator" 15 | ], 16 | "INPUTS": [ 17 | { 18 | "NAME": "invert", 19 | "TYPE": "bool" 20 | }, 21 | { 22 | "NAME" : "zoom", 23 | "TYPE" : "float", 24 | "DEFAULT": 1.0, 25 | "MIN": 1e-4, 26 | "MAX": 40.0 27 | }, 28 | { 29 | "NAME" : "grid", 30 | "TYPE" : "float", 31 | "DEFAULT": 5.0, 32 | "MIN": 0.1, 33 | "MAX": 20.0 34 | }, 35 | { 36 | "NAME" : "dotSize", 37 | "TYPE" : "float", 38 | "DEFAULT": 0.1, 39 | "MIN": 0.0, 40 | "MAX": 0.5 41 | }, 42 | { 43 | "NAME" : "xScale", 44 | "TYPE" : "float", 45 | "DEFAULT": 0.0, 46 | "MIN": 0.0, 47 | "MAX": 0.49 48 | }, 49 | { 50 | "NAME" : "yScale", 51 | "TYPE" : "float", 52 | "DEFAULT": 0.0, 53 | "MIN": 0.0, 54 | "MAX": 0.49 55 | }, 56 | { 57 | "NAME" : "xRandom", 58 | "TYPE" : "float", 59 | "DEFAULT": 12.9898, 60 | "MIN": 1e-4, 61 | "MAX": 12.9898 62 | }, 63 | { 64 | "NAME" : "yRandom", 65 | "TYPE" : "float", 66 | "DEFAULT": 78.233, 67 | "MIN": 1e-4, 68 | "MAX": 78.233 69 | }, 70 | { 71 | "NAME" : "randomMultiplier", 72 | "TYPE" : "float", 73 | "DEFAULT": 43758.5453, 74 | "MIN": 1e-4, 75 | "MAX": 43758.5453 76 | }, 77 | { 78 | "NAME": "speed", 79 | "TYPE": "float", 80 | "DEFAULT": 20.0, 81 | "MIN": 0.0, 82 | "MAX": 40.0 83 | }, 84 | { 85 | "NAME": "rotate", 86 | "TYPE": "float", 87 | "DEFAULT": 0.0, 88 | "MIN": 0.0, 89 | "MAX": 1.0 90 | }, 91 | { 92 | "NAME": "pos", 93 | "TYPE": "point2D", 94 | "DEFAULT": [0.0,0.5], 95 | "MIN":[0.0,0.0], 96 | "MAX":[1.0,1.0] 97 | } 98 | ] 99 | }*/ 100 | 101 | #ifdef GL_ES 102 | precision mediump float; 103 | #endif 104 | 105 | #define TWO_PI 6.28318530718 106 | 107 | 108 | float random(in float x){ return fract(sin(x)*randomMultiplier); } // original value was 43758.5453 109 | float random(in vec2 st){ return fract(sin(dot(st.xy,vec2(xRandom,yRandom))) * randomMultiplier); } // 12.9898, 78.233, & 43758.5453 110 | 111 | float randomChar(vec2 outer,vec2 inner){ 112 | float grid = grid; 113 | vec2 margin = vec2(xScale,yScale); 114 | vec2 borders = step(margin,inner)*step(margin,1.-inner); 115 | vec2 ipos = floor(inner*grid); 116 | vec2 fpos = fract(inner*grid); 117 | return step(.5,random(outer*64.+ipos)) * borders.x * borders.y * step(dotSize,fpos.x) * step(dotSize,fpos.y); 118 | } 119 | 120 | // Rotate 121 | mat2 rotate2d(float _angle){ 122 | return mat2(cos(_angle),-sin(_angle), 123 | sin(_angle),cos(_angle)); 124 | } 125 | 126 | void main(){ 127 | vec2 st = gl_FragCoord.st/RENDERSIZE.xy; 128 | st -= vec2(pos); //center uv to pos location 129 | st.y *= RENDERSIZE.y/RENDERSIZE.x; 130 | 131 | st *= zoom; 132 | st = rotate2d(rotate*-TWO_PI) * st; 133 | 134 | vec3 color = vec3(0.0); 135 | 136 | vec2 ipos = floor(st); 137 | vec2 fpos = fract(st); 138 | 139 | ipos += vec2(0.,floor(TIME*speed*random(ipos.x+1.))); 140 | 141 | float pct = 1.0; 142 | pct *= randomChar(ipos,fpos); 143 | //pct *= random(ipos); 144 | 145 | color = vec3(pct); 146 | 147 | if (invert) color = color *-1.0 + 1.0; //invert colors 148 | 149 | gl_FragColor = vec4( color , 1.0); 150 | } -------------------------------------------------------------------------------- /ISF/41_CB4.fs: -------------------------------------------------------------------------------- 1 | // SaturdayShader #41 : CB4 2 | // Joseph Fiola (http://www.joefiola.com) 3 | // 2016-12-10 4 | 5 | // Based on "4 cells DF" example by Patricio Gonzalez Vivo from the Book of Shaders' chapter on Cellular Noise 6 | // http://thebookofshaders.com/12/ 7 | 8 | /*{ 9 | "CREDIT": "", 10 | "ISFVSN": "2", 11 | "DESCRIPTION": "", 12 | "CATEGORIES": [ 13 | "Generators" 14 | ], 15 | "INPUTS": [ 16 | { 17 | "NAME": "invert", 18 | "TYPE": "bool", 19 | "DEFAULT":1 20 | }, 21 | { 22 | "NAME" : "spread", 23 | "TYPE" : "float", 24 | "DEFAULT": 1.0, 25 | "MIN": 0.0, 26 | "MAX": 1.0 27 | }, 28 | { 29 | "NAME" : "rings", 30 | "TYPE" : "float", 31 | "DEFAULT": 100.0, 32 | "MIN": 0.0, 33 | "MAX": 400.0 34 | }, 35 | { 36 | "NAME" : "thickness", 37 | "TYPE" : "float", 38 | "DEFAULT": 0.5, 39 | "MIN": 0.001, 40 | "MAX": 0.995 41 | }, 42 | { 43 | "NAME" : "fade", 44 | "TYPE" : "float", 45 | "DEFAULT": 1.5, 46 | "MIN": -2.0, 47 | "MAX": 2.0 48 | }, 49 | { 50 | "NAME": "point1pos", 51 | "TYPE": "point2D", 52 | "DEFAULT":[0,1], 53 | "MAX": [1,1], 54 | "MIN": [0,0] 55 | }, 56 | { 57 | "NAME": "point2pos", 58 | "TYPE": "point2D", 59 | "DEFAULT": [1,1], 60 | "MAX": [1,1], 61 | "MIN": [0,0] 62 | }, 63 | { 64 | "NAME": "point3pos", 65 | "TYPE": "point2D", 66 | "DEFAULT": [0,0], 67 | "MAX": [1,1], 68 | "MIN": [0,0] 69 | }, 70 | { 71 | "NAME": "point4pos", 72 | "TYPE": "point2D", 73 | "DEFAULT": [1,0], 74 | "MAX": [1,1], 75 | "MIN": [0,0] 76 | }, 77 | { 78 | "NAME" : "canvas_xPos", 79 | "TYPE" : "float", 80 | "DEFAULT": 0.5, 81 | "MIN": 0.0, 82 | "MAX": 1.0 83 | }, 84 | { 85 | "NAME" : "canvas_yPos", 86 | "TYPE" : "float", 87 | "DEFAULT": 0.5, 88 | "MIN": 0.0, 89 | "MAX": 1.0 90 | }, 91 | { 92 | "NAME" : "zoom", 93 | "TYPE" : "float", 94 | "DEFAULT": 2.5, 95 | "MIN": 1.0, 96 | "MAX": 4.0 97 | }, 98 | { 99 | "NAME": "rotate", 100 | "TYPE": "float", 101 | "DEFAULT": 0, 102 | "MIN": 0, 103 | "MAX": 1 104 | } 105 | ] 106 | }*/ 107 | 108 | #ifdef GL_ES 109 | precision mediump float; 110 | #endif 111 | 112 | #define TWO_PI 6.28318530718 113 | 114 | 115 | mat2 rotate2d(float _angle){ 116 | return mat2(cos(_angle),-sin(_angle), 117 | sin(_angle),cos(_angle)); 118 | } 119 | 120 | 121 | 122 | void main() { 123 | vec2 st = gl_FragCoord.xy/RENDERSIZE.xy; 124 | 125 | st -= vec2(canvas_xPos,canvas_yPos); //center uv to pos location 126 | st *=zoom; 127 | 128 | st.y *= RENDERSIZE.y/RENDERSIZE.x; // make comp square 129 | 130 | st = rotate2d(rotate*-TWO_PI) * st; 131 | 132 | st +=0.5; // center 133 | 134 | 135 | 136 | vec3 color = vec3(0.0); 137 | 138 | // Cell positions 139 | vec2 point[4]; 140 | point[0] = point1pos; 141 | point[1] = point2pos; 142 | point[2] = point3pos; 143 | point[3] = point4pos; 144 | 145 | float m_dist = spread; // minimun distance 146 | 147 | // Iterate through the points positions 148 | for (int i = 0; i < 4; i++) { 149 | float dist = distance(st, point[i]); 150 | 151 | // Keep the closer distance 152 | m_dist = min(m_dist, dist); 153 | } 154 | 155 | // Draw the min distance (distance field) 156 | color += m_dist*fade; 157 | 158 | // Show isolines 159 | 160 | color += smoothstep(thickness,thickness+(thickness*0.003*zoom)+(rings*0.003*zoom),(0.8,abs(sin(rings*m_dist)))); 161 | 162 | //invert colors 163 | if (invert) color = color *-1.0 + 1.0; 164 | 165 | gl_FragColor = vec4(color,1.0); 166 | } -------------------------------------------------------------------------------- /ISF/42_CellularIterations.fs: -------------------------------------------------------------------------------- 1 | // SaturdayShader #42 : Cellular Iterations 2 | // Joseph Fiola (http://www.joefiola.com) 3 | // 2017-04-08 4 | 5 | // Based on the tiling and iteration example by Patricio Gonzalez Vivo from the Book of Shaders' chapter on Cellular Noise 6 | // http://thebookofshaders.com/12/ 7 | 8 | /*{ 9 | "CREDIT": "", 10 | "DESCRIPTION": "", 11 | "CATEGORIES": [ 12 | "Generators" 13 | ], 14 | "INPUTS": [ 15 | { 16 | "NAME": "invert", 17 | "TYPE": "bool", 18 | "DEFAULT":1 19 | }, 20 | { 21 | "NAME": "zoom", 22 | "TYPE": "float", 23 | "DEFAULT": 4.0, 24 | "MIN": 0.0, 25 | "MAX": 50.0 26 | }, 27 | { 28 | "NAME" : "rings", 29 | "TYPE" : "float", 30 | "DEFAULT": 20.0, 31 | "MIN": 0.0, 32 | "MAX": 200.0 33 | }, 34 | { 35 | "NAME" : "thickness", 36 | "TYPE" : "float", 37 | "DEFAULT": 0.5, 38 | "MIN": 0.001, 39 | "MAX": 0.995 40 | }, 41 | { 42 | "NAME": "grid", 43 | "TYPE": "float", 44 | "DEFAULT": 0.025, 45 | "MIN": 0.0, 46 | "MAX": 1.0 47 | }, 48 | { 49 | "NAME": "gridColor", 50 | "TYPE": "bool", 51 | "DEFAULT":1 52 | }, 53 | { 54 | "NAME": "rotate", 55 | "TYPE": "float", 56 | "DEFAULT": 0.0, 57 | "MIN": 0, 58 | "MAX": 1 59 | }, 60 | { 61 | "NAME": "pos", 62 | "TYPE": "point2D", 63 | "DEFAULT": [0.5,0.5], 64 | "MIN":[0.0,0.0], 65 | "MAX":[1.0,1.0] 66 | }, 67 | { 68 | "NAME": "time", 69 | "TYPE": "float", 70 | "DEFAULT": 0.0, 71 | "MIN": 0.0, 72 | "MAX": 1.0 73 | }, 74 | { 75 | "NAME": "amplitude", 76 | "TYPE": "float", 77 | "DEFAULT": 0.5, 78 | "MIN": 0.0, 79 | "MAX": 0.5 80 | }, 81 | { 82 | "NAME": "offsets", 83 | "TYPE": "point2D", 84 | "DEFAULT": [0.0,0.0], 85 | "MIN":[-2.0,-2.0], 86 | "MAX":[2.0,2.0] 87 | } 88 | 89 | ] 90 | }*/ 91 | 92 | 93 | #ifdef GL_ES 94 | precision mediump float; 95 | #endif 96 | 97 | #define TWO_PI 6.28318530718 98 | 99 | vec2 random2( vec2 p ) { 100 | return fract(sin(vec2(dot(p,vec2(127.1,311.7)),dot(p,vec2(269.5,183.3))))*43758.5453); 101 | } 102 | 103 | mat2 rotate2d(float _angle){ 104 | return mat2(cos(_angle),-sin(_angle), 105 | sin(_angle),cos(_angle)); 106 | } 107 | 108 | void main() { 109 | float animate = time * TWO_PI; 110 | vec2 st = gl_FragCoord.xy/RENDERSIZE.xy; 111 | 112 | st -= vec2(pos.x,pos.y); //center uv to pos location 113 | 114 | 115 | st.x *= RENDERSIZE.x/RENDERSIZE.y; // 1:1 ratio 116 | 117 | st = rotate2d(rotate*-TWO_PI) * st; 118 | 119 | float color = 0.0; 120 | 121 | // Scale 122 | st *= zoom; 123 | 124 | // Tile the space 125 | vec2 i_st = floor(st); 126 | vec2 f_st = fract(st); 127 | 128 | float m_dist = 1.; // minimun distance 129 | 130 | for (int y= -1; y <= 1; y++) { 131 | for (int x= -1; x <= 1; x++) { 132 | // Neighbor place in the grid 133 | vec2 neighbor = vec2(float(x),float(y)); 134 | 135 | // Random position from current + neighbor place in the grid 136 | vec2 point = random2(i_st + neighbor); 137 | 138 | // Animate the point 139 | //point = 0.5 + 0.5*sin(animate + 6.2831*point); 140 | point = 0.5 + amplitude*sin(animate + TWO_PI * point)+(offsets); 141 | 142 | // Vector between the pixel and the point 143 | vec2 diff = neighbor + point - f_st; 144 | 145 | // Distance to the point 146 | float dist = length(diff); 147 | 148 | // Keep the closer distance 149 | m_dist = min(m_dist, dist); 150 | } 151 | } 152 | 153 | // Draw the min distance (distance field) 154 | color += m_dist; 155 | 156 | // Draw cell center 157 | //color += 1.-step(.02, m_dist); 158 | 159 | // Draw grid 160 | if(grid > 0.0) { 161 | float thick = 1.0 - grid; 162 | if (gridColor) color = color *-1.0 + 1.0; 163 | color -= step(thick, f_st.x) + step(thick, f_st.y); 164 | if (gridColor) color = color *-1.0 + 1.0; 165 | } 166 | 167 | // Show isolines 168 | if(rings > 0.0) color += smoothstep(thickness,thickness+(thickness*0.002*zoom)+(rings*0.002*zoom),(0.8,abs(sin(rings*m_dist)))); 169 | 170 | //invert colors 171 | if (invert) color = color *-1.0 + 1.0; 172 | 173 | 174 | gl_FragColor = vec4(vec3(color),1.0); 175 | } -------------------------------------------------------------------------------- /Images/SaturdayShader_Week15_Goto10.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/JosephFiola/SaturdayShaders/1e27444d61d046a17a3507843203f6e2bf66ddb3/Images/SaturdayShader_Week15_Goto10.png -------------------------------------------------------------------------------- /Images/SaturdayShader_Week23_DiscSpin.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/JosephFiola/SaturdayShaders/1e27444d61d046a17a3507843203f6e2bf66ddb3/Images/SaturdayShader_Week23_DiscSpin.jpg -------------------------------------------------------------------------------- /Images/SaturdayShader_Week40_Matrix.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/JosephFiola/SaturdayShaders/1e27444d61d046a17a3507843203f6e2bf66ddb3/Images/SaturdayShader_Week40_Matrix.png -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Saturday Shaders 2 | 3 | These are GLSL shaders in the [ISF format](https://vidvox.github.io/isf/), configured to run in [VDMX](https://vidvox.net/) or any other application which supports ISF shader files. With minor adjustments they could be made to work in any application which supports GLSL shaders. 4 | 5 | 6 | ## Some examples of Saturday Shaders from the ISF sharing site 7 | ![Week 15: Goto10](Images/SaturdayShader_Week15_Goto10.png) 8 | [Week 15: Goto10](https://www.interactiveshaderformat.com/sketches/696) 9 | 10 | ![Week 23: DiscSpin](Images/SaturdayShader_Week23_DiscSpin.jpg) 11 | [Week 23: DiscSpin](https://www.interactiveshaderformat.com/sketches/839) 12 | 13 | ![Week 40: Matrix](Images/SaturdayShader_Week40_Matrix.png) 14 | [Week 40: Matrix](https://www.interactiveshaderformat.com/sketches/1219) 15 | 16 | --- 17 | 18 | To read more on Saturday Shaders [see this article on the VDMX website](https://vdmx.vidvox.net/blog/vj-zef-saturday-shaders). 19 | 20 | --- 21 | 22 | [VJ Zef](http://www.joefiola.com/vjzef/) || [Saturdayshaders](www.joefiola.com/saturdayshaders/) || [JoeFiola.com](http://www.joefiola.com/) 23 | --------------------------------------------------------------------------------