├── Fire.gif
├── Fire.shader
├── Fireworks.gif
├── Fireworks.shader
├── README.md
├── cloudyskies.gif
├── cloudyskies.shader
├── pixeltransition.gif
└── pixeltransition.shader


/Fire.gif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/BlooRabbit/Godot-shaders/c3f414a4f54944f3f89f7f06de046125b01733cd/Fire.gif


--------------------------------------------------------------------------------
/Fire.shader:
--------------------------------------------------------------------------------
 1 | // Fire shader
 2 | 
 3 | shader_type canvas_item;
 4 | 
 5 | uniform vec2 fireMovement = vec2(-0.01, -0.5);
 6 | uniform vec2 distortionMovement = vec2(-0.01, -0.3);
 7 | uniform float normalStrength = 40.0;
 8 | uniform float distortionStrength=0.1;
 9 | 
10 | 
11 | /** NOISE **/
12 | float rand(vec2 co) {
13 |   return fract(sin(dot(co.xy ,vec2(12.9898,78.233))) * 43758.5453);
14 | }
15 | 
16 | vec2 hash( vec2 p ) {
17 | 	p = vec2( dot(p,vec2(127.1,311.7)),
18 | 			  dot(p,vec2(269.5,183.3)) );
19 | 
20 | 	return -1.0 + 2.0*fract(sin(p)*43758.5453123);
21 | }
22 | 
23 | float noise( in vec2 p ) {
24 |    float K1 = 0.366025404; // (sqrt(3)-1)/2;
25 |    float K2 = 0.211324865; // (3-sqrt(3))/6;
26 | 
27 | 	vec2 i = floor( p + (p.x+p.y)*K1 );
28 | 	
29 |     vec2 a = p - i + (i.x+i.y)*K2;
30 |     vec2 o = step(a.yx,a.xy);    
31 |     vec2 b = a - o + K2;
32 | 	vec2 c = a - 1.0 + 2.0*K2;
33 | 
34 |     vec3 h = max( 0.5-vec3(dot(a,a), dot(b,b), dot(c,c) ), 0.0 );
35 | 
36 | 	vec3 n = h*h*h*h*vec3( dot(a,hash(i+0.0)), dot(b,hash(i+o)), dot(c,hash(i+1.0)));
37 | 
38 |     return dot( n, vec3(70.0) );
39 | }
40 | 
41 | float fbm ( in vec2 p ) {
42 |     float f = 0.0;
43 |     mat2 m = mat2(vec2(1.6,  1.2), vec2(-1.2,  1.6 ));
44 |     f  = 0.5000*noise(p); p = m*p;
45 |     f += 0.2500*noise(p); p = m*p;
46 |     f += 0.1250*noise(p); p = m*p;
47 |     f += 0.0625*noise(p); p = m*p;
48 |     f = 0.5 + 0.5 * f;
49 |     return f;
50 | }
51 | 
52 | /** DISTORTION **/
53 | vec3 bumpMap(vec2 uv) { 
54 | 	vec2 iResolution = vec2(1024,600);
55 |     vec2 s = 1. / iResolution.xy;
56 |     float p =  fbm(uv);
57 |     float h1 = fbm(uv + s * vec2(1., 0));
58 |     float v1 = fbm(uv + s * vec2(0, 1.));
59 |        
60 |    	vec2 xy = (p - vec2(h1, v1)) * normalStrength;
61 |     return vec3(xy + .5, 1.);
62 | }
63 | 
64 | /** MAIN **/
65 | void fragment() {
66 | 	float timeScale = TIME * 1.0;
67 | 	vec2 iResolution = vec2(1024,600);
68 |     vec2 uv = FRAGCOORD.xy/iResolution.xy;
69 | 
70 |     vec3 normal = bumpMap(uv * vec2(1.0, 0.3) + distortionMovement * timeScale);
71 |     
72 |     vec2 displacement = clamp((normal.xy - .5) * distortionStrength, -1., 1.);
73 |     uv += displacement; 
74 |     
75 |     vec2 uvT = (uv * vec2(1.0, 0.5)) + timeScale * fireMovement;
76 |     float n = pow(fbm(8.0 * uvT), 1.0);    
77 |     
78 |     float gradient = pow(1.0 - uv.y, 2.0) * 5.;
79 |     float finalNoise = n * gradient;
80 |     
81 |     vec3 color = finalNoise * vec3(2.*n, 2.*n*n*n, n*n*n*n);
82 |     COLOR = vec4(color, 1.);
83 | }


--------------------------------------------------------------------------------
/Fireworks.gif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/BlooRabbit/Godot-shaders/c3f414a4f54944f3f89f7f06de046125b01733cd/Fireworks.gif


--------------------------------------------------------------------------------
/Fireworks.shader:
--------------------------------------------------------------------------------
 1 | // Fireworks shader
 2 | // Based on shadertoy shader by Martijn Steinrucken aka BigWings - 2015 
 3 | // (https://www.shadertoy.com/view/lscGRl)
 4 | 
 5 | shader_type canvas_item;
 6 | 
 7 | uniform float PI = 3.141592653589793238;
 8 | uniform float TWOPI = 6.283185307179586 ;
 9 | uniform float NUM_EXPLOSIONS = 8.0;
10 | uniform float NUM_PARTICLES = 70.0;
11 | 
12 | // Noise functions by Dave Hoskins
13 | 
14 | uniform vec3 MOD3 = vec3(0.1031,0.11369,0.13787);
15 | 
16 | vec3 hash31(float p) {
17 |    vec3 p3 = fract(vec3(p) * MOD3);
18 |    p3 += dot(p3, p3.yzx + 19.19);
19 |    return fract(vec3((p3.x + p3.y)*p3.z, (p3.x+p3.z)*p3.y, (p3.y+p3.z)*p3.x));
20 | }
21 | 
22 | float hash12(vec2 p) // attention changement vec2 p en vec3
23 | {
24 |                 vec3 p3  = fract(vec3(p.xy, 0.0) * MOD3);
25 |     p3 += dot(p3, p3.yzx + 19.19);
26 |     return fract((p3.x + p3.y) * p3.z);
27 | }
28 | 
29 | float circ(vec2 uv, vec2 pos, float size) {
30 |                 uv -= pos;
31 |     
32 |     size *= size;
33 |     return smoothstep(size*1.1, size, dot(uv, uv));
34 | }
35 | 
36 | float lighter(vec2 uv, vec2 pos, float size) {
37 |     uv -= pos;
38 |     size *= size;
39 |     return size/dot(uv, uv);
40 | }
41 | 
42 | vec3 explosion(vec2 uv, vec2 p, float seed, float t) {
43 |                 
44 |     vec3 col = vec3(0.);
45 |     
46 |     vec3 en = hash31(seed);
47 |     vec3 baseCol = en;
48 |     for(float i=0.; i<NUM_PARTICLES; i++) {
49 |                vec3 n = hash31(i)-.5;
50 |        
51 |                                vec2 startP = p-vec2(0., t*t*.1);        
52 |         vec2 endP = startP+normalize(n.xy)*n.z;
53 |         
54 |         
55 |         float pt = 1.-pow(t-1., 2.);
56 |         vec2 pos = mix(p, endP, pt);    
57 |         float size = mix(.01, .005, smoothstep(0., .1, pt));
58 |         size *= smoothstep(1., .1, pt);
59 |         
60 |         float sparkle = (sin((pt+n.z)*100.)*.5+.5);
61 |         sparkle = pow(sparkle, pow(en.x, 3.)*50.)*mix(0.01, .01, en.y*n.y);
62 | 		float B = smoothstep(en.x-en.z, en.x+en.z, t)*smoothstep(en.y+en.z, en.y-en.z, t);
63 |         size += sparkle*B;
64 |         
65 |         col += baseCol*lighter(uv, pos, size);
66 |     }
67 |     
68 |     return col;
69 | }
70 | 
71 | 
72 | void fragment() {
73 |     vec2 iResolution = vec2(1024,600);
74 | 	vec2 uv = FRAGCOORD.xy / iResolution.xy;
75 |                 uv.x -= .5;
76 |     uv.x *= iResolution.x/iResolution.y;
77 |     
78 |     float n = hash12(uv+10.0);
79 |     float t = TIME*.5;
80 |     
81 |     vec3 c = vec3(0.);
82 |     
83 |     for(float i=0.; i<NUM_EXPLOSIONS; i++) {
84 |                float et = t+i*1234.45235;
85 |         float id = floor(et);
86 |         et -= id;
87 |         
88 |         vec2 p = hash31(id).xy;
89 |         p.x -= .5;
90 |         p.x *= 1.6;
91 |         c += explosion(uv, p, id, et);
92 | 		}
93 |     
94 | 	float alpha = 1.0;
95 | //	if (c.x < 0.2){alpha=0.0;} 
96 |     COLOR = vec4(c, alpha);
97 | }
98 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # Godot-shaders
 2 | A selection of Godot shaders, most of them translated / adapted from Shadertoy stuff. Can be used by anyone, for any project, anywhere, at your own risk.
 3 | 
 4 | ## Pixeltransition
 5 | 
 6 | ![Demo](./pixeltransition.gif)
 7 | 
 8 | ## Cloudyskies
 9 | ![Demo](./cloudyskies.gif)
10 | 
11 | ## Fire
12 | ![Demo](./Fire.gif) 
13 | 
14 | ## Fireworks
15 | ![Demo](./Fireworks.gif)
16 | 


--------------------------------------------------------------------------------
/cloudyskies.gif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/BlooRabbit/Godot-shaders/c3f414a4f54944f3f89f7f06de046125b01733cd/cloudyskies.gif


--------------------------------------------------------------------------------
/cloudyskies.shader:
--------------------------------------------------------------------------------
  1 | // cloudy skies shader
  2 | // inspired from shadertoy shader made by Drift (https://www.shadertoy.com/view/4tdSWr) 
  3 | 
  4 | shader_type canvas_item;
  5 | 
  6 | uniform float cloudscale = 1.1;
  7 | uniform float speed = 0.01;
  8 | uniform float clouddark = 0.5;
  9 | uniform float cloudlight = 0.3;
 10 | uniform float cloudcover = 0.2;
 11 | uniform float cloudalpha = 8.0;
 12 | uniform float skytint = 0.5;
 13 | uniform vec3 skycolour1 = vec3(0.2, 0.4, 0.6);
 14 | uniform vec3 skycolour2 = vec3(0.4, 0.7, 1.0);
 15 | uniform mat2 m = mat2(vec2(1.6,1.2),vec2(-1.2,1.6)); // changement
 16 | 
 17 | // functions
 18 | 
 19 | vec2 hash( vec2 p ) {
 20 |                 p = vec2(dot(p,vec2(127.1,311.7)), dot(p,vec2(269.5,183.3)));
 21 |                 return -1.0 + 2.0*fract(sin(p)*43758.5453123);
 22 | }
 23 | 
 24 | float noise( in vec2 p ) {
 25 |     float K1 = 0.366025404; // (sqrt(3)-1)/2;
 26 |     float K2 = 0.211324865; // (3-sqrt(3))/6;
 27 |                 vec2 i = floor(p + (p.x+p.y)*K1); 
 28 |     vec2 a = p - i + (i.x+i.y)*K2;
 29 |     vec2 o = (a.x>a.y) ? vec2(1.0,0.0) : vec2(0.0,1.0); //vec2 of = 0.5 + 0.5*vec2(sign(a.x-a.y), sign(a.y-a.x));
 30 |     vec2 b = a - o + K2;
 31 |                 vec2 c = a - 1.0 + 2.0*K2;
 32 |     vec3 h = max(0.5-vec3(dot(a,a), dot(b,b), dot(c,c) ), 0.0 );
 33 |                 vec3 n = h*h*h*h*vec3( dot(a,hash(i+0.0)), dot(b,hash(i+o)), dot(c,hash(i+1.0)));
 34 |     return dot(n, vec3(70.0));       
 35 | }
 36 | 
 37 | float fbm(vec2 n) {
 38 |                 float total = 0.0, amplitude = 0.1;
 39 |                 for (int i = 0; i < 7; i++) {
 40 |                                total += noise(n) * amplitude;
 41 |                                n = m * n;
 42 |                                amplitude *= 0.4;
 43 |                 }
 44 |                 return total;
 45 | }
 46 | 
 47 | // fragment shader
 48 | 
 49 | void fragment() {
 50 | vec2 res = 1.0 / SCREEN_PIXEL_SIZE;
 51 | vec2 p = FRAGCOORD.xy / res.xy; // changement
 52 |                 vec2 uv = p*vec2(res.x/res.y,1.0);    // changement
 53 |     float time = TIME * speed ;
 54 |     float q = fbm(uv * cloudscale * 0.5);
 55 |     
 56 |     //ridged noise shape
 57 |                 float r = 0.0;
 58 |                 uv *= cloudscale;
 59 |     uv += q - time;
 60 |     float weight = 0.8;
 61 |     for (int i=0; i<8; i++){
 62 |                                r += abs(weight*noise( uv ));
 63 |         uv = m*uv + time;
 64 |                                weight *= 0.7;
 65 |     }
 66 |     
 67 |     //noise shape
 68 |                 float f = 0.0;
 69 |     uv = p*vec2(res.x/res.y,1.0); // changement
 70 |                 uv *= cloudscale;
 71 |     uv += q - time;
 72 |     weight = 0.7;
 73 |     for (int i=0; i<8; i++){
 74 |                                f += weight*noise( uv );
 75 |         uv = m*uv + time;
 76 |                                weight *= 0.6;
 77 |     }
 78 |     
 79 |     f *= r + f;
 80 |     
 81 |     //noise colour
 82 |     float c = 0.0;
 83 |     time = TIME * speed * 2.0;
 84 |     uv = p*vec2(res.x/res.y,1.0); // changement
 85 |                 uv *= cloudscale*2.0;
 86 |     uv += q - time;
 87 |     weight = 0.4;
 88 |     for (int i=0; i<7; i++){
 89 |                                c += weight*noise( uv );
 90 |         uv = m*uv + time;
 91 |                                weight *= 0.6;
 92 |     }
 93 |     
 94 |     //noise ridge colour
 95 |     float c1 = 0.0;
 96 |     time = TIME * speed * 3.0;
 97 |     uv = p*vec2(res.x/res.y,1.0);
 98 |                 uv *= cloudscale*3.0;
 99 |     uv += q - time;
100 |     weight = 0.4;
101 |     for (int i=0; i<7; i++){
102 |                                c1 += abs(weight*noise( uv ));
103 |         uv = m*uv + time;
104 |                                weight *= 0.6;
105 |     }
106 |                 
107 |     c += c1;
108 |     
109 |     vec3 skycolour = mix(skycolour2, skycolour1, p.y);
110 |     vec3 cloudcolour = vec3(1.1, 1.1, 0.9) * clamp((clouddark + cloudlight*c), 0.0, 1.0);
111 |    
112 |     f = cloudcover + cloudalpha*f*r;
113 |     
114 |     vec3 result = mix(skycolour, clamp(skytint * skycolour + cloudcolour, 0.0, 1.0), clamp(f + c, 0.0, 1.0));
115 |     
116 |     COLOR.rgb = vec3(result); 
117 | }
118 | 
119 | 


--------------------------------------------------------------------------------
/pixeltransition.gif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/BlooRabbit/Godot-shaders/c3f414a4f54944f3f89f7f06de046125b01733cd/pixeltransition.gif


--------------------------------------------------------------------------------
/pixeltransition.shader:
--------------------------------------------------------------------------------
 1 | // Pixel transition shader
 2 | // Adapted from a shadertoy shader by iJ01 (https://www.shadertoy.com/view/Xl2SRd)
 3 | 
 4 | shader_type canvas_item;
 5 | 
 6 | float rand(vec2 co){
 7 |     return fract(sin(dot(co.xy ,vec2(12.9898,78.233))) * 43758.5453);
 8 | }
 9 | 
10 | void fragment()
11 | {
12 | 	vec2 iResolution = 1.0 / SCREEN_PIXEL_SIZE;
13 | 	vec2 uv = FRAGCOORD.xy / iResolution.xy;
14 |     float resolution = 5.0;
15 |     vec2 lowresxy = vec2(
16 |     	floor(FRAGCOORD.x / resolution),
17 |     	floor(FRAGCOORD.y / resolution)
18 |     );
19 |     
20 |     if(sin(TIME) > rand(lowresxy)){
21 | 		COLOR = vec4(uv,0.5+0.5*sin(5.0 * FRAGCOORD.x),1.0);
22 |     }else{
23 | 		COLOR = vec4(0.0,0.0,0.0,1.0);
24 | 		// change to COLOR = vec4(0.0,0.0,0.0,0.0); to make transparent
25 |     } 
26 | }
27 | 


--------------------------------------------------------------------------------