float sdCappedCylinder( vec3 p, float h, float r ){
  vec2 d = abs(vec2(length(p.xz),p.y)) - vec2(h,r);
  return min(max(d.x,d.y),0.0) + length(max(d,0.0));
}
float smin( float a, float b, float k ){
    float h = clamp( 0.5 + 0.5 * (b - a) / k, 0.0, 1.0 );
    return mix( b, a, h ) - k * h * (1.0 - h);
}
float smax( float a, float b, float k ){
    float h = clamp( 0.5 + 0.5 * (a - b) / k, 0.0, 1.0 );
    return mix( b, a, h ) + k * h * (1.0 - h);
}
float knochen(vec3 p, vec3 xyz, vec3 dim, float th, float phi, float ga, 
                float spiegel, float r){
    
    vec3 sp = p - xyz;
    sp.x = abs(sp.x) - spiegel;
    
    float cs = cos(th), si = sin(th);
    sp.yz*=mat2(cs, si, -si, cs);
    
    cs = cos(phi), si = sin(phi);
    sp.xz*= mat2(cs, si, -si, cs);
    
    cs = cos(ga), si = sin(ga);
    sp.xy*= mat2(cs, si, -si, cs);
        
    sp = abs(sp) - dim;
    return min(max(sp.x, max(sp.y, sp.z)), 0.0) + length(max(sp, 0.0)) - r;    
}
float sdCircleCircle( in vec3 p, in int n, float zeichen){
float a0 = float(n) / radians(360.); 
float a = round(atan(p.z, p.x) * a0) / a0;
vec3 sp = p - vec3(cos(a), 0.0, sin(a));
  
float cs = cos(a), si = sin(a);//erste versuch!!!!
sp.xz*=mat2(cs, si, -si, cs);
  
cs = cos(0.3*zeichen), si = sin(0.3*zeichen);//erste versuch!!!!
sp.xy*=mat2(cs, si, -si, cs);
    
sp = abs(sp) - vec3(0.1 + cos(sp.y*8.)*0.03, 0.19, 0.07 + cos(sp.y*6.+ 1.4)*0.05*zeichen);
return min(max(sp.x, max(sp.y, sp.z)), 0.0) + length(max(sp, 0.0)) - 0.03;  

    
    //return sdCappedCylinder(sp, 0.05, 0.06) - 0.05; 
}

const mat3 m = mat3( 0.00,  0.80,  0.60,
                    -0.80,  0.36, -0.48,
                    -0.60, -0.48,  0.64 );
vec4 objID, oSvObjID;
float svObjID; // Global ID to keep a copy of the above from pass to pass.
float skull(vec3 p){
    vec3 altp = p;
    p.x+=1.;
    p.x = mod(p.x, 2.) - 1.;
    
    float PosX, PosY;
   // PosX = 0. + sin(iTime*20.)/4.;// - (iMouse.x)/iResolution.x;//0.2*2.*(rechts - links);
  //  PosY = -0.1 + sin(iTime*2.)/4.;;//(iMouse.y)/iResolution.y*4.;
    
    //zufall 
    float cs = cos(PosX), si = sin(PosX);
    //p.xy = mat2(cs, si, -si, cs)*p.xy;
    if (altp.x > 0.75 || altp.x < -0.75){
    p.xz = mat2(cs, si, -si, cs)*p.xz;}
    else{
    cs = cos(PosY), si = sin(PosY);
    p.yz = mat2(cs, si, -si, cs)*p.yz;}
    
    //guckmal
    float gu = -1.6;
    cs = cos(gu), si = sin(gu);
    p.yz = mat2(cs, si, -si, cs)*p.yz;
    
    
	p*=0.6;
    p.y-=0.2;// + sin(iTime)*0.1;
    

    
    vec3 sp = p - vec3(0., 0., 0.03);
    float k = length(sp*vec3(1.-sin(sp.z*6.-0.4)*0.05, 
                             0.95+sin(sp.z*6.+1.6)*0.05, 
                             0.87)) - 0.5;
    float alle = k;
    
    //schadel unten schneiden
    sp = p;
    k = length(sp - vec3(0., -0.9, -0.5)) - 0.7;
    alle = smax(alle, -k, 0.09);
    
    ///return alle;
    
    //schadel seite
    sp = p  - vec3(0., -0.05, -0.28);
    sp.x = abs(sp.x) - 0.65;
    //length(sp*vec3(1., 0.95+sin(sp.z*4.+0.8)*0.07, 0.87))
    k = length(sp) - 0.3;
    //k = length(sp*vec3(1., 0.95+sin(sp.z*4.+0.8)*0.07, 0.6)) - 0.3;
    //alle = smax(alle, -k, 0.09);

    //schadel seite knochen schneiden versuch
    sp = p;
    k = knochen(p, vec3(0., -0.15 , -0.18 ), 
                vec3(0.005, 
                     0.17 + sin(sp.z*4.+2.4)*0.1, 
                     0.2+ sin(sp.y*4.+2.)*0.18), 
                -0.2, -0.4, 0.1, 0.42+ sin(sp.z*4.+2.4)*0.05, 0.03);
    alle = smax(alle, -k, 0.09);
    
    //return alle;
    
    //oben augen knochen
    sp = p;
    k = knochen(p, vec3(0., 
                        0. + cos(abs(sp.x)*8. + 5.)*0.03*1. - 0.04*1. , 
                        -0.45 - cos(abs(sp.x)*8. + 5.8)*0.05), 
                vec3(0.12, 0.005, 0.005), 
                0., 0., -0., 0.14, 0.04);
    alle = smin(alle, k, 0.07);
    
    //return alle;

    
    //oberest knochen
    sp = p;
    k = knochen(p, vec3(0., 0.055 , -0.37 ), vec3(0.005, 0.005, 0.12), 
                -1., -0.25, 0., 0.28, 0.02);
    alle = smin(alle, k, 0.06);
    
    //augen seit knochen
    sp = p;
    k = knochen(p, vec3(0., -0.14 , -0.46+ cos(sp.y*8.+1.5)*0.07), 
                vec3(0.01, 0.08, 0.02), 
                0.0, 0.0, 0.35, 0.26+ cos(sp.y*12.+1.2)*0.06, 0.015);
    alle = smin(alle, k, 0.06);
    

    
    
    //wangen knochen vor
    sp = p;
    k = knochen(p, vec3(0., -0.28, -0.42+cos(abs(sp.x)*8.+2.)*0.02), 
                vec3(0.13, 0.055+sin(abs(sp.x)*8.+2.)*0.02, 0.05), 
                -0.5, 0.2, -0.1, 0.12, 0.05);
    alle = smin(alle, k, 0.09);
    
    //return alle;
    
    //wangen knochen seit sollte dasselb (gesamt)breit haben wie die augen seit!
    //wangen knochen seit
    sp = p;
    k = knochen(p, vec3(0., -0.3, -0.28), 
                vec3(0.007, 0.02-cos(sp.z*8. + 1.7-cos(sp.z*20. + 1.7))*0.01, 0.16), 
                0., 0.1, 0., 0.27 + cos(sp.z*8. + 2.)*0.09, 
                0.03 + cos(sp.z*8. + 4.7)*0.015);
    alle = smin(alle, k, 0.02);
    
    float keiferHohe = 0.01;
    //wangen knochen zu keifer
    sp = p;
    k = knochen(p, vec3(0., -0.51+keiferHohe, -0.25 - cos(abs(sp.y)*12. + 3.)*0.04), 
                vec3(0.005-cos(sp.z*12.+4.5)*0.004 - cos(sp.y*6.+1.2)*0.017, 
                     0.125, 
                     0.1), 
                0.2+(-sp.y-0.5)*0.2, -0.35, -0.25, 
                0.29 , 0.01); //keifer ein bisschen mehr eng war hilfreich
    float keifer = k;
    
    
    
    
    //keifer
    sp = p;
    k = knochen(p, vec3(0., -0.67+keiferHohe, -0.35), vec3(0.005, 0.02, 0.16), 
                -0.3, -0.5, 0., 0.18+cos(sp.z*8.+3.14)*0.02, 0.045);
    keifer = smin(keifer, k, 0.04);
    
    //wkk schneid
    sp = p;
    k = knochen(p, vec3(0., -0.58+keiferHohe, -0.28 - cos(abs(sp.y)*12. + 3.)*0.06), 
                vec3(0.001, 0.15, 0.055), 
                0.2+(-sp.y-0.5)*0.2, -0.45, -0.3, 0.34, 0.01);
    keifer = smax(keifer, -k, 0.04);
    
    //wkk loch
    sp = p;
    sp.x = abs(sp.x) - 0.31;
    k = length(sp - vec3(0., -0.38+keiferHohe, -0.23)) - 0.06;
    keifer = smax(keifer, -k, 0.04);
    
    
    //kinn
    sp = p;
    k = knochen(p, vec3(0., -0.73+keiferHohe, -0.45-cos(sp.x*8.)*0.1), vec3(0.09, 0.02, 0.015), 
                0., 0., 0., 0., 0.03);
    keifer = smin(keifer, k, 0.09);
    

    //sollte siemlich schaf sein
    //augen loche
    sp = p;
    sp.x = abs(sp.x) - 0.172;
    k = length(sp - vec3(0., -0.14, -0.48)) - 0.084;
    alle = smax(alle, -k, 0.075);
    
    //nase
    sp = p;
    k = knochen(p, vec3(0., -0.23, -0.51), vec3(0.03, 0.09, 0.08), 
                -0.3, 0., 0.3, 0., 0.039);
    alle = smin(alle, k, 0.06);
    
    //nase scheiden
    sp = p;
    k = knochen(p, vec3(0., -0.25, -0.54), vec3(0.022, 0.08, 0.07), 
                -0.35, 0., 0.3, 0., 0.03);
    alle = smax(alle, -k, 0.04);
    
    //nase linie
    sp = p;
    k = knochen(p, vec3(0., -0.25, -0.5), vec3(0.001, 0.12, 0.07), 
                -0.35, 0., 0., 0., 0.005);
    alle = smin(alle, k, 0.03);
    
    
    float zahnNum = 12.;
    float th = 0.15;
    sp = p;
    cs = cos(th), si = sin(th);
    
    sp = sp - vec3(0., -0.43, -0.4);
    sp.yz*=mat2(cs, si, -si, cs);
    
    //cyl oben
    
    k = sdCappedCylinder(sp, 0.17 //nicht so breit
                         + cos(sp.y*12. -5.)*0.015
                         + abs(cos(atan(sp.z,sp.x)*zahnNum - 0.8))*0.005
                         , 0.045 - abs(cos(atan(sp.z,sp.x)*zahnNum - 0.8))*0.02
                        - cos(sp.z*6.-1.75)*0.05
                        );
    alle = smin(alle, k, 0.06); //weniger smooth weil die echte schadel
    
    
    //return alle;
    
    //cyl unten
    sp = p - vec3(0., -0.65+keiferHohe, -0.42);
    k = sdCappedCylinder(sp, 0.15
                         + cos(sp.y*12. - 1.5)*0.03
                         + abs(cos(atan(sp.z,sp.x)*zahnNum - 0.8))*0.01
                         , 0.05 - abs(cos(atan(sp.z,sp.x)*zahnNum - 0.8))*0.01);
    keifer = smin(keifer, k, 0.06);
    
    
    
    
  
    //oben zhan
    sp = p - vec3(0.0, -0.51, -0.41);
    cs = cos(0.33), si = sin(0.33);//erste versuch!!!!
	sp.xz*=mat2(cs, si, -si, cs);
    k = sdCircleCircle(sp*6.6, 24, 1.); //nicht so breit
    float zahn = k;
    
    //unten zahn
    sp = p - vec3(0.0, -0.58+keiferHohe, -0.39);
    cs = cos(0.33), si = sin(0.33);//erste versuch!!!!
	sp.xz*=mat2(cs, si, -si, cs);
    
    k = sdCircleCircle(sp*6.6, 24, -1.);//nicht so breit
    zahn = min(zahn, k);
    
    objID = vec4(zahn-0.05, alle, keifer, 0);
    alle = smin(zahn,alle, 0.09);
    alle = smin(alle, keifer, 0.09);
    
    //cyl schneiden
    sp = p - vec3(0., -0.58, -0.15);
    k = sdCappedCylinder(sp, 0.17, 0.24);
    alle = smax(alle, -k, 0.06);
    
    //schonheit
    sp = p;
    sp.x = abs(sp.x) - 0.18;
    k = length(sp - vec3(0., -0.32, -0.522)) - 0.012;
    alle = smax(alle, -k, 0.01);
    
    return alle;
}
#define FAR 100.
#define eps 10./iResolution.y
#define R iResolution
#define F fragCoord
#define S smoothstep
#define T iTime
#define PI acos(-1.)
#define TAU PI*2.
#define M (iMouse.xy*2.-R.xy)/R.y
#define Mz iMouse.z
#define E 2./R.y
#define ROT(a) mat2(cos(a + vec4(0,11,33,0)))
#define F5(u) (fract((u))-0.5)
#define aFract(u) abs(fract((u))-0.5)

#define L(p,u) length(u-p)//max(abs(u.x-p.x),abs(u.y-p.y))//
#define SOLID(shape,r) S(r+E,r-E,shape)

//r=radius, t = thickness,  E=epsilon  //add t to shift to edge
#define OUTLINE(shape,r,t) S(t+E,t-E,abs(shape-r+t))
//double outline for ends of a shape
    //  r = radius, ot = outline thickness
    //  rt = orig ring thickness                      
    //add rt to shift corrent
    //subtract  (rt-ot) to sprad correct
#define DOUTLINE(shape,r,ot,rt) S(ot+E*2.,ot-E*2.,abs(abs(shape-r+rt)-(rt-ot)))

//r=radius, t = thickness, b = blur   //add t to shift to edge
#define OLS(shape,r,t,b) S(t*1.25+b,t*1.25-b,abs(shape-r+t))
#define OUTSHADOW(shape,r,l) S(r+l,r,shape)
#define INSHADOW(shape,r,t,l) S(r+E,r-E,shape)*S(t+E,t-E-l,abs(shape-r+t/4.))
#define GLOW(shape,r,t,l) S(t+E,t-E-l,abs(shape-r+t/4.))

#define CKR(u) mod(floor((u).x)+mod(floor((u).y)+1.,2.),2.)
#define CKRF(u) max(aFract(u).x,aFract(u).y)
#define CKRO(u) S(0.47,0.48,max(aFract(u).x,aFract(u).y))

#define TX0(u) texture(iChannel0,u).rgb
#define TX1(u) texture(iChannel1,u).rgb
#define TX2(u) texture(iChannel2,u).rgb
#define TX3(u) texture(iChannel3,u).rgb

#define WHITE vec3(1.,1.,1.)
#define BLACK vec3(0.,0.,0.)
#define GREY1 vec3(0.1,0.1,0.1)
#define GREY3 vec3(0.3,0.3,0.3) 
#define GREY5 vec3(0.5,0.5,0.5)
#define GREY7 vec3(0.7,0.7,0.7)
#define GREY9 vec3(0.9,0.9,0.9) 

#define RED vec3(0.5,0.2,0.)
#define GOLD vec3(0.9,0.5,0.3)
#define BLUE vec3(0.1,0.4,0.5)

float vig(vec2 uv){
    uv *=  1.0 - uv.yx;
    float vig = uv.x*uv.y * 25.0;
    return pow(vig, 1.); 
}

float hash(float p)
{
	 return fract(sin(p*324.341)*23402.43);
}

float hash21(vec2 st){
    return fract(sin(dot(vec2(12.23,74.343),st))*43254.);  
}

mat2 rot(float a) {
    return mat2(cos(a - vec4(0,11,33,0)));
}

float sdBox(vec3 p, vec3 s) {
    p = abs(p)-s;
	return length(max(p, 0.))+min(max(p.x, max(p.y, p.z)), 0.);
}

float Gyroid(vec3 p, float scale, float thickness, float bias) {
    p *= scale;
    float d = abs(dot(sin(p), cos(p.zxy))-bias)/scale-thickness;
	return d;
}


bool checkLogoBoundingBox(vec3 p){
    
    return (p.x < -4.5 || p.x > 4.5 || 
            p.y < -3. || p.y > 2. || 
            p.z < -4. || p.z > 4.);
    
}

//float objID = 0.;
float map(vec3 p) {
    float d = length(p)-1.5;//sdBox(p, vec3(1));
    
    return d;//skull(p);
}

float RayMarch(vec3 ro, vec3 rd) {
	float t=0.;
    
    for(int i=0; i<100; i++) {
    	vec3 p = ro + rd*t;
        float d = map(p);
        t += d*0.7;
        if(t>FAR || abs(d)<0.001) break;
    }
    
    return t;
}

vec3 GetNormal(vec3 p) {
    vec2 e = vec2(.001, 0);
    vec3 n = map(p) - 
        vec3(
            map(p-e.xyy), 
            map(p-e.yxy),
            map(p-e.yyx)
            );
    
    return normalize(n);
}


vec3 camRay(vec2 uv, vec3 o, vec3 target, float zoom){
    
    vec3 fwd = normalize(target - o);
    vec3 uu = vec3(0.,1.,0.);
    uu = dot(target,uu) < 0.01 ? vec3(0.,0.,1.) : uu;
    vec3 right = normalize(cross(uu, fwd));
    vec3 up = cross(fwd,right);
    vec3 rd = right*uv.x + up*uv.y + fwd*zoom;
    return normalize(rd);

}

vec2 map_from_sphere(vec3 p)
{
    p = normalize(p);
    return vec2(atan(p.x,p.y)/PI/2.+0.5, acos(p.z)/PI/2.+0.5);
}

vec3 checkers(vec2 u){
   // u.x += T*0.1;
    vec2 st = u;
    u*=2.;
    //u.x +=0.14;
    u = F5(u*2.)*2.;
    u = u.x*u.y < 0. ? abs(u.yx) : abs(u);
    u = abs(u)-0.7155;//-0.8;//-0.1
    u = abs(u)-0.5;//-0.3;//-0.6
    
    vec3 col = GREY5*0.35-CKR(st*20.)*0.15-CKRF(st*20.)*0.03;
    col -= (CKRO(st*20.)*0.82-0.01 );
    return col;
    }
vec3 celtic(vec2 u){
   // u.x += T*0.1;
    vec2 st = u;
    u*=2.;
    //u.x +=0.14;
    u = F5(u*2.)*2.;
    u = u.x*u.y < 0. ? abs(u.yx) : abs(u);
    u = abs(u)-0.7155;//-0.8;//-0.1
    u = abs(u)-0.5;//-0.3;//-0.6
    
    vec3 col = GREY5*0.35-CKR(st*20.)*0.15-CKRF(st*20.)*0.03;
    col -= (CKRO(st*20.)*0.82-0.01 );
    float radius = 0.959;
    float thick = 0.08;
    float othick = 0.01;
    float bthick = 0.013;
    float blur = 0.06;
    vec3 REDNEW = pow(RED*TX1(st*4.),vec3(1.4))*2.;
    
    col = mix(col,BLACK,OLS(L(vec2(0.5,-0.5),u),radius,thick,blur));
    col = mix(col,REDNEW,OUTLINE(L(vec2(0.5,-0.5),u),radius,thick));
    col = mix(col,BLACK,DOUTLINE(L(vec2(0.5,-0.5),u),radius,bthick,thick));
    col = mix(col,GOLD*(0.1+TX0(st*2.)),DOUTLINE(L(vec2(0.5,-0.5),u),radius,othick,thick));
    col = mix(col,BLACK,DOUTLINE(L(vec2(0.5,-0.5),u),radius,bthick*0.2,thick));
   
   
    col = mix(col,BLACK,OLS(L(vec2(0.5,0.5),u),radius,thick,blur));
    col = mix(col,REDNEW,OUTLINE(L(vec2(0.5,0.5),u),radius,thick));
    col = mix(col,BLACK,DOUTLINE(L(vec2(0.5,0.5),u),radius,bthick,thick));
    col = mix(col,GOLD*(0.1+TX0(st*2.)),DOUTLINE(L(vec2(0.5,0.5),u),radius,othick,thick));
    col = mix(col,BLACK,DOUTLINE(L(vec2(0.5,0.5),u),radius,bthick*0.2,thick));
    
    col = mix(col,BLACK,OLS(L(vec2(-0.5,0.5),u),radius,thick,blur));
    col = mix(col,REDNEW,OUTLINE(L(vec2(-0.5,0.5),u),radius,thick));
    col = mix(col,BLACK,DOUTLINE(L(vec2(-0.5,0.5),u),radius,bthick,thick));
    col = mix(col,GOLD*(0.1+TX0(st*2.)),DOUTLINE(L(vec2(-0.5,0.5),u),radius,othick,thick));
    col = mix(col,BLACK,DOUTLINE(L(vec2(-0.5,0.5),u),radius,bthick*0.2,thick));
    
    return col;
}

vec3 triplanar(vec3 p, vec3 n){
    n = abs(n);
    return mix(mix(celtic(p.yz),celtic(p.xy),n.z),celtic(p.xz),n.y);
}

// returns cubemap coordinates (FROM BIGWINGS)
// xy = uv coords for face of cube, z = cube index (-3,-2,-1, 1, 2, 3)
vec3 WorldToCube(vec3 p) {
	vec3 ap = abs(p);
    vec3 sp = sign(p);
    float m = max(ap.x, max(ap.y, ap.z));
    vec3 st;
    if(m==ap.x)
        st = vec3(p.zy, 1.*sp.x);
    else if(m==ap.y)
        st = vec3(p.zx, 2.*sp.y);
    else
        st = vec3(p.xy, 3.*sp.z);
    
    st.xy /= m;

    // iq version, no trig, short and sweet
   st.xy *= 3.0/(2.0+abs(st.xy));
//st.xy *= (1.45109572583 - 0.451095725826*abs(st.xy));
    return st;
}


void mainImage( out vec4 fragColor, in vec2 fragCoord )
{
    vec2 uv = (fragCoord-.5*iResolution.xy)/iResolution.y;
	vec2 m = iMouse.xy/iResolution.xy;

    vec3 ro = vec3(0, 4, -1);
    vec3 light = normalize(vec3(-1.,2.,1.));
    vec3 light2 = normalize(vec3(1.,2.,-1.));
  //  light = normalize(vec3(-1.,4.,1.));
  //  ro.yz *= rot(-m.y*PI+1.+iTime);
    //ro.xz *= rot(-m.x*TAU);
   // light.yz *= rot(-m.y*PI+1.);
   // light.xz *= rot(-m.x*TAU);
    
    vec3 rd = camRay(uv, ro, vec3(0,0.,0), 1.);
    vec3 col = celtic(uv.xy+iTime*0.05)*vig((F.xy/R.xy))*vec3(0.6,0.5,0.3);
    col = mix(col,BLACK,smoothstep(0.,0.3,(1.-length(uv+vec2(-0.09,0.1))-0.5))*0.8);
    float t = RayMarch(ro, rd);

    if(t<FAR) {
        vec3 p = ro + rd * t;
        
        
        vec3 n = GetNormal(p);
        
        
        
        float ld = length(light-p);
        float ld2 = length(light2-p);
        
        p.yz *= rot(-m.y*PI+1.+iTime*0.2);
        p.xz *= rot(-m.x*TAU+iTime*0.2);
        
        vec3 cubeCoords = WorldToCube(p);
        /*
        vec3 CXA = WorldToCube(p) + vec3(0.,E,0.);
        vec3 CXB = WorldToCube(p) + vec3(0.,-E,0.);
        vec3 CYA = WorldToCube(p) + vec3(E,0.,0.);
        vec3 CYB = WorldToCube(p) + vec3(-E,0.,0.);
        vec3 bump = vec3(CXB-CXA,CYB-CYA,0.);*/
        
        float attn = 1./(0.3+ld*0.2+ld*ld);
        float diff = max(0.,dot(n,light))*0.8+0.05;
        float spec = pow(max(0.,dot(
                     reflect(n,-light
                     ),rd)),100.);
         
        
        float attn2 = 1./(0.3+ld2*0.2+ld2*ld2);
        float diff2 = max(0.,dot(n,light2))*0.8+0.05;
        float spec2 = pow(max(0.,dot(
                     reflect(n,-light2
                     ),rd)),100.);
                     
        float ref = TX2(-reflect(n,rd)).x;   
        vec3 tp_tex = triplanar(p*0.5,n);
        vec3 sc_tex = celtic(map_from_sphere(p));
        
        vec3 cc_text = celtic((cubeCoords.xy*0.5+cubeCoords.z));//TX0(map_from_sphere(p)*3.);
      //  col = mix(sc_tex,tp_tex,abs(n.z)) * diff;
        vec3 col1 = 1.4*clamp(cc_text,0.,1.)*diff*1.6*attn + ref*0.0*diff*BLUE +  BLUE*spec*.08;
        vec3 col2 = 1.4*clamp(cc_text,0.,1.)*diff2*1.6*attn2*RED + ref*0.0*diff2 +  RED*spec2*.08;
        col = (col1+col2);
    
    }
    
    col = pow(col, vec3(.4545));
    
    fragColor = vec4(col,1.0);
}
