#include <common>

uniform vec2 resolution;

// removed:
//// INSERT DEFINE



// /COP/builder_BG/SDFSphere1
float dot2( in vec2 v ) { return dot(v,v); }
float dot2( in vec3 v ) { return dot(v,v); }
float ndot( in vec2 a, in vec2 b ) { return a.x*b.x - a.y*b.y; }
// https://iquilezles.org/articles/distfunctions/


/*
*
* SDF PRIMITIVES
*
*/
float sdSphere( vec3 p, float s )
{
	return length(p)-s;
}
float sdCutSphere( vec3 p, float r, float h )
{
	// sampling independent computations (only depend on shape)
	float w = sqrt(r*r-h*h);

	// sampling dependant computations
	vec2 q = vec2( length(p.xz), p.y );
	float s = max( (h-r)*q.x*q.x+w*w*(h+r-2.0*q.y), h*q.x-w*q.y );
	return (s<0.0) ? length(q)-r :
				(q.x<w) ? h - q.y :
					length(q-vec2(w,h));
}
float sdCutHollowSphere( vec3 p, float r, float h, float t )
{
	// sampling independent computations (only depend on shape)
	float w = sqrt(r*r-h*h);
	
	// sampling dependant computations
	vec2 q = vec2( length(p.xz), p.y );
	return ((h*q.x<w*q.y) ? length(q-vec2(w,h)) : 
							abs(length(q)-r) ) - t;
}

float sdBox( vec3 p, vec3 b )
{
	vec3 q = abs(p) - b*0.5;
	return length(max(q,0.0)) + min(max(q.x,max(q.y,q.z)),0.0);
}
float sdRoundBox( vec3 p, vec3 b, float r )
{
	vec3 q = abs(p) - b*0.5;
	return length(max(q,0.0)) + min(max(q.x,max(q.y,q.z)),0.0) - r;
}


float sdBoxFrame( vec3 p, vec3 b, float e )
{
		p = abs(p  )-b*0.5;
	vec3 q = abs(p+e)-e;
	return min(min(
		length(max(vec3(p.x,q.y,q.z),0.0))+min(max(p.x,max(q.y,q.z)),0.0),
		length(max(vec3(q.x,p.y,q.z),0.0))+min(max(q.x,max(p.y,q.z)),0.0)),
		length(max(vec3(q.x,q.y,p.z),0.0))+min(max(q.x,max(q.y,p.z)),0.0));
}
float sdCapsule( vec3 p, vec3 a, vec3 b, float r )
{
	vec3 pa = p - a, ba = b - a;
	float h = clamp( dot(pa,ba)/dot(ba,ba), 0.0, 1.0 );
	return length( pa - ba*h ) - r;
}
float sdVerticalCapsule( vec3 p, float h, float r )
{
	p.y -= clamp( p.y, 0.0, h );
	return length( p ) - r;
}
float sdCone( in vec3 p, in vec2 c, float h )
{
	// c is the sin/cos of the angle, h is height
	// Alternatively pass q instead of (c,h),
	// which is the point at the base in 2D
	vec2 q = h*vec2(c.x/c.y,-1.0);

	vec2 w = vec2( length(p.xz), p.y );
	vec2 a = w - q*clamp( dot(w,q)/dot(q,q), 0.0, 1.0 );
	vec2 b = w - q*vec2( clamp( w.x/q.x, 0.0, 1.0 ), 1.0 );
	float k = sign( q.y );
	float d = min(dot( a, a ),dot(b, b));
	float s = max( k*(w.x*q.y-w.y*q.x),k*(w.y-q.y)  );
	return sqrt(d)*sign(s);
}
float sdConeWrapped(vec3 pos, float angle, float height){
	return sdCone(pos, vec2(sin(angle), cos(angle)), height);
}
float sdRoundCone( vec3 p, float r1, float r2, float h )
{
	float b = (r1-r2)/h;
	float a = sqrt(1.0-b*b);

	vec2 q = vec2( length(p.xz), p.y );
	float k = dot(q,vec2(-b,a));
	if( k<0.0 ) return length(q) - r1;
	if( k>a*h ) return length(q-vec2(0.0,h)) - r2;
	return dot(q, vec2(a,b) ) - r1;
}
float sdOctogonPrism( in vec3 p, in float r, float h )
{
	const vec3 k = vec3(-0.9238795325,  // sqrt(2+sqrt(2))/2 
						0.3826834323,   // sqrt(2-sqrt(2))/2
						0.4142135623 ); // sqrt(2)-1 
	// reflections
	p = abs(p);
	p.xy -= 2.0*min(dot(vec2( k.x,k.y),p.xy),0.0)*vec2( k.x,k.y);
	p.xy -= 2.0*min(dot(vec2(-k.x,k.y),p.xy),0.0)*vec2(-k.x,k.y);
	// polygon side
	p.xy -= vec2(clamp(p.x, -k.z*r, k.z*r), r);
	vec2 d = vec2( length(p.xy)*sign(p.y), p.z-h );
	return min(max(d.x,d.y),0.0) + length(max(d,0.0));
}
float sdHexPrism( vec3 p, vec2 h )
{
	const vec3 k = vec3(-0.8660254, 0.5, 0.57735);
	p = abs(p);
	p.xy -= 2.0*min(dot(k.xy, p.xy), 0.0)*k.xy;
	vec2 d = vec2(
		length(p.xy-vec2(clamp(p.x,-k.z*h.x,k.z*h.x), h.x))*sign(p.y-h.x),
		p.z-h.y );
	return min(max(d.x,d.y),0.0) + length(max(d,0.0));
}
float sdHorseshoe( in vec3 p, in float angle, in float r, in float le, vec2 w )
{
	vec2 c = vec2(cos(angle),sin(angle));
	p.x = abs(p.x);
	float l = length(p.xy);
	p.xy = mat2(-c.x, c.y, 
			c.y, c.x)*p.xy;
	p.xy = vec2((p.y>0.0 || p.x>0.0)?p.x:l*sign(-c.x),
				(p.x>0.0)?p.y:l );
	p.xy = vec2(p.x,abs(p.y-r))-vec2(le,0.0);
	
	vec2 q = vec2(length(max(p.xy,0.0)) + min(0.0,max(p.x,p.y)),p.z);
	vec2 d = abs(q) - w;
	return min(max(d.x,d.y),0.0) + length(max(d,0.0));
}
float sdTriPrism( vec3 p, vec2 h )
{
	vec3 q = abs(p);
	return max(q.z-h.y,max(q.x*0.866025+p.y*0.5,-p.y)-h.x*0.5);
}
float sdPyramid( vec3 p, float h)
{
	float m2 = h*h + 0.25;

	p.xz = abs(p.xz);
	p.xz = (p.z>p.x) ? p.zx : p.xz;
	p.xz -= 0.5;

	vec3 q = vec3( p.z, h*p.y - 0.5*p.x, h*p.x + 0.5*p.y);

	float s = max(-q.x,0.0);
	float t = clamp( (q.y-0.5*p.z)/(m2+0.25), 0.0, 1.0 );

	float a = m2*(q.x+s)*(q.x+s) + q.y*q.y;
	float b = m2*(q.x+0.5*t)*(q.x+0.5*t) + (q.y-m2*t)*(q.y-m2*t);

	float d2 = min(q.y,-q.x*m2-q.y*0.5) > 0.0 ? 0.0 : min(a,b);

	return sqrt( (d2+q.z*q.z)/m2 ) * sign(max(q.z,-p.y));
}

float sdPlane( vec3 p, vec3 n, float h )
{
	// n must be normalized
	return dot(p,n) + h;
}

float sdTorus( vec3 p, vec2 t )
{
	vec2 q = vec2(length(p.xz)-t.x,p.y);
	return length(q)-t.y;
}
float sdCappedTorus(in vec3 p, in float an, in float ra, in float rb)
{
	vec2 sc = vec2(sin(an),cos(an));
	p.x = abs(p.x);
	float k = (sc.y*p.x>sc.x*p.z) ? dot(p.xz,sc) : length(p.xz);
	return sqrt( dot(p,p) + ra*ra - 2.0*ra*k ) - rb;
}
float sdLink( vec3 p, float le, float r1, float r2 )
{
  vec3 q = vec3( p.x, max(abs(p.y)-le,0.0), p.z );
  return length(vec2(length(q.xy)-r1,q.z)) - r2;
}
// c is the sin/cos of the desired cone angle
float sdSolidAngle(vec3 pos, vec2 c, float radius)
{
	vec2 p = vec2( length(pos.xz), pos.y );
	float l = length(p) - radius;
	float m = length(p - c*clamp(dot(p,c),0.0,radius) );
	return max(l,m*sign(c.y*p.x-c.x*p.y));
}
float sdSolidAngleWrapped(vec3 pos, float angle, float radius){
	return sdSolidAngle(pos, vec2(sin(angle), cos(angle)), radius);
}
float sdTube( vec3 p, float r )
{
	return length(p.xz)-r;
}
float sdTubeCapped( vec3 p, float h, float r )
{
	vec2 d = abs(vec2(length(p.xz),p.y)) - vec2(r,h);
	return min(max(d.x,d.y),0.0) + length(max(d,0.0));
}
float sdOctahedron( vec3 p, float s)
{
  p = abs(p);
  float m = p.x+p.y+p.z-s;
  vec3 q;
       if( 3.0*p.x < m ) q = p.xyz;
  else if( 3.0*p.y < m ) q = p.yzx;
  else if( 3.0*p.z < m ) q = p.zxy;
  else return m*0.57735027;
    
  float k = clamp(0.5*(q.z-q.y+s),0.0,s); 
  return length(vec3(q.x,q.y-s+k,q.z-k)); 
}
float udTriangle( vec3 p, vec3 a, vec3 b, vec3 c, float thickness )
{
	vec3 ba = b - a; vec3 pa = p - a;
	vec3 cb = c - b; vec3 pb = p - b;
	vec3 ac = a - c; vec3 pc = p - c;
	vec3 nor = cross( ba, ac );

	return - thickness + sqrt(
		(sign(dot(cross(ba,nor),pa)) +
		sign(dot(cross(cb,nor),pb)) +
		sign(dot(cross(ac,nor),pc))<2.0)
		?
		min( min(
		dot2(ba*clamp(dot(ba,pa)/dot2(ba),0.0,1.0)-pa),
		dot2(cb*clamp(dot(cb,pb)/dot2(cb),0.0,1.0)-pb) ),
		dot2(ac*clamp(dot(ac,pc)/dot2(ac),0.0,1.0)-pc) )
		:
		dot(nor,pa)*dot(nor,pa)/dot2(nor) );
}
float udQuad( vec3 p, vec3 a, vec3 b, vec3 c, vec3 d, float thickness )
{
	vec3 ba = b - a; vec3 pa = p - a;
	vec3 cb = c - b; vec3 pb = p - b;
	vec3 dc = d - c; vec3 pc = p - c;
	vec3 ad = a - d; vec3 pd = p - d;
	vec3 nor = cross( ba, ad );

	return - thickness + sqrt(
		(sign(dot(cross(ba,nor),pa)) +
		sign(dot(cross(cb,nor),pb)) +
		sign(dot(cross(dc,nor),pc)) +
		sign(dot(cross(ad,nor),pd))<3.0)
		?
		min( min( min(
		dot2(ba*clamp(dot(ba,pa)/dot2(ba),0.0,1.0)-pa),
		dot2(cb*clamp(dot(cb,pb)/dot2(cb),0.0,1.0)-pb) ),
		dot2(dc*clamp(dot(dc,pc)/dot2(dc),0.0,1.0)-pc) ),
		dot2(ad*clamp(dot(ad,pd)/dot2(ad),0.0,1.0)-pd) )
		:
		dot(nor,pa)*dot(nor,pa)/dot2(nor) );
}

/*
*
* SDF OPERATIONS
*
*/
float SDFUnion( float d1, float d2 ) { return min(d1,d2); }
float SDFSubtract( float d1, float d2 ) { return max(-d1,d2); }
float SDFIntersect( float d1, float d2 ) { return max(d1,d2); }

float SDFSmoothUnion( float d1, float d2, float k ) {
	float h = clamp( 0.5 + 0.5*(d2-d1)/k, 0.0, 1.0 );
	return mix( d2, d1, h ) - k*h*(1.0-h);
}

float SDFSmoothSubtract( float d1, float d2, float k ) {
	float h = clamp( 0.5 - 0.5*(d2+d1)/k, 0.0, 1.0 );
	return mix( d2, -d1, h ) + k*h*(1.0-h);
}

float SDFSmoothIntersect( float d1, float d2, float k ) {
	float h = clamp( 0.5 - 0.5*(d2-d1)/k, 0.0, 1.0 );
	return mix( d2, d1, h ) + k*h*(1.0-h);
}

vec4 SDFElongateFast( in vec3 p, in vec3 h )
{
	return vec4( p-clamp(p,-h,h), 0.0 );
}
vec4 SDFElongateSlow( in vec3 p, in vec3 h )
{
	vec3 q = abs(p)-h;
	return vec4( max(q,0.0), min(max(q.x,max(q.y,q.z)),0.0) );
}

float SDFOnion( in float sdf, in float thickness )
{
	return abs(sdf)-thickness;
}

// /COP/builder_BG/complement1
float complement(float x){return 1.0-x;}
vec2 complement(vec2 x){return vec2(1.0-x.x, 1.0-x.y);}
vec3 complement(vec3 x){return vec3(1.0-x.x, 1.0-x.y, 1.0-x.z);}
vec4 complement(vec4 x){return vec4(1.0-x.x, 1.0-x.y, 1.0-x.z, 1.0-x.w);}


// /COP/builder_BG/easing1

float sineInOut(float t) {
  return -0.5 * (cos(PI * t) - 1.0);
}



// /COP/builder_BG/colorCorrect1
// from https://github.com/williammalo/hsluv-glsl
/*
HSLUV-GLSL v4.2
HSLUV is a human-friendly alternative to HSL. ( http://www.hsluv.org )
GLSL port by William Malo ( https://github.com/williammalo )
Put this code in your fragment shader.
*/

vec3 hsluv_intersectLineLine(vec3 line1x, vec3 line1y, vec3 line2x, vec3 line2y) {
	return (line1y - line2y) / (line2x - line1x);
}

vec3 hsluv_distanceFromPole(vec3 pointx,vec3 pointy) {
	return sqrt(pointx*pointx + pointy*pointy);
}

vec3 hsluv_lengthOfRayUntilIntersect(float theta, vec3 x, vec3 y) {
	vec3 len = y / (sin(theta) - x * cos(theta));
	if (len.r < 0.0) {len.r=1000.0;}
	if (len.g < 0.0) {len.g=1000.0;}
	if (len.b < 0.0) {len.b=1000.0;}
	return len;
}

float hsluv_maxSafeChromaForL(float L){
	mat3 m2 = mat3(
		 3.2409699419045214  ,-0.96924363628087983 , 0.055630079696993609,
		-1.5373831775700935  , 1.8759675015077207  ,-0.20397695888897657 ,
		-0.49861076029300328 , 0.041555057407175613, 1.0569715142428786  
	);
	float sub0 = L + 16.0;
	float sub1 = sub0 * sub0 * sub0 * .000000641;
	float sub2 = sub1 > 0.0088564516790356308 ? sub1 : L / 903.2962962962963;

	vec3 top1   = (284517.0 * m2[0] - 94839.0  * m2[2]) * sub2;
	vec3 bottom = (632260.0 * m2[2] - 126452.0 * m2[1]) * sub2;
	vec3 top2   = (838422.0 * m2[2] + 769860.0 * m2[1] + 731718.0 * m2[0]) * L * sub2;

	vec3 bounds0x = top1 / bottom;
	vec3 bounds0y = top2 / bottom;

	vec3 bounds1x =              top1 / (bottom+126452.0);
	vec3 bounds1y = (top2-769860.0*L) / (bottom+126452.0);

	vec3 xs0 = hsluv_intersectLineLine(bounds0x, bounds0y, -1.0/bounds0x, vec3(0.0) );
	vec3 xs1 = hsluv_intersectLineLine(bounds1x, bounds1y, -1.0/bounds1x, vec3(0.0) );

	vec3 lengths0 = hsluv_distanceFromPole( xs0, bounds0y + xs0 * bounds0x );
	vec3 lengths1 = hsluv_distanceFromPole( xs1, bounds1y + xs1 * bounds1x );

	return  min(lengths0.r,
			min(lengths1.r,
			min(lengths0.g,
			min(lengths1.g,
			min(lengths0.b,
				lengths1.b)))));
}

float hsluv_maxChromaForLH(float L, float H) {

	float hrad = radians(H);

	mat3 m2 = mat3(
		 3.2409699419045214  ,-0.96924363628087983 , 0.055630079696993609,
		-1.5373831775700935  , 1.8759675015077207  ,-0.20397695888897657 ,
		-0.49861076029300328 , 0.041555057407175613, 1.0569715142428786  
	);
	float sub1 = pow(L + 16.0, 3.0) / 1560896.0;
	float sub2 = sub1 > 0.0088564516790356308 ? sub1 : L / 903.2962962962963;

	vec3 top1   = (284517.0 * m2[0] - 94839.0  * m2[2]) * sub2;
	vec3 bottom = (632260.0 * m2[2] - 126452.0 * m2[1]) * sub2;
	vec3 top2   = (838422.0 * m2[2] + 769860.0 * m2[1] + 731718.0 * m2[0]) * L * sub2;

	vec3 bound0x = top1 / bottom;
	vec3 bound0y = top2 / bottom;

	vec3 bound1x =              top1 / (bottom+126452.0);
	vec3 bound1y = (top2-769860.0*L) / (bottom+126452.0);

	vec3 lengths0 = hsluv_lengthOfRayUntilIntersect(hrad, bound0x, bound0y );
	vec3 lengths1 = hsluv_lengthOfRayUntilIntersect(hrad, bound1x, bound1y );

	return  min(lengths0.r,
			min(lengths1.r,
			min(lengths0.g,
			min(lengths1.g,
			min(lengths0.b,
				lengths1.b)))));
}

float hsluv_fromLinear(float c) {
	return c <= 0.0031308 ? 12.92 * c : 1.055 * pow(c, 1.0 / 2.4) - 0.055;
}
vec3 hsluv_fromLinear(vec3 c) {
	return vec3( hsluv_fromLinear(c.r), hsluv_fromLinear(c.g), hsluv_fromLinear(c.b) );
}

float hsluv_toLinear(float c) {
	return c > 0.04045 ? pow((c + 0.055) / (1.0 + 0.055), 2.4) : c / 12.92;
}

vec3 hsluv_toLinear(vec3 c) {
	return vec3( hsluv_toLinear(c.r), hsluv_toLinear(c.g), hsluv_toLinear(c.b) );
}

float hsluv_yToL(float Y){
	return Y <= 0.0088564516790356308 ? Y * 903.2962962962963 : 116.0 * pow(Y, 1.0 / 3.0) - 16.0;
}

float hsluv_lToY(float L) {
	return L <= 8.0 ? L / 903.2962962962963 : pow((L + 16.0) / 116.0, 3.0);
}

vec3 xyzToRgb(vec3 tuple) {
	const mat3 m = mat3( 
		3.2409699419045214  ,-1.5373831775700935 ,-0.49861076029300328 ,
		-0.96924363628087983 , 1.8759675015077207 , 0.041555057407175613,
		0.055630079696993609,-0.20397695888897657, 1.0569715142428786  );
	
	return hsluv_fromLinear(tuple*m);
}

vec3 rgbToXyz(vec3 tuple) {
	const mat3 m = mat3(
		0.41239079926595948 , 0.35758433938387796, 0.18048078840183429 ,
		0.21263900587151036 , 0.71516867876775593, 0.072192315360733715,
		0.019330818715591851, 0.11919477979462599, 0.95053215224966058 
	);
	return hsluv_toLinear(tuple) * m;
}

vec3 xyzToLuv(vec3 tuple){
	float X = tuple.x;
	float Y = tuple.y;
	float Z = tuple.z;

	float L = hsluv_yToL(Y);
	
	float div = 1./dot(tuple,vec3(1,15,3)); 

	return vec3(
		1.,
		(52. * (X*div) - 2.57179),
		(117.* (Y*div) - 6.08816)
	) * L;
}


vec3 luvToXyz(vec3 tuple) {
	float L = tuple.x;

	float U = tuple.y / (13.0 * L) + 0.19783000664283681;
	float V = tuple.z / (13.0 * L) + 0.468319994938791;

	float Y = hsluv_lToY(L);
	float X = 2.25 * U * Y / V;
	float Z = (3./V - 5.)*Y - (X/3.);

	return vec3(X, Y, Z);
}

vec3 luvToLch(vec3 tuple) {
	float L = tuple.x;
	float U = tuple.y;
	float V = tuple.z;

	float C = length(tuple.yz);
	float H = degrees(atan(V,U));
	if (H < 0.0) {
		H = 360.0 + H;
	}
	
	return vec3(L, C, H);
}

vec3 lchToLuv(vec3 tuple) {
	float hrad = radians(tuple.b);
	return vec3(
		tuple.r,
		cos(hrad) * tuple.g,
		sin(hrad) * tuple.g
	);
}

vec3 hsluvToLch(vec3 tuple) {
	tuple.g *= hsluv_maxChromaForLH(tuple.b, tuple.r) * .01;
	return tuple.bgr;
}

vec3 lchToHsluv(vec3 tuple) {
	tuple.g /= hsluv_maxChromaForLH(tuple.r, tuple.b) * .01;
	return tuple.bgr;
}

vec3 hpluvToLch(vec3 tuple) {
	tuple.g *= hsluv_maxSafeChromaForL(tuple.b) * .01;
	return tuple.bgr;
}

vec3 lchToHpluv(vec3 tuple) {
	tuple.g /= hsluv_maxSafeChromaForL(tuple.r) * .01;
	return tuple.bgr;
}

vec3 lchToRgb(vec3 tuple) {
	return xyzToRgb(luvToXyz(lchToLuv(tuple)));
}

vec3 rgbToLch(vec3 tuple) {
	return luvToLch(xyzToLuv(rgbToXyz(tuple)));
}

vec3 hsluvToRgb(vec3 tuple) {
	return lchToRgb(hsluvToLch(tuple));
}

vec3 rgbToHsluv(vec3 tuple) {
	return lchToHsluv(rgbToLch(tuple));
}

vec3 hpluvToRgb(vec3 tuple) {
	return lchToRgb(hpluvToLch(tuple));
}

vec3 rgbToHpluv(vec3 tuple) {
	return lchToHpluv(rgbToLch(tuple));
}

vec3 luvToRgb(vec3 tuple){
	return xyzToRgb(luvToXyz(tuple));
}

// allow vec4's
vec4   xyzToRgb(vec4 c) {return vec4(   xyzToRgb( vec3(c.x,c.y,c.z) ), c.a);}
vec4   rgbToXyz(vec4 c) {return vec4(   rgbToXyz( vec3(c.x,c.y,c.z) ), c.a);}
vec4   xyzToLuv(vec4 c) {return vec4(   xyzToLuv( vec3(c.x,c.y,c.z) ), c.a);}
vec4   luvToXyz(vec4 c) {return vec4(   luvToXyz( vec3(c.x,c.y,c.z) ), c.a);}
vec4   luvToLch(vec4 c) {return vec4(   luvToLch( vec3(c.x,c.y,c.z) ), c.a);}
vec4   lchToLuv(vec4 c) {return vec4(   lchToLuv( vec3(c.x,c.y,c.z) ), c.a);}
vec4 hsluvToLch(vec4 c) {return vec4( hsluvToLch( vec3(c.x,c.y,c.z) ), c.a);}
vec4 lchToHsluv(vec4 c) {return vec4( lchToHsluv( vec3(c.x,c.y,c.z) ), c.a);}
vec4 hpluvToLch(vec4 c) {return vec4( hpluvToLch( vec3(c.x,c.y,c.z) ), c.a);}
vec4 lchToHpluv(vec4 c) {return vec4( lchToHpluv( vec3(c.x,c.y,c.z) ), c.a);}
vec4   lchToRgb(vec4 c) {return vec4(   lchToRgb( vec3(c.x,c.y,c.z) ), c.a);}
vec4   rgbToLch(vec4 c) {return vec4(   rgbToLch( vec3(c.x,c.y,c.z) ), c.a);}
vec4 hsluvToRgb(vec4 c) {return vec4( hsluvToRgb( vec3(c.x,c.y,c.z) ), c.a);}
vec4 rgbToHsluv(vec4 c) {return vec4( rgbToHsluv( vec3(c.x,c.y,c.z) ), c.a);}
vec4 hpluvToRgb(vec4 c) {return vec4( hpluvToRgb( vec3(c.x,c.y,c.z) ), c.a);}
vec4 rgbToHpluv(vec4 c) {return vec4( rgbToHpluv( vec3(c.x,c.y,c.z) ), c.a);}
vec4   luvToRgb(vec4 c) {return vec4(   luvToRgb( vec3(c.x,c.y,c.z) ), c.a);}
// allow 3 floats
vec3   xyzToRgb(float x, float y, float z) {return   xyzToRgb( vec3(x,y,z) );}
vec3   rgbToXyz(float x, float y, float z) {return   rgbToXyz( vec3(x,y,z) );}
vec3   xyzToLuv(float x, float y, float z) {return   xyzToLuv( vec3(x,y,z) );}
vec3   luvToXyz(float x, float y, float z) {return   luvToXyz( vec3(x,y,z) );}
vec3   luvToLch(float x, float y, float z) {return   luvToLch( vec3(x,y,z) );}
vec3   lchToLuv(float x, float y, float z) {return   lchToLuv( vec3(x,y,z) );}
vec3 hsluvToLch(float x, float y, float z) {return hsluvToLch( vec3(x,y,z) );}
vec3 lchToHsluv(float x, float y, float z) {return lchToHsluv( vec3(x,y,z) );}
vec3 hpluvToLch(float x, float y, float z) {return hpluvToLch( vec3(x,y,z) );}
vec3 lchToHpluv(float x, float y, float z) {return lchToHpluv( vec3(x,y,z) );}
vec3   lchToRgb(float x, float y, float z) {return   lchToRgb( vec3(x,y,z) );}
vec3   rgbToLch(float x, float y, float z) {return   rgbToLch( vec3(x,y,z) );}
vec3 hsluvToRgb(float x, float y, float z) {return hsluvToRgb( vec3(x,y,z) );}
vec3 rgbToHsluv(float x, float y, float z) {return rgbToHsluv( vec3(x,y,z) );}
vec3 hpluvToRgb(float x, float y, float z) {return hpluvToRgb( vec3(x,y,z) );}
vec3 rgbToHpluv(float x, float y, float z) {return rgbToHpluv( vec3(x,y,z) );}
vec3   luvToRgb(float x, float y, float z) {return   luvToRgb( vec3(x,y,z) );}
// allow 4 floats
vec4   xyzToRgb(float x, float y, float z, float a) {return   xyzToRgb( vec4(x,y,z,a) );}
vec4   rgbToXyz(float x, float y, float z, float a) {return   rgbToXyz( vec4(x,y,z,a) );}
vec4   xyzToLuv(float x, float y, float z, float a) {return   xyzToLuv( vec4(x,y,z,a) );}
vec4   luvToXyz(float x, float y, float z, float a) {return   luvToXyz( vec4(x,y,z,a) );}
vec4   luvToLch(float x, float y, float z, float a) {return   luvToLch( vec4(x,y,z,a) );}
vec4   lchToLuv(float x, float y, float z, float a) {return   lchToLuv( vec4(x,y,z,a) );}
vec4 hsluvToLch(float x, float y, float z, float a) {return hsluvToLch( vec4(x,y,z,a) );}
vec4 lchToHsluv(float x, float y, float z, float a) {return lchToHsluv( vec4(x,y,z,a) );}
vec4 hpluvToLch(float x, float y, float z, float a) {return hpluvToLch( vec4(x,y,z,a) );}
vec4 lchToHpluv(float x, float y, float z, float a) {return lchToHpluv( vec4(x,y,z,a) );}
vec4   lchToRgb(float x, float y, float z, float a) {return   lchToRgb( vec4(x,y,z,a) );}
vec4   rgbToLch(float x, float y, float z, float a) {return   rgbToLch( vec4(x,y,z,a) );}
vec4 hsluvToRgb(float x, float y, float z, float a) {return hsluvToRgb( vec4(x,y,z,a) );}
vec4 rgbToHslul(float x, float y, float z, float a) {return rgbToHsluv( vec4(x,y,z,a) );}
vec4 hpluvToRgb(float x, float y, float z, float a) {return hpluvToRgb( vec4(x,y,z,a) );}
vec4 rgbToHpluv(float x, float y, float z, float a) {return rgbToHpluv( vec4(x,y,z,a) );}
vec4   luvToRgb(float x, float y, float z, float a) {return   luvToRgb( vec4(x,y,z,a) );}

/*
END HSLUV-GLSL
*/


// from https://gist.github.com/mattatz/44f081cac87e2f7c8980
// converted to glsl by gui@polygonjs.com
// and made function names consistent with the ones above
/*
 * Conversion between RGB and LAB colorspace.
 * Import from flowabs glsl program : https://code.google.com/p/flowabs/source/browse/glsl/?r=f36cbdcf7790a28d90f09e2cf89ec9a64911f138
 */



vec3 xyzToLab( vec3 c ) {
	vec3 n = c / vec3(95.047, 100, 108.883);
	vec3 v;
	v.x = ( n.x > 0.008856 ) ? pow( n.x, 1.0 / 3.0 ) : ( 7.787 * n.x ) + ( 16.0 / 116.0 );
	v.y = ( n.y > 0.008856 ) ? pow( n.y, 1.0 / 3.0 ) : ( 7.787 * n.y ) + ( 16.0 / 116.0 );
	v.z = ( n.z > 0.008856 ) ? pow( n.z, 1.0 / 3.0 ) : ( 7.787 * n.z ) + ( 16.0 / 116.0 );
	return vec3(( 116.0 * v.y ) - 16.0, 500.0 * ( v.x - v.y ), 200.0 * ( v.y - v.z ));
}

vec3 rgbToLab( vec3 c ) {
	vec3 lab = xyzToLab( rgbToXyz( c ) );
	return vec3( lab.x / 100.0, 0.5 + 0.5 * ( lab.y / 127.0 ), 0.5 + 0.5 * ( lab.z / 127.0 ));
}

vec3 labToXyz( vec3 c ) {
	float fy = ( c.x + 16.0 ) / 116.0;
	float fx = c.y / 500.0 + fy;
	float fz = fy - c.z / 200.0;
	return vec3(
		 95.047 * (( fx > 0.206897 ) ? fx * fx * fx : ( fx - 16.0 / 116.0 ) / 7.787),
		100.000 * (( fy > 0.206897 ) ? fy * fy * fy : ( fy - 16.0 / 116.0 ) / 7.787),
		108.883 * (( fz > 0.206897 ) ? fz * fz * fz : ( fz - 16.0 / 116.0 ) / 7.787)
	);
}



vec3 labToRgb( vec3 c ) {
	return xyzToRgb( labToXyz( vec3(100.0 * c.x, 2.0 * 127.0 * (c.y - 0.5), 2.0 * 127.0 * (c.z - 0.5)) ) );
}

// adapted from
// THREEjs math/Color.js
float sRGBToLinear( float c ) {
	return ( c < 0.04045 ) ? c * 0.0773993808 : pow( c * 0.9478672986 + 0.0521327014, 2.4 );
}
vec3 sRGBToLinear( vec3 c ) {
	return vec3( sRGBToLinear(c.r), sRGBToLinear(c.g), sRGBToLinear(c.b) );
}
vec4 sRGBToLinear( vec4 c ) {
	return vec4( sRGBToLinear(c.r), sRGBToLinear(c.g), sRGBToLinear(c.b), c.a );
}





void main() {

	vec4 diffuseColor = vec4(0.0,0.0,0.0,1.0);


// removed:
//	// INSERT BODY



	// /COP/builder_BG/constant1
	vec3 v_POLY_constant1_val = vec3(0.0, 0.04666508633021928, 0.11193242782769693);
	
	// /COP/builder_BG/constant2
	vec3 v_POLY_constant2_val = vec3(0.01764195448412081, 0.36625259558833256, 0.3864294337766795);
	
	// /COP/builder_BG/globals1
	vec2 v_POLY_globals1_uv = vec2(gl_FragCoord.x / (resolution.x-1.), gl_FragCoord.y / (resolution.y-1.));
	
	// /COP/builder_BG/constant5
	vec3 v_POLY_constant5_val = vec3(0.002428215868235294, 0.28314874041918053, 0.5209955731953768);
	
	// /COP/builder_BG/vec2ToVec3_1
	vec3 v_POLY_vec2ToVec3_1_vec3 = vec3(v_POLY_globals1_uv.xy, 0.0);
	
	// /COP/builder_BG/SDFSphere1
	float v_POLY_SDFSphere1_float = sdSphere(v_POLY_vec2ToVec3_1_vec3 - vec3(1.0, 1.0, 0.0), 0.18);
	
	// /COP/builder_BG/SDFSphere2
	float v_POLY_SDFSphere2_float = sdSphere(v_POLY_vec2ToVec3_1_vec3 - vec3(0.0, 0.0, 0.0), 0.16);
	
	// /COP/builder_BG/multAdd1
	float v_POLY_multAdd1_val = (1.0*(v_POLY_SDFSphere1_float + 0.6)) + 0.0;
	
	// /COP/builder_BG/multAdd2
	float v_POLY_multAdd2_val = (1.0*(v_POLY_SDFSphere2_float + 0.6)) + 0.0;
	
	// /COP/builder_BG/clamp1
	float v_POLY_clamp1_val = clamp(v_POLY_multAdd1_val, 0.0, 1.0);
	
	// /COP/builder_BG/clamp2
	float v_POLY_clamp2_val = clamp(v_POLY_multAdd2_val, 0.0, 1.0);
	
	// /COP/builder_BG/complement1
	float v_POLY_complement1_val = complement(v_POLY_clamp1_val);
	
	// /COP/builder_BG/complement2
	float v_POLY_complement2_val = complement(v_POLY_clamp2_val);
	
	// /COP/builder_BG/easing1
	float v_POLY_easing1_out = sineInOut(v_POLY_complement1_val);
	
	// /COP/builder_BG/easing2
	float v_POLY_easing2_out = sineInOut(v_POLY_complement2_val);
	
	// /COP/builder_BG/mix1
	vec3 v_POLY_mix1_mix = mix(v_POLY_constant1_val, v_POLY_constant2_val, v_POLY_easing1_out);
	
	// /COP/builder_BG/mix3
	vec3 v_POLY_mix3_mix = mix(v_POLY_mix1_mix, v_POLY_constant5_val, v_POLY_easing2_out);
	
	// /COP/builder_BG/vec3ToVec4_1
	vec4 v_POLY_vec3ToVec4_1_vec4 = vec4(v_POLY_mix3_mix.xyz, 0.0);
	
	// /COP/builder_BG/colorCorrect1
	vec4 v_POLY_colorCorrect1_out = v_POLY_vec3ToVec4_1_vec4;
	
	// /COP/builder_BG/vec4ToVec3_1
	vec3 v_POLY_vec4ToVec3_1_vec3 = v_POLY_colorCorrect1_out.xyz;
	
	// /COP/builder_BG/output1
	diffuseColor.xyz = v_POLY_vec4ToVec3_1_vec3;




	gl_FragColor = vec4( diffuseColor );
}