template.glsl

// uniform vec3 iResolution;
// uniform float iTime;
// uniform float iTimeDelta;
// uniform float iFrame;
// uniform float iChannelTime[4];
// uniform vec4 iMouse;
// uniform vec4 iDate;
// uniform float iSampleRate;
// uniform vec3 iChannelResolution[4];
// uniform samplerXX iChanneli;

#ifdef GL_ES
precision mediump float;
#endif

#define PI 3.14159265359
#define TWO_PI 6.28318530718
#define EPS 0.01

float CSG_Union (float d1, float d2) {
    return min(d1, d2);
}

float CSG_Intersection (float d1, float d2) {
    return max(d1, d2);
}

float CSG_Substraction (float d1, float d2) {
    return max(d1, -d2);
}

vec3 mod289(vec3 x) { return x - floor(x * (1.0 / 289.0)) * 289.0; }
vec2 mod289(vec2 x) { return x - floor(x * (1.0 / 289.0)) * 289.0; }
vec3 permute(vec3 x) { return mod289(((x * 34.0) + 1.0) * x); }

float snoise(vec2 v) {
    // Precompute values for skewed triangular grid
    const vec4 C = vec4(0.211324865405187,
                        // (3.0-sqrt(3.0))/6.0
                        0.366025403784439,
                        // 0.5*(sqrt(3.0)-1.0)
                        -0.577350269189626,
                        // -1.0 + 2.0 * C.x
                        0.024390243902439);
                        // 1.0 / 41.0

    // First corner (x0)
    vec2 i  = floor(v + dot(v, C.yy));
    vec2 x0 = v - i + dot(i, C.xx);

    // Other two corners (x1, x2)
    vec2 i1 = vec2(0.0);
    i1 = (x0.x > x0.y)? vec2(1.0, 0.0):vec2(0.0, 1.0);
    vec2 x1 = x0.xy + C.xx - i1;
    vec2 x2 = x0.xy + C.zz;

    // Do some permutations to avoid
    // truncation effects in permutation
    i = mod289(i);
    vec3 p = permute(
            permute( i.y + vec3(0.0, i1.y, 1.0))
                + i.x + vec3(0.0, i1.x, 1.0 ));

    vec3 m = max(0.5 - vec3(
                        dot(x0,x0),
                        dot(x1,x1),
                        dot(x2,x2)
                        ), 0.0);

    m = m*m ;
    m = m*m ;

    // Gradients:
    //  41 pts uniformly over a line, mapped onto a diamond
    //  The ring size 17*17 = 289 is close to a multiple
    //      of 41 (41*7 = 287)

    vec3 x = 2.0 * fract(p * C.www) - 1.0;
    vec3 h = abs(x) - 0.5;
    vec3 ox = floor(x + 0.5);
    vec3 a0 = x - ox;

    // Normalise gradients implicitly by scaling m
    // Approximation of: m *= inversesqrt(a0*a0 + h*h);
    m *= 1.79284291400159 - 0.85373472095314 * (a0*a0+h*h);

    // Compute final noise value at P
    vec3 g = vec3(0.0);
    g.x  = a0.x  * x0.x  + h.x  * x0.y;
    g.yz = a0.yz * vec2(x1.x,x2.x) + h.yz * vec2(x1.y,x2.y);
    return 130.0 * dot(m, g);
}

vec2 skew (vec2 st) {
    vec2 r = vec2(0.0);
    r.x = 1.1547 * st.x;
    r.y = st.y + 0.5 * r.x;
    return r;
}

float random (vec2 st) {
    return fract( sin( dot( st.xy, vec2( 12.9898, 78.233 ) ) ) * 43758.5453123 );
}

vec2 random2( vec2 p ) {
    return fract(sin(vec2(dot(p, vec2(127.1, 311.7)), dot(p, vec2(269.5,183.3)))) * 43758.5453);
}

mat2 scale2d(vec2 _scale) {
    return mat2(_scale.x, 0.0,
                0.0, _scale.y);
}

mat2 rotate2d(float _angle) {
    float c = cos(_angle);
    float s = sin(_angle);
    return mat2(c, -s,
                s, c);
}

//  Function from Iñigo Quiles
//  https://www.shadertoy.com/view/MsS3Wc
vec3 hsb2rgb( in vec3 c ){
    vec3 rgb = clamp(abs(mod(c.x * 6.0 + vec3(0.0, 4.0, 2.0),
                             6.0) - 3.0) - 1.0,
                     0.0,
                     1.0 );
    rgb = rgb * rgb * (3.0 - 2.0 * rgb);
    return c.z * mix(vec3(1.0), rgb, c.y);
}

float circle(in vec2 _st, in float _radius, in float _th){
	return 1. - smoothstep( _radius - (_radius * _th),
                            _radius + (_radius * _th),
                            dot(_st, _st));
}

float box(in vec2 _st, in vec2 _wh, in float _smooth) {
    vec2 r = abs(_st);
    return 1. - max(smoothstep(_wh.x, _wh.x + _smooth, r.x), smoothstep(_wh.y, _wh.y + _smooth, r.y));
}

float plot(in vec2 _st, in float _pct, in float _t) {
    return smoothstep( _pct - _t, _pct, _st.y) -
    smoothstep( _pct, _pct + _t, _st.y);
}

float ngon(in vec2 _st, in float _r, in float _t, in int _n) {
  // Angle and radius from the current pixel
  float a = atan(_st.x, _st.y) + PI;
  float r = TWO_PI / float(_n);

  // Shaping function that modulate the distance
  float d = cos(floor(.5 + a / r) * r - a) * length(_st);
  return 1.0 - smoothstep(_r, _r + _t, d);
}

/*--------------------------------------------------*/
void mainImage( out vec4 fragColor, in vec2 fragCoord )
{
    /*----------*/
	float t = iTime;
    float dt = iTimeDelta;
    vec3 color = vec3(0.);
    vec2 st = 2. * fragCoord.xy / iResolution.xy - 1.0; // -1 <> 1
    vec2 st01 = fragCoord.xy / iResolution.xy; // 0 <> 1
    vec2 mouse = 2. * iMouse.xy / iResolution.xy - 1.0;
    vec3 camera = vec3(0., 0., -5.);
    float near = 2.5;
    vec3 ray = normalize(vec3(st, near));
    /*----------*/

    fragColor = vec4(color,  1.);
}