//	STATIC: "ENVMAP_MASK"				"0..1"
//	STATIC: "TANGENTSPACE"				"0..1"
//  STATIC: "BUMPMAP"					"0..1"
//  STATIC: "DIFFUSEBUMPMAP"			"0..1"
//  STATIC: "VERTEXCOLOR"				"0..1"
//  STATIC: "VERTEXALPHATEXBLENDFACTOR"	"0..1"
//  STATIC: "SEAMLESS"                  "0..1"
//  STATIC: "BUMPMASK"                  "0..1"

//  DYNAMIC: "FASTPATH"					"0..1"
//	DYNAMIC: "DOWATERFOG"				"0..1"

// This should not be a combo since I'm a moron with the tangent space and the flashlight.
//  SKIP: !$BUMPMAP && $DIFFUSEBUMPMAP
//  SKIP: $SEAMLESS && $RELIEF_MAPPING
//  SKIP: $BUMPMASK && $RELIEF_MAPPING
//  SKIP: $BUMPMASK && $SEAMLESS
// SKIP: $CASCADED_SHADOW && $LIGHTING_PREVIEW

#include "common_cbuffers_def_noskinning_fxc.h"

#include "common_vs_fxc.h"

static const int g_FogType						= DOWATERFOG;
static const bool g_UseSeparateEnvmapMask		= ENVMAP_MASK;
static const bool g_bTangentSpace				= TANGENTSPACE;
static const bool g_bBumpmap					= BUMPMAP;
static const bool g_bBumpmapDiffuseLighting		= DIFFUSEBUMPMAP;
static const bool g_bVertexColor				= VERTEXCOLOR;
static const bool g_bVertexAlphaTexBlendFactor	= VERTEXALPHATEXBLENDFACTOR;
static const bool g_BumpMask					= BUMPMASK;

#include "lightmappedgeneric_dx11_shared_fxc.h"

cbuffer LightmappedGeneric_VS : register(b3)
{
	LightmappedGeneric_t c;
};

#define SEAMLESS_SCALE c.cSeamlessScale

struct VS_INPUT
{
	float3 vPos							: POSITION;
	float4 vNormal						: NORMAL;
	float2 vBaseTexCoord				: TEXCOORD0;
	float2 vLightmapTexCoord			: TEXCOORD1;
	float2 vLightmapTexCoordOffset		: TEXCOORD2;
	float3 vTangentS					: TANGENT;
	float3 vTangentT					: BINORMAL;
	float4 vColor						: COLOR;
};

struct VS_OUTPUT
{
    float4 projPos					: SV_POSITION;	
	float4 vertexColor				: COLOR; // in seamless, r g b = blend weights
#if SEAMLESS
	float4 SeamlessTexCoord_VertexBlend	: TEXCOORD0;            // x y z 
#else
	float3 baseTexCoord_VertexBlend		: TEXCOORD0;
#endif
	float4 detailOrBumpAndEnvmapMaskTexCoord : TEXCOORD1;
	float4 lightmapTexCoord1And2	: TEXCOORD2;
	float4 lightmapTexCoord3		: TEXCOORD3;			// and basetexcoord*mask_scale
	float4 worldPos_projPosZ		: TEXCOORD4;

#if TANGENTSPACE || (LIGHTING_PREVIEW)
	float3x3 tangentSpaceTranspose	: TEXCOORD5;	// and 6 and 7
#endif

	float3 eyePos					: COLOR1;
};

VS_OUTPUT main( const VS_INPUT v )
{
	VS_OUTPUT o = ( VS_OUTPUT )0;

	float3 vObjNormal;
	DecompressVertex_Normal( v.vNormal, vObjNormal );

	float3 worldPos = mul( float4( v.vPos, 1 ), cModelMatrix ).xyz;

	o.eyePos = mul(float4(worldPos, 1), cViewMatrix).xyz;

	float4 vProjPos = ComputeProjPos(v.vPos.xyz, cModelMatrix, cViewMatrix, cProjMatrix);
	o.projPos = vProjPos;
	
	o.worldPos_projPosZ = float4( worldPos, vProjPos.z );
	
	float3 worldNormal = mul( vObjNormal, ( float3x3 )cModelMatrix );
	
#if TANGENTSPACE || (LIGHTING_PREVIEW)
	float3 worldTangentS = mul( v.vTangentS, ( const float3x3 )cModelMatrix );
	float3 worldTangentT = mul( v.vTangentT, ( const float3x3 )cModelMatrix );
	o.tangentSpaceTranspose[0] = worldTangentS;
	o.tangentSpaceTranspose[1] = worldTangentT;
	o.tangentSpaceTranspose[2] = worldNormal;
#endif

	//float3 worldVertToEyeVector = VSHADER_VECT_SCALE * (cEyePos - worldPos);

#if SEAMLESS
	{
		// we need to fill in the texture coordinate projections
		o.SeamlessTexCoord_VertexBlend.xyz = SEAMLESS_SCALE*worldPos;
	}
#else
	{
		if (FASTPATH)
		{
			o.baseTexCoord_VertexBlend.xy = v.vBaseTexCoord;
		}
		else
		{
			o.baseTexCoord_VertexBlend.x = dot( v.vBaseTexCoord, c.cBaseTexCoordTransform[0] ) + c.cBaseTexCoordTransform[0].w;
			o.baseTexCoord_VertexBlend.y = dot( v.vBaseTexCoord, c.cBaseTexCoordTransform[1] ) + c.cBaseTexCoordTransform[1].w;
		}
#if ( RELIEF_MAPPING == 0 )
		{
            // calculate detailorbumptexcoord
			if ( FASTPATH )
				o.detailOrBumpAndEnvmapMaskTexCoord.xy = v.vBaseTexCoord.xy;
			else
			{
				o.detailOrBumpAndEnvmapMaskTexCoord.x = dot( v.vBaseTexCoord, c.cDetailOrBumpTexCoordTransform[0] ) + c.cDetailOrBumpTexCoordTransform[0].w;
				o.detailOrBumpAndEnvmapMaskTexCoord.y = dot( v.vBaseTexCoord, c.cDetailOrBumpTexCoordTransform[1] ) + c.cDetailOrBumpTexCoordTransform[1].w;
			}
		}
#endif
	}
#endif
	if ( FASTPATH )
	{
		o.lightmapTexCoord3.zw = v.vBaseTexCoord;
	}
	else
	{
		o.lightmapTexCoord3.z = dot( v.vBaseTexCoord, c.cBlendMaskTexCoordTransform[0] ) + c.cBlendMaskTexCoordTransform[0].w;
		o.lightmapTexCoord3.w = dot( v.vBaseTexCoord, c.cBlendMaskTexCoordTransform[1] ) + c.cBlendMaskTexCoordTransform[1].w;
	}
	
	//  compute lightmap coordinates
	if( g_bBumpmap && g_bBumpmapDiffuseLighting )
	{
		o.lightmapTexCoord1And2.xy = v.vLightmapTexCoord + v.vLightmapTexCoordOffset;

		float2 lightmapTexCoord2 = o.lightmapTexCoord1And2.xy + v.vLightmapTexCoordOffset;
		float2 lightmapTexCoord3 = lightmapTexCoord2 + v.vLightmapTexCoordOffset;

		// reversed component order
		o.lightmapTexCoord1And2.w = lightmapTexCoord2.x;
		o.lightmapTexCoord1And2.z = lightmapTexCoord2.y;

		o.lightmapTexCoord3.xy = lightmapTexCoord3;
	}
	else
	{
		o.lightmapTexCoord1And2.xy = v.vLightmapTexCoord;
	}

#if ( RELIEF_MAPPING == 0)
	if( g_UseSeparateEnvmapMask || g_BumpMask )
	{
		// reversed component order
#	if FASTPATH
		o.detailOrBumpAndEnvmapMaskTexCoord.wz = v.vBaseTexCoord.xy;
#	else
		o.detailOrBumpAndEnvmapMaskTexCoord.w = dot( v.vBaseTexCoord, c.cEnvmapMaskTexCoordTransform[0] ) + c.cEnvmapMaskTexCoordTransform[0].w;
		o.detailOrBumpAndEnvmapMaskTexCoord.z = dot( v.vBaseTexCoord, c.cEnvmapMaskTexCoordTransform[1] ) + c.cEnvmapMaskTexCoordTransform[1].w;
#	endif
	}
#endif

	if (!g_bVertexColor)
	{
		o.vertexColor = float4( 1.0f, 1.0f, 1.0f, c.cModulationColor.a );
	}
	else
	{
#if FASTPATH
		o.vertexColor = v.vColor;
#else
		if ( g_bVertexAlphaTexBlendFactor )
		{
			o.vertexColor.rgb = v.vColor.rgb;
			o.vertexColor.a = c.cModulationColor.a;
		}
		else
		{
			o.vertexColor = v.vColor;
			o.vertexColor.a *= c.cModulationColor.a;
		}
#endif
	}
#if SEAMLESS
	// compute belnd weights in rgb
	float3 vNormal=normalize( worldNormal );
	o.vertexColor.xyz = vNormal * vNormal;           // sums to 1.
#endif

	if ( g_bVertexAlphaTexBlendFactor )
	{
#if SEAMLESS
		o.SeamlessTexCoord_VertexBlend.w = v.vColor.a;
#else
		o.baseTexCoord_VertexBlend.z = v.vColor.a;
#endif
	}
	
	return o;
}