Shader "Custom/simple" {
 	Properties {
		_outlineWidth ("Outline-Stärke", float) = 0.1
		_refractionValue ("Refraktionswert", float) = 0.1
		_diffuseMap ("diffuse map", 2D) = "white" {}
		_normalMap ("normal map", 2D) = "white" {}
		_environmentMap ("environment map", CUBE) = "white" {}
		_vLightPositionWS ("Lichtposition", vector) = (5, 3, 1)
 	}
	SubShader {
		Tags { "RenderType"="Opaque" }
		LOD 200

		pass {
			Tags { "LightMode"="Vertex" }
			
			CGPROGRAM
				#include "UnityCG.cginc"
				#include "HLSLSupport.cginc"
				#include "Lighting.cginc"
				#include "AutoLight.cginc"


				sampler2D _diffuseMap;
				sampler2D _normalMap;
				samplerCUBE _environmentMap;
				
				float3 _vLightPositionWS;
				

				struct VS_OUTPUT {
					float4	vPositionPS	:	SV_POSITION;
					float3	vPositionMS	:	TEXCOORD1;
					float3	vNormalMS	:	TEXCOORD2;
					float3 	vTangentMS	:	TEXCOORD3;
					float3 	vBinormalMS	:	TEXCOORD4;
					float2	vTexCoord	:	TEXCOORD0;
				};

								
				VS_OUTPUT vsMain(appdata_full vIn) {
					VS_OUTPUT vOut;
					vOut.vPositionPS = mul(UNITY_MATRIX_MVP, vIn.vertex);
					vOut.vPositionMS = vIn.vertex;
					vOut.vNormalMS = vIn.normal;
					vOut.vTexCoord = vIn.texcoord.xy;
					vOut.vTangentMS = vIn.tangent.xyz;
					vOut.vBinormalMS = cross(vIn.normal, vIn.tangent.xyz) * vIn.tangent.w;
					return vOut;
				};
						
			
				struct PS_OUTPUT {
					float4 vColor	: COLOR0;
				};
			
				PS_OUTPUT psMain(VS_OUTPUT vIn) {

					vIn.vNormalMS = normalize(vIn.vNormalMS);
					vIn.vTangentMS = normalize(vIn.vTangentMS);
					vIn.vBinormalMS = normalize(vIn.vBinormalMS);

					// calculate new normal from normal map 					
					float3 vNormalTS = tex2D(_normalMap, vIn.vTexCoord).rgb * 2 - 1;
					float3x3 mTStoMS = float3x3(vIn.vTangentMS, vIn.vBinormalMS, vIn.vNormalMS);
					vIn.vNormalMS = mul(vNormalTS, mTStoMS);
				
				
					float3 vCameraPosMS = mul(float4(0,0,0,1), UNITY_MATRIX_IT_MV).xyz;
					float3 vEyeVecMS = normalize(vCameraPosMS - vIn.vPositionMS);
					
					if (dot(vIn.vNormalMS, vEyeVecMS) < 0)
					{
						// normal faces away from camera --> fix it
						float3 vCross = cross(vIn.vNormalMS, vEyeVecMS);
						vIn.vNormalMS = -cross(vCross, vEyeVecMS);
					}
					
					
					float3 vLightVecMS = normalize(mul(unity_LightPosition[0], UNITY_MATRIX_IT_MV)).xyz;
					float3 vReflectedEyeVecMS = -reflect(vEyeVecMS, vIn.vNormalMS);
				
					
//
//					float4 c = max(0, dot(vLightVecMS, vIn.vNormalMS));			// lambert lighting
//					c *= tex2D(_diffuseMap, vIn.vTexCoord);
//					c += pow(max(0, dot(vReflectedEyeVecMS, vLightVecMS)), 20);	// phong lighting
//					float4 vRefractionColor = c;
//					
					float _refractionValue;
					
					float3 vRefractionMS = -normalize(lerp(vEyeVecMS, vIn.vNormalMS, _refractionValue));
					float3 vRefractionWS = mul(_Object2World, float4(vRefractionMS, 0)).xyz;
					
					float4 vRefractionColor = texCUBE(_environmentMap, vRefractionWS);
			
					
					float3 vReflectedEyeVecWS = mul(_Object2World, float4(vReflectedEyeVecMS, 0)).xyz;
					
					//
					//float height = 0.1;
					//float2 vEnvironmentTexcoord = (height/vReflectedEyeVecWS.y) * vReflectedEyeVecWS.xz;
					//
					
					//
					//float alpha = vReflectedEyeVecWS.x >= 0 ? asin(vReflectedEyeVecWS.z / length(vReflectedEyeVecWS.xz))
					//										: 3.14159 - asin(vReflectedEyeVecWS.z / length(vReflectedEyeVecWS.xz));
					//float beta = asin(vReflectedEyeVecWS.y);
					//float2 vEnvironmentTexcoord = float2(alpha / (2 * 3.14159), beta / 3.14159 + 0.5);
					//
					
					float4 vReflectionColor = texCUBE(_environmentMap, vReflectedEyeVecWS); //* float4(1, 0.8, 0.3, 0);
					
					float fresnell = 1/pow(dot(vIn.vNormalMS, vEyeVecMS) + 1, 8);
					
					
					PS_OUTPUT vOut;
					vOut.vColor = lerp(vRefractionColor, vReflectionColor, fresnell);
					return vOut;
				};
			
				#pragma vertex vsMain
				#pragma fragment psMain
				
			ENDCG
		}
		
		
		pass {
		
			Cull Front
			
			CGPROGRAM
				#include "UnityCG.cginc"
			
				struct VS_OUTPUT {
					float4	vPositionPS	:	SV_POSITION;
				};
				
				float _outlineWidth;
				
				VS_OUTPUT vsMain(appdata_full vIn) {
				
					vIn.vertex.xyz += vIn.normal * _outlineWidth;
//					vIn.vertex.xyz += vIn.normal * 0.5 * sin(_Time.y + (vIn.texcoord.x * 5 + vIn.texcoord.y * 3) * 3.14159 * 2);
				
					VS_OUTPUT vOut;
					vOut.vPositionPS = mul(UNITY_MATRIX_MVP, vIn.vertex);
					return vOut;
				};			
						
			
				struct PS_OUTPUT {
					float4 vColor	: COLOR0;
				};
			
				PS_OUTPUT psMain(VS_OUTPUT vIn) {
					PS_OUTPUT vOut;
					vOut.vColor = float4(0, 0, 0, 1);
					return vOut;
				};
			
				#pragma vertex vsMain
				#pragma fragment psMain
				
			ENDCG
		}

	} 
	FallBack "Diffuse"
}