////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
//SW_ESCHER_SHADER
////////////////////////////////////////////////////////////////////
#ifndef FILTERWIDTH_H
#define FILTERWIDTH_H 1

/* Define metrics for estimating filter widths, if none has already
 * been defined.  This is crucial for antialiasing.
 */
#ifndef MINFILTWIDTH
#  define MINFILTWIDTH 1.0e-6
#endif


/* The filterwidth macro takes a float and returns the approximate 
 * amount that the float changes from pixel to adjacent pixel.
 */
#define filterwidth(x)  max (abs(Du(x)*du) + abs(Dv(x)*dv), MINFILTWIDTH)


/* The filterwidthp macro is similar to filterwidth, but is for 
 * point data.
 */
#define filterwidthp(p) max (sqrt(area(p)), MINFILTWIDTH)



/* Given a function g, its known average g_avg, its high frequency
 * feature size, and a filter width, fade to the average as we approach
 * the Nyquist limit.
 */
#define fadeout(g,g_avg,featuresize,fwidth) \
        mix (g, g_avg, smoothstep(.2,.6,fwidth/featuresize))


#endif /* FILTERWIDTH_H */
////////////////////////////////////////////////////////////////////
#define vsnoise(x) (2*(vector noise(x))-1)

vector 
vfBm(point p; uniform float octaves, lacunarity, gain)
{
	uniform float amp = 1;
	varying point pp = p;
	varying vector sum = 0;

	uniform float i;
	
	for (i=0; i<octaves; i+=1){
		sum += amp * vsnoise(pp);
		amp *= gain; pp*=lacunarity;
	}
	return sum;
}

////////////////////////////////////////////////////////////////////
color CelOutline (normal N; float outlinethickness;
					color LineColor;)
{
    float angle = abs(normalize(N) . normalize(I));
    float dangle = filterwidth(angle);
    float border = 1 - filterstep (5*outlinethickness, angle/dangle);
	Ci = mix (Ci, LineColor, border);
}
////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
surface 
SW_ESHCERSHADER(float 	inkwidth = 0.2, lineFreq = 10, Jitter = 10, U_Switch = 1, V_Switch = 1;
				color 	U_Color = 0, V_Color = 0, matte = 1;
				float 	taperwidth = 0.3,
						rotateU = 0,
						rotateV = 0,
		  				Ka = 0.2, Kd = 0.8, Ks = 0.6, 
						roughness = 0.1,
						Dots = 0,
						SwitchOutLine = 0,
						outlinethickness = 1;
				color 	outlineColor = 0;)
{	
point PP;
float a, b, c, d, e, f, x, y, z;
float dist, dist1, detail, width;
float Spec_Illumination;
float which, Highpoints, taper;
color white = 1, ColorU, ColorV;

///////////////////////////////////////////////////////////////////

normal Nf = faceforward(normalize(N), I);
vector V = -normalize(I);

//////////////////////////////////////////////////////////////////

PP = transform("shader", P);
if (Dots == 1){
	PP = PP + (P + 0.2 * vfBm(2*P, 4, 2, Jitter));
}else{
 PP = PP + point noise (PP * Jitter) * 0.02; 
}
/////////////////////////////////////////////////////////////////

x = xcomp(PP);
y = ycomp(PP);


/////////////////////////////////////////////////////////////////

Spec_Illumination = comp( Oi * white * (Ka * ambient() + Kd * 
				diffuse(Nf)) + Ks * specular(Nf, V, roughness)
				, 0);
			
////////////////////////////////////////////////////////////////

Ci =matte;

///////////////////////////////////////////////////////////////
/////////////////////////////U Lines//////////////////////////
//////////////////////////////////////////////////////////////
a = rotateU;
b = U_Switch;


dist = (a*x+b*y)/sqrt(a*a+b*b);
//creates a formala for one line//

dist =dist * lineFreq;
//Here dist create a number for how many lines a user wants//

which = mod(floor(dist), 2);
//mod is use by dividing the first value by the second and giving it a reminder//
//floor is used bc it is a int that is no greater than the value given, we now have two//
//intergers to give a remainder

dist -= floor(dist);
//takes defined line and creates a row//
	
	Highpoints =  1 * pow(.5, which);
	taper = taperwidth * pow(0.5, which);
	//These variables are set in order to create normal lines and tapers in the line//
	
		width = inkwidth;
		width = width * (1-smoothstep(Highpoints-taper/2, Highpoints+taper/2, Spec_Illumination));
		//create a taper based upon Spec_Illuminatin//
	
	dist = smoothstep( 0, width*0.25, dist) - smoothstep( width, width*1.25, dist);//creates Lines//
	Ci = mix( Ci, U_Color, dist);
////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////VLINES//////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////

	d = V_Switch;
	e = rotateV;
	
	
	dist1 = (d*x+e*y)/sqrt(d*d+e*e);

	dist1 =dist1 * lineFreq;
	which = mod(floor(dist1), 2);
	dist1 -= floor(dist1);

		Highpoints =  1 * pow(0.5, which);
		taper = taperwidth * pow(0.5, which);
			width = inkwidth;
			width = width * (1-smoothstep(Highpoints-taper/2, Highpoints+taper/2, Spec_Illumination));
	
	dist1 = smoothstep( 0, width*0.25, dist1) - smoothstep( width, width*1.25, dist1);
	Ci = mix( Ci, V_Color, dist1);

//////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////LINEOUTLINE/////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////

	if (SwitchOutLine == 1)
	{
    Oi = Os;  Ci *= Oi;
    Ci = CelOutline (N, outlinethickness, outlineColor);
	}

}