//do not delete the following comments!

//none of your parameters can have the following names:
//frames, canvas, groups, position, forward, right, pinhole, zoom, reset
//pathtrace, epsilon, iterations, temp1, bounces, sunpos, floor, focallength
//aperture, breakout
    
//additionally, the following words cannot be used in code:
//E, PI, seed, first, depth

//put any uniforms here, in the format
//name : type, //[input method]
//valid input methods: [default value] or [default, min, max, step]
//valid types: i32, f32, u32, vec[1,2,3,4]<i32/f32/u32>
MI : i32, //[5, 0, 20, 1]
Size : f32, //[1, 0, 2, .01]
CSize : vec3<f32>, //[1, 0, 2, .01]
C : vec3<f32>, //[0, -2, 2, .01]
DEoffset : f32, //[0, 0, .01, .0001]
Offset : vec3<f32>, //[0, -2, 2, .01]
MnIterations : i32, //[2, 0, 20, 1]
MnScale : f32, //[3, 0, 4, .01]
MnOffset : vec3<f32>,//[1, 0, 2, .01]
cutoff : f32,//[2.5, .5, 10., .01]

//Code:
//via https://github.com/Syntopia/Fragmentarium

fn Menger(p : vec3<f32>) -> f32
{
    var r : f32;
    
    var n = 0;
    // Fold
    var z = abs(p);
    if (z.x<z.y){z = z.yxz;}
    if (z.x<z.z){z = vec3<f32>(z.z, z.y, z.x);}
    if (z.y<z.z){z = z.xzy;}
    if (z.z<1./3.) {
        z.z = z.z - 2. * (z.z - 1. / 3.);
    }
    
    while (n < uniforms.MnIterations && dot(z,z)<100.0) {
        
        z=uniforms.MnScale* (z-uniforms.MnOffset)+uniforms.MnOffset;
        
        // Fold
        z = abs(z);
        if (z.x<z.y){ z = z.yxz;}
        if (z.x<z.z){ z = vec3<f32>(z.z, z.y, z.x);}
        if (z.y<z.z){ z = z.xzy;}
        if (z.z<1./3.) {
            z.z = z.z - 2. * (z.z - 1. / 3.);
        }
        
        r = dot(z-uniforms.MnOffset, z-uniforms.MnOffset);

        n = n + 1;
    }

    return f32(z.x-uniforms.MnOffset.x) * pow(uniforms.MnScale, f32(-n));
}



fn Thing2(z : vec3<f32>) -> f32 {
    var p = z;
    var r2=dot(p,p);

    var DEfactor=1.;
    
    for(var i=0;i<uniforms.MI && r2<60.;i = i + 1){
        p=2.*clamp(p, -uniforms.CSize, uniforms.CSize)-p;
        
        r2=dot(p,p);
        
        var k=max(uniforms.Size/r2,1.);
        p=p*k; DEfactor=DEfactor*k;
        
        p=p+uniforms.C;

        r2=dot(p,p);
    }
    //Call basic shape and scale its DE
    return abs(0.5*Menger(p-uniforms.Offset)/DEfactor-uniforms.DEoffset);
}

fn DE(p : vec3<f32>) -> f32 {
    return  max(Thing2(p),  length(p) - uniforms.cutoff);
}

fn getColor(z : vec3<f32>) -> vec3<f32> {
    return (vec3<f32>(1.));
}