/*
==================================================================================
INTERACTION_VERTEX

output:
	texcoord 0.xyzw	is the light projection / falloff texture coordinates
	texcoord 1.xy	is the bump / diffuse / specular texture coordinate
	texcoord 2.xyz	is the global vertex position after model matrix transform
	texcoord 3.xyz	is the normal transform 1
	texcoord 4.xyz	is the normal transform 2
	texcoord 5.xyz	is the normal transform 3
	texcoord 6.xyzw	is the shadow buffer coordinates
==================================================================================
*/
#template INTERACTION_VERTEX()
{
	// texture 0 has four texgens for light projection and falloff
	result.texcoord0.x = dot4( position, $lightProjectionS );
	result.texcoord0.y = dot4( position, $lightProjectionT );
	result.texcoord0.z = dot4( position, $lightProjectionR );
	result.texcoord0.w = dot4( position, $lightProjectionQ );

	// Convert back from 16 bit vertex elements.
	float4 texcoord0 = ( vertex.texcoord0.xyxy * $vertexStScaleBias.xyxy + $vertexStScaleBias.zwzw ) + skinOffsets.xyzw;

	// texture 1 takes the base texture coordinates
	result.texcoord1 = texcoord0;

	float4 worldPosition;
	worldPosition.x = dot4( position, $modelMatrixX );
	worldPosition.y = dot4( position, $modelMatrixY );
	worldPosition.z = dot4( position, $modelMatrixZ );
	worldPosition.w = dot4( position, $modelMatrixW );

	// texture 2 takes the global position
	result.texcoord2.x = worldPosition.x;
	result.texcoord2.y = worldPosition.y;
	result.texcoord2.z = worldPosition.z;
	result.texcoord2.w = - dot4( worldPosition, $viewMatrixZ );

	//transform the local space vectors to world space
	result.texcoord3.x = dot3( tangent,   $modelMatrixX );
	result.texcoord3.y = dot3( bitangent, $modelMatrixX );
	result.texcoord3.z = dot3( normal,    $modelMatrixX );
	result.texcoord3.w = 1.0;

	result.texcoord4.x = dot3( tangent,   $modelMatrixY );
	result.texcoord4.y = dot3( bitangent, $modelMatrixY );
	result.texcoord4.z = dot3( normal,    $modelMatrixY );
	result.texcoord4.w = 1.0;

	result.texcoord6.x = dot3( tangent,   $modelMatrixZ );
	result.texcoord6.y = dot3( bitangent, $modelMatrixZ );
	result.texcoord6.z = dot3( normal,    $modelMatrixZ );
	result.texcoord6.w = 1.0;

#ifndef NOSHADOW
	// texcoord 5 has the shadow buffer texcoords
	// transform local space xyz into light space
	result.texcoord5.x = dot4( position, $localToLightS );
	result.texcoord5.y = dot4( position, $localToLightT );
	result.texcoord5.z = dot4( position, $localToLightR );
	result.texcoord5.w = dot4( position, $localToLightQ );
#endif

	// position
	result.position.x = dot4( position, $mvpMatrixX );
	result.position.y = dot4( position, $mvpMatrixY );
	result.position.z = dot4( position, $mvpMatrixZ );
	result.position.w = dot4( position, $mvpMatrixW );
}
#endtemplate

/*
==================================================================================
INTERACTION_FRAGMENT_BASIC

Should the color of the light influence the environment color? probably.

vertex input:
	texcoord 0.xyzw	is the light projection / falloff texture coordinates
	texcoord 1.xy	is the bump / diffuse / specular texture coordinate
	texcoord 2.xyz	is the global vertex position after model matrix transform
	texcoord 3.xyz	is the normal transform 1
	texcoord 4.xyz	is the normal transform 2
	texcoord 5.xyzw	is the shadow buffer coordinates
	texcoord 6.xyz	is the normal transform 3

	in float shadow;

render parms:
	globalViewOrigin
	globalLightOrigin
==================================================================================
*/
#template INTERACTION_FRAGMENT_BASIC( shadow )
{
	//-------- non-wrapping virtual texture lookup ------------
	float2 texcoord = fragment.texcoord1.xy;
	BRANCH if ( $useVirtualMapping.x > 0 ) {
		// this is basically only for non pre-lit levels, and shouldn't be used often.
		// this doesn't attempt to get the derivative correct at the frac crossing point
		texcoord = frac( texcoord ) * $virtualMapping.xy + $virtualMapping.zw;
	}

	float3 physCoord = VmtrVirtualToPhysical( texcoord );

	//---------------------------------------------------------------
	// load the virtual textures
	//---------------------------------------------------------------
#ifdef USE_VIRTUAL_ANISO_FOOTPRINT
	float2 dx = ddx( texcoord.xy ) * physCoord.z;
	float2 dy = ddy( texcoord.xy ) * physCoord.z;

	half4 specularPage = texPhys( $physicalVmtrPagesMap0, physCoord.xy, dx, dy );
	half4 YCoCg = texPhys( $physicalVmtrPagesMap1, physCoord.xy, dx, dy );
	half4 bumpPage = texPhys( $physicalVmtrPagesMap2, physCoord.xy, dx, dy );
#else
	half4 specularPage = texPhys( $physicalVmtrPagesMap0, physCoord.xy );
	half4 YCoCg = texPhys( $physicalVmtrPagesMap1, physCoord.xy );
	half4 bumpPage = texPhys( $physicalVmtrPagesMap2, physCoord.xy );
#endif

	specularPage.xyz = ScaleSpecular( specularPage.xyz, bumpPage.z );
	bumpPage.z = 0;

	//---------------------------------------------------------------
	// derive localNormal, then transform to a global normal
	//---------------------------------------------------------------

	float3 localNormal = float3( ( bumpPage.wy * 2.0 ) - 1.0, 0.0 );

	// derive the localNormal.z component
	localNormal.z = sqrt( abs( 1.0 - dot3( localNormal, localNormal ) ) );

	// transform into global space
	float3 globalNormal;
	globalNormal.x = dot3( localNormal, fragment.htexcoord3 );
	globalNormal.y = dot3( localNormal, fragment.htexcoord4 );
	globalNormal.z = dot3( localNormal, fragment.htexcoord6 );
	globalNormal = normalize( globalNormal );

	//---------------------------------------------------------------
	// normalize the directions to the light and viewer
	//---------------------------------------------------------------
	float3 toLight = normalize( $globalLightOrigin.xyz - fragment.texcoord2.xyz );
	float3 toViewer = normalize( $globalViewOrigin.xyz - fragment.texcoord2.xyz );

	//---------------------------------------------------------------
	// Incoming light color is the product of two light projection
	// texture maps, the light color parameter, the dor with the surface
	// normal, and the faded shadow factor
	// optimize: if we assumed one or both of the light maps are monochrome,
	// we could save some math.
	//---------------------------------------------------------------

	half3 light;
	{
		float3 lightTexCoord = fragment.htexcoord0.xyz / fragment.htexcoord0.w;

		half4 lpm = h4tex2D( $lightProjectMap, lightTexCoord.xy );
		half4 lfm = h4tex2D( $lightFalloffMap, float2( lightTexCoord.z, 0.5 ) );

		light = _float3( dot3( toLight, globalNormal ) );

		// modulate by the light projection and falloff
		light *= lpm.xyz * lfm.xyz;

		// modulate by the light color
		light *= $lightColor.xyz;

		// modulate by the shadow factor adjusted by the shadow fade
		light *= ( shadow * $shadowFade.x ) + $shadowFade.y;
	}

	half3 specular;
	{
#if 0
		//---------------------------------------------------------------
		// calculate the static specular at this point
		//---------------------------------------------------------------

		// reflection vector = 2 * N * ( N . V ) - V
		half3 reflection;
		reflection = ( 2.0 * globalNormal * dot3( globalNormal, toLight ) ) - toLight;

		// Use the absolute value of the dot, so we get static
		// highlights on both sides of objects.  Oh, the horror! :-)
		float specularD = abs( dot3( reflection, $staticSpecularVector ) );

		// power factor is stored in bumpPage.x as 0.0 - 1.0, we want a 0 to 64 scale
		float power = bumpPage.x * 64;

		float specularStrength = $staticSpecularScale.x * pow( specularD, power );

		specular = specularStrength;
#else
		//---------------------------------------------------------------
		// sample envColor from the environment map
		//---------------------------------------------------------------

		// reflection vector = 2 * N * ( N . V ) - V
		half4 reflection;
		reflection.xyz = ( 2.0 * globalNormal * dot3( globalNormal, toViewer ) ) - toViewer;

		// power factor is stored in bumpPage.x as 0.0 - 1.0, we want a 0 | 1 | 2 | 3 mip value
		// we could probably skip the floor, but I am wary of hardware / api rounding
		// the artists really prefer white to be shiny instead of dull, so invert it here
		reflection.w = floor( ( 1.0 - bumpPage.x ) * 4.0 + $newPowerScale.x );

		half3 envColor = texCUBElod( $dynamicEnvMap, reflection ).xyz;

		specular = envColor * specularPage.xyz * $newSpecularScale.xyz;
#endif
	}

	//---------------------------------------------------------------
	// covert the diffuse from YCoCg
	//---------------------------------------------------------------
	half4 diffuse;
	{
		YCoCg.z = ( YCoCg.z * 31.875 ) + 1.0;			//z = z * 255.0/8.0 + 1.0
		YCoCg.z = 1.0 / YCoCg.z;
		YCoCg.xy *= YCoCg.z;
		diffuse.x = dot4( YCoCg, matrixCoCg1YtoRGB1X );
		diffuse.y = dot4( YCoCg, matrixCoCg1YtoRGB1Y );
		diffuse.z = dot4( YCoCg, matrixCoCg1YtoRGB1Z );
		diffuse.w = 1.0;
		diffuse.xyz *= $newDiffuseScale.xyz * 2.0;
	}

	//---------------------------------------------------------------
	// sum everything up
	//---------------------------------------------------------------
	half3 color = light * ( specular + diffuse.xyz );

	result.color.rgb = color;
	result.color.a = 1;
}
#endtemplate

/*
==================================================================================
INTERACTION_FRAGMENT_GRAZING

Should the color of the light influence the environment color? probably.

vertex input:
	texcoord 0.xyzw	is the light projection / falloff texture coordinates
	texcoord 1.xy	is the bump / diffuse / specular texture coordinate
	texcoord 2.xyz	is the global vertex position after model matrix transform
	texcoord 3.xyz	is the normal transform 1
	texcoord 4.xyz	is the normal transform 2
	texcoord 5.xyzw	is the shadow buffer coordinates
	texcoord 6.xyz	is the normal transform 3

	in float shadow;

render parms:
	globalViewOrigin
	globalLightOrigin
==================================================================================
*/
#template INTERACTION_FRAGMENT_GRAZING( shadow )
{
	//-------- non-wrapping virtual texture lookup ------------
	float2 texcoord = fragment.texcoord1.xy;
	BRANCH if ( $useVirtualMapping.x > 0 ) {
		// this is basically only for non pre-lit levels, and shouldn't be used often.
		// this doesn't attempt to get the derivative correct at the frac crossing point
		texcoord = frac( texcoord ) * $virtualMapping.xy + $virtualMapping.zw;
	}

	float3 physCoord = VmtrVirtualToPhysical( texcoord );

	//---------------------------------------------------------------
	// load the virtual textures
	//---------------------------------------------------------------
#ifdef USE_VIRTUAL_ANISO_FOOTPRINT
	float2 dx = ddx( texcoord.xy ) * physCoord.z;
	float2 dy = ddy( texcoord.xy ) * physCoord.z;

	half4 specularPage = texPhys( $physicalVmtrPagesMap0, physCoord.xy, dx, dy );
	half4 YCoCg = texPhys( $physicalVmtrPagesMap1, physCoord.xy, dx, dy );
	half4 bumpPage = texPhys( $physicalVmtrPagesMap2, physCoord.xy, dx, dy );
#else
	half4 specularPage = texPhys( $physicalVmtrPagesMap0, physCoord.xy );
	half4 YCoCg = texPhys( $physicalVmtrPagesMap1, physCoord.xy );
	half4 bumpPage = texPhys( $physicalVmtrPagesMap2, physCoord.xy );
#endif

	specularPage.xyz = ScaleSpecular( specularPage.xyz, bumpPage.z );
	bumpPage.z = 0;

	//---------------------------------------------------------------
	// derive localNormal, then transform to a global normal
	//---------------------------------------------------------------

	float3 localNormal = float3( ( bumpPage.wy * 2.0 ) - 1.0, 0.0 );

	// derive the localNormal.z component
	localNormal.z = sqrt( abs( 1.0 - dot3( localNormal, localNormal ) ) );

	// transform into global space
	float3 globalNormal;
	globalNormal.x = dot3( localNormal, fragment.htexcoord3 );
	globalNormal.y = dot3( localNormal, fragment.htexcoord4 );
	globalNormal.z = dot3( localNormal, fragment.htexcoord6 );
	globalNormal = normalize( globalNormal );

	//---------------------------------------------------------------
	// normalize the directions to the light and viewer
	//---------------------------------------------------------------
	float3 toLight = normalize( $globalLightOrigin.xyz - fragment.texcoord2.xyz );
	float3 toViewer = normalize( $globalViewOrigin.xyz - fragment.texcoord2.xyz );

	//---------------------------------------------------------------
	// Incoming light color is the product of two light projection
	// texture maps, the light color parameter, the dor with the surface
	// normal, and the faded shadow factor
	// optimize: if we assumed one or both of the light maps are monochrome,
	// we could save some math.
	//---------------------------------------------------------------

	half3 light;
	{
		float3 lightTexCoord = fragment.htexcoord0.xyz / fragment.htexcoord0.w;

		half4 lpm = h4tex2D( $lightProjectMap, lightTexCoord.xy );
		half4 lfm = h4tex2D( $lightFalloffMap, float2( lightTexCoord.z, 0.5 ) );

		light = _float3( dot3( toLight, globalNormal ) );

		// modulate by the light projection and falloff
		light *= lpm.xyz * lfm.xyz;

		// modulate by the light color
		light *= $lightColor.xyz;

		// modulate by the shadow factor adjusted by the shadow fade
		light *= ( shadow * $shadowFade.x ) + $shadowFade.y;
	}

	half3 specular;
	{
#if 0
		//---------------------------------------------------------------
		// calculate the static specular
		//---------------------------------------------------------------

		// reflection vector = 2 * N * ( N . V ) - V
		half3 reflection;
		reflection = ( 2.0 * globalNormal * dot3( globalNormal, toLight ) ) - toLight;

		// Use the absolute value of the dot, so we get static
		// highlights on both sides of objects.  Oh, the horror! :-)
		float specularD = abs( dot3( reflection, $staticSpecularVector ) );

		// power factor is stored in bumpPage.x as 0.0 - 1.0, we want a 0 to 64 scale
		float power = bumpPage.x * 64;

		float specularStrength = $staticSpecularScale.x * pow( specularD, power );

		specular = specularStrength;
#else
		//---------------------------------------------------------------
		// sample envColor from the environment map
		//---------------------------------------------------------------

		// reflection vector = 2 * N * ( N . V ) - V
		half4 reflection;
		reflection.xyz = ( 2.0 * globalNormal * dot3( globalNormal, toViewer ) ) - toViewer;

		// power factor is stored in bumpPage.x as 0.0 - 1.0, we want a 0 | 1 | 2 | 3 mip value
		// we could probably skip the floor, but I am wary of hardware / api rounding
		// the artists really prefer white to be shiny instead of dull, so invert it here
		reflection.w = floor( ( 1.0 - bumpPage.x ) * 4.0 + $newPowerScale.x );

		half3 envColor = texCUBElod( $dynamicEnvMap, reflection ).xyz;

		specular = envColor * $newSpecularScale.xyz;
#endif
	}

	//---------------------------------------------------------------
	// covert the diffuse from YCoCg
	//---------------------------------------------------------------
	half4 diffuse;
	{
		YCoCg.z = ( YCoCg.z * 31.875 ) + 1.0;			//z = z * 255.0/8.0 + 1.0
		YCoCg.z = 1.0 / YCoCg.z;
		YCoCg.xy *= YCoCg.z;
		diffuse.x = dot4( YCoCg, matrixCoCg1YtoRGB1X );
		diffuse.y = dot4( YCoCg, matrixCoCg1YtoRGB1Y );
		diffuse.z = dot4( YCoCg, matrixCoCg1YtoRGB1Z );
		diffuse.w = 1.0;
	}

	//---------------------------------------------------------------
	// Calculate the light grazing fraction
	//---------------------------------------------------------------

	float graze = dot3( toViewer, globalNormal );
	graze = saturate( ( $viewGraze.x - graze ) / ( $viewGraze.x + 0.0001 ) );

	// The diffuse color will be a lerp between the diffuseMap and grazingDiffuseColor
	// and a modulate by the constant diffuse factor ( automatically scale newDiffuseScale
	// by 2.0 to match the baked-in behavior )
	half3 grazingDiffuse  = lerp( diffuse.xyz,  $grazingDiffuseColor.xyz,  graze );
	half3 grazingSpecular = lerp( specularPage.xyz, $grazingSpecularColor.xyz, graze );

	half3 color = light * ( specular * grazingSpecular + grazingDiffuse * $newDiffuseScale.xyz * 2.0 );

	result.color.rgb = color;
	result.color.a = 1;
}
#endtemplate

/*
==================================================================================
INTERACTION_FRAGMENT_SIMPLE

Should the color of the light influence the environment color? probably.

vertex input:
	texcoord 0.xyzw	is the light projection / falloff texture coordinates
	texcoord 1.xy	is the bump / diffuse / specular texture coordinate
	texcoord 2.xyz	is the global vertex position after model matrix transform
	texcoord 3.xyz	is the normal transform 1
	texcoord 4.xyz	is the normal transform 2
	texcoord 5.xyzw	is the shadow buffer coordinates
	texcoord 6.xyz	is the normal transform 3

	in float shadow;

render parms:
	globalViewOrigin
	globalLightOrigin
==================================================================================
*/
#template INTERACTION_FRAGMENT_SIMPLE( shadow )
{
	//-------- non-wrapping virtual texture lookup ------------
	float2 texcoord = fragment.texcoord1.xy;
	BRANCH if ( $useVirtualMapping.x > 0 ) {
		// this is basically only for non pre-lit levels, and shouldn't be used often.
		// this doesn't attempt to get the derivative correct at the frac crossing point
		texcoord = frac( texcoord ) * $virtualMapping.xy + $virtualMapping.zw;
	}

	float3 physCoord = VmtrVirtualToPhysical( texcoord );

	//---------------------------------------------------------------
	// load the virtual textures
	//---------------------------------------------------------------
#ifdef USE_VIRTUAL_ANISO_FOOTPRINT
	float2 dx = ddx( texcoord.xy ) * physCoord.z;
	float2 dy = ddy( texcoord.xy ) * physCoord.z;

	half4 specularPage = texPhys( $physicalVmtrPagesMap0, physCoord.xy, dx, dy );
	half4 YCoCg = texPhys( $physicalVmtrPagesMap1, physCoord.xy, dx, dy );
	half4 bumpPage = texPhys( $physicalVmtrPagesMap2, physCoord.xy, dx, dy );
#else
	half4 specularPage = texPhys( $physicalVmtrPagesMap0, physCoord.xy );
	half4 YCoCg = texPhys( $physicalVmtrPagesMap1, physCoord.xy );
	half4 bumpPage = texPhys( $physicalVmtrPagesMap2, physCoord.xy );
#endif

	specularPage.xyz = ScaleSpecular( specularPage.xyz, bumpPage.z );
	bumpPage.z = 0;

	//---------------------------------------------------------------
	// derive localNormal, then transform to a global normal
	//---------------------------------------------------------------

	float3 localNormal = float3( ( bumpPage.wy * 2.0 ) - 1.0, 0.0 );

	// derive the localNormal.z component
	localNormal.z = sqrt( abs( 1.0 - dot3( localNormal, localNormal ) ) );

	// transform into global space
	float3 globalNormal;
	globalNormal.x = dot3( localNormal, fragment.htexcoord3 );
	globalNormal.y = dot3( localNormal, fragment.htexcoord4 );
	globalNormal.z = dot3( localNormal, fragment.htexcoord6 );
	globalNormal = normalize( globalNormal );

	//---------------------------------------------------------------
	// normalize the directions to the light and viewer
	//---------------------------------------------------------------
	float3 toLight = normalize( $globalLightOrigin.xyz - fragment.texcoord2.xyz );
	float3 toViewer = normalize( $globalViewOrigin.xyz - fragment.texcoord2.xyz );

	//---------------------------------------------------------------
	// Incoming light color is the product of two light projection
	// texture maps, the light color parameter, the dor with the surface
	// normal, and the faded shadow factor
	// optimize: if we assumed one or both of the light maps are monochrome,
	// we could save some math.
	//---------------------------------------------------------------

	half3 light;
	{
		float3 lightTexCoord = fragment.htexcoord0.xyz / fragment.htexcoord0.w;

		half4 lpm = h4tex2D( $lightProjectMap, lightTexCoord.xy );
		half4 lfm = h4tex2D( $lightFalloffMap, float2( lightTexCoord.z, 0.5 ) );

		light = _float3( dot3( toLight, globalNormal ) );

		// modulate by the light projection and falloff
		light *= lpm.xyz * lfm.xyz;

		// modulate by the light color
		light *= $lightColor.xyz;

		// modulate by the shadow factor adjusted by the shadow fade
		light *= ( shadow * $shadowFade.x ) + $shadowFade.y;
	}

	//---------------------------------------------------------------
	// sample envColor from the environment map
	//---------------------------------------------------------------

	half3 specular;
	{
		// reflection vector = 2 * N * ( N . V ) - V
		half4 reflection;
		reflection.xyz = ( 2.0 * globalNormal * dot3( globalNormal, toViewer ) ) - toViewer;

		// power factor is stored in bumpPage.x as 0.0 - 1.0, we want a 0 | 1 | 2 | 3 mip value
		// we could probably skip the floor, but I am wary of hardware / api rounding
		// the artists really prefer white to be shinny instead of dull, so invert it here
		reflection.w = floor( ( 1.0 - bumpPage.x ) * 4.0 + $newPowerScale.x );

		half3 envColor = texCUBElod( $dynamicEnvMap, reflection ).xyz;

		specular = envColor * specularPage.xyz * $newSpecularScale.xyz;
	}

	half3 diffuse = _float3( 1.0f );

	half3 color = light * ( specular + diffuse );

	result.color.xyz = color;
	result.color.w = 1.0f;
}
#endtemplate

/*
==================================================================================
INTERACTION_FRAGMENT_EYE

For the cornea sclera we scale the diffuse towards black using the alpha so that
the hole into the iris doesn't give off any diffuse color.
We do keep the specular as is since we want the rounded glass shape the eye over
the actual iris rendered underneath.

Should the color of the light influence the environment color? probably.

vertex input:
	texcoord 0.xyzw	is the light projection / falloff texture coordinates
	texcoord 1.xy	is the bump / diffuse / specular texture coordinate
	texcoord 2.xyz	is the global vertex position after model matrix transform
	texcoord 3.xyz	is the normal transform 1
	texcoord 4.xyz	is the normal transform 2
	texcoord 5.xyzw	is the shadow buffer coordinates
	texcoord 6.xyz	is the normal transform 3

	in float shadow;

render parms:
	globalViewOrigin
	globalLightOrigin
==================================================================================
*/
#template INTERACTION_FRAGMENT_EYE( shadow )
{
	half power = 1.0;

	half4 sampleDiffuse = tex2D( $spareDiffuseMap, fragment.texcoord1.xy );
	half4 sampleSpecular = tex2D( $spareSpecularMap, fragment.texcoord1.xy );
	half4 sampleBump = tex2D( $spareBumpMap, fragment.texcoord1.xy );
	
	//---------------------------------------------------------------
	// derive localNormal, then transform to a global normal
	//---------------------------------------------------------------

	half3 localNormal = half3( ( sampleBump.wy * 2.0 ) - 1.0, 0.0 );

	// derive the localNormal.z component
	localNormal.z = sqrt( abs( 1.0 - dot3( localNormal, localNormal ) ) );
	
	// transform into global space
	half3 globalNormal;
	globalNormal.x = dot3( localNormal, fragment.htexcoord3 );
	globalNormal.y = dot3( localNormal, fragment.htexcoord4 );
	globalNormal.z = dot3( localNormal, fragment.htexcoord6 );
	globalNormal = normalize( globalNormal );

	//---------------------------------------------------------------
	// normalize the directions to the light and viewer
	//---------------------------------------------------------------
	half3 toLight = normalize( $globalLightOrigin.xyz - fragment.texcoord2.xyz );
	half3 toViewer = normalize( $globalViewOrigin.xyz - fragment.texcoord2.xyz );

	//---------------------------------------------------------------
	// Incoming light color is the product of two light projection
	// texture maps, the light color parameter, the dor with the surface
	// normal, and the faded shadow factor
	// optimize: if we assumed one or both of the light maps are monochrome,
	// we could save some math.
	//---------------------------------------------------------------

	half3 light;
	{
		half3 lightTexCoord = fragment.htexcoord0.xyz / fragment.htexcoord0.w;

		half4 lpm = h4tex2D( $lightProjectMap, lightTexCoord.xy );
		half4 lfm = h4tex2D( $lightFalloffMap, half2( lightTexCoord.z, 0.5 ) );

		light = _half3( saturate( dot3( toLight, globalNormal ) + 0.1 ) );

		// modulate by the light projection and falloff
		light *= lpm.xyz * lfm.xyz;

		// modulate by the light color
		light *= $lightColor.xyz;

		// modulate by the shadow factor adjusted by the shadow fade
		light *= ( shadow * $shadowFade.x ) + $shadowFade.y;
	}

	half3 specular;
	{
		//---------------------------------------------------------------
		// sample envColor from the environment map
		//---------------------------------------------------------------

		// reflection vector = 2 * N * ( N . V ) - V
		half4 reflection;
		reflection.xyz = ( 2.0 * globalNormal * dot3( globalNormal, toViewer ) ) - toViewer;

		// power factor is stored in ________ as 0.0 - 1.0, we want a 0 | 1 | 2 | 3 mip value
		// we could probably skip the floor, but I am wary of hardware / api rounding
		// the artists really prefer white to be shiny instead of dull, so invert it here
		reflection.w = floor( ( 1.0 - power ) * 4.0 + $newPowerScale.x );

		half3 envColor = texCUBElod( $dynamicEnvMap, reflection ).xyz;

		specular = envColor * sampleSpecular.xyz * $newSpecularScale.xyz;
	}
	
	{
		half3 toCameraLight = normalize( toViewer + half3( 0.0, 0.0, 6.5 ) );
		half coss = saturate( dot3( globalNormal, toCameraLight ) );
		specular += _half3( saturate( pow( coss, $eyeHighlightPowLevel.x ) * $eyeHighlightPowLevel.y ) );
	}
	
	half3 diffuse = sampleDiffuse.xyz;
	
	// Scale diffuse so that we get black where the iris is supposed to be.
	diffuse *= _half3( saturate( ceil( sampleDiffuse.w - 0.5 ) ) );
	
	half3 color = light * ( diffuse + specular );
	
	result.color.xyz = color;
	result.color.w = 1;
}
#endtemplate


/*
==================================================================================
INTERACTION_FRAGMENT_SKIN

Should the color of the light influence the environment color? probably.

vertex input:
	texcoord 0.xyzw	is the light projection / falloff texture coordinates
	texcoord 1.xy	is the bump / diffuse-bump / diffuse / specular / ambient-occlusion texture coordinate
	texcoord 2.xyz	is the global vertex position after model matrix transform
	texcoord 3.xyz	is the normal transform 1
	texcoord 4.xyz	is the normal transform 2
	texcoord 5.xyzw	is the shadow buffer coordinates
	texcoord 6.xyz	is the normal transform 3

	in float shadow;

render parms:
	globalViewOrigin
	globalLightOrigin
==================================================================================
*/
#template INTERACTION_FRAGMENT_SKIN( shadow )
{
	//-------- non-wrapping virtual texture lookup ------------
	half2 texcoord = fragment.texcoord1.xy;
	BRANCH if ( $useVirtualMapping.x > 0 ) {
		// this is basically only for non pre-lit levels, and shouldn't be used often.
		// this doesn't attempt to get the derivative correct at the frac crossing point
		texcoord = frac( texcoord ) * $virtualMapping.xy + $virtualMapping.zw;
	}

	half3 physCoord = VmtrVirtualToPhysical( texcoord );

	//---------------------------------------------------------------
	// load the virtual textures
	//---------------------------------------------------------------
#ifdef USE_VIRTUAL_ANISO_FOOTPRINT
	half2 dx = ddx( texcoord.xy ) * physCoord.z;
	half2 dy = ddy( texcoord.xy ) * physCoord.z;

	half4 sampleSpecular = texPhys( $physicalVmtrPagesMap0, physCoord.xy, dx, dy );
	half4 sampleYCoCg = texPhys( $physicalVmtrPagesMap1, physCoord.xy, dx, dy );
	half4 sampleSpecularNormal = texPhys( $physicalVmtrPagesMap2, physCoord.xy, dx, dy );
#else
	half4 sampleSpecular = texPhys( $physicalVmtrPagesMap0, physCoord.xy );
	half4 sampleYCoCg = texPhys( $physicalVmtrPagesMap1, physCoord.xy );
	half4 sampleSpecularNormal = texPhys( $physicalVmtrPagesMap2, physCoord.xy );
#endif

	//---------------------------------------------------------------
	// load the diffuse normal and ambient occlusion
	//---------------------------------------------------------------
	half4 sampleDiffuseNormal = tex2D( $spareBumpMap, fragment.texcoord1.xy );
	half4 sampleAmbientOcclusion = tex2D( $transMap, fragment.texcoord1.xy );
	
	float occlusionRes;
	half4 bumpRes;
#ifdef INTERWRINKLE
	SAMPLE_WRINKLEMAPS( occlusionRes, bumpRes, sampleAmbientOcclusion, sampleDiffuseNormal, fragment.texcoord1 );
#else //INTERWRINKLE
	occlusionRes = sampleAmbientOcclusion.g;
	bumpRes = sampleDiffuseNormal;
#endif //INTERWRINKLE
	
	//---------------------------------------------------------------
	// convert the diffuse from YCoCg
	//---------------------------------------------------------------
	half4 surfaceDiffuse;
	{
		sampleYCoCg.z = ( sampleYCoCg.z * 31.875 ) + 1.0;			//z = z * 255.0/8.0 + 1.0
		sampleYCoCg.z = 1.0 / sampleYCoCg.z;
		sampleYCoCg.xy *= sampleYCoCg.z;
		surfaceDiffuse.x = dot4( sampleYCoCg, matrixCoCg1YtoRGB1X );
		surfaceDiffuse.y = dot4( sampleYCoCg, matrixCoCg1YtoRGB1Y );
		surfaceDiffuse.z = dot4( sampleYCoCg, matrixCoCg1YtoRGB1Z );
		surfaceDiffuse.w = 1.0;
	}

	//---------------------------------------------------------------
	// scale specular
	//---------------------------------------------------------------
	half3 surfaceSpecular;
	{
		surfaceSpecular.xyz = ScaleSpecular( sampleSpecular.xyz, sampleSpecularNormal.z );
		sampleSpecularNormal.z = 0;
	}

	//---------------------------------------------------------------
	// calculate global diffuse normal
	//---------------------------------------------------------------
	half3 globalDiffuseNormal;
	{
		half3 localNormal = half3( ( bumpRes.wy * 2.0 ) - 1.0, 0.0 );
		localNormal.z = sqrt( abs( 1.0 - dot3( localNormal, localNormal ) ) );
		
		globalDiffuseNormal.x = dot3( localNormal, fragment.htexcoord3 );
		globalDiffuseNormal.y = dot3( localNormal, fragment.htexcoord4 );
		globalDiffuseNormal.z = dot3( localNormal, fragment.htexcoord6 );
		globalDiffuseNormal = normalize( globalDiffuseNormal );
	}
	
	//---------------------------------------------------------------
	// calculate global specular normal
	//---------------------------------------------------------------
	half3 globalSpecularNormal;
	{
		half3 localNormal = half3( ( sampleSpecularNormal.wy * 2.0 ) - 1.0, 0.0 );
		localNormal.z = sqrt( abs( 1.0 - dot3( localNormal, localNormal ) ) );
		
		globalSpecularNormal.x = dot3( localNormal, fragment.htexcoord3 );
		globalSpecularNormal.y = dot3( localNormal, fragment.htexcoord4 );
		globalSpecularNormal.z = dot3( localNormal, fragment.htexcoord6 );
		globalSpecularNormal = normalize( globalSpecularNormal );
	}
	
	//---------------------------------------------------------------
	// normalize the directions to the light and viewer
	//---------------------------------------------------------------
	half3 toLight = normalize( $globalLightOrigin.xyz - fragment.texcoord2.xyz );
	half3 toViewer = normalize( $globalViewOrigin.xyz - fragment.texcoord2.xyz );

	//---------------------------------------------------------------
	// calculate and apply the diffuse light grazing
	//---------------------------------------------------------------
	{
		half grazeDiffuse = dot3( toViewer, globalDiffuseNormal );
		grazeDiffuse = saturate( ( $viewGraze.x - max( grazeDiffuse, -grazeDiffuse ) ) / max( $viewGraze.x, 0.0001 ) );
		surfaceDiffuse.xyz = lerp( surfaceDiffuse.xyz, $grazingDiffuseColor.xyz, grazeDiffuse );
	}
	
	//---------------------------------------------------------------
	// calculate and apply the specular light grazing
	//---------------------------------------------------------------
	{
		half grazeSpecular = dot3( toViewer, globalSpecularNormal );
		grazeSpecular = saturate( ( $viewGraze.x - max( grazeSpecular, -grazeSpecular ) ) / max( $viewGraze.x, 0.0001 ) );
		surfaceSpecular.xyz = lerp( surfaceSpecular.xyz, $grazingSpecularColor.xyz, grazeSpecular );
	}
	
	//---------------------------------------------------------------
	// apply specular reflection
	//---------------------------------------------------------------
	{
		// reflection vector = 2 * N * ( N . V ) - V
		half4 reflection;
		reflection.xyz = ( 2.0 * globalSpecularNormal * dot3( globalSpecularNormal, toViewer ) ) - toViewer;

		// power factor is stored in sampleSpecularNormal.x as 0.0 - 1.0, we want a 0 | 1 | 2 | 3 mip value
		// we could probably skip the floor, but I am wary of hardware / api rounding
		// the artists really prefer white to be shiny instead of dull, so invert it here
		reflection.w = floor( ( 1.0 - sampleSpecularNormal.x ) * 4.0 + $newPowerScale.x );

		// sample envColor from the environment map
		half3 envColor = texCUBElod( $dynamicEnvMap, reflection ).xyz;

		// apply
		surfaceSpecular *= envColor;
	}

	//---------------------------------------------------------------
	// diffuse light is the dot between the diffuse surface normal and the light,
	// this is then used to lookup a warp value in a texture
	//---------------------------------------------------------------
	half3 diffuseLight;
	{
		// pw-note: I get super weird artifacts on edges if I don't clamp them down, probably texture filtering? :(
		//			it's weird I don't get them in the skinVmtr programs though (?)
		half cosd = max( min( dot3( toLight, globalDiffuseNormal ) * 0.5 + 0.5, 0.99 ), 0.01 );
		half3 diffuseWarp = tex2D( $textureMap, half2( cosd, 0.0 ) ).xyz;

		diffuseLight = diffuseWarp;
	}
	
	//---------------------------------------------------------------
	// specular light is the dot between the specular surface normal and the light
	//---------------------------------------------------------------
	half3 specularLight;
	{
		half coss = saturate( dot3( toLight, globalSpecularNormal ) );
		specularLight = _half3( coss );
	}
	
	//---------------------------------------------------------------
	// Incoming light color is the product of two light projection
	// texture maps, the light color parameter and the faded shadow factor
	// optimize: if we assumed one or both of the light maps are monochrome,
	// we could save some math.
	//---------------------------------------------------------------
	half3 lightColor;
	{
		half3 lightTexCoord = fragment.htexcoord0.xyz / fragment.htexcoord0.w;
		half4 lpm = h4tex2D( $lightProjectMap, lightTexCoord.xy );
		half4 lfm = h4tex2D( $lightFalloffMap, half2( lightTexCoord.z, 0.5 ) );
		
		// Modulate with ambient occlusion (this is not really correct)
		lightColor = _float3( occlusionRes );
		
		// modulate by the light projection and falloff
		lightColor *= lpm.xyz * lfm.xyz;

		// modulate by the light color
		lightColor *= $lightColor.xyz;

		// modulate by the shadow factor adjusted by the shadow fade
		lightColor *= ( shadow * $shadowFade.x ) + $shadowFade.y;
	}
	
	//---------------------------------------------------------------
	// apply light scale on diffuse and specular
	//---------------------------------------------------------------
	{
		diffuseLight *= lightColor;
		specularLight *= lightColor;
	}
	
	//---------------------------------------------------------------
	// apply diffuse and specular scales
	//---------------------------------------------------------------
	{
		surfaceDiffuse.xyz *= $newDiffuseScale.xyz * 2.0;
		surfaceSpecular.xyz *= $newSpecularScale.xyz;
	}
	
	//---------------------------------------------------------------
	// sum everything up
	//---------------------------------------------------------------
	half3 color = _half3( 0.0 );
	color += specularLight * surfaceSpecular.xyz;
	color += diffuseLight * surfaceDiffuse.xyz;

	result.color.rgb = color;
	result.color.a = 1;
}
#endtemplate

/*
==================================================================================
INTERACTION_FRAGMENT_HAIR

Should the color of the light influence the environment color? probably.

vertex input:
	texcoord 0.xyzw	is the light projection / falloff texture coordinates
	texcoord 1.xy	is the bump / diffuse / specular texture coordinate
	texcoord 2.xyz	is the global vertex position after model matrix transform
	texcoord 3.xyz	is the normal transform 1
	texcoord 4.xyz	is the normal transform 2
	texcoord 5.xyzw	is the shadow buffer coordinates
	texcoord 6.xyz	is the normal transform 3

	in float shadow;

render parms:
	globalViewOrigin
	globalLightOrigin
==================================================================================
*/
#template INTERACTION_FRAGMENT_HAIR( shadow )
{
	float2 texcoord2 = fragment.texcoord7.xy;

	//---------------------------------------------------------------
	// load the coverage and clip pixel if not visible
	//---------------------------------------------------------------
	half4 coverage;
	{
		coverage = tex2D( $transMap, texcoord2 );
	}
	clip( coverage.w - 0.25 );
	
	//-------- non-wrapping virtual texture lookup ------------
	float2 texcoord = fragment.texcoord1.xy;
	BRANCH if ( $useVirtualMapping.x > 0 ) {
		// this is basically only for non pre-lit levels, and shouldn't be used often.
		// this doesn't attempt to get the derivative correct at the frac crossing point
		texcoord = frac( texcoord ) * $virtualMapping.xy + $virtualMapping.zw;
	}

	float3 physCoord = VmtrVirtualToPhysical( texcoord );

	//---------------------------------------------------------------
	// load the virtual textures
	//---------------------------------------------------------------
#ifdef USE_VIRTUAL_ANISO_FOOTPRINT
	float2 dx = ddx( texcoord.xy ) * physCoord.z;
	float2 dy = ddy( texcoord.xy ) * physCoord.z;

	half4 specularPage = texPhys( $physicalVmtrPagesMap0, physCoord.xy, dx, dy );
	half4 YCoCg = texPhys( $physicalVmtrPagesMap1, physCoord.xy, dx, dy );
	half4 bumpPage = texPhys( $physicalVmtrPagesMap2, physCoord.xy, dx, dy );
#else
	half4 specularPage = texPhys( $physicalVmtrPagesMap0, physCoord.xy );
	half4 YCoCg = texPhys( $physicalVmtrPagesMap1, physCoord.xy );
	half4 bumpPage = texPhys( $physicalVmtrPagesMap2, physCoord.xy );
#endif

	specularPage.xyz = ScaleSpecular( specularPage.xyz, bumpPage.z );
	bumpPage.z = 0;

	//---------------------------------------------------------------
	// derive localNormal, then transform to a global normal
	//---------------------------------------------------------------

	float3 localNormal = float3( ( bumpPage.wy * 2.0 ) - 1.0, 0.0 );

	// derive the localNormal.z component
	localNormal.z = sqrt( abs( 1.0 - dot3( localNormal, localNormal ) ) );

	// transform into global space
	float3 globalNormal;
	globalNormal.x = dot3( localNormal, fragment.htexcoord3 );
	globalNormal.y = dot3( localNormal, fragment.htexcoord4 );
	globalNormal.z = dot3( localNormal, fragment.htexcoord6 );
	globalNormal = normalize( globalNormal );

	//---------------------------------------------------------------
	// normalize the directions to the light and viewer
	//---------------------------------------------------------------
	float3 toLight = normalize( $globalLightOrigin.xyz - fragment.texcoord2.xyz );
	float3 toViewer = normalize( $globalViewOrigin.xyz - fragment.texcoord2.xyz );

	//---------------------------------------------------------------
	// Incoming light color is the product of two light projection
	// texture maps, the light color parameter, the dor with the surface
	// normal, and the faded shadow factor
	// optimize: if we assumed one or both of the light maps are monochrome,
	// we could save some math.
	//---------------------------------------------------------------

	half3 light;
	{
		float3 lightTexCoord = fragment.htexcoord0.xyz / fragment.htexcoord0.w;

		half4 lpm = h4tex2D( $lightProjectMap, lightTexCoord.xy );
		half4 lfm = h4tex2D( $lightFalloffMap, float2( lightTexCoord.z, 0.5 ) );

		light = _float3( dot3( toLight, globalNormal ) );

		// modulate by the light projection and falloff
		light *= lpm.xyz * lfm.xyz;

		// modulate by the light color
		light *= $lightColor.xyz;

		// modulate by the shadow factor adjusted by the shadow fade
		light *= ( shadow * $shadowFade.x ) + $shadowFade.y;
	}

	half3 specular;
	{
		//---------------------------------------------------------------
		// sample envColor from the environment map
		//---------------------------------------------------------------

		// reflection vector = 2 * N * ( N . V ) - V
		half4 reflection;
		reflection.xyz = ( 2.0 * globalNormal * dot3( globalNormal, toViewer ) ) - toViewer;

		// power factor is stored in bumpPage.x as 0.0 - 1.0, we want a 0 | 1 | 2 | 3 mip value
		// we could probably skip the floor, but I am wary of hardware / api rounding
		// the artists really prefer white to be shiny instead of dull, so invert it here
		reflection.w = floor( ( 1.0 - bumpPage.x ) * 4.0 + $newPowerScale.x );

		half3 envColor = texCUBElod( $dynamicEnvMap, reflection ).xyz;

		specular = envColor * specularPage.xyz * $newSpecularScale.xyz;
	}

	//---------------------------------------------------------------
	// covert the diffuse from YCoCg
	//---------------------------------------------------------------
	half4 diffuse;
	{
		YCoCg.z = ( YCoCg.z * 31.875 ) + 1.0;			//z = z * 255.0/8.0 + 1.0
		YCoCg.z = 1.0 / YCoCg.z;
		YCoCg.xy *= YCoCg.z;
		diffuse.x = dot4( YCoCg, matrixCoCg1YtoRGB1X );
		diffuse.y = dot4( YCoCg, matrixCoCg1YtoRGB1Y );
		diffuse.z = dot4( YCoCg, matrixCoCg1YtoRGB1Z );
		diffuse.w = 1.0;
		diffuse.xyz *= $newDiffuseScale.xyz * 2.0;
	}
	
	//---------------------------------------------------------------
	// sum everything up
	//---------------------------------------------------------------
	half3 color = light * ( specular + diffuse.xyz );
	
	result.color.rgb = color;
	result.color.a = 1;
}
#endtemplate

/*
==================================================================================
INTERACTION_FRAGMENT_BASIC_NOVMTR

Should the color of the light influence the environment color? probably.

vertex input:
	texcoord 0.xyzw	is the light projection / falloff texture coordinates
	texcoord 1.xy	is the bump / diffuse / specular texture coordinate
	texcoord 2.xyz	is the global vertex position after model matrix transform
	texcoord 3.xyz	is the normal transform 1
	texcoord 4.xyz	is the normal transform 2
	texcoord 5.xyzw	is the shadow buffer coordinates
	texcoord 6.xyz	is the normal transform 3

	in float shadow;

render parms:
	globalViewOrigin
	globalLightOrigin
==================================================================================
*/
#template INTERACTION_FRAGMENT_BASIC_NOVMTR( shadow )
{
	float2 texcoord = fragment.texcoord1.xy;

	//---------------------------------------------------------------
	// sample diffuse, bump, specular textures
	//---------------------------------------------------------------
	half4 sampleDiffuse = tex2D( $spareDiffuseMap, texcoord );
	half4 sampleSpecular = tex2D( $spareSpecularMap, texcoord );
	half4 sampleBump = tex2D( $spareBumpMap, texcoord );
	
	//---------------------------------------------------------------
	// sample morph diffuse, bump, specular textures and interpolate
	//---------------------------------------------------------------

	BRANCH if ( $useSkinBlending.x > 0.0 ) {	// fragment.htexcoord3.w > 0.0
		half4 sampleDiffuse2 = tex2D( $spareDiffuseMap2, texcoord );
		half4 sampleSpecular2 = tex2D( $spareSpecularMap2, texcoord );
		half4 sampleBump2 = tex2D( $spareBumpMap2, texcoord );

		half morphScale = fragment.htexcoord3.w;
		sampleDiffuse = lerp( sampleDiffuse, sampleDiffuse2, morphScale );
		sampleSpecular = lerp( sampleSpecular, sampleSpecular2, morphScale );
		sampleBump = lerp( sampleBump, sampleBump2, morphScale );
	}

	//---------------------------------------------------------------
	// derive localNormal, then transform to a global normal
	//---------------------------------------------------------------

	float3 localNormal = float3( ( sampleBump.wy * 2.0 ) - 1.0, 0.0 );

	// derive the localNormal.z component
	localNormal.z = sqrt( abs( 1.0 - dot3( localNormal, localNormal ) ) );

	// transform into global space
	float3 globalNormal;
	globalNormal.x = dot3( localNormal, fragment.htexcoord3 );
	globalNormal.y = dot3( localNormal, fragment.htexcoord4 );
	globalNormal.z = dot3( localNormal, fragment.htexcoord6 );
	globalNormal = normalize( globalNormal );

	//---------------------------------------------------------------
	// normalize the directions to the light and viewer
	//---------------------------------------------------------------
	float3 toLight = normalize( $globalLightOrigin.xyz - fragment.texcoord2.xyz );
	float3 toViewer = normalize( $globalViewOrigin.xyz - fragment.texcoord2.xyz );

	//---------------------------------------------------------------
	// Incoming light color is the product of two light projection
	// texture maps, the light color parameter, the dor with the surface
	// normal, and the faded shadow factor
	// optimize: if we assumed one or both of the light maps are monochrome,
	// we could save some math.
	//---------------------------------------------------------------

	half3 light;
	{
		float3 lightTexCoord = fragment.htexcoord0.xyz / fragment.htexcoord0.w;

		half4 lpm = h4tex2D( $lightProjectMap, lightTexCoord.xy );
		half4 lfm = h4tex2D( $lightFalloffMap, float2( lightTexCoord.z, 0.5 ) );

		light = _float3( dot3( toLight, globalNormal ) );

		// modulate by the light projection and falloff
		light *= lpm.xyz * lfm.xyz;

		// modulate by the light color
		light *= $lightColor.xyz;

		// modulate by the shadow factor adjusted by the shadow fade
		light *= ( shadow * $shadowFade.x ) + $shadowFade.y;
	}

	half3 specular;
	half power = 1.0;
	{
#if 0
		//---------------------------------------------------------------
		// calculate the static specular at this point
		//---------------------------------------------------------------

		// reflection vector = 2 * N * ( N . V ) - V
		half3 reflection;
		reflection = ( 2.0 * globalNormal * dot3( globalNormal, toLight ) ) - toLight;

		// Use the absolute value of the dot, so we get static
		// highlights on both sides of objects.  Oh, the horror! :-)
		float specularD = abs( dot3( reflection, $staticSpecularVector ) );

		// power factor is stored in __________ as 0.0 - 1.0, we want a 0 to 64 scale
		float factor = power * 64;

		float specularStrength = $staticSpecularScale.x * pow( specularD, factor );

		specular = specularStrength;
#else
		//---------------------------------------------------------------
		// sample envColor from the environment map
		//---------------------------------------------------------------

		// reflection vector = 2 * N * ( N . V ) - V
		half4 reflection;
		reflection.xyz = ( 2.0 * globalNormal * dot3( globalNormal, toViewer ) ) - toViewer;

		// power factor is stored in __________ as 0.0 - 1.0, we want a 0 | 1 | 2 | 3 mip value
		// we could probably skip the floor, but I am wary of hardware / api rounding
		// the artists really prefer white to be shiny instead of dull, so invert it here
		reflection.w = floor( ( 1.0 - power ) * 4.0 + $newPowerScale.x );

		half3 envColor = texCUBElod( $dynamicEnvMap, reflection ).xyz;

		specular = envColor * sampleSpecular.xyz * $newSpecularScale.xyz;
#endif
	}

	//---------------------------------------------------------------
	// scale the diffuse from texture sample
	//---------------------------------------------------------------
	half4 diffuse;
	{
		diffuse.xyz = sampleDiffuse.xyz * $newDiffuseScale.xyz * 2.0;
		diffuse.w = 1.0;
	}

	//---------------------------------------------------------------
	// sum everything up
	//---------------------------------------------------------------
	half3 color = light * ( specular + diffuse.xyz );

	result.color.rgb = color;
	result.color.a = 1;
}
#endtemplate