This is my Bad Trip - GLSL



link ShaderToy : https://www.shadertoy.com/view/WddGWN

void mainImage( out vec4 fragColor, in vec2 fragCoord )
{

 
    float x = fragCoord.x;
    float y2 = fragCoord.y;
 
    vec2 p = fragCoord.xy / iResolution.yy;
    vec2 q = fragCoord.xy / iResolution.yy;
 
    vec2 translate = vec2(cos(iTime),sin(iTime));
    vec2 translate2 = vec2(sin(iTime),cos(iTime));
 
 
    if (sin(iTime)>0.)
    p += translate*1.35*fract(sin(iTime)*1.0);
    else
    p += translate2*1.35*fract(sin(iTime)*1.0);
 
    vec2 pix = fragCoord.xy*p;
    vec3 col = texture(iChannel0,floor(pix/17.0)*8.0/iResolution.xy).rgb;
    vec3 col2 = texture(iChannel2, floor(pix/8.0)*8.0/iResolution.xy).rgb;
    vec3 col3 = texture(iChannel1, floor(pix/8.0)*8.0/iResolution.xy).rgb;

    fragColor = vec4(0.1+col3.x+col.x*tan(iTime)+col2.x*1.8,0.3+col3.y+col2.y+col.y*cos(iTime),0.3+col3.z+col.z*sin(iTime)+col2.z,1);
 
}
Read More

GLSL - Fireflies in Darkness



// This is a rework of https://www.shadertoy.com/view/lsfGzr,
// created by @paulofalcao, with sound, by Radical Ed
// License: Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported License


#define time iTime

float makePoint(float x,float y,float fx,float fy,float sx,float sy,float t, float w){
   float xx=x+sin(t*fx)*sx*tan(fx*t)*log(fx*t);
   float yy=y+cos(t*fy)*sy*tan(fy*t)*log(fy*t);
   return 5.0*abs(sin(25.0*t/337.0))/sqrt(xx*xx+yy*yy)+log(w/4.0);
}

void mainImage( out vec4 fragColor, in vec2 fragCoord ) {

   vec2 p=(fragCoord.xy/iResolution.x)*2.0-vec2(1.0,iResolution.y/iResolution.x);


 
   // create pixel coordinates
   vec2 uv = fragCoord.xy / iResolution.xy;

   // the sound texture is 512x2
   int tx = int(uv.x*512.0);
 

   // second row is the sound wave, one texel is one mono sample
   float wave = texelFetch( iChannel0, ivec2(tx,1), 0 ).x;
 
   vec2 translate = vec2(cos(iTime),sin(iTime));
 
 
 
   p=p*7.0*abs(sin(iTime));
   p += translate*1.35*sin(iTime);
 
   float x=p.x;
   float y=p.y;
 
   vec3 col = vec3( 0.0, 0.0, 0.0);

    // add wave form on top
   //col += smoothstep( 0.0, 0.15, abs(wave- uv.x)/2.0 );
 
    //if (wave > 0.4) { wave = 0.4 ;}
 

   float a=
   makePoint(x + col.x,y + col.y,2.0,2.9,0.3,0.3,time, wave);
   a=a+makePoint(x + col.x,y + col.y,1.9,2.0,0.4,0.4,time, wave);
   a=a+makePoint(x + col.x,y + col.y,0.8,0.7,0.4,0.5,time, wave);
   a=a+makePoint(x + col.x,y + col.y,2.3,0.1,0.6,0.3,time, wave);
   a=a+makePoint(x + col.x,y + col.y,0.8,1.7,0.5,0.4,time, wave);
   a=a+makePoint(x + col.x,y + col.y,0.3,1.0,0.4,0.4,time, wave);
   a=a+makePoint(x + col.x,y + col.y,1.4,1.7,0.4,0.5,time, wave);
   a=a+makePoint(x + col.x,y + col.y,1.3,2.1,0.6,0.3,time, wave);
   a=a+makePoint(x + col.x,y + col.y,1.8,1.7,0.5,0.4,time, wave);
   
 
   float b=
   makePoint(x + col.x,y + col.y,1.2,1.9,0.3,0.3,time, wave);
   b=b+makePoint(x + col.x,y + col.y,0.7,2.7,0.4,0.4,time, wave);
   b=b+makePoint(x + col.x,y + col.y,1.4,0.6,0.4,0.5,time, wave);
   b=b+makePoint(x + col.x,y + col.y,2.6,0.4,0.6,0.3,time, wave);
   b=b+makePoint(x + col.x,y + col.y,0.7,1.4,0.5,0.4,time, wave);
   b=b+makePoint(x + col.x,y + col.y,0.7,1.7,0.4,0.4,time, wave);
   b=b+makePoint(x + col.x,y + col.y,0.8,0.5,0.4,0.5,time, wave);
   b=b+makePoint(x + col.x,y + col.y,1.4,0.9,0.6,0.3,time, wave);
   b=b+makePoint(x + col.x,y + col.y,0.7,1.3,0.5,0.4,time, wave);
 

   float c=
   makePoint(x + col.x,y + col.y,3.7,0.3,0.3,0.3,time, wave);
   c=c+makePoint(x + col.x,y + col.y,1.9,1.3,0.4,0.4,time, wave);
   c=c+makePoint(x + col.x,y + col.y,0.8,0.9,0.4,0.5,time, wave);
   c=c+makePoint(x + col.x,y + col.y,1.2,1.7,0.6,0.3,time, wave);
   c=c+makePoint(x + col.x,y + col.y,0.3,0.6,0.5,0.4,time, wave);
   c=c+makePoint(x + col.x,y + col.y,0.3,0.3,0.4,0.4,time, wave);
   c=c+makePoint(x + col.x,y + col.y,1.4,0.8,0.4,0.5,time, wave);
   c=c+makePoint(x + col.x,y + col.y,0.2,0.6,0.6,0.3,time, wave);
   c=c+makePoint(x + col.x,y + col.y,1.3,0.5,0.5,0.4,time, wave);
 
 
   vec3 d=vec3(a,b,c)/22.0;
 
 
   fragColor = vec4(d.x*2.0,d.x,d.x,1.0);
}
Read More

GLSL + SuperCollider :: REBOP



#define PERIOD 2.
#define REPETITIONS 2

const float PI = 3.1415926535;


float box(in vec2 _st, in vec2 _size){
    _size = vec2(0.5) - _size*0.5;
    vec2 uv = smoothstep(_size,
                        _size+vec2(0.001),
                        _st);
    uv *= smoothstep(_size,
                    _size+vec2(0.001),
                    vec2(1.0)-_st);
    return uv.x*uv.y;
}

float cross2(in vec2 _st, float _size){
    return  box(_st, vec2(_size,_size/4.)) +
            box(_st, vec2(_size/4.,_size));
}

vec3 shadeBlob(vec2 p, float index, float value, float scale)
{
    float screenRatio = iResolution.x / iResolution.y;
    vec2 pc = vec2(0.1 + (screenRatio - 0.2) * value, index);
 
    float d = length(pc - p) / 0.015*scale/(1.37+abs(sin(iTime)));
 
    return vec3(3. * vec3(0.5, 0.5, 0.7) / (max(d * d, 1.)));
}

float step_interp(float x) {
    return step(0.5, x);
}

float linear_interp(float x) {
    float c = clamp(x, 0., 1.);
 
    return c;
}

float cosine_interp(float x) {
    float c = clamp(x, 0., 1.);
 
    return 0.5 * (1. - cos(PI * c));
}

float smoothstep_interp(float x) {
//    return smoothstep(0., 1., x);

    float c = clamp(x, 0., 1.);
 
    return c * c * (3. - 2. * c);
}

float quintic_interp(float x) {
    float c = clamp(x, 0., 1.);
 
    return c * c * c * ((6. * c - 15.) * c + 10.);
}

void mainImage( out vec4 fragColor, in vec2 fragCoord )
{
    vec2 p = fragCoord.xy / iResolution.yy;
    vec2 q = fragCoord.xy / iResolution.xy;
 
    int tx = int(p.x*128.0);
    int ty = int(p.y*128.0);
 
    // per lo Spectrum Audio
    float wave = texelFetch( iChannel0, ivec2(ty,1), 0 ).x;
    vec3 spec = vec3(wave/0.5);
 
 
    // per lo Spectrum Audio
    //vec4 spec = vec4(0.1,0.1,0.1,0.1);
 
    vec2 translate = vec2(cos(iTime),sin(iTime));
    vec2 translate2 = vec2(sin(iTime),cos(iTime));
    //p += translate*0.35*sin(iTime);
    q += translate2*1.35*sin(iTime);
 
    float t = abs(2. * fract(iTime / PERIOD) - 1.);
 
 
    // Background pattern
 
 
 
    vec3 col = vec3(0.0);
 
    col += shadeBlob(p, 0.3, smoothstep_interp(t)*0.1, spec.x/0.4);
    col += shadeBlob(p, 0.4, linear_interp(t)*0.1, spec.x/0.4);
    col += shadeBlob(p, 0.5, cosine_interp(t)*0.1, spec.x/0.4 );
    col += shadeBlob(p, 0.6, smoothstep_interp(t)*0.1, spec.x/0.4);
    col += shadeBlob(p, 0.7, quintic_interp(t)*0.1, spec.x/0.4);
 
    //col += shadeBlob(p, 0.3, smoothstep_interp(t)*spec.x+0.2, 0.1/0.1);
    col += shadeBlob(p, 0.4, linear_interp(t)*0.1+0.05, spec.x/0.4);
    col += shadeBlob(p, 0.5, cosine_interp(t)*0.1+0.05, spec.x/0.4);
    //col += shadeBlob(p, 0.6, smoothstep_interp(t)*spec.z+0.2, 0.1/0.1);
    col += shadeBlob(p, 0.7, quintic_interp(t)*0.1+0.05, spec.x/0.4);
 
    col += shadeBlob(p, 0.3, smoothstep_interp(t)*0.1+0.1, spec.x/0.4);
    //col += shadeBlob(p, 0.4, linear_interp(t)*spec.y+0.1, 0.1/0.1);
    //col += shadeBlob(p, 0.5, cosine_interp(t)*spec.z+0.1, 0.1/0.1);
    col += shadeBlob(p, 0.6, smoothstep_interp(t)*0.1+0.1, spec.x/0.4);
    //col += shadeBlob(p, 0.7, quintic_interp(t)*spec.z+0.1, 0.1/0.1);
 
    col += shadeBlob(p, 0.3, smoothstep_interp(t)*0.1+0.2, spec.y/0.4);
    col += shadeBlob(p, 0.4, linear_interp(t)*0.1+0.2, spec.y/0.4);
    col += shadeBlob(p, 0.5, cosine_interp(t)*0.1+0.2, spec.y/0.4);
    col += shadeBlob(p, 0.6, smoothstep_interp(t)*0.1+0.2, spec.y/0.4);
    col += shadeBlob(p, 0.7, quintic_interp(t)*0.1+0.2, spec.y/0.4);
 
    col += shadeBlob(p, 0.3, smoothstep_interp(t)*0.1+0.25, spec.x/0.4);
    //col += shadeBlob(p, 0.4, linear_interp(t)*spec.y+0.25, 0.1/0.1);
    col += shadeBlob(p, 0.5, cosine_interp(t)*0.1+0.25, spec.x/0.4);
    //col += shadeBlob(p, 0.6, smoothstep_interp(t)*spec.z+0.25, 0.1/0.1);
    col += shadeBlob(p, 0.7, quintic_interp(t)*0.1+0.25, spec.x/0.4);
 
    col += shadeBlob(p, 0.3, smoothstep_interp(t)*0.1+0.3, spec.x/0.4);
    //col += shadeBlob(p, 0.4, linear_interp(t)*spec.y+0.25, 0.1/0.1);
    //col += shadeBlob(p, 0.5, cosine_interp(t)*spec.z+0.25, 0.1/0.1);
    //col += shadeBlob(p, 0.6, smoothstep_interp(t)*spec.z+0.25, 0.1/0.1);
    col += shadeBlob(p, 0.7, quintic_interp(t)*0.1+0.3, spec.x/0.4);
 
    col += shadeBlob(p, 0.3, smoothstep_interp(t)*0.1+0.4, spec.x/0.4);
    col += shadeBlob(p, 0.4, linear_interp(t)*0.1+0.4, spec.x/0.4);
    col += shadeBlob(p, 0.5, cosine_interp(t)*0.1+0.4, spec.x/0.4);
    col += shadeBlob(p, 0.6, smoothstep_interp(t)*0.1+0.4, spec.x/0.4);
    col += shadeBlob(p, 0.7, quintic_interp(t)*0.1+0.4, spec.x/0.4);
 
    col += shadeBlob(p, 0.3, smoothstep_interp(t)*0.1+0.45, spec.x/0.4);
    //col += shadeBlob(p, 0.4, linear_interp(t)*spec.y+0.45, 0.1/0.1);
    col += shadeBlob(p, 0.5, cosine_interp(t)*0.1+0.45, spec.x/0.4);
    //col += shadeBlob(p, 0.6, smoothstep_interp(t)*spec.z+0.45, 0.1/0.1);
    col += shadeBlob(p, 0.7, quintic_interp(t)*0.1+0.45, spec.x/0.4);
 
    col += shadeBlob(p, 0.3, smoothstep_interp(t)*0.1+0.5, spec.x/0.4);
    col += shadeBlob(p, 0.4, linear_interp(t)*0.1+0.5, spec.x/0.4);
    //col += shadeBlob(p, 0.5, cosine_interp(t)*spec.z+0.5, 0.1/0.1);
    col += shadeBlob(p, 0.6, smoothstep_interp(t)*0.1+0.5, spec.x/0.4);
    col += shadeBlob(p, 0.7, quintic_interp(t)*0.1+0.5, spec.x/0.4);
 
    col += shadeBlob(p, 0.3, smoothstep_interp(t)*0.1+0.6, spec.x/0.4);
    col += shadeBlob(p, 0.4, linear_interp(t)*0.1+0.6, spec.x/0.4);
    col += shadeBlob(p, 0.5, cosine_interp(t)*0.1+0.6, spec.x/0.4);
    col += shadeBlob(p, 0.6, smoothstep_interp(t)*0.1+0.6, spec.x/0.4);
    col += shadeBlob(p, 0.7, quintic_interp(t)*0.1+0.6, spec.x/0.4);
 
    col += shadeBlob(p, 0.3, smoothstep_interp(t)*0.1+0.65, spec.x/0.4);
    //col += shadeBlob(p, 0.4, linear_interp(t)*spec.y+0.65, 0.1/0.1);
    //col += shadeBlob(p, 0.5, cosine_interp(t)*spec.z+0.65, 0.1/0.1);
    //col += shadeBlob(p, 0.6, smoothstep_interp(t)*spec.z+0.65, 0.1/0.1);
    col += shadeBlob(p, 0.7, quintic_interp(t)*0.1+0.65, spec.x/0.4);
 
    col += shadeBlob(p, 0.3, smoothstep_interp(t)*0.1+0.7, spec.x/0.4);
    col += shadeBlob(p, 0.4, linear_interp(t)*0.1+0.7, spec.x/0.4);
    col += shadeBlob(p, 0.5, cosine_interp(t)*0.1+0.7, spec.x/0.4);
    col += shadeBlob(p, 0.6, smoothstep_interp(t)*0.1+0.7, spec.x/0.4);
    col += shadeBlob(p, 0.7, quintic_interp(t)*0.1+0.7, spec.x/0.4);
 
    col += shadeBlob(p, 0.3, smoothstep_interp(t)*0.1+0.8, spec.x/0.4);
    col += shadeBlob(p, 0.4, linear_interp(t)*0.1+0.8, spec.x/0.4);
    col += shadeBlob(p, 0.5, cosine_interp(t)*0.1+0.8, spec.x/0.4);
    col += shadeBlob(p, 0.6, smoothstep_interp(t)*0.1+0.8, spec.x/0.4);
    col += shadeBlob(p, 0.7, quintic_interp(t)*0.1+0.8, spec.x/0.4);
 
    //col += shadeBlob(p, 0.3, smoothstep_interp(t)*spec.x+0.8, 0.1/0.1);
    //col += shadeBlob(p, 0.4, linear_interp(t)*spec.y+0.8, 0.1/0.1);
    col += shadeBlob(p, 0.5, cosine_interp(t)*0.1+0.85, spec.x/0.4);
    //col += shadeBlob(p, 0.6, smoothstep_interp(t)*spec.z+0.8, 0.1/0.1);
    col += shadeBlob(p, 0.7, quintic_interp(t)*0.1+0.85, spec.x/0.4);
 
    //col += shadeBlob(p, 0.3, smoothstep_interp(t)*spec.x+0.8, 0.1/0.1);
    //col += shadeBlob(p, 0.4, linear_interp(t)*spec.y+0.8, 0.1/0.1);
    col += shadeBlob(p, 0.5, cosine_interp(t)*0.1+0.9, spec.x/0.4);
    col += shadeBlob(p, 0.6, smoothstep_interp(t)*0.1+0.9, spec.x/0.4);
    col += shadeBlob(p, 0.7, quintic_interp(t)*0.1+0.9, spec.x/0.4);
 
 
 
    col += 1.0 -  smoothstep( 0.0, 0.15, abs(wave - q.x) );
 
    //col = pow(col, vec3(1.3));
    //col2 = pow(col2, vec3(0.45));
 
    fragColor = vec4(col, 1.0);
}
Read More

OpenGL Shading Language - 71337 Water Mites





#define PERIOD 2.
#define REPETITIONS 2

const float PI = 3.1415926535;


float box(in vec2 _st, in vec2 _size){
    _size = vec2(0.5) - _size*0.5;
    vec2 uv = smoothstep(_size,
                        _size+vec2(0.001),
                        _st);
    uv *= smoothstep(_size,
                    _size+vec2(0.001),
                    vec2(1.0)-_st);
    return uv.x*uv.y;
}

float cross2(in vec2 _st, float _size){
    return  box(_st, vec2(_size,_size/4.)) +
            box(_st, vec2(_size/4.,_size));
}

vec3 shadeBlob(vec2 p, float index, float value, float scale)
{
    float screenRatio = iResolution.x / iResolution.y;
    vec2 pc = vec2(0.1 + (screenRatio - 0.2) * value, index);
   
    float d = length(pc - p) / 0.015*scale/0.3;
   
    return vec3(3. * vec3(0.2, 0.5, 0.7) / (max(d * d, 1.)));
}

float step_interp(float x) {
    return step(0.5, x);
}

float linear_interp(float x) {
    float c = clamp(x, 0., 1.);
   
    return c;
}

float cosine_interp(float x) {
    float c = clamp(x, 0., 1.);
   
    return 0.5 * (1. - cos(PI * c));
}

float smoothstep_interp(float x) {
//    return smoothstep(0., 1., x);

    float c = clamp(x, 0., 1.);
   
    return c * c * (3. - 2. * c);
}

float quintic_interp(float x) {
    float c = clamp(x, 0., 1.);
   
    return c * c * c * ((6. * c - 15.) * c + 10.);
}

void mainImage( out vec4 fragColor, in vec2 fragCoord )
{
    vec2 p = fragCoord.xy / iResolution.yy;
    vec2 q = fragCoord.xy / iResolution.yy;
   
    int tx = int(p.x*128.0);
   
    // per lo Spectrum Audio
    float wave = texelFetch( iChannel0, ivec2(tx,1), 0 ).x;
    vec3 spec = vec3(wave);
   
    vec2 translate = vec2(cos(iTime),sin(iTime));
    vec2 translate2 = vec2(sin(iTime),cos(iTime));
    p += translate*0.35*sin(iTime);
    q += translate2*1.35*sin(iTime);
   
    float t = abs(2. * fract(iTime / PERIOD) - 1.);
    //int sel = int(6. * fract(time / (float(REPETITIONS) * PERIOD) / 6.));
    int sel = 5;
   
    // Background pattern
   
    vec3 col = vec3(0.0 + 0.000 * mod(floor(p.x * 10.0) + floor(p.y * 10.0), 2.0));
    vec3 col2 = vec3(0.0 + 0.000 * mod(floor(q.y * 5.0) + floor(q.x * 5.0), 2.0));
    //vec3 col = vec3(0.0,0.0,0.0,0.0));
   
   
    col += shadeBlob(p, 0.1, smoothstep_interp(t)*spec.x+0.5, wave/3.0);
    col2 += shadeBlob(q, 0.3+spec.z, linear_interp(t)*spec.y+0.5, wave/3.0);
    col += shadeBlob(p, 0.5+spec.x, cosine_interp(t)*spec.z+0.7, wave/3.0);
    col2 += shadeBlob(q, 0.7, smoothstep_interp(t)*spec.z+0.1, wave/3.0);
    col += shadeBlob(p, 0.9-spec.y, quintic_interp(t)*spec.z+0.3, wave/3.0);
   
   
    col = pow(col, vec3(0.45));
    col2 = pow(col2, vec3(0.45));
   
    fragColor = vec4(col+col2, 1.0);
}

Read More

OpenGL Shading Language - Water Mites Beta





#define PERIOD 2.
#define REPETITIONS 2

uniform float time;
uniform vec2 resolution;
uniform vec2 mouse;
uniform vec3 spectrum;

const float PI = 3.1415926535;


float box(in vec2 _st, in vec2 _size){
    _size = vec2(0.5) - _size*0.5;
    vec2 uv = smoothstep(_size,
                        _size+vec2(0.001),
                        _st);
    uv *= smoothstep(_size,
                    _size+vec2(0.001),
                    vec2(1.0)-_st);
    return uv.x*uv.y;
}

float cross(in vec2 _st, float _size){
    return  box(_st, vec2(_size,_size/4.)) +
            box(_st, vec2(_size/4.,_size));
}

vec3 shadeBlob(vec2 p, float index, float value, float scale)
{
    float screenRatio = resolution.x / resolution.y;
    vec2 pc = vec2(0.1 + (screenRatio - 0.2) * value, index);
 
    float d = length(pc - p) / 0.015*scale/0.3;
 
    return vec3(3. * vec3(0.2, 0.5, 0.7) / (max(d * d, 1.)));
}

float step_interp(float x) {
    return step(0.5, x);
}

float linear_interp(float x) {
    float c = clamp(x, 0., 1.);
 
    return c;
}

float cosine_interp(float x) {
    float c = clamp(x, 0., 1.);
 
    return 0.5 * (1. - cos(PI * c));
}

float smoothstep_interp(float x) {
//    return smoothstep(0., 1., x);

    float c = clamp(x, 0., 1.);
 
    return c * c * (3. - 2. * c);
}

float quintic_interp(float x) {
    float c = clamp(x, 0., 1.);
 
    return c * c * c * ((6. * c - 15.) * c + 10.);
}

void main(void)
{
    vec2 p = gl_FragCoord.xy / resolution.yy;
    vec2 q = gl_FragCoord.xy / resolution.yy;
 
    vec3 spec = .1+spectrum;
 
    vec2 translate = vec2(cos(time),sin(time));
    vec2 translate2 = vec2(sin(time),cos(time));
    p += translate*0.35*sin(time);
    q += translate2*1.35*sin(time);
 
    float t = abs(2. * fract(time / PERIOD) - 1.);
 
 
    vec3 col = vec3(0.0 + 0.000 * mod(floor(p.x * 10.0) + floor(p.y * 10.0), 2.0));
    vec3 col2 = vec3(0.0 + 0.000 * mod(floor(q.y * 5.0) + floor(q.x * 5.0), 2.0));
 
 
    col += shadeBlob(p, 0.1, smoothstep_interp(t)*spec.x+0.5, spec.x/0.1);
    col2 += shadeBlob(q, 0.3+spec.z, linear_interp(t)*spec.y+0.5, spec.z);
    col += shadeBlob(p, 0.5+spec.x, cosine_interp(t)*spec.z+0.7, spec.z/0.3);
    col2 += shadeBlob(q, 0.7, smoothstep_interp(t)*spec.z+0.1, spec.x/0.6);
    col += shadeBlob(p, 0.9-spec.y, quintic_interp(t)*spec.z+0.3, spec.z/0.9);

 
    col = pow(col, vec3(0.45));
    col2 = pow(col2, vec3(0.45));
 
    gl_FragColor = vec4(col+col2, 1.0);
}
Read More

OpenGL Shading Language - Live Shader

#ifdef GL_ES
precision mediump float;
#endif

uniform vec2 resolution;
uniform vec2 mouse;
uniform vec3 spectrum;
uniform float time;

// Plot a line on Y using a value between 0.0-1.0
float plot(vec2 st, float pct){
return smoothstep( pct-0.01, pct, st.y) -
smoothstep( pct, pct+0.01, st.y);
}

void main() {
vec2 st = gl_FragCoord.xy/resolution;

float y = st.x;

vec3 color = vec3(0,0,0);
vec3 spec = spectrum*27.0;

// Plot a line
float pct = plot(st,spec.x);

color = (1.0-pct)*color+pct*vec3(0,1,1);

gl_FragColor = vec4(color,1.0);
}

------- Parabola

#ifdef GL_ES
precision mediump float;
#endif

#define PI 3.14159265359

uniform vec2 resolution;
uniform vec2 mouse;
uniform vec3 spectrum;
uniform float time;

// Plot a line on Y using a value between 0.0-1.0
float plot(vec2 st, float pct){
return smoothstep( pct-0.01, pct, st.y) -
smoothstep( pct, pct+0.01, st.y);
}

float impulse( float k, float x )
{
float h = k*x;
return h*exp(1.0-h);
}

float parabola( float x, float k )
{
return pow( 4.0*x*(1.0-x), k );
}

void main() {
vec2 st = gl_FragCoord.xy/resolution;

float y=parabola(st.x,2.0);

vec3 color = vec3(0,0,0);
vec3 spec = .1+spectrum;

// Plot a line
float pct = plot(st*spec.x,y*spec.y);

color = (1.0-pct)*color+pct*vec3(0.3,0.3,0.3);

gl_FragColor = vec4(color,1.0);

}
Read More
Update cookies preferences