1.  Shader "Custom/simple" {
2.         Properties {
3.                 _outlineWidth ("Outline-Stärke", float) = 0.1
4.                 _refractionValue ("Refraktionswert", float) = 0.1
5.                 _diffuseMap ("diffuse map", 2D) = "white" {}
6.                 _normalMap ("normal map", 2D) = "white" {}
7.                 _environmentMap ("environment map", CUBE) = "white" {}
8.                 _vLightPositionWS ("Lichtposition", vector) = (5, 3, 1)
9.         }
10.         SubShader {
11.                 Tags { "RenderType"="Opaque" }
12.                 LOD 200
13.  
14.                 pass {
15.                         Tags { "LightMode"="Vertex" }
16.                        
17.                         CGPROGRAM
18.                                 #include "UnityCG.cginc"
19.                                 #include "HLSLSupport.cginc"
20.                                 #include "Lighting.cginc"
21.                                 #include "AutoLight.cginc"
22.  
23.  
24.                                 sampler2D _diffuseMap;
25.                                 sampler2D _normalMap;
26.                                 samplerCUBE _environmentMap;
27.                                
28.                                 float3 _vLightPositionWS;
29.                                
30.  
31.                                 struct VS_OUTPUT {
32.                                         float4  vPositionPS     :       SV_POSITION;
33.                                         float3  vPositionMS     :       TEXCOORD1;
34.                                         float3  vNormalMS       :       TEXCOORD2;
35.                                         float3  vTangentMS      :       TEXCOORD3;
36.                                         float3  vBinormalMS     :       TEXCOORD4;
37.                                         float2  vTexCoord       :       TEXCOORD0;
38.                                 };
39.  
40.                                                                
41.                                 VS_OUTPUT vsMain(appdata_full vIn) {
42.                                         VS_OUTPUT vOut;
43.                                         vOut.vPositionPS = mul(UNITY_MATRIX_MVP, vIn.vertex);
44.                                         vOut.vPositionMS = vIn.vertex;
45.                                         vOut.vNormalMS = vIn.normal;
46.                                         vOut.vTexCoord = vIn.texcoord.xy;
47.                                         vOut.vTangentMS = vIn.tangent.xyz;
48.                                         vOut.vBinormalMS = cross(vIn.normal, vIn.tangent.xyz) * vIn.tangent.w;
49.                                         return vOut;
50.                                 };
51.                                                
52.                        
53.                                 struct PS_OUTPUT {
54.                                         float4 vColor   : COLOR0;
55.                                 };
56.                        
57.                                 PS_OUTPUT psMain(VS_OUTPUT vIn) {
58.  
59.                                         vIn.vNormalMS = normalize(vIn.vNormalMS);
60.                                         vIn.vTangentMS = normalize(vIn.vTangentMS);
61.                                         vIn.vBinormalMS = normalize(vIn.vBinormalMS);
62.  
63.                                         // calculate new normal from normal map                                        
64.                                         float3 vNormalTS = tex2D(_normalMap, vIn.vTexCoord).rgb * 2 - 1;
65.                                         float3x3 mTStoMS = float3x3(vIn.vTangentMS, vIn.vBinormalMS, vIn.vNormalMS);
66.                                         vIn.vNormalMS = mul(vNormalTS, mTStoMS);
67.                                
68.                                
69.                                         float3 vCameraPosMS = mul(float4(0,0,0,1), UNITY_MATRIX_IT_MV).xyz;
70.                                         float3 vEyeVecMS = normalize(vCameraPosMS - vIn.vPositionMS);
71.                                        
72.                                         if (dot(vIn.vNormalMS, vEyeVecMS) < 0)
73.                                         {
74.                                                 // normal faces away from camera --> fix it
75.                                                 float3 vCross = cross(vIn.vNormalMS, vEyeVecMS);
76.                                                 vIn.vNormalMS = -cross(vCross, vEyeVecMS);
77.                                         }
78.                                        
79.                                        
80.                                         float3 vLightVecMS = normalize(mul(unity_LightPosition[0], UNITY_MATRIX_IT_MV)).xyz;
81.                                         float3 vReflectedEyeVecMS = -reflect(vEyeVecMS, vIn.vNormalMS);
82.                                
83.                                        
84. //
85. //                                      float4 c = max(0, dot(vLightVecMS, vIn.vNormalMS));                     // lambert lighting
86. //                                      c *= tex2D(_diffuseMap, vIn.vTexCoord);
87. //                                      c += pow(max(0, dot(vReflectedEyeVecMS, vLightVecMS)), 20);     // phong lighting
88. //                                      float4 vRefractionColor = c;
89. //                                     
90.                                         float _refractionValue;
91.                                        
92.                                         float3 vRefractionMS = -normalize(lerp(vEyeVecMS, vIn.vNormalMS, _refractionValue));
93.                                         float3 vRefractionWS = mul(_Object2World, float4(vRefractionMS, 0)).xyz;
94.                                        
95.                                         float4 vRefractionColor = texCUBE(_environmentMap, vRefractionWS);
96.                        
97.                                        
98.                                         float3 vReflectedEyeVecWS = mul(_Object2World, float4(vReflectedEyeVecMS, 0)).xyz;
99.                                        
100.                                         //
101.                                         //float height = 0.1;
102.                                         //float2 vEnvironmentTexcoord = (height/vReflectedEyeVecWS.y) * vReflectedEyeVecWS.xz;
103.                                         //
104.                                        
105.                                         //
106.                                         //float alpha = vReflectedEyeVecWS.x >= 0 ? asin(vReflectedEyeVecWS.z / length(vReflectedEyeVecWS.xz))
107.                                         //                                                                              : 3.14159 - asin(vReflectedEyeVecWS.z / length(vReflectedEyeVecWS.xz));
108.                                         //float beta = asin(vReflectedEyeVecWS.y);
109.                                         //float2 vEnvironmentTexcoord = float2(alpha / (2 * 3.14159), beta / 3.14159 + 0.5);
110.                                         //
111.                                        
112.                                         float4 vReflectionColor = texCUBE(_environmentMap, vReflectedEyeVecWS); //* float4(1, 0.8, 0.3, 0);
113.                                        
114.                                         float fresnell = 1/pow(dot(vIn.vNormalMS, vEyeVecMS) + 1, 8);
115.                                        
116.                                        
117.                                         PS_OUTPUT vOut;
118.                                         vOut.vColor = lerp(vRefractionColor, vReflectionColor, fresnell);
119.                                         return vOut;
120.                                 };
121.                        
122.                                 #pragma vertex vsMain
123.                                 #pragma fragment psMain
124.                                
125.                         ENDCG
126.                 }
127.                
128.                
129.                 pass {
130.                
131.                         Cull Front
132.                        
133.                         CGPROGRAM
134.                                 #include "UnityCG.cginc"
135.                        
136.                                 struct VS_OUTPUT {
137.                                         float4  vPositionPS     :       SV_POSITION;
138.                                 };
139.                                
140.                                 float _outlineWidth;
141.                                
142.                                 VS_OUTPUT vsMain(appdata_full vIn) {
143.                                
144.                                         vIn.vertex.xyz += vIn.normal * _outlineWidth;
145. //                                      vIn.vertex.xyz += vIn.normal * 0.5 * sin(_Time.y + (vIn.texcoord.x * 5 + vIn.texcoord.y * 3) * 3.14159 * 2);
146.                                
147.                                         VS_OUTPUT vOut;
148.                                         vOut.vPositionPS = mul(UNITY_MATRIX_MVP, vIn.vertex);
149.                                         return vOut;
150.                                 };                     
151.                                                
152.                        
153.                                 struct PS_OUTPUT {
154.                                         float4 vColor   : COLOR0;
155.                                 };
156.                        
157.                                 PS_OUTPUT psMain(VS_OUTPUT vIn) {
158.                                         PS_OUTPUT vOut;
159.                                         vOut.vColor = float4(0, 0, 0, 1);
160.                                         return vOut;
161.                                 };
162.                        
163.                                 #pragma vertex vsMain
164.                                 #pragma fragment psMain
165.                                
166.                         ENDCG
167.                 }
168.  
169.         }
170.         FallBack "Diffuse"
171. }
172.