Revise paste 86bc4964912d8

void CalculateEmissiveContribution(inout SurfaceProperties surfaceInfo)
{
#if EMISSIVE || EMISSIVE_ADDITIVE
	surfaceInfo.surface_emissiveIntensity = emissiveMultiplier * 
											surfaceInfo.surface_diffuseColor.a * 
											gEmissiveScale;

#if EMISSIVE_NIGHTONLY
		surfaceInfo.surface_emissiveIntensity *= gDayNightEffects;
	#endif
#else
	surfaceInfo.surface_emissiveIntensity = 0.0;
#endif
}

// ----------------------------------------------------------------------------------------------- //
#define MIN_NUM_OF_PXM_STEPS 8
#define MAX_NUM_OF_PXM_STEPS 30

SurfaceProperties GetSurfaceProperties(	float4			IN_baseColor,
#if PALETTE_TINT
										float4			IN_baseColorTint,
#endif
#if DIFFUSE_TEXTURE
										float2			IN_diffuseTexCoord,
										sampler2D		IN_diffuseSampler,
#endif
#if DIFFUSE2 || DIFFUSE3 || OVERLAY_DIFFUSE2
										float2			IN_diffuseTexCoord2,
										sampler2D		IN_diffuseSampler2,
#endif
#if OVERLAY_DIFFUSE2 && OVERLAY_DIFFUSE2_SEPARATE_ALPHA_SOURCE
										float			IN_diffuse2Alpha,
#endif
#if SPEC_MAP
										float2			IN_specularTexCoord,
										sampler2D		IN_specularSampler,
#endif	// SPEC_MAP
#if REFLECT
										float3			IN_worldEyePos,
										REFLECT_SAMPLER	IN_environmentSampler,
	#if REFLECT_MIRROR
										float2			IN_mirrorTexCoord,
										float4			IN_screenPos,
	#endif // REFLECT_MIRROR
#endif // REFLECT 
#if NORMAL_MAP
										float2			IN_bumpTexCoord,
										sampler2D		IN_bumpSampler,
										float3			IN_worldTangent,
										float3			IN_worldBinormal,
	#if PARALLAX || PARALLAX_MAP_V2
		#if PARALLAX
										float3			IN_tanEyePos,
		#endif
		#if PARALLAX_MAP_V2
										float3			IN_worldEyePosPOM,
										sampler2D		IN_heightSampler,
			#if EDGE_WEIGHT
										float2			IN_edgeWeight,
			#endif // EDGE_WEIGHT
		#endif // PARALLAX_MAP_V2
	#endif //  PARALLAX || PARALLAX_MAP_V2
#endif	// NORMAL_MAP
#if NORMAL_MAP2
										float2			IN_bumpTexCoord2,
										sampler2D		IN_bumpSampler2,
										float3			IN_worldTangent2,
										float3			IN_worldBinormal2,
#endif	// NORMAL_MAP2
#if DIRT_NORMALMAP
										float3			IN_dirtBumpUV,		// xy = UV, z = dirtLevel
										sampler2D		IN_dirtBumpSampler,
#endif//DIRT_NORMALMAP...
#if DETAIL_UV
										float2			IN_detailUV,
#endif //DETAIL_UV...
										float3			IN_worldNormal
						)
{
	SurfaceProperties OUT = (SurfaceProperties)0;

OUT.surface_baseColor		= IN_baseColor;

#if PALETTE_TINT
	OUT.surface_baseColorTint	= IN_baseColorTint;
#endif

#if DIFFUSE2 || DIFFUSE3 || OVERLAY_DIFFUSE2
	OUT.surface_overlayColor = tex2D(IN_diffuseSampler2, IN_diffuseTexCoord2);	
#if OVERLAY_DIFFUSE2_SEPARATE_ALPHA_SOURCE
	OUT.surface_overlayColor.a = IN_diffuse2Alpha;
#endif // OVERLAY_DIFFUSE2_SEPARATE_ALPHA_SOURCE
#endif	// DIFFUSE2

#if PARALLAX
	float2 outTexCoord;
	float3 parallaxPackedNormalHeight = CalculateParallax(
		IN_tanEyePos, 
		tex2D_NormalHeightMap(IN_bumpSampler, IN_bumpTexCoord.xy), 
		IN_diffuseTexCoord, 
		IN_bumpTexCoord, 
		IN_bumpSampler, 
		outTexCoord).xyz;
	IN_diffuseTexCoord = outTexCoord;
#endif // NORMAL_MAP

#if PARALLAX_MAP_V2 && __SHADERMODEL >= 40
#if EDGE_WEIGHT
	float edgeWeight = 1.0f - clamp(IN_edgeWeight.x, 0.0f, 1.0f);
	float zLimit = clamp(1.0f - IN_edgeWeight.y, 0.1f, 1.0f);
#else
	float edgeWeight = 1.0f;
	float zLimit = 0.1f;
#endif

if(POMDisable == 0)
	{
		float3 tanEyePos;

tanEyePos.x = dot(IN_worldTangent.xyz, IN_worldEyePosPOM.xyz);
		tanEyePos.y = dot(IN_worldBinormal.xyz, IN_worldEyePosPOM.xyz);
		tanEyePos.z = dot(IN_worldNormal.xyz,	IN_worldEyePosPOM.xyz);

tanEyePos = normalize(tanEyePos);
		float clampedZ = max(zLimit, tanEyePos.z);
		
		float VdotN = abs(dot(normalize(IN_worldEyePosPOM.xyz), normalize(IN_worldNormal.xyz)));
		float numberOfSteps = lerp(POMMaxSteps, POMMinSteps, VdotN);

float globalScale = globalHeightScale * edgeWeight * saturate(numberOfSteps - 1.0f) * saturate(VdotN / POMVDotNBlendFactor);

float2 maxParallaxOffset = (-tanEyePos.xy / clampedZ) * heightScale * globalScale;
		float2 heightBiasOffset = (tanEyePos.xy / clampedZ) * heightBias * globalScale;

float height = TraceHeight(IN_heightSampler, IN_diffuseTexCoord, maxParallaxOffset, heightBiasOffset, numberOfSteps).r;
		float2 textCoordOffset = heightBiasOffset + (maxParallaxOffset * (1.0f - height));

IN_diffuseTexCoord += textCoordOffset;
		IN_bumpTexCoord += textCoordOffset;
#if SPEC_MAP
		IN_specularTexCoord += textCoordOffset;
#endif // SPEC_MAP	
	}
#endif // PARALLAX_MAP_V2 && __SHADERMODEL >= 40

#if DIFFUSE_TEXTURE
		float4 diffuseColor = tex2D(IN_diffuseSampler, IN_diffuseTexCoord);
	#else
		float4 diffuseColor = float4(1.0, 1.0, 1.0, 1.0);
	#endif
	OUT.surface_diffuseColor = calculateDiffuseColor(diffuseColor);
	
#ifdef USE_DETAIL_MAP
	float detailInten=1.f;
	#if DETAIL_USE_SPEC_ALPHA_AS_CONTROL && SPECULAR && SPEC_MAP	
		detailInten = tex2D(IN_specularSampler, IN_specularTexCoord.xy).w;
	#endif

#if DETAIL_UV
		float2 detailUV	= IN_detailUV.xy;
	#elif DIRT_NORMALMAP
		float2 detailUV = IN_dirtBumpUV.xy;	
	#else
		float2 detailUV = IN_diffuseTexCoord.xy;
	#endif
	float3 detailBumpAndIntensity = GetDetailBumpAndIntensity(  detailUV,  detailInten);

OUT.surface_diffuseColor  *= detailBumpAndIntensity.z;
#endif

#if WRINKLE_MAP
	OUT.surface_worldNormal.xyz = CalculateWrinkleNormal(
		IN_bumpSampler, 
		IN_bumpTexCoord.xy, 
		IN_worldTangent, 
		IN_worldBinormal,
		IN_worldNormal);
#else
	#if NORMAL_MAP
		#if PARALLAX
			float3 packedNormal = float3(0.0, 0.0, 0.0);
		#else
			float3 packedNormal = tex2D_NormalMap(IN_bumpSampler, IN_bumpTexCoord.xy).xyz;
		#endif
		float3 packedNormalHeight = CalculatePackedNormal(
			packedNormal,
			#if PARALLAX
				parallaxPackedNormalHeight,
			#endif
			#if DIRT_NORMALMAP
				IN_dirtBumpSampler,
				IN_dirtBumpUV.xyz,
			#endif
			IN_bumpTexCoord.xy);

#ifdef USE_DETAIL_MAP
				packedNormalHeight.xy += detailBumpAndIntensity.xy;
			#endif

OUT.surface_worldNormal.xyz = CalculateWorldNormal(
				packedNormalHeight.xy, 
				bumpiness, 
				IN_worldTangent, 
				IN_worldBinormal, 
				IN_worldNormal);
	#else
		//should be normalized as the normal is interpolated from vertex normals
		OUT.surface_worldNormal.xyz = normalize(IN_worldNormal.xyz); 
	#endif
#endif

#ifdef DECAL_USE_NORMAL_MAP_ALPHA
	OUT.surface_worldNormal.a = packedNormalHeight.z;
#endif

#if NORMAL_MAP2
	float3 packedNormalHeight2 = tex2D_NormalMap(IN_bumpSampler2, IN_bumpTexCoord2.xy).xyz;
	OUT.surface_worldNormal2.xyz = CalculateWorldNormal(packedNormalHeight2.xy, bumpiness, IN_worldTangent2, IN_worldBinormal2, IN_worldNormal);
#endif

#if SPECULAR
	CalculateSpecularContribution(
		OUT,
		#if SPEC_MAP
			IN_specularSampler,
			IN_specularTexCoord.xy,
		#endif
		IN_baseColor,
		OUT.surface_worldNormal);

#ifdef USE_DETAIL_MAP
		OUT.surface_specularIntensity *=detailBumpAndIntensity.z;
	#endif

#endif

#if REFLECT
	float3 surfaceToEyeDir = normalize(IN_worldEyePos);	
	CalculateReflection(
		OUT,
		IN_environmentSampler,
		#if REFLECT_MIRROR
			IN_screenPos,
		#endif
		#if defined(USE_MIRROR_CRACK_MAP)
			IN_mirrorTexCoord,
		#endif
		#if SPECULAR
			OUT.surface_specularExponent,
		#endif
		surfaceToEyeDir,
		OUT.surface_worldNormal);
#endif

#if PARALLAX
	// parallax only: if BumpMap.xy is (0,0), then we want no lighting:
	const float threshold = 0.002f; // 0.00001f
	float parallaxLightMask = (dot(packedNormalHeight.xy, packedNormalHeight.xy) >= threshold);

OUT.surface_diffuseColor.rgb	*= parallaxLightMask;
	OUT.surface_baseColor.rgb		*= parallaxLightMask;
	OUT.surface_specularIntensity	*= parallaxLightMask;
#endif //PARALLAX...

#ifdef COLORIZE
	OUT.surface_diffuseColor.rgba*=colorize;
#endif

#if SELF_SHADOW
	OUT.surface_selfShadow = 1.0f;
#endif

#if PARALLAX_MAP_V2 && __SHADERMODEL >= 40
	float3 tanLightDirection;

tanLightDirection.x = dot(IN_worldTangent.xyz, gDirectionalLight.xyz);
	tanLightDirection.y = dot(IN_worldBinormal.xyz, gDirectionalLight.xyz);
	tanLightDirection.z = dot(IN_worldNormal.xyz, gDirectionalLight.xyz);
	float shadowAmount = TraceSelfShadow(IN_diffuseTexCoord, IN_heightSampler, tanLightDirection, 1.0f - IN_edgeWeight, heightScale * globalHeightScale);
	OUT.surface_selfShadow = (1.0f - shadowAmount * parallaxSelfShadowAmount);

#if EDGE_WEIGHT
	if(POMEdgeVisualiser)
	{
		OUT.surface_diffuseColor.r = clamp(IN_edgeWeight.x, 0.0f, 1.0f);
		OUT.surface_diffuseColor.g = 1.0f - clamp(IN_edgeWeight.y, 0.0f, 1.0f);
		OUT.surface_diffuseColor.b = 0.0f;
	}
#endif
#endif

#if USE_SLOPE
	OUT.slope = CalcSlope(IN_worldNormal.z);
#endif

CalculateEmissiveContribution(OUT);

return OUT;
}