uniform float Speed;
uniform float Direction;
uniform int Negative;
precision mediump float;
/*{
    "CATEGORIES": [
        "Automatically Converted",
        "Shadertoy"
    ],
    "CREDIT": "",
    "DESCRIPTION": "Automatically converted from https://www.shadertoy.com/view/MtcGD7 by CaliCoastReplay.  A big thank you to \tFabriceNeyret2  who told me how to achieve this more vivid look!  Positively conflagarative!  Try it in fire rain config!\n\nRemix 1 here:  https://www.shadertoy.com/view/llc3DM\nOriginal here:  \nhttps://www.shadertoy.com/view/XsXXRN",
    "IMPORTED": {
    },
    "INPUTS": [

precision mediump float;
uniform vec2 resolution;
uniform float time;
float hash(float n){return fract(sin(n)*43758.5453);} 
void main(){
 vec2 uv=gl_FragCoord.xy/resolution.xy;
 float row=floor(uv.y*520.0);
 float streak=hash(row)*0.18+hash(row+17.0)*0.08;
 float wave=0.08*sin(uv.x*46.0+hash(row)*6.283)+0.05*sin(uv.x*113.0+time*0.15);
 float shine=pow(max(0.0,1.0-abs(uv.y-0.48-wave)*3.2),3.0);
 vec3 base=mix(vec3(0.18,0.19,0.2),vec3(0.72,0.74,0.76),uv.x*0.35+0.35+streak);
 gl_FragColor=vec4(base+shine*vec3(0.42,0.5,0.58),1.0);
}

precision mediump float;
uniform vec2 resolution;
uniform float time;
vec2 hash(vec2 p){p=vec2(dot(p,vec2(127.1,311.7)),dot(p,vec2(269.5,183.3)));return fract(sin(p)*43758.5453);} 
void main(){
 vec2 uv=gl_FragCoord.xy/resolution.xy; uv.x*=resolution.x/resolution.y;
 vec2 g=uv*6.0; vec2 id=floor(g); vec2 f=fract(g);
 float d=9.0; vec2 nearest=vec2(0.0);
 for(int y=-1;y<=1;y++)for(int x=-1;x<=1;x++){vec2 o=vec2(float(x),float(y));vec2 r=hash(id+o);float nd=length(o+r-f);if(nd<d){d=nd;nearest=r;}}
 float facet=smoothstep(0.0,0.9,d);
 vec3 col=0.45+0.45*cos(vec3(0.0,2.2,4.1)+facet*6.0+nearest.x*3.0+time*0.15);
 gl_FragColor=vec4(col*(1.0-d*0.55)+0.18,1.0);
}

precision mediump float;
uniform vec2 resolution;
uniform float time;
float hash(vec2 p){return fract(sin(dot(p,vec2(13.1,117.7)))*43758.5453);} float noise(vec2 p){vec2 i=floor(p),f=fract(p);f=f*f*(3.0-2.0*f);return mix(mix(hash(i),hash(i+vec2(1,0)),f.x),mix(hash(i+vec2(0,1)),hash(i+1.0),f.x),f.y);} 
float fbm(vec2 p){float v=0.0,a=.5;for(int i=0;i<5;i++){v+=a*noise(p);p*=2.;a*=.5;}return v;}
void main(){
 vec2 uv=gl_FragCoord.xy/resolution.xy; uv.x*=resolution.x/resolution.y; float h=fbm(uv*4.0+vec2(time*.015,0)); float ridges=sin((uv.x*2.5+h*1.4)*28.0); float crest=smoothstep(.65,1.0,ridges); vec3 sand=mix(vec3(.45,.28,.11),vec3(.95,.72,.38),h); gl_FragColor=vec4(sand+crest*.16,1.0);
}

precision mediump float;
#define GLSLIFY 1
// Common uniforms
uniform vec2 u_resolution;
uniform vec2 u_mouse;
uniform float u_time;
uniform float u_frame;

// Texture uniforms
uniform sampler2D u_texture;

// Texture varyings
varying vec2 v_uv;

precision mediump float;
uniform sampler2D uTexture;
uniform float uTextureFrequency;
uniform float u_time;
uniform float uHslTimeFrequency;
uniform float uHslHue;
uniform float uHslHueOffset;
uniform float uHslHueFrequency; 
uniform float uHslLightness; 
uniform float uHslLightnessVariation; 
uniform float uHslLightnessFrequency; 
uniform float uTextureOffset; 

precision mediump float;
varying vec2 v_texcoord;
uniform float u_time;
uniform float uAmplitude;
uniform float uScrollSpeed;

uniform sampler2D uDiffuse;

float inverseLerp(float v, float minVal, float maxVal) {
    return (v - minVal) / (maxVal - minVal);
}

float remap(float v, float inMin, float inMax, float outMin, float outMax) {
    float t = inverseLerp(v, inMin, inMax);

precision mediump float;
#define GLSLIFY 1
#define PI 3.14159265

// Common uniforms
uniform vec2 u_resolution;
uniform vec2 u_mouse;
uniform float u_time;
uniform float u_frame;

/*
 * Random number generator with a float seed
 *
 * Credits:

precision mediump float;
varying vec2 v_texCoord;
uniform sampler2D u_texture;
uniform vec2 u_resolution;
uniform float u_intensity; // 0-1
uniform float u_size;      // grain size (0.5-10)
uniform int   u_color;     // 0=color, 1=grayscale

float hash(vec2 p) {
  return fract(sin(dot(p, vec2(12.9898, 78.233))) * 43758.5453);
}

void main() {
  vec4 c = texture2D(u_texture, v_texCoord);

precision mediump float;
uniform vec2 resolution;
uniform float time;
float hash(vec2 p){return fract(sin(dot(p,vec2(12.989,78.233)))*43758.5453);} 
float noise(vec2 p){vec2 i=floor(p),f=fract(p);f=f*f*(3.0-2.0*f);return mix(mix(hash(i),hash(i+vec2(1,0)),f.x),mix(hash(i+vec2(0,1)),hash(i+1.0),f.x),f.y);} 
void main(){
 vec2 uv=gl_FragCoord.xy/resolution.xy; uv.x*=resolution.x/resolution.y;
 float n=noise(uv*5.0+time*0.05)+0.5*noise(uv*13.0-time*0.04);
 float phase=n*8.0+uv.x*4.0-uv.y*3.0+time*0.15;
 vec3 rainbow=0.5+0.5*cos(phase+vec3(0.0,2.09,4.18));
 float sheen=smoothstep(0.2,1.0,n);
 gl_FragColor=vec4(mix(vec3(0.015,0.012,0.018), rainbow, sheen),1.0);
}

precision mediump float;
uniform vec2 resolution;
uniform float time;
float hash(vec2 p){ return fract(sin(dot(p, vec2(41.0, 289.0))) * 45758.5453); }
float noise(vec2 p){ vec2 i=floor(p), f=fract(p); f=f*f*(3.0-2.0*f); return mix(mix(hash(i),hash(i+vec2(1,0)),f.x),mix(hash(i+vec2(0,1)),hash(i+1.0),f.x),f.y); }
float fbm(vec2 p){ float v=0.0; float a=0.5; for(int i=0;i<5;i++){ v += a*noise(p); p*=2.05; a*=0.5; } return v; }
void main(){
  vec2 uv = gl_FragCoord.xy / resolution.xy;
  uv.x *= resolution.x / resolution.y;
  float n = fbm(uv * 3.0 + vec2(time * 0.035, -time * 0.02));
  float veins = sin((uv.x + n * 1.8) * 22.0);
  float line = smoothstep(0.72, 1.0, veins);
  vec3 stone = mix(vec3(0.08,0.09,0.11), vec3(0.78,0.82,0.86), n);
  vec3 vein = mix(vec3(0.02,0.025,0.035), vec3(0.9,0.75,0.55), line);

precision mediump float;
uniform vec2 resolution;
uniform float time;
void main(){
  vec2 uv=gl_FragCoord.xy/resolution.xy; uv.x*=resolution.x/resolution.y;
  float c=0.0;
  for(int i=0;i<5;i++){
    float fi=float(i)+1.0;
    vec2 p=uv*fi*2.4 + vec2(sin(time*0.25*fi), cos(time*0.18*fi));
    c += abs(sin(p.x*3.14159 + sin(p.y*2.2+time))) / fi;
    c += abs(sin(p.y*3.14159 + cos(p.x*2.0-time*0.7))) / fi;
  }
  c=pow(1.0-smoothstep(0.8,1.45,c/2.4),3.0);
  vec3 water=vec3(0.0,0.18,0.28)+vec3(0.02,0.28,0.38)*uv.y;

precision mediump float;
uniform vec2 resolution;
uniform float time;
float hash(vec2 p){return fract(sin(dot(p,vec2(91.7,45.3)))*43758.5453);} 
float noise(vec2 p){vec2 i=floor(p),f=fract(p);f=f*f*(3.0-2.0*f);return mix(mix(hash(i),hash(i+vec2(1,0)),f.x),mix(hash(i+vec2(0,1)),hash(i+1.0),f.x),f.y);} 
void main(){
 vec2 uv=gl_FragCoord.xy/resolution.xy; uv.x*=resolution.x/resolution.y; vec2 p=uv*vec2(8.0,5.0); p.x+=mod(floor(p.y),2.0)*0.5; vec2 f=fract(p); vec2 id=floor(p);
 float mortar=step(f.x,0.06)+step(0.94,f.x)+step(f.y,0.08)+step(0.92,f.y); float n=noise(uv*28.0)+0.5*noise(uv*71.0); vec3 brick=mix(vec3(0.32,0.08,0.035),vec3(0.72,0.24,0.12),hash(id)*0.6+n*0.25); vec3 col=mix(brick,vec3(0.48,0.43,0.36),clamp(mortar,0.0,1.0)); gl_FragColor=vec4(col,1.0);
}

precision mediump float;
uniform float u_time;
varying vec2 v_tex_coord;
varying vec4 v_color_mix;
vec4 SKDefaultShading(){ return vec4(1.0); }
//
// Creates moving multi-colored noise.
//
// This works using a simple (but brilliant!) and well-known trick: if you
// calculate the dot product of a texture coordinate with a vec2 containing
// two numbers that are unlikely to repeat, then calculate the sine of that
// and multiply it by a large number, you'll end up with what looks more or
// less like random numbers in the fraction digits – i.e., everything after
// the decimal place.

precision mediump float;
varying vec2 v_tex_coord;
varying vec4 v_color_mix;
vec4 SKDefaultShading(){ return vec4(1.0); }
//
// Creates fixed multi-colored noise.
//
// This works using a simple (but brilliant!) and well-known trick: if you
// calculate the dot product of a texture coordinate with a vec2 containing
// two numbers that are unlikely to repeat, then calculate the sine of that
// and multiply it by a large number, you'll end up with what looks more or
// less like random numbers in the fraction digits – i.e., everything after
// the decimal place.
//

precision mediump float;
uniform float u_time;
uniform sampler2D u_texture;
varying vec2 v_tex_coord;
varying vec4 v_color_mix;
//
// Warps a textured node to create a water rippling effect.
// NOTE: This must be applied to something that has a texture.
// Uniform: u_speed, how many fast to make the water ripple. Ranges from 0.5 to 10 work best; try starting with 3.
// Uniform: u_strength, how pronounced the rippling effect should be. Ranges from 1 to 5 work best; try starting with 3.
// Uniform: u_frequency, how often ripples should be created. Ranges from 5 to 25 work best; try starting with 10.
//
// This works by using a nearby pixel color rather than the original pixel color. Which neighbour is
// chosen depends on the algorithm: we pass the original coordinate, speed, and frequency

precision mediump float;
uniform vec2 resolution;
uniform float time;
float hash(vec2 p){return fract(sin(dot(p,vec2(19.19,73.17)))*43758.5453);} 
float noise(vec2 p){vec2 i=floor(p),f=fract(p);f=f*f*(3.0-2.0*f);return mix(mix(hash(i),hash(i+vec2(1,0)),f.x),mix(hash(i+vec2(0,1)),hash(i+1.0),f.x),f.y);} 
float fbm(vec2 p){float v=0.0,a=0.5;for(int i=0;i<5;i++){v+=a*noise(p);p*=2.1;a*=0.5;}return v;}
void main(){
 vec2 uv=(gl_FragCoord.xy*2.0-resolution.xy)/min(resolution.x,resolution.y);
 float r=length(uv);
 float n=fbm(uv*4.0+time*0.22);
 float disk=smoothstep(0.72,0.66,r+n*0.05);
 float flare=pow(max(0.0,1.0-r),2.0)*0.7;
 vec3 col=mix(vec3(0.1,0.0,0.0), vec3(1.0,0.25,0.02), disk);
 col+=vec3(1.0,0.75,0.18)*(n*disk+flare);

precision mediump float;
uniform vec2 resolution;
uniform float time;
float hash(vec2 p){return fract(sin(dot(p,vec2(27.1,61.7)))*43758.5453);} 
void main(){
 vec2 uv=gl_FragCoord.xy/resolution.xy;
 float fibers=0.0;
 for(int i=0;i<4;i++){float fi=float(i); vec2 p=uv*vec2(30.0+fi*12.0,180.0); float r=hash(floor(p)+fi); fibers+=smoothstep(0.985,1.0,sin((uv.x*45.0+uv.y*9.0+fi)*3.14159+r*6.283));}
 float nap=pow(max(0.0,1.0-distance(uv,vec2(0.5+0.15*sin(time*.2),0.45))*1.7),2.0);
 vec3 col=mix(vec3(0.08,0.01,0.07),vec3(0.55,0.08,0.38),nap)+fibers*0.035;
 gl_FragColor=vec4(col,1.0);
}

uniform sampler2D startImage;
uniform sampler2D endImage;
uniform float progress;
uniform float speed;
uniform float amplitude;
precision mediump float;
/*{
    "CATEGORIES": [
        "Distortion"
    ],
    "CREDIT": "Automatically converted from https://www.github.com/gl-transitions/gl-transitions/tree/master/WaterDrop.glsl",
    "DESCRIPTION": "",
    "INPUTS": [
        {

precision mediump float;
uniform vec2 resolution;
uniform float time;
float hash(vec2 p){ return fract(sin(dot(p, vec2(13.13, 117.17))) * 43758.5453); }
float noise(vec2 p){ vec2 i=floor(p), f=fract(p); f=f*f*(3.0-2.0*f); return mix(mix(hash(i),hash(i+vec2(1,0)),f.x),mix(hash(i+vec2(0,1)),hash(i+1.0),f.x),f.y); }
void main(){
 vec2 uv = gl_FragCoord.xy / resolution.xy; uv.x *= resolution.x/resolution.y;
 float n = noise(uv*9.0) + 0.5*noise(uv*22.0);
 float rings = sin((uv.x + n*0.09 + 0.02*sin(uv.y*18.0)) * 55.0);
 float grain = smoothstep(-0.2, 1.0, rings);
 vec3 dark = vec3(0.22,0.10,0.035), light = vec3(0.72,0.38,0.13);
 gl_FragColor = vec4(mix(dark, light, grain) * (0.75 + 0.25*n), 1.0);
}