// See the descriptions for these in `project`. They're only relevant if you zoom out.
//#define TILE_PERSPECTIVE
//#define CLAMP_PERSPECTIVE
// "FOV", poorly-defined. affects *zoom*.
#define FOV (1.5)
#define SAMPLES 1
#define LIGHT_SAMPLES 7

// The maximum number of steps a ray can take during marching before giving up
// and colliding with nothing. This prevents scenes from taking infinite time to render.
#define MAX_STEPS 300
// The maximum distance a ray can travel before we give up and just say it collides
// with nothing. This helps prevent the background from appearing warped by the foreground
// due to rays which march close to a foreground object run out of steps before
// reaching their destination when slightly farther rays do reach their target.
#define MAX_DIST 50.
// The minimum distance between two points before they are considered the same point.
// Setting a minimum distance prevents graphical glitches when ray marching parallel
// to a surface, where the ray does not intersect an object, but comes close enough
// that the march becomes so slow that it fails to reach its actual destination.
#define MIN_DIST     (0.001953125/256.)
// The distance between samples when estimating a surface's normal.
#define NORMAL_DELTA (MIN_DIST/2.)
// How far away from the source to start marching a scatter ray, to prevent accidental collision.
#define SCATTER_MAGIC (MIN_DIST*16.)
// Only march this much of MIN_DIST at a time to account for imprecision in the distance
// calculations. Chosen by experimentation.
#define IMPRECISION_FACTOR 1.

#ifndef SAMPLES
#define SAMPLES 1
#endif

#ifndef LIGHT_SAMPLES
#define LIGHT_SAMPLES 1
#endif

#define NAN sqrt(-1.)
#define INF (1./0.)

// stolen from iq: https://www.shadertoy.com/view/4sfGzS
//------------------------------------------------------------------
// oldschool rand() from Visual Studio
//------------------------------------------------------------------
#if 1
int  seed = 1;
void srand(int s ) { seed = s; }
int  rand(void) { seed = seed*0x343fd+0x269ec3; return (seed>>16)&32767; }
float frand(void) { return float(rand())/32767.0; }
#else
// this isn't copied from iq. it's unclear which version is faster.
float seed = 0.;
void srand(int s) { seed = mod(float(s), 256. * 256.)/256.; }
float frand(void) {
    float x, y;
    x = modf(seed, y);
    seed += 1./256.;
    x *= 256.;
    return texelFetch(iChannel0, ivec2(int(x), int(y)),0).r;
}
#endif
//------------------------------------------------------------------
// hash to initialize the random sequence (copied from Hugo Elias)
//------------------------------------------------------------------
int hash( int n )
{
	n = (n << 13) ^ n;
    return n * (n * n * 15731 + 789221) + 1376312589;
}

void initRandoms(vec2 fragCoord) {
    ivec2 q = ivec2(fragCoord);
    srand( hash(q.x+hash(q.y+hash(iFrame))));
}
//------------------------------------------------------------------
// end stolen from iq

float time;

/// The amount of outgoing light reflected is related to the angle of the
/// incoming light and the normal of the surface. The naive approach is
/// to divide the outgoing light by `dot(norm, dir)`, but by preferentially
/// sampling points according to their weight, we achieve the same effect
/// but with more information per-sample on average.
// by fizzer via IQ: http://www.amietia.com/lambertnotangent.html
vec3 cosine_direction(vec3 norm) {
    float u = frand();
    float v = frand();

    float a = 6.2831853 * v;
    u = 2.0*u - 1.0;
    return normalize(norm + vec3(sqrt(1.0 - u*u)*vec2(cos(a), sin(a)), u));
}
// end by fizzer

float dist_light(vec3 pos) {
    float l1 = distance(pos, vec3(1.5, 1.2, 7.)) - 0.7;
    float l2 = distance(pos, vec3(-1.2, 0.5, 5.0)) - 0.5;
    return min(l1, l2);
}

float dist_floor(vec3 pos) {
    return pos.y + 1.0;
}

// The distance from a point to the nearest object in the scene.
float dist(vec3 pos) {
    vec3 sphere_pos = vec3(0., -0.15, 8.);
    vec3 neg_pos = sphere_pos + .7*vec3(sin(time), 0., cos(time));
    float sphere = distance(pos, sphere_pos) - 1.;
    float sphere2 = distance(pos, neg_pos) - 0.5;
    float plane = dist_floor(pos);
    return min(dist_light(pos), min(max(sphere, -sphere2), plane));
}

/// Approximate the distance to the nearest object along a ray
/// using our signed distance function (`dist`).
float march1(vec3 origin, vec3 direction, float magic) {
    float total_dist = 0.;
    float delta = magic >= MIN_DIST ? magic / IMPRECISION_FACTOR : dist(origin);
    for (int steps = 0; steps < MAX_STEPS && total_dist < MAX_DIST && delta >= MIN_DIST; steps++) {
        total_dist += delta * IMPRECISION_FACTOR;
        vec3 pos = origin + direction * total_dist;
        delta = dist(pos);
    }
    return delta < MIN_DIST ? total_dist : INF;
}

vec3 intersect1(vec3 origin, vec3 direction, float magic) {
    return origin + direction*march1(origin, direction, magic);
}

vec3 intersect2(vec3 origin, vec3 direction, float magic) {
    float total_dist = 0.;
    float delta = magic >= MIN_DIST ? magic / IMPRECISION_FACTOR : dist(origin);
    vec3 pos = origin;
    for (int steps = 0; steps < MAX_STEPS && total_dist < MAX_DIST && delta >= MIN_DIST; steps++) {
        pos += direction * delta * IMPRECISION_FACTOR;
        delta = dist(pos);
        total_dist = distance(origin, pos);
    }
    return delta < MIN_DIST ? pos : vec3(INF);
}

float march2(vec3 origin, vec3 direction, float magic) {
    return distance(origin, intersect2(origin, direction, magic));
}

#define MARCH_ALG 1

float march(vec3 origin, vec3 direction, float magic) {
#if MARCH_ALG
    return march1(origin, direction, magic);
#else
    return march2(origin, direction, magic);
#endif
}

/// Intersect with an object in the scene by ray marching.
vec3 intersect(vec3 origin, vec3 direction, float magic) {
#if MARCH_ALG
    return intersect1(origin, direction, magic);
#else
    return intersect2(origin, direction, magic);
#endif
}

float march(vec3 origin, vec3 direction) {
    return march(origin, direction, 0.);
}

vec3 intersect(vec3 pos, vec3 dir) {
    return intersect(pos, dir, 0.);
}

// Estimate the angle from the nearest surface to a point.
vec3 normal(vec3 pos) {
    vec2 delta = vec2(NORMAL_DELTA, 0.);
    vec3 dq = (dist(pos) - vec3(
        dist(pos - delta.xyy),
        dist(pos - delta.yxy),
        dist(pos - delta.yyx)
    )); // alternate version: divide by /delta.x, but skip the normalize
    
    return normalize(dq);
}

struct LightSample {
    // Position of point of interest
    vec3 position;
    // Angle of incoming light
    vec3 incoming;
    // Angle of outgoing light
    vec3 outgoing;
} light_samples[LIGHT_SAMPLES];

/// Choose which direction to cast the next ray, depending on the
/// surface normal, material, and angle of incoming light.
///
/// This distribution *must be weighted by importance*! In particular,
/// by the angle between the incoming and outgoing rays, and by the BRDF;
/// if the BRDF would evenly reject all wavelengths, it should instead probabilistically
/// choose to *not* scatter by emitting a NaN direction so we can stop unnecessarily
/// bouncing our paths around.
vec3 scatter(vec3 pos, vec3 dir) {
    if (dist_floor(pos) <= MIN_DIST && frand() < 0.25) {
        vec3 norm = normal(pos);
        vec3 refl = 2.*dot(dir, norm)*norm - dir;
        return refl;
    }
    if (frand() < 0.4) {
        vec3 norm = normal(pos);
        vec3 refl = 2.*dot(dir, norm)*norm - dir;
        return normalize(cosine_direction(refl) + norm);
    }
    return cosine_direction(normal(pos));
}

/// Choose how much light to reflect based on the bidirectional reflectance distribution function,
/// then add light according to the matterial's emittance. These are fundamentally separate concepts,
/// but they're combined into this function so we have to sample the material only once instead of twice.
void brdf_emit(inout vec3 color, in int sample_i) {
    LightSample samp = light_samples[sample_i];
    if (dist_light(samp.position) <= MIN_DIST) {
        color += vec3(0.9) * dot(samp.outgoing, normal(samp.position));
    } else if (dist_floor(samp.position) <= MIN_DIST) {
        color.r *= 0.3;
        color.g *= 0.2;
        color.b *= 0.9;
        //color += vec3(0., 0., 0.01);
    } else {
        color.gb *= 0.3;
        //color += vec3(0.004, 0., 0.);
    }
}

vec4 light(vec3 pos, vec3 dir) {
#if 1
    int sample_i = 0;
    
    for (; sample_i < LIGHT_SAMPLES; sample_i++) {
        pos = intersect(pos, dir, SCATTER_MAGIC);
        // We've stuck in the void forever!
        if (any(isinf(pos))) break;
        vec3 neg_incoming = scatter(pos, -dir);
        vec3 outgoing = -dir;
        // The surface is darkening itself by simply choosing not to sample.
        // This is going to be worse on a per-sample basis for most materials,
        // but it averages out, and massively saves performance by letting us quit
        // recursing.
        if (any(isnan(neg_incoming))) break;
        light_samples[sample_i] = LightSample(pos, -neg_incoming, outgoing);
        dir = neg_incoming;
    }
    
    if (sample_i == 0) return vec4(0.);
    
    vec3 color = vec3(0.);
    for (; sample_i >= 0; sample_i--) {
        brdf_emit(color, sample_i);
    }

    return vec4(color, 1.);
    
#elif 0
    // debug intersection location
    pos = intersect(pos, dir);
    if (any(isinf(pos))) return vec4(0.);
    return vec4(pos, 1.);
#elif 0
    // debug ray marching
    float dist = march(pos, dir);
    return (vec4(vec3(dist), 1.) - 0.) / 10.;
#elif 0
    // debug ray marching algorithms
    float dist = distance(march1(pos, dir, 0.), march2(pos, dir, 0.));
    return vec4(vec3(dist), 1.);
#elif 0
    // debug normals
    pos = intersect(pos, dir);
    vec3 norm = normal(pos);
    return vec4(abs(norm), 1.);
#elif 0
    // debug scattering
    pos = intersect(pos, dir);
    return vec4(abs(scatter(pos)), 1.);
#else
    // debug scatter magic
    pos = intersect(pos, dir);
    vec3 o = pos;
    vec3 scat = scatter(pos);
    pos = intersect1(o, scat, SCATTER_MAGIC)/10.;
    pos = vec3(distance(pos, intersect2(o, scat, SCATTER_MAGIC)/10.));
    //pos = vec3(march(pos, scat, SCATTER_MAGIC))/10.;
    return vec4(pos, 1.);
#endif
}

/// Project a coordinate on the unit circle onto the unit hemisphere.
/// This is used for curvilinear perspective.
vec3 project(vec2 coord) {
    // The sign of the direction we're facing. 1 is forward, -1 is backward.
    float dir = 1.;
    #ifdef TILE_PERSPECTIVE
    // This projection only supports coordinates within the unit circle
    // and only projects into the unit hemisphere. Ideally we'd want
    // some sort of extension which takes points outside the unit circle
    // and projects them somewhere behind you (with the point at infinity
    // being directly behind you), but I haven't come up with any reasonable
    // extension of this perspective system which behaves in that manner.
    //
    // What we can do instead is *tile* the projection so that adjacent projections
    // are a mirrored projection of the unit hemisphere *behind* you.
    // This is a logical extension because the projection becomes continuous
    // along the x and y axis (you're just looking around in perfect circles),
    // and it allows you to view the entire space. The main problem to this approach
    // is that all of the space between the tiled circles is still undefined,
    // but this is still the best solution which I'm aware of.
    coord -= 1.;
    coord = mod(coord + 2., 4.) - 1.;
    if (coord.x > 1.) {
        coord.x = 1. - (coord.x - 1.);
        dir = -dir;
    }
    if (coord.y > 1.) {
        coord.y = 1. - (coord.y - 1.);
        dir = -dir;
    }
    #endif
    float z = dir*sqrt(1. - coord.x*coord.x - coord.y*coord.y);
    #ifdef CLAMP_PERSPECTIVE
    // We can "define" the remaining undefined region of the screen
    // by clamping it to the nearest unit circle. This is sometimes
    // better than nothing, though it can also be a lot worse because
    // we still have to actually *render* all of those pixels.
    if (isnan(z)) {
        coord = normalize(coord);
        z = 0.;
    }
    #endif
    return vec3(coord, z);
}

/// Return the camera's position and direction.
vec3 camera(inout vec3 e) {
    // camera direction (forward vector)
    vec3 d = vec3(0., 0., 1.);
    
    // point projection relative to direction
    // this really needs to be simplified,
    // but I don't know the math to understand how to do it.
    vec3 up = vec3(0., 1., 0.);
    //vec3 x = cross(up, d);
    vec3 x = vec3(d.z, 0., -d.x);
    //vec3 y = cross(d, x);
    vec3 y = vec3(-d.y*d.x, d.z*d.z+d.x*d.x, -d.y*d.z);
    
    mat3 rot = mat3(
        x.x, y.x, d.x,
        x.y, y.y, d.y,
        x.z, y.z, d.z
    );
    
    e = normalize(rot * e);
    
    // camera position
    return vec3(0., 0., 0.);
    
    /*e = vec3(
        e.x*d.z - e.y*d.y*d.x + d.x,
        e.y*(d.z*d.z+d.x*d.x) + d.y,
        -e.x*d.x - e.y*d.y*d.z + d.z
    );
    e = normalize(e);*/
    
}

/// Map pixel coordinate (from 0,0 to resolution) onto the coordinate system
/// *we* use to represent the screen (from (-1, -1) to (1, 1) with a square
/// aspect ratio).
vec2 screen2square(vec2 screen) {
    // Map rectangular screen into square coordinate space.
    vec2 square = ((screen / iResolution.xy) - 0.5) * 2.;
    // Adjust for aspect ratio to get square coordinates.
    if (iResolution.x > iResolution.y) {
        return vec2(square.x, square.y * iResolution.y / iResolution.x);
    } else {
        return vec2(square.x * iResolution.x / iResolution.y, square.y);
    }
}

vec4 colorPixel(vec2 fragCoord) {
    vec2 uv = screen2square(fragCoord) * 1.;
    uv /= FOV;
    vec3 eye = project(uv);
    if (any(isnan(eye))) {
        // The projection is undefined at this pixel coordinate (see `project`);
        // don't bother rendering it, and return 100% transparent black to indicate that
        // we didn't render it.
        return vec4(NAN);
    }
    
    vec3 pos = camera(eye);
    return light(pos, eye);
}

/// Convert from linear RGB to sRGB color space.
vec3 linear2srgb(vec3 linear_rgb) {
    // I believe the first version is technically more accurate,
    // but the difference is usually negligable in practice.
    #if 1
    // copied from somewhere on the internet
    bvec3 cutoff = lessThan(linear_rgb, vec3(0.0031308));
    vec3 higher = vec3(1.055)*pow(linear_rgb, vec3(1.0/2.4)) - vec3(0.055);
    vec3 lower = linear_rgb * vec3(12.92);

    return mix(higher, lower, cutoff);
    // end copied from somewhere on the internet
    #else
    return pow(linear_rgb, vec3(1./2.2));
    #endif
}

void mainImage(out vec4 fragColor, vec2 fragCoord) {
    initRandoms(fragCoord);
    
    // Sample a bunch of times around the pixel and return the average.
    vec4 color = vec4(0.);
    for (int i = 0; i < SAMPLES; i++) {
        vec2 uv = fragCoord + vec2(frand(), frand()) - 0.5;
        // Add noise to time for temporal antialiasing.
        time = iTime + frand() * iTimeDelta;
        vec4 samp = colorPixel(uv);
        // We failed to render a sample at this location.
        if (any(isnan(samp))) continue;
        color += samp;
    }
    color /= float(SAMPLES);
    
    color = clamp(vec4(0.), color, vec4(1.));
    fragColor = vec4(linear2srgb(color.rgb), color.a);
}