//Shader created by: Max Kruf / Maxartz15
//Shader generated with ShaderSandwich!

Shader "MA_Shaders/MSUI" 
{
	Properties 
	{
		[HideInInspector]Texcoord ("Generic UV Coords (You shouldn't be seeing this aaaaah!)", 2D) = "white" {}
		[HideInInspector]_MainTex ("Source Image", 2D) = "white" {}
		_Color ("Color", Color) = (0,0,0,1)
		_SSSHighLightColor ("Highlight Color", Color) = (0.6705883,0.2862745,0.2862745,1)
		_SSSMask ("Mask", 2D) = "white" {}
		_SSSMaskSize ("Mask Size", Range(-1.000000000,1.000000000)) = 0.000000000
	}

	SubShader 
	{
		Tags { "RenderType"="Transparent" "Queue"="Transparent" }
		LOD 200
		AlphaToMask Off
		Pass 
		{
			Name "FORWARD"
			Tags { "LightMode" = "ForwardBase" }
			Fog {Mode Off}
			ZTest LEqual
			ZWrite Off
			Blend SrcAlpha OneMinusSrcAlpha
			Cull Off

			
			CGPROGRAM
			#pragma vertex VertShader
			#pragma fragment FragmentShader
			#pragma target 3.0
			#pragma multi_compile __ UNITY_COLORSPACE_GAMMA
			#pragma multi_compile_fwdbase noshadow nolightmap nodynlightmap novertexlight
			#include "HLSLSupport.cginc"
			#include "UnityShaderVariables.cginc"
			#define UNITY_PASS_FORWARDBASE
			#include "UnityCG.cginc"
			#include "Lighting.cginc"
			#include "UnityPBSLighting.cginc"
			#include "AutoLight.cginc"

			#define INTERNAL_DATA
			#define WorldReflectionVector(data,normal) data.worldRefl
			#define WorldNormalVector(data,normal) normal
			#pragma glsl
			#ifndef LIGHTMAP_OFF
			#define LIGHTMAP_OFF
			#endif

			sampler2D _MainTex;
			float4 _MainTex_ST;
			float4 _Color;
			float4 _SSSHighLightColor;
			sampler2D _SSSMask;
			float4 _SSSMask_ST;
			float _SSSMaskSize;

			struct UsefulData
			{
				float3 Albedo;
				float3 Specular;
				float3 Normal;
				float Alpha;
				float Occlusion;
				float Height;
				float4 Emission;
				float Smoothness;
				float LightSmoothness;
				float Atten;
				float3 worldPos;
				float4 screenPos;
				fixed4 color;
				float ShellDepth;
				float Mask0;
				float2 uv_MainTex;
				float2 uvTexcoord;
			};

			#ifdef LIGHTMAP_OFF
			struct v2f_surf 
			{
				float4 pos : SV_POSITION;
				float3 worldPos: TEXCOORD0;
				float4 screenPos: TEXCOORD1;
				float4 dataToPack0 : TEXCOORD2;
				fixed4 color : COLOR0;
				#if UNITY_SHOULD_SAMPLE_SH
					half3 sh : TEXCOORD3;
				#endif
			};
			#endif
			struct appdata_min 
			{
				float4 vertex : POSITION;
				float4 tangent : TANGENT;
				float3 normal : NORMAL;
				float4 texcoord : TEXCOORD0;
				float4 texcoord1 : TEXCOORD1;
				float4 texcoord2 : TEXCOORD2;
				fixed4 color : COLOR;
			};

			float4 GammaToLinear(float4 col)
			{
				#if defined(UNITY_COLORSPACE_GAMMA)
				#else
					col = pow(col,2.2);
				#endif
				return col;
			}

			float4 GammaToLinearForce(float4 col)
			{
				#if defined(UNITY_COLORSPACE_GAMMA)
				#else
					col = pow(col,2.2);
				#endif
				return col;
			}

			float4 LinearToGamma(float4 col)
			{
				return col;
			}

			float4 LinearToGammaForWeirdSituations(float4 col)
			{
				#if defined(UNITY_COLORSPACE_GAMMA)
					col = pow(col,2.2);
				#endif
				return col;
			}

			float3 GammaToLinear(float3 col)
			{
				#if defined(UNITY_COLORSPACE_GAMMA)
				#else
					col = pow(col,2.2);
				#endif
				return col;
			}

			float3 GammaToLinearForce(float3 col)
			{
				#if defined(UNITY_COLORSPACE_GAMMA)
				#else
					col = pow(col,2.2);
				#endif
				return col;
			}

			float3 LinearToGamma(float3 col)
			{
				return col;
			}

			v2f_surf VertShader (appdata_min v) 
			{
				v2f_surf o;
				UNITY_INITIALIZE_OUTPUT(v2f_surf,o);
				float4 Vertex = v.vertex;
				o.pos = UnityObjectToClipPos (Vertex);
					o.dataToPack0.xy = TRANSFORM_TEX(v.texcoord, _MainTex);
					o.dataToPack0.zw = v.texcoord;
				o.color = v.color;
				float4 screenPos = ComputeScreenPos (o.pos);
				float3 worldPos = mul(unity_ObjectToWorld, Vertex).xyz;
				o.worldPos = worldPos;
				o.screenPos = screenPos;
				float ShellDepth = 0;
				float Mask0 = 1;
				half4 Mask02_Copy_CopyMask0_Sample1 = LinearToGamma(tex2Dlod(_SSSMask,float4((((((ComputeScreenPos(UnityObjectToClipPos (v.vertex))/ComputeScreenPos(UnityObjectToClipPos (v.vertex)).w).xyw)).xy)),0,0)));
				Mask02_Copy_CopyMask0_Sample1 = (Mask02_Copy_CopyMask0_Sample1+_SSSMaskSize);
				Mask0 = Mask02_Copy_CopyMask0_Sample1.a;
				Vertex.w = v.vertex.w;
				v.vertex.xyz = Vertex.xyz;
				o.pos = UnityObjectToClipPos (Vertex);
				return o;
			}

			void FragmentShader (v2f_surf IN, out fixed4 outputColor : SV_Target) 
			{
				UsefulData d;
				UNITY_INITIALIZE_OUTPUT(UsefulData,d);
				d.Albedo = float3(0.8,0.8,0.8);
				d.Specular = float3(0.3,0.3,0.3);
				d.Occlusion = 1;
				d.Emission = float4(0,0,0,0);
				d.Smoothness = 0;
				d.LightSmoothness = 0;
				d.Alpha = 1;
				d.worldPos = IN.worldPos;
				d.screenPos = IN.screenPos;
				d.screenPos.xy /= d.screenPos.w;
				d.color = IN.color;
				d.ShellDepth = 1-0;
				float ShellDepth = d.ShellDepth;
					d.uv_MainTex = IN.dataToPack0.xy;
				d.uvTexcoord = IN.dataToPack0.zw;
				fixed4 c = 0;
				UnityGI gi;
				UNITY_INITIALIZE_OUTPUT(UnityGI, gi);
				#ifndef USING_DIRECTIONAL_LIGHT
					fixed3 lightDir = normalize(UnityWorldSpaceLightDir(d.worldPos));
				#else
					fixed3 lightDir = _WorldSpaceLightPos0.xyz;
				#endif
				float Mask0 = 1;
				half4 Mask02_Copy_CopyMask0_Sample1 = LinearToGamma(tex2D(_SSSMask,((((d.screenPos.xyw)).xy))));
				Mask02_Copy_CopyMask0_Sample1 = (Mask02_Copy_CopyMask0_Sample1+_SSSMaskSize);
				Mask0 = Mask02_Copy_CopyMask0_Sample1.a;
				d.Mask0 = Mask0;
				d.Smoothness = 0;
				d.LightSmoothness = 0;
				half4 AlbedoAlbedo_Sample1 = LinearToGamma(tex2D(_MainTex,(((d.uv_MainTex.xy)))));
				d.Albedo = AlbedoAlbedo_Sample1.rgb;
				half4 Albedo4Albedo_Sample1 = GammaToLinear(_Color);
				d.Albedo = lerp(d.Albedo,d.Albedo*Albedo4Albedo_Sample1.rgb,Albedo4Albedo_Sample1.a);
				half4 Albedo3_CopyAlbedo_Sample1 = GammaToLinear(_SSSHighLightColor);
				d.Albedo = lerp(d.Albedo,Albedo3_CopyAlbedo_Sample1.rgb,Albedo3_CopyAlbedo_Sample1.a*Mask0);
				half4 Albedo_CopyAlpha_Sample1 = LinearToGamma(tex2D(_MainTex,(((d.uv_MainTex.xy)))));
				d.Alpha = Albedo_CopyAlpha_Sample1.a;
				d.Alpha-=0;
				c = float4(d.Albedo+d.Emission.rgb,d.Alpha+d.Emission.a);
				outputColor = c;
			}
			ENDCG
		}
	}
	Fallback "Legacy Shaders/Diffuse"
}