// Title: 
//			MONSTER v2.0
 
 
// What is this? (for newcomers)
//
//			Ever wrote a shader to support one particular setup, then another for another setup,
//			finally ending up with lots of shaders doing almost the same thing?
//			With #define-s and other preproc. directives, you can have "branching" in compile-time,
//			no need to slow the code down with conditional statements.
//			This also allows to write ONE shader code that is VERY close to optimal for many situations.
//			(Of course you need to recompile, but auto-generated versions are far easier this way.)
//			That is what you'll find here.
//			Check features below.
 
// Notes:
//			- mainly for outdoor rendering, due to hemispherical lighting
//			  (I wanted to have offset-mapping on every side of an object, which is quite
//			   hard with directional lights, also they are too stark for an ambient outdoor
//			   lighting)
//			- watch out for light positions rivalizing in distance from object's center:
//			  a typical artifact source /closest light switches between 2 lights/
//			- avoid crazy parameter combos
//			- notice how shader instruction count varies with shader complexity:
//				HLSL vertex:	a full-blown vs is 58, while it is 38 with no normal mapping
//							and only 25 if light0-light2 are disabled also (hemi still on!)
//							BTW the minimal possible with MONSTER_2 is 4 instr. :D
//				HLSL pixel:	full-blown gets to 73, won't compile, just as expected,
//							with no normal-mapping: 56.
//							with light0-light2 disabled (hemi and offset on): 29.
//							with just hemi (but fading, specular gloss, diffusetex): 12.
//							BTW the minimal is 2 instr. Pretty useless :D.
 
// Limitations:
//
//		As you will notice, many parameters are #define-s, for faster code, but if 
//		real-time change is needed, they could be handed as uniforms as well.
//		(This applies inversely as well, so some parameters might be #defined instead of passing
//		 them as uniforms, for faster code.)
//
//		I also skipped the Ka, Kd, Ks, etc. constants present in many shaders, to
//		be used as coefficient when summing lighting parts, obviously for performance.
//		They can be 'faked' by properly adjusting the diffuse/gloss/AO textures' brighness
//		in an image editor. Add them if you wish, but they slow MONSTER down.
//		(Ka can be coded into AO map, Kd into diffuse map, Ks into gloss map)
//		They also contribute to instruction count, so beware.
//
//		Also note that I placed no lighting restrictions on the user in this release.
//		It's a free for all. You decide what you want, but do not expect any compiler to
//		create you a shader that does *MAX* candy for *MAX* lights, given the instruction
//		count limits of ps_2_0 / arbfp1.
//
//		No directional lights. Hemisphere is better, and leaving them makes syntax clearer too.
//
//		One more thing: all lights have diffuse color = specular color as an optimization.
//		I believe it to be reasonable.
//
//		I use 2 UV sets for now, 1 is for auto-generated AOmap, and the other is
//		for diffuse/normal maps. I you are skilled/lucky, you can go with 1 UV set as well.
//		Artist/model dependant.
 
// Features:
//
//		-	improved lighting accuracy on low-poly meshes (2 tri quad for ex)
//
//		-	clearer code
//
//		-	2 uv sets
//
//		-	faster attenuation
//
//		-	1 hemispheric skylight with specular
//				/tune with: SKY_LIGHT_DIR, SKY_COLOR, GROUND_COLOR, SKY_EXPONENT/
//
//		-	max. 3 local lights
//				/diffuse part, specular part, attenuation/
//
//		-	per-pixel lighting / normal-mapping / offset-mapping
//
//		-	texturing: (diffuse + gloss), (normal + height), ambient occlusion
//
//		-	buggy distance-fadeout effect (someone should fix it, I can't get it right)
//
//		-	oFusion compatibility as usual
//
//		-	some typos, as usual :D
 
 
// GLSL users:
//
//		I do not compile this file as cg, because that way is not optimal.
//		Cg compiler sometimes generates longer code than HLSL.
//		If you need OpenGL, just change the definition in .material file to cg,
//		and the "target" word to "profiles" like:
//
//		vertex_program Simple_Perpixel_Vert cg
//		..
//		profiles vs_1_1 arbvp1 
//		//target vs_1_1
//
//		and of course do the same for fragment_program.
//		Or, for real-time support of both HLSL and GLSL, create 2 versions of MONSTER,
//		on with cg, one with HLSL, and use 2 techniques.
//
//		BTW interesting thing is that GLSL code has only ~2/3 instructions. Dunno why.
//		This lets you have more complex version running with GLSL.
 
 
 
// Want more lights?
//
//		What to do if you want *MORE* dynamic lights affecting a single static mesh?
//		(obviously this works mainly for large meshes and small area, attenuated lights)
//
//		0. use deferred shading (needs a good card to be fast enough)
//		1. use multiple passes (costy)
//		2. use cheaper frag shader (looks less cool) or vertex-lights (ugly without tessellation)
//		3. divide mesh to small parts in editor, bake it in static geometry, and you're done
//		   (set up lots of lights swarming around the mesh, and each part will be affected by 2,
//		    but the 2 closest, which will differ with the parts position)
 
 
 
// ADDITIONAL DOCS:
//
//		check earlier versions of MONSTER in Ogre WIKI, write mail, etc.
 
// TODO:
//
//		alpha-maps, environment-mapping, detail-texturing (both diffuse-map and offset-map)
//		volume-lighting, lightmaps, emissive-texture mapping, spot-lights, fog (volumetric?),
//		skinning, instancing,
//		...
//
//		Future dream-plan:
//		a demo app like GLSLdemo with texture/mesh browser, uniform sliders, and recompile option.
 
// CONTACT:
//
//		the name is guilderstein, email: forgamedev@yahoo.com, insert OGRE into subject please,
//		private message is better however
//
//		That's all for now, go and shade :D
 
 
 
	//pre-defines for compiler, ignore them
#define DIFFUSE_MAP 0
#define EXTRA_GLOSS_MAP 0
#define AMBIENT_OCC_MAP 0
#define NORMAL_MAP 0
#define EXTRA_HEIGHT_MAP 0
#define LIGHT_0 0
#define LIGHT_1 0
#define LIGHT_2 0
#define LIGHT_0_SPECULAR 0
#define LIGHT_1_SPECULAR 0
#define LIGHT_2_SPECULAR 0
#define HEMI_SKYLIGHT 0
#define HEMI_SKYLIGHT_SPECULAR 0
#define ATTENUATION 0
#define SPECULAR 0
#define SKY_LIGHT_DIR 0
#define GROUND_COLOR 0
#define SKY_COLOR 0
#define SKY_EXPONENT 0
#define EXPONENT_0 0
#define EXPONENT_1 0
#define EXPONENT_2 0
#define ATTEN_0 0
#define ATTEN_1 0
#define ATTEN_2 0
 
 
 
	// general switches
#define DISTANCE_FADING 0	//do not use fading, buggy
#define TEXTURING 1
#define LIGHTING 1
 
#if TEXTURING
  #define DIFFUSE_MAP 1
  #if DIFFUSE_MAP
    #define EXTRA_GLOSS_MAP 1
  #endif
  #define AMBIENT_OCC_MAP 1
  #if LIGHTING
    #define NORMAL_MAP 1
    #if NORMAL_MAP
      #define EXTRA_HEIGHT_MAP 1
    #endif
  #endif
#endif
 
//	ATTEN values are ~ 1/light range, larger value -> stronger atten.
 
#if LIGHTING
  #define ATTENUATION 1
 
  #define SPECULAR 1
  //diffuse in on if light is on
 
  #define LIGHT_0 1
  #if SPECULAR
	#define LIGHT_0_SPECULAR 1
  #endif
 
  #define LIGHT_1 1
  #if SPECULAR
	#define LIGHT_1_SPECULAR 1
  #endif
 
  #define LIGHT_2 1
  #if SPECULAR
	#define LIGHT_2_SPECULAR 0
  #endif
 
  #define HEMI_SKYLIGHT 1
  #if SPECULAR
	#define HEMI_SKYLIGHT_SPECULAR 1
  #endif
#endif
 
	// per-light switches
#if HEMI_SKYLIGHT
  #define SKY_LIGHT_DIR float3(0,1,0)
  #define GROUND_COLOR float3(0.1,0.1,0.1)
  #define SKY_COLOR    float3(0.9,0.9,1.0)
  #if HEMI_SKYLIGHT_SPECULAR
    #define SKY_EXPONENT 8
  #endif
#endif
 
#if LIGHT_0
  #if LIGHT_0_SPECULAR
    #define EXPONENT_0 120
  #endif
  #if ATTENUATION
    #define ATTEN_0 0.002
  #endif
#endif
 
#if LIGHT_1
  #if LIGHT_1_SPECULAR
    #define EXPONENT_1 120
  #endif
  #if ATTENUATION
    #define ATTEN_1 0.002
  #endif
#endif
 
#if LIGHT_2
  #if LIGHT_2_SPECULAR
    #define EXPONENT_2 120
  #endif
  #if ATTENUATION
    #define ATTEN_2 0.002
  #endif
#endif
 
//diff: first texture (reg s0), uv1, UVs.xy, TEXCOORD0
//AO:	second texture (reg s1), uv2, UVs.zw, TEXCOORD1
//norm: third texture (reg s2), uv1, UVs.xy, TEXCOORD0
 
//////////////////////////////////////////////////////////////////////////////////////////////
//										VERTEX SHADER										//	
//////////////////////////////////////////////////////////////////////////////////////////////
void MONSTER_vs
(
///////////////////////
//VS INPUT PARAMETERS//
///////////////////////
 
	//texturing
		#if TEXTURING
			#if DIFFUSE_MAP
				float2 uv1		: TEXCOORD0,
				uniform float tile_factor,
				//tiles diffuse & normal maps via uv1
			#elif NORMAL_MAP
				float2 uv1		: TEXCOORD0,
				uniform float tile_factor,
				//you can have only 1 on, and both on as well
			#endif
				//both normal and diffuse uses uv1
 
			#if AMBIENT_OCC_MAP
				float2 uv2		: TEXCOORD1,	
				//ao uses uv2
			#endif
 
			out float4 oUVs		: TEXCOORD1,				//oUVs: oT1
				//texturing means oUVs on, and both uv1
				//and uv2 get passed in oUVs
 
			#if NORMAL_MAP
				float3 tangent     	: TEXCOORD2,
			#endif
		#endif
 
	//lighting
		#if LIGHTING //lightposX is in object space
			#if HEMI_SKYLIGHT
				#if NORMAL_MAP
					out float3 oSkyLightDir	: TEXCOORD2,	//oSkyDir: oT2
				#endif
				//if no normal mapping is used, ps can use
				//the defined SKY_LIGHT_DIR otherwise we 
				//need to transform it to tangent space
			#endif
 
			#if LIGHT_0
				uniform float4 lightpos0, 
				out float3 oLightDir0: TEXCOORD3,			//oLDir0: oT3
				#if LIGHT_0_SPECULAR
					out float3 oHalfAngle0: TEXCOORD6,		//oHA0:	oT6
				#endif
			#endif
 
			#if LIGHT_1
				uniform float4 lightpos1,	
				out float3 oLightDir1: TEXCOORD4,			//oLDir1: oT4
				#if LIGHT_1_SPECULAR
					out float3 oHalfAngle1: TEXCOORD7,		//oHA1: oT7
				#endif
			#endif
 
			#if LIGHT_2
				uniform float4 lightpos2,	
				out float3 oLightDir2: TEXCOORD5,			//oLDir2: oT5
				#if LIGHT_2_SPECULAR
					out float3 oHalfAngle2: TEXCOORD0,	
				#endif
			#endif
				//I don't have more oTX space for oHalfAngle2,
				//could interleave since many oTX uses only 3 float of 4,
				//but that is messy, and ps might overrun its instr. limit, too,
				//so LIGHT_2_SPECULAR is disabled by default
		#endif
 
	//eye/camera position in object space
		#if DISTANCE_FADING
			#if EXTRA_HEIGHT_MAP
				out float3 oEyeDir     : TEXCOORD0,			//oEye: oT0
			//if offset mapping is used, oT0 is free, normal does not go to ps
			#endif
			out float4 oFadeColor	: COLOR,
			uniform float fade_start_dist,
			uniform float fade_end_dist,
			uniform float3 eyepos,
			//we can have fading with offset mapping, and wo it
		#elif EXTRA_HEIGHT_MAP
			out float3 oEyeDir     : TEXCOORD0,				//oEye: oT0		
			uniform float3 eyepos,
		#elif SPECULAR				
			uniform float3 eyepos,
		#endif
 
	//mixed basics
		#if !NORMAL_MAP
			#if LIGHTING
				out float3 oNorm: TEXCOORD0,					//oNorm: oT0
			#endif
		#endif
 
		float4 pos		: POSITION,
		uniform float4x4 wvp,
 
		float3 norm		: NORMAL,
		out float4 oPos : POSITION
) 
{
///////////////////////
//VS CODE STARTS HERE//
///////////////////////
 
	//mixed basics
		oPos = mul(wvp, pos);
		#if !NORMAL_MAP
			#if LIGHTING
				oNorm = norm;
			#endif
		#endif
 
	#if DISTANCE_FADING
      float ratio = saturate(1-(distance(eyepos, pos.xyz)-fade_start_dist) / fade_end_dist); 
 	  oFadeColor =  float4(0,0,0,ratio);
    #endif
 
	//texturing
		#if TEXTURING
				oUVs = float4(0,0,0,0);
			#if DIFFUSE_MAP
				oUVs.xy = uv1 * tile_factor;
			#elif NORMAL_MAP
				oUVs.xy = uv1 * tile_factor;
			#endif
			#if AMBIENT_OCC_MAP
				oUVs.zw = uv2;
			#endif
		#endif
 
	//lighting & normal mapping
		#if LIGHTING
			#if NORMAL_MAP
				float3 binormal = cross(tangent, norm);
				float3x3 rotation = float3x3(tangent, binormal, norm);
				#if HEMI_SKYLIGHT
					oSkyLightDir = mul(rotation, SKY_LIGHT_DIR);
				#endif
				#if EXTRA_HEIGHT_MAP
					float3 EyeDir = eyepos - pos.xyz;
					EyeDir = mul(rotation, EyeDir);
					oEyeDir = EyeDir;
					#if SPECULAR
						float3 normed_EyeDir = normalize(EyeDir);
					#endif
					//if I pass a vector un-normalized to frag shader,
					//I get better interpolation, but normalization
					//is needed for halfvectors
				#elif SPECULAR
					float3 normed_EyeDir = normalize(eyepos - pos.xyz);
					//this allows having specular with only normal maps
				#endif
			#elif SPECULAR
				float3 normed_EyeDir = normalize(eyepos - pos.xyz);
			#endif
 
			#if LIGHT_0
				#if ATTENUATION
					oLightDir0    = ATTEN_0 * (lightpos0 -  pos).xyz;
				#else
					oLightDir0    = (lightpos0 -  pos).xyz;
				#endif
				#if NORMAL_MAP
					oLightDir0 = mul(rotation, oLightDir0);
				#endif
				#if LIGHT_0_SPECULAR
					oHalfAngle0   = normalize(normalize(oLightDir0) + normed_EyeDir);
				#endif
			#endif
 
			#if LIGHT_1
				#if ATTENUATION
					oLightDir1    = ATTEN_1 * (lightpos1 -  pos).xyz;
				#else
					oLightDir1    = (lightpos1 -  pos).xyz;
				#endif
				#if NORMAL_MAP
					oLightDir1 = mul(rotation, oLightDir1);
				#endif
				#if LIGHT_1_SPECULAR
					oHalfAngle1   = normalize(normalize(oLightDir1) + normed_EyeDir);
				#endif
			#endif
 
			#if LIGHT_2
				#if ATTENUATION
					oLightDir2    = ATTEN_2 * (lightpos2 -  pos).xyz;
				#else
					oLightDir2    = (lightpos2 -  pos).xyz;
				#endif
				#if NORMAL_MAP
					oLightDir2 = mul(rotation, oLightDir2);
				#endif
				#if LIGHT_2_SPECULAR
					oHalfAngle2   = normalize(normalize(oLightDir2) + normed_EyeDir);
				#endif
			#endif
		#endif
} 
 
 
 
// Note: instead of passing v2f the HalfAngle of each light, it (or reflection vector) could be calculated in fs!
//	 oTx space vs. instr.count decision, and would make vs real fast!
 
//////////////////////////////////////////////////////////////////////////////////////////////
//										PIXEL SHADER										//	
//////////////////////////////////////////////////////////////////////////////////////////////
void MONSTER_ps
(
///////////////////////
//PS INPUT PARAMETERS//
///////////////////////
 
	//mixed basics
		#if !NORMAL_MAP
			#if LIGHTING
				float3 norm				:	TEXCOORD0,
			#endif
		#endif
 
		#if DISTANCE_FADING
			float opacity		:	COLOR,
		#endif
 
	//texturing
		#if TEXTURING
			float4 UVs				:	TEXCOORD1,	//uv2 AND already scaled uv1
			#if DIFFUSE_MAP
				uniform sampler2D   DiffuseGlossMap		: 	register(s0),	//first texture
			#endif
			#if AMBIENT_OCC_MAP
				uniform sampler2D   AoMap		: 	register(s1),	//second texture
			#endif
			#if NORMAL_MAP
				uniform sampler2D   NormalHeightMap	:	register(s2),	//third texture
			#endif
		#endif
 
	//lighting
		#if LIGHTING
			#if HEMI_SKYLIGHT
				#if NORMAL_MAP
					float3 TSkyLightDir	:	TEXCOORD2,
				#endif
			//again, if I do no normal mapping with hemi, I can go with
			//just using the #define-d SKY_LIGHT_DIR
			#endif
			#if LIGHT_0
				uniform float3 lightColor0,
				float3 LightDir0	:	TEXCOORD3,
				#if LIGHT_0_SPECULAR
					float3 HalfAngle0	:	TEXCOORD6,
				#endif
			#endif
			#if LIGHT_1
				uniform float3 lightColor1,
				float3 LightDir1	:	TEXCOORD4,
				#if LIGHT_1_SPECULAR
					float3 HalfAngle1	:	TEXCOORD7,
				#endif
			#endif
			#if LIGHT_2
				uniform float3 lightColor2,
				float3 LightDir2	:	TEXCOORD5,
				#if LIGHT_2_SPECULAR
					float3 HalfAngle2	:	TEXCOORD0,
				#endif
			#endif
			#if EXTRA_HEIGHT_MAP
				uniform float2 scaleBias,
				float3 EyeDir		:	TEXCOORD0,
				//offset mapping needs no normal from vs, hence T0 is free
			#endif
		#endif
 
	//final color
		out float4 oColor 	:	COLOR
) 
{
///////////////////////
//PS CODE STARTS HERE//
///////////////////////
 
	//lighting and texturing
		#if LIGHTING
 
			#if !NORMAL_MAP
				float3 N = normalize(norm);
			#else
				#if EXTRA_HEIGHT_MAP
					EyeDir	 = normalize(EyeDir);
					//get offset uvs
					float height = tex2D(NormalHeightMap, UVs.xy).a;
					float2 newTexCoord = UVs.xy + EyeDir.xy * (height * scaleBias.x + scaleBias.y);
					float3 bumpVec = tex2D(NormalHeightMap, newTexCoord ).xyz * 2 - 1; 
					//lookup with texcoord 0, and expand from range comressed
				#else
					float3 bumpVec = tex2D(NormalHeightMap, UVs.xy ).xyz * 2 -1;
					//same, but just normal-mapping
				#endif
				float3 N = normalize(bumpVec);
			#endif
			//okay, now we have a normal to do lighting
 
	//TODO/?/:	send a HalfAngle_Sky from vs to get cheaper sky-specular, but that
	//			would cost 1 additional texcoord, maybe taken from light_2
	//			/again, interleaving is an option, since many times I use only 3
	//			float values of texcoords to pass data vert2frag, but all texcoords
	//			are float4 vectors; biggest problem is usage complexity/
 
	//TODO:	Issues with SKY_SPECULAR, now sky can only have spec. if offset is on
 
			#if HEMI_SKYLIGHT
				#if NORMAL_MAP
					float SKYdotN = dot(TSkyLightDir, N);
					#if EXTRA_HEIGHT_MAP
						#if HEMI_SKYLIGHT_SPECULAR
							float SKYdotH = dot(normalize(EyeDir + TSkyLightDir), N);
							float4 hemispec = pow(saturate(SKYdotH), SKY_EXPONENT);
						//try with lit()!
						#endif
					#endif
				#else
					float SKYdotN = dot(SKY_LIGHT_DIR, N);
				#endif
				float3 hemi = lerp(GROUND_COLOR, SKY_COLOR, 0.5 + 0.5 * SKYdotN);
			#endif
 
			#if LIGHT_0
				LightDir0 = normalize(LightDir0);
				#if ATTENUATION
					float atten0 = saturate(1 - dot(LightDir0, LightDir0));
				#endif
				float NdotL0 = dot(LightDir0, N);
				#if LIGHT_0_SPECULAR
					float NdotH0 = dot(HalfAngle0, N);
					float4 Lit0 = lit(NdotL0,NdotH0,EXPONENT_0);
				#endif
			#endif
 
			#if LIGHT_1
				LightDir1 = normalize(LightDir1);
				#if ATTENUATION
					float atten1 = saturate(1 - dot(LightDir1, LightDir1));
				#endif
				float NdotL1 = dot(LightDir1, N);
				#if LIGHT_1_SPECULAR
					float NdotH1 = dot(HalfAngle1, N);
					float4 Lit1 = lit(NdotL1,NdotH1,EXPONENT_1);
				#endif
			#endif
 
			#if LIGHT_2
				LightDir2 = normalize(LightDir2);
				#if ATTENUATION
					float atten2 = saturate(1 - dot(LightDir2, LightDir2));
				#endif
				float NdotL2 = dot(LightDir2, N);
				#if LIGHT_2_SPECULAR
					float NdotH2 = dot(float3(0,1,0), N);
					float4 Lit2 = lit(NdotL2,NdotH2,EXPONENT_2);
				#endif
			#endif
		#endif
 
		//color texturing
		#if TEXTURING
			#if EXTRA_HEIGHT_MAP
				#if EXTRA_GLOSS_MAP
					float4 diff = tex2D(DiffuseGlossMap, newTexCoord).xyzw;
					float3 diffusetex = diff.xyz;
					float gloss_power = diff.w;
				#elif DIFFUSE_MAP
					float3 diffusetex = tex2D(DiffuseGlossMap, newTexCoord).xyz;
					//lookup with offsetted texcoord 0
				#endif
			#else
				#if EXTRA_GLOSS_MAP
					float4 diff = tex2D(DiffuseGlossMap, UVs.xy).xyzw;
					float3 diffusetex = diff.xyz;
					float gloss_power = diff.w;
				#elif DIFFUSE_MAP
					float3 diffusetex = tex2D(DiffuseGlossMap, UVs.xy).xyz;
				#endif
				//lookup with texcoord 0
			#endif
			#if AMBIENT_OCC_MAP
				float occlusionfactor = tex2D(AoMap, UVs.zw).x;	//lookup with texcoord 1
				//Clumpsy solution, since it is a grayscale map anyway,
				//it could go into for ex. diffuse's alpha channel if no
				//specular gloss mapping is done
				//Though you will need to have either 2 lookup with the 2 uv sets on
				//the same texture, OR have 1 uv set for all maps, and go with 1 lookup
			#endif
		#endif
 
	//All is set up, now comes the most complex part, final color computation:
	//Though many variations are possible, I go with this one:
	//	(at maximum, and in readable form)
	//
	//	oColor =	hemi * occlusionfactor			//-> ambient lighting
	//			 +  sky_color * sky_specular_coeff	//-> ambient specular
	//			 +	sum( atten[i] * lightcolor[i] * diffuse_coeff[i]) * diffusetex
	//			 +	sum( atten[i] * lightcolor[i] * specular_coeff[i]) * gloss_power
	//
	//Try modulating (hemi * AO) also with diffusetex, etc.
 
	//Though syntax might seem chaotic, compiler does a great job in optimizing out float3(0,0,0) for ex.
	oColor = float4	(	float3(0,0,0)
 
				#if !LIGHTING
					#if TEXTURING
						#if DIFFUSE_MAP
							+ diffusetex
							#if AMBIENT_OCC_MAP //just ao
								* occlusionfactor.xxx
							#endif
						#elif AMBIENT_OCC_MAP
							+ occlusionfactor.xxx
						#endif
						//TODO: add normal map output as diffuse for debug purposes
					#endif
				#endif
 
				#if HEMI_SKYLIGHT
					+ hemi
					#if AMBIENT_OCC_MAP
					* occlusionfactor
					#endif
					#if EXTRA_HEIGHT_MAP
						#if HEMI_SKYLIGHT_SPECULAR
							+ hemispec
							#if EXTRA_GLOSS_MAP
								* gloss_power
							#endif
						#endif
					#endif
				#endif
 
				#if LIGHT_0
						+ lightColor0 * (
					#if ATTENUATION
							atten0 * (
						#if LIGHT_0_SPECULAR
							Lit0.y
							#if DIFFUSE_MAP
								* diffusetex
							#endif
							+ Lit0.z
							#if EXTRA_GLOSS_MAP
								* gloss_power ))
							#else
								))
							#endif
						#else
							NdotL0 ))
						#endif
					#elif LIGHT_0_SPECULAR	//no atten, but spec and diff
						Lit0.y
						#if DIFFUSE_MAP
							* diffusetex
						#endif
						+ Lit0.z
						#if EXTRA_GLOSS_MAP
							* gloss_power)
						#else
							)
						#endif
					#else	//no. atten, just diffuse
						NdotL0
						#if DIFFUSE_MAP
							* diffusetex )
						#else
							)
						#endif
					#endif
				#endif
 
				#if LIGHT_1
						+ lightColor1 * (
					#if ATTENUATION
							atten1 * (
						#if LIGHT_1_SPECULAR
							Lit1.y
							#if DIFFUSE_MAP
								* diffusetex
							#endif
							+ Lit1.z
							#if EXTRA_GLOSS_MAP
								* gloss_power ))
							#else
								))
							#endif
						#else
							NdotL1 ))
						#endif
					#elif LIGHT_1_SPECULAR	//no atten, but spec and diff
						Lit1.y
						#if DIFFUSE_MAP
							* diffusetex
						#endif
						+ Lit1.z
						#if EXTRA_GLOSS_MAP
							* gloss_power)
						#else
							)
						#endif
					#else	//no. atten, just diffuse
						NdotL1
						#if DIFFUSE_MAP
							* diffusetex )
						#else
							)
						#endif
					#endif
				#endif
 
				#if LIGHT_2
						+ lightColor2 * (
					#if ATTENUATION
							atten2 * (
						#if LIGHT_2_SPECULAR
							Lit2.y
							#if DIFFUSE_MAP
								* diffusetex
							#endif
							+ Lit2.z
							#if EXTRA_GLOSS_MAP
								* gloss_power ))
							#else
								))
							#endif
						#else
							NdotL2 ))
						#endif
					#elif LIGHT_2_SPECULAR	//no atten, but spec and diff
						Lit2.y
						#if DIFFUSE_MAP
							* diffusetex
						#endif
						+ Lit2.z
						#if EXTRA_GLOSS_MAP
							* gloss_power)
						#else
							)
						#endif
					#else	//no. atten, just diffuse
						NdotL2
						#if DIFFUSE_MAP
							* diffusetex )
						#else
							)
						#endif
					#endif
				#endif
			 ,
			#if DISTANCE_FADING
				opacity
			#else
				1
			#endif
			);	
}