// Upgrade NOTE: replaced 'UNITY_INSTANCE_ID' with 'UNITY_VERTEX_INPUT_INSTANCE_ID'

// Unity built-in shader source. Copyright (c) 2016 Unity Technologies. MIT license (see license.txt)

#ifndef UNITY_STANDARD_INPUT_INCLUDED
#define UNITY_STANDARD_INPUT_INCLUDED

#include "UnityCG.cginc"
#include "UnityStandardConfig.cginc"
#include "UnityPBSLighting.cginc" // TBD: remove
#include "UnityStandardUtils.cginc"

//---------------------------------------
// Directional lightmaps & Parallax require tangent space too
#if (_NORMALMAP || DIRLIGHTMAP_COMBINED || _PARALLAXMAP)
	#define _TANGENT_TO_WORLD 1
#endif

#if (_DETAIL_MULX2 || _DETAIL_MUL || _DETAIL_ADD || _DETAIL_LERP)
	#define _DETAIL 1
#endif

//---------------------------------------
half4	   _Color;
half		_Cutoff;

sampler2D   _MainTex;
float4	  _MainTex_ST;

sampler2D   _DetailAlbedoMap;
float4	  _DetailAlbedoMap_ST;

sampler2D   _BumpMap;
half		_BumpScale;

sampler2D   _DetailMask;
sampler2D   _DetailNormalMap;
half		_DetailNormalMapScale;

sampler2D   _SpecGlossMap;
sampler2D   _MetallicGlossMap;
half		_Metallic;
half		_Glossiness;

sampler2D   _OcclusionMap;
half		_OcclusionStrength;

sampler2D   _ParallaxMap;
half		_Parallax;
half		_UVSec;

half4		_EmissionColor;
sampler2D   _EmissionMap;
float4		_EmissionMap_ST;

//-------------------------------------------------------------------------------------
// Input functions

struct VertexInput
{
	float4 vertex   : POSITION;
	half3 normal	: NORMAL;
	float2 uv0	  : TEXCOORD0;
	float2 uv1	  : TEXCOORD1;
#if defined(DYNAMICLIGHTMAP_ON) || defined(UNITY_PASS_META)
	float2 uv2	  : TEXCOORD2;
#endif
#ifdef _TANGENT_TO_WORLD
	half4 tangent   : TANGENT;
#endif
#if defined(UNITY_VERTEX_INPUT_INSTANCE_ID)
	UNITY_VERTEX_INPUT_INSTANCE_ID
#else
	UNITY_VERTEX_INPUT_INSTANCE_ID
#endif
};

float4 TexCoords(VertexInput v)
{
	float4 texcoord;
	texcoord.xy = TRANSFORM_TEX(v.uv0, _MainTex); // Always source from uv0
	texcoord.zw = TRANSFORM_TEX(((_UVSec == 0) ? v.uv0 : v.uv1), _DetailAlbedoMap);
	return texcoord;
}

half DetailMask(float2 uv)
{
	return tex2D (_DetailMask, uv).a;
}

#if defined(VERTEX_COLOR_ON)
half3 Albedo(float4 texcoords, half4 color)
#else
half3 Albedo(float4 texcoords)
#endif
{
	half3 albedo = _Color.rgb * tex2D(_MainTex, texcoords.xy).rgb;

#if _DETAIL
	#if (SHADER_TARGET < 30)
		// SM20: instruction count limitation
		// SM20: no detail mask
		half mask = 1;
	#else
		half mask = DetailMask(texcoords.xy);
	#endif
	half3 detailAlbedo = tex2D (_DetailAlbedoMap, texcoords.zw).rgb;
	#if _DETAIL_MULX2
		albedo *= LerpWhiteTo (detailAlbedo * unity_ColorSpaceDouble.rgb, mask);
	#elif _DETAIL_MUL
		albedo *= LerpWhiteTo (detailAlbedo, mask);
	#elif _DETAIL_ADD
		albedo += detailAlbedo * mask;
	#elif _DETAIL_LERP
		albedo = lerp (albedo, detailAlbedo, mask);
	#endif
#endif
	return albedo;
}

half Alpha(float2 uv)
{
#if defined(_SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A)
	return _Color.a;
#else
	return tex2D(_MainTex, uv).a * _Color.a;
#endif
}

half Occlusion(float2 uv)
{
#if (SHADER_TARGET < 30)
	// SM20: instruction count limitation
	// SM20: simpler occlusion
	return tex2D(_OcclusionMap, uv).r;
#else
	half occ = tex2D(_OcclusionMap, uv).r;
	return LerpOneTo (occ, _OcclusionStrength);
#endif
}

half4 SpecularGloss(float2 uv)
{
	half4 sg;
#ifdef _SPECGLOSSMAP
	#if defined(_SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A)
		sg.rgb = tex2D(_SpecGlossMap, uv).rgb;
		sg.a = tex2D(_MainTex, uv).a;
	#else
		sg = tex2D(_SpecGlossMap, uv);
	#endif
	sg *= half4(_SpecColor.rgb, _Glossiness);
#else
	sg.rgb = _SpecColor.rgb;
	#ifdef _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A
		sg.a = tex2D(_MainTex, uv).a * _Glossiness;
	#else
		sg.a = _Glossiness;
	#endif
#endif
	return sg;
}

half2 MetallicGloss(float2 uv)
{
	half2 mg;

#ifdef _METALLICGLOSSMAP
	#ifdef _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A
		mg.r = tex2D(_MetallicGlossMap, uv).b;
		mg.g = tex2D(_MainTex, uv).a;
	#else
		mg = tex2D(_MetallicGlossMap, uv).bg;
	#endif
	mg *= half2(_Metallic, _Glossiness);
#else
	mg.r = _Metallic;
	#ifdef _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A
		mg.g = tex2D(_MainTex, uv).a * _Glossiness;
	#else
		mg.g = _Glossiness;
	#endif
#endif
	// it's roughness, not glossiness. invert it
	mg.g = 1.0f - mg.g;
	return mg;
}

half2 MetallicRough(float2 uv)
{
	half2 mg;

#if UNITY_SETUP_BRDF_INPUT == MetallicSetup
	#ifdef _METALLICGLOSSMAP
		mg = half2(_Metallic, _Glossiness) * tex2D(_MetallicGlossMap, uv).bg;
	#else
		mg = half2(_Metallic, _Glossiness);
	#endif
#else
	#ifdef _SPECGLOSSMAP
		mg.r = _Metallic;
		mg.g = 1.0f - _Glossiness * tex2D(_SpecGlossMap, uv).a;
	#else
		mg = half2(Metallic, 1.0f - _Glossiness);
	#endif
#endif
	return mg;
}

half3 Emission(float2 uv)
{
#ifndef _EMISSION
	return 0;
#else
	return tex2D(_EmissionMap, TRANSFORM_TEX(uv, _EmissionMap)).rgb * _EmissionColor.rgb;
#endif
}

// see this link regarding unpacking instructions:
// https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/schema/material.normalTextureInfo.schema.json#L13
half3 UnpackScaleNormalGLTF(half4 packednormal, half bumpScale)
{
	float3 normal = packednormal.xyz * 2.0 - 1.0;
	normal.xy *= bumpScale;
	return normalize(normal);
}

#ifdef _NORMALMAP
half3 NormalInTangentSpace(float4 texcoords)
{
	half3 normalTangent = UnpackScaleNormalGLTF(tex2D (_BumpMap, texcoords.xy), _BumpScale);

#if _DETAIL && defined(UNITY_ENABLE_DETAIL_NORMALMAP)
	half mask = DetailMask(texcoords.xy);
	half3 detailNormalTangent = UnpackScaleNormal(tex2D (_DetailNormalMap, texcoords.zw), _DetailNormalMapScale);
	#if _DETAIL_LERP
		normalTangent = lerp(
			normalTangent,
			detailNormalTangent,
			mask);
	#else
		normalTangent = lerp(
			normalTangent,
			BlendNormals(normalTangent, detailNormalTangent),
			mask);
	#endif
#endif

	return normalTangent;
}
#endif

float4 Parallax (float4 texcoords, half3 viewDir)
{
// D3D9/SM30 supports up to 16 samplers, skip the parallax map in case we exceed the limit
#define EXCEEDS_D3D9_SM3_MAX_SAMPLER_COUNT  (defined(LIGHTMAP_ON) && defined(SHADOWS_SHADOWMASK) && defined(SHADOWS_SCREEN) && defined(_NORMALMAP) && \
											 defined(_EMISSION) && defined(_DETAIL) && (defined(_METALLICGLOSSMAP) || defined(_SPECGLOSSMAP)))

#if !defined(_PARALLAXMAP) || (SHADER_TARGET < 30) || (defined(SHADER_API_D3D9) && EXCEEDS_D3D9_SM3_MAX_SAMPLER_COUNT)
	// SM20: instruction count limitation
	// SM20: no parallax
	return texcoords;
#else
	half h = tex2D (_ParallaxMap, texcoords.xy).g;
	float2 offset = ParallaxOffset1Step (h, _Parallax, viewDir);
	return float4(texcoords.xy + offset, texcoords.zw + offset);
#endif

#undef EXCEEDS_D3D9_SM3_MAX_SAMPLER_COUNT
}

#endif // UNITY_STANDARD_INPUT_INCLUDED