//////// ================================
//////// SETTINGS: Settings
//////// ================================

//
// If you don't feel like tweaking settings, try one of these presets:
//
//     0: Maximize FPS at the cost of image quality. (DEFAULT)
//     1: A balance between image quality and FPS.
//     2: Just render a pretty static image.
//     3: Demonstrate off the weird tiling render feature.
//
// The user settings below will override whatever preset you use.
//
#define PRESET 2

//
// Scenes:
//
//     1: A glossy rotating orange ball with two divets and blue floor.
//     2: 
//
#define SCENE 1

//////// --------------------------------
//////// Scene settings
//////// --------------------------------

//     0: circle around the origin
//     1: portrait
//     2: profile
//     3: 3/4
//#define SCENE2_CAMERA 0

//////// --------------------------------
//////// User settings
//////// --------------------------------
//////// Tweak these according to your preferences and the power of your graphics card.
//////// Comment out a setting to restore it to its default value.

//// ********************************
//// Sample settings
//// ********************************

// The number of color samples taken per pixel. Increasing this has a dramatic effect on
// image quality, reducing graininess and preventing overly-bright pixels ("fireflies").
// However, how much GPU power you need to render a frame scales linearly with
// the number of samples.
//#define SAMPLES 1

// The maximum number of times light can reflect or scatter before it is extinguished.
//#define PATH_SEGMENTS 14

//// ********************************
//// Postprocessing settings
//// ********************************

// If a pixel color is too bright for fit in sRGB, there are two ways to handle it:
//
//    1. Clamp the pixel within the limits of sRGB, resulting in (near-)maximum
//       brightness at the cost of the color's saturation. (If it's too bright, it'll
//       become entirely white.)
//    2. Reduce the brightness of the color until it fits within sRGB, preserving
//       the color's saturation, but losing even *more* brightness.
//
// Correction for saturation generally looks better, but isn't usually necessary
// for more than five or so samples (because the bright pixels will average out
// with the dark pixels and fall back within sRGB).
//#define SATURATION_CORRECTION 1

// The dithering looks pretty good. Honestly, at 1440p it makes even
// 3 bits per color channel look *very* convincing. As far as I'm aware
// there are no downsides to leaving it enabled. It would probably help
// reduce color banding and improve color clarity in general.
//#define ENABLE_DITHER 1

// The number of available colors *per channel*.
//define DITHER_COLORS 1<<8

// The size of the Bayer matrix is 2^DITHER_BASE, so e.g. 4 is a 16x16 matrix.
// This can't be larger than 16 because dithering is implemented using a 16-bit bit hack.
//#define DITHER_BASE 16

// Artifically restrict the colors to those specified in DITHER_COLORS.
// If you set DITHER_COLORS to 6 or so and enable DITHER_NEAREST then screenshot
// and convert the image to a GIF* using an appropriate conversion tool,
// it will look exactly the same as it looks on your screen.
// This was the motivating reason for adding dithering, and it looks amazing.
//
// * Pronounced "yif". Fite me.
//#define DITHER_NEAREST 0

//// ********************************
//// Perspective settings
//// ********************************

// This shader natively uses a square (circular?) aspect ratio. With ASPECT_RATIO_CROP
// enabled, if you use a wide aspect ratio, the frame will have its height
// cropped so that the image can take up the full width of the screen.
//#define ASPECT_RATIO_CROP 1

// This setting affects how far you zoom in on the scene.
// Greater values = more zoom. Fractional values zoom out. Negative values mirror the scene.
//#define FOV 1.5

// Camera position and angle. (Feel free to reference `time` here.)
//#define CAMERA_POS vec3(0.)
// (Don't worry, we call `normalize` for you.
//#define CAMERA_DIR vec3(0., 0., 1.)

///
/// TILE_PERSPECTIVE and CLAMP_PERSPECTIVE are only relevant if you zoom out
/// (e.g. an FOV < ~1.15). For more information on how and why these settings
/// behave the way they do, see their extended descriptions in the `project` function.
///

// Points on the screen >1 or <-1 show the portion of the scene *behind* you,
// mirrored so that the edges of each adjacent tile lines up (e.g. tiles above
// and below are mirrored vertically, to the left and right horizontally).
// This tiling is infinite. You might want to combine this with an IMAGE_OFFSET of
// (-1, 0) so that you can see two whole hemispheres instead of one whole hemisphere
// and two halves on opposite sides.
//#define TILE_PERSPECTIVE 0

// Points on the screen outside of the unit circle (within a tile) are clamped
// to the nearest point on the unit circle. This doesn't look very good, but
// might be preferable to just rendering black?
//#define CLAMP_PERSPECTIVE 0

// Slide the image around on the screen. Each time is `2x2` centered on the
// origin, so an offset of e.g. (2,0) with TILE_PERSPECTIVE enabled
// will show you the portion of the scene *behind* you.
//#define IMAGE_OFFSET vec2(0., 0.)

//// ********************************
//// Simulation settings
//// ********************************

// 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 200

// 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 20.

// Average the color across frames by storing them in the buffer.
// This is like supersampling, but across frames instead of within a pixel,
// which lets you render with thousands of samples without crashing.
// It's strongly advised that you enable FREEZE_TIME when this is enabled!
// This uses iFrame, so if you want to enable this, make sure you hit the
// "reset time" function or things will get screwed up.
//#define AVERAGE_FRAMES 1

// Set a time in seconds. The simulation will be frozen at this point in time every frame.
// Comment this out to allow time to pass normally.
//#define FREEZE_TIME 2.75

// Loop time over an interval of this duration, beginning at FREEZE_TIME,
// or 0, if FREEZE_TIME is not set.
//#define LOOP_TIME 0.

// Set the maximum duration of temporal antialiasing (i.e. how much time
// motion blur smears across). Note that this is a *maximum* time, and motion
// blur will never be greater than the duration of a frame. That said, when rendering
// a still image with FREEZE_TIME you probably want this set to 0., and if you're
// stuttering a lot, the large variance in frame times can make objects in the image
// appear to jerk back and forth, so this probably shouldn't be any higher
// than (the reciprocal of) your average framerate. Comment this out to
// remove any cap on the amount of motion blur.
//#define MAX_TAA_DIFF (1./30.)


//////// --------------------------------
//////// Internal settings
//////// --------------------------------
//////// If you're just viewing the shader, you shouldn't usually need to tweak these.

// The minimum distance between two points before they are considered the same point.
// Setting lower values increases the sharpness of the image at the cost of performance
// and rounding errors at objects very far from 0.
//
// Ray marching halves the distance to the surface of an object each iteration, but the
// end goal of ray marching is to pass slightly *inside* the object. Setting a minimum
// distance prevents zeno's paradox. This also serves as a optimization
// because the number of steps increases logarithmically as you decrease the minimum distance.
//
// Chosen to be 2^(-9), or about ~2mm, because that's the largest you can set it before
// the quality of the image is significantly effected. You can set it as low as about
// 2^(-19) before things begin to break. It's good to experiment with both high and low
// values to help find bugs in the numerical precision of the light simulation.
// If you have precision bugs, the simulation ends up getting affected pretty dramatically
// by changes to MIN_DIST, whereas a numerically stable simulation is not affected much at all.
//
// I expect that a minimum distance of 2^(-9) would work until about 10km from the origin
// with 32-bit floating point before starting to break down, but I have not tested it.
//#define MIN_DIST     (0.001953125)

// The distance between samples when estimating a surface's normal. Smaller values result
// in more precise calculations, but are more sensitive to numerical imprecision.
// This should probably be less than MIN_DIST.
//#define NORMAL_DELTA (MIN_DIST/4.)

// Only march this much of MIN_DIST at a time to account for imprecision in the distance
// calculations. Chosen by experimentation. If you have to set this low, that often means
// that there's a bug somewhere (e.g. you forgot to call `normalize`).
//
// Right now, the simulation is numerically stable and I don't have to use it at all!
// But I often find that it's necessary to set this to around ~0.92 when debugging
// numerical issues.
//#define IMPRECISION_FACTOR 1.

//////// --------------------------------
//////// Default settings & presets
//////// --------------------------------
//////// So you can restore a setting to its default value by commenting it out.

#ifndef PRESET
#define PRESET 0
#endif

#ifndef SCENE
#define SCENE 2
#endif

//// ********************************
//// Scene 2
//// ********************************
#if SCENE == 2
#ifndef SCENE2_CAMERA
#define SCENE2_CAMERA 1
#endif

#ifndef FOV
#define FOV 1.2
#endif

#if SCENE2_CAMERA == 1

#ifndef CAMERA_POS
#define CAMERA_POS vec3(0., -0.1, -0.5)
#endif
#ifndef CAMERA_DIR
#define CAMERA_DIR vec3(0., 0., 1.)
#endif

#elif SCENE2_CAMERA == 2

#ifndef CAMERA_POS
#define CAMERA_POS vec3(0.5, -0.1, 0.0)
#endif
#ifndef CAMERA_DIR
#define CAMERA_DIR vec3(-1.0, 0.0, 0.0)
#endif

#elif SCENE2_CAMERA == 3

#ifndef CAMERA_POS
#define CAMERA_POS vec3(-sqrt(0.5/4.), -0.1, -sqrt(0.5/4.))
#endif
#ifndef CAMERA_DIR
#define CAMERA_DIR vec3(sqrt(0.5), 0., sqrt(0.5))
#endif

#else

#ifndef CAMERA_POS
#define CAMERA_POS vec3(sin(-time)*0.5, -0.1, cos(-time)*0.5)
#endif
#ifndef CAMERA_DIR
#define CAMERA_DIR vec3(-sin(-time), 0., -cos(-time))
#endif

#endif

#endif

//// ********************************
//// Preset 1
//// ********************************
#if PRESET == 1

#ifndef SAMPLES
#define SAMPLES 6
#endif
#ifndef PATH_SEGMENTS
#define PATH_SEGMENTS 16
#endif
#ifndef MAX_TAA_DIFF
#define MAX_TAA_DIFF (1./30.)
#endif

//// ********************************
//// Preset 2
//// ********************************
#elif PRESET == 2

#ifndef PATH_SEGMENTS
#define PATH_SEGMENTS 10
#endif
#ifndef MAX_STEPS
#define MAX_STEPS 300
#endif
#ifndef MAX_DIST
#define MAX_DIST 50.
#endif
#ifndef MIN_DIST
#define MIN_DIST (0.001953125/128.)
#endif
#ifndef MAX_TAA_DIFF
#define MAX_TAA_DIFF 0.
#endif
#ifndef AVERAGE_FRAMES
#define AVERAGE_FRAMES 1
#endif
#ifndef FREEZE_TIME
#if SCENE == 1
#define FREEZE_TIME 2.75
#elif SCENE == 2
#define FREEZE_TIME 2.3
#else
#define FREEZE_TIME 0.
#endif
#endif

//// ********************************
//// Preset 3
//// ********************************
#elif PRESET == 3

#ifndef FOV
#define FOV 0.5
#endif
#ifndef TILE_PERSPECTIVE
#define TILE_PERSPECTIVE 1
#endif
#ifndef CLAMP_PERSPECTIVE
#define CLAMP_PERSPECTIVE 1
#endif
#ifndef IMAGE_OFFSET
#define IMAGE_OFFSET vec2(0., 0.)
#endif

#endif

//// ********************************
//// Preset 0 (defaults)
//// ********************************
#ifndef SAMPLES
#define SAMPLES 1
#endif
#ifndef PATH_SEGMENTS
#define PATH_SEGMENTS 10
#endif

#ifndef SATURATION_CORRECTION
#define SATURATION_CORRECTION 1
#endif
#ifndef ENABLE_DITHER
#define ENABLE_DITHER 1
#endif
#ifndef DITHER_BASE
#define DITHER_BASE 16
#endif
#ifndef DITHER_COLORS
#define DITHER_COLORS (1<<8)
#endif
#ifndef DITHER_NEAREST
#define DITHER_NEAREST 0
#endif

#ifndef FOV
#define FOV 1.5
#endif
#ifndef CAMERA_POS
#define CAMERA_POS vec3(0.)
#endif
#ifndef CAMERA_DIR
#define CAMERA_DIR vec3(0., 0., 1.)
#endif
#ifndef ASPECT_RATIO_CROP
#define ASPECT_RATIO_CROP 1
#endif
#ifndef TILE_PERSPECTIVE
#define TILE_PERSPECTIVE 0
#endif
#ifndef CLAMP_PERSPECTIVE
#define CLAMP_PERSPECTIVE 0
#endif
#ifndef IMAGE_OFFSET
#define IMAGE_OFFSET vec2(0., 0.)
#endif
#ifndef MAX_STEPS
#define MAX_STEPS 200
#endif
#ifndef MAX_DIST
#define MAX_DIST 20.
#endif
#ifndef AVERAGE_FRAMES
#define AVERAGE_FRAMES 0
#endif
// FREEZE_TIME, LOOP_TIME, and MAX_TAA_DIFF are *undefined* by default.

#ifndef MIN_DIST
#define MIN_DIST (0.001953125/8.)
#endif
#ifndef NORMAL_DELTA
#define NORMAL_DELTA (MIN_DIST/4.)
#endif
#ifndef IMPRECISION_FACTOR
#define IMPRECISION_FACTOR 1.
#endif

//////// ================================
//////// DOCS: Declarations & documentation
//////// ================================

/// Convert a color from linear RGB to the sRGB color space.
vec3 linear2srgb(vec3 color);

/// Convert a color from RGB (Red/Green/Blue) to HSV (Hue/Saturation/Value).
vec3 rgb2hsv(vec3 rgb);

/// Convert a color from HSV (Hue/Saturation/Value) to RGB (Red/Green/Blue).
vec3 hsv2rgb(vec3 hsv);

/// Return a random number between 0 and 1 (with uniform distribution);
float rand();

/// Use the fragment coordinate and current frame to seed the random number generator.
void seed_randoms(vec3 seed);

// Convenience definitions
#define INF (1./0.)
// NOTE: I used to use `sqrt(-1)`, but apparently that doesn't evaluate to NaN????
// This makes me wonder if NaN isn't portable due to constant folding or something.
#define NAN (0./0.)

//////// ================================
//////// VENDOR: Vendored code
//////// ================================

////
//// AUTHOR: unknown
////

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
}

////
//// AUTHOR: Sam Hocevar (http://lolengine.net/blog/2013/07/27/rgb-to-hsv-in-glsl)
////

vec3 rgb2hsv(vec3 c)  {
    vec4 K = vec4(0.0, -1.0 / 3.0, 2.0 / 3.0, -1.0);
    vec4 p = mix(vec4(c.bg, K.wz), vec4(c.gb, K.xy), step(c.b, c.g));
    vec4 q = mix(vec4(p.xyw, c.r), vec4(c.r, p.yzx), step(p.x, c.r));

    float d = q.x - min(q.w, q.y);
    float e = 1.0e-10;
    return vec3(abs(q.z + (q.w - q.y) / (6.0 * d + e)), d / (q.x + e), q.x);
}

vec3 hsv2rgb(vec3 c) {
    vec4 K = vec4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0);
    vec3 p = abs(fract(c.xxx + K.xyz) * 6.0 - K.www);
    return c.z * mix(K.xxx, clamp(p - K.xxx, 0.0, 1.0), c.y);
}

////
//// AUTHOR: iq
////

// Randoms (https://www.shadertoy.com/view/4sfGzS))
// oldschool rand() from Visual Studio
int  _seed = 1;
int  irand(void) { _seed = _seed*0x343fd+0x269ec3; return (_seed>>16)&32767; }
float rand(void) { return float(irand())/32767.0; }
// 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 seed_randoms(vec3 s) {
    ivec3 q = ivec3(s);
    _seed = hash(q.x+hash(q.y+hash(q.z)));
}