1 | //metal:
|
---|
2 | float3 n, k; // R 700 nm, G 550 nm, B 435 nm
|
---|
3 | float3 F0;
|
---|
4 | /*
|
---|
5 |
|
---|
6 | // copper
|
---|
7 | n = float3(0.21f, 0.96f, 1.17f);
|
---|
8 | k = float3(4.16f, 2.57f, 2.32f); }
|
---|
9 | // gold
|
---|
10 | n = float3(0.16f, 0.35f, 1.6f);
|
---|
11 | k = float3(3.98f, 2.71f, 1.92f); }
|
---|
12 | // silver
|
---|
13 | n = float3(0.142f, 0.124f, 0.158f);
|
---|
14 | k = float3(4.52f, 3.33f, 2.32f); }
|
---|
15 | // alu
|
---|
16 | n = float3(1.83f, 0.96f, 0.577f);
|
---|
17 | k = float3(8.31f, 6.69f, 5.288f); }
|
---|
18 |
|
---|
19 | */
|
---|
20 |
|
---|
21 | // material constants
|
---|
22 | const float3 ambientMaterial= float3(0.3, 0.3, 0.3);
|
---|
23 | const float3 diffuseMaterial = float3(1.0, 1.0, 1.0);
|
---|
24 | const float3 specularMaterial = float3(1.0, 1.0, 1.0);
|
---|
25 |
|
---|
26 | //------------------------------------------------------------------------------------ |
---|
27 | void DISCARD_BY_TEX(float2 Tex) |
---|
28 | { |
---|
29 | if (Tex.x > 1 || Tex.x < 0 || Tex.y > 1 || Tex.y < 0) |
---|
30 | discard; |
---|
31 | }
|
---|
32 |
|
---|
33 | //------------------------------------------
|
---|
34 | // Attenuation with the square of the distance
|
---|
35 | //------------------------------------------
|
---|
36 | float SQR(float x) { return x*x; }
|
---|
37 | float Attenuation(float3 Light)
|
---|
38 | {
|
---|
39 | return 1.0 / dot(Light, Light);
|
---|
40 | }
|
---|
41 |
|
---|
42 | //-----------------------------------------------------------------------------
|
---|
43 | // Illumination function used in shading: all input vectors are normalized
|
---|
44 | //-----------------------------------------------------------------------------
|
---|
45 | /*
|
---|
46 | float4 Illumination(float3 Light, float3 Normal, float3 View, float2 TexCoord, float Attenuation)
|
---|
47 | {
|
---|
48 | // Blinn lighting
|
---|
49 | float3 Half = normalize(Light + View);
|
---|
50 | float Diffuse = dot(Normal, Light);
|
---|
51 | float Specular = dot(Normal, Half);
|
---|
52 | float4 Lighting = lit(Diffuse, Specular, 16);
|
---|
53 | float4 Color= tex2D(ColorMapSampler, TexCoord);
|
---|
54 |
|
---|
55 | return float4(
|
---|
56 | Lighting.x * ambientMaterial * Color +
|
---|
57 | (Lighting.y * diffuseMaterial * Color +
|
---|
58 | Lighting.z * specularMaterial) * Attenuation, 1);
|
---|
59 | }*/ |
---|
60 | |
---|
61 | //-----------------------------------------------------------------------------
|
---|
62 | // Computes transformation matrix from modeling to tangent space
|
---|
63 | //-----------------------------------------------------------------------------
|
---|
64 | float3x3 TransfModelToTangent( in float3 Tangent, in float3 Binormal, in float3 Normal ) { |
---|
65 | float T2 = dot(Tangent, Tangent);
|
---|
66 | float B2 = dot(Binormal, Binormal);
|
---|
67 | float N2 = dot(Normal, Normal);
|
---|
68 | float BT = dot(Binormal, Tangent);
|
---|
69 | float det = B2 * T2 - BT * BT;
|
---|
70 |
|
---|
71 | return float3x3( (B2 * Tangent - BT * Binormal)/det,
|
---|
72 | (T2 * Binormal - BT * Tangent)/det,
|
---|
73 | Normal/N2 );
|
---|
74 | /*
|
---|
75 | // simplified solution |
---|
76 | return float3x3(Tangent/T2, Binormal/B2, Normal/N2); |
---|
77 | */ |
---|
78 | }
|
---|
79 |
|
---|
80 | float4 readCubeMap(samplerCUBE cm, float3 coord)
|
---|
81 | {
|
---|
82 | float4 color = texCUBE( cm, float3(coord.xy, - coord.z) );
|
---|
83 | return color;
|
---|
84 | }
|
---|
85 |
|
---|
86 | float readDistanceCubeMap(samplerCUBE dcm, float3 coord)
|
---|
87 | {
|
---|
88 | float dist = texCUBE(dcm, float3(coord.xy, - coord.z)).r;
|
---|
89 | if(dist == 0) dist = 10000; ///sky
|
---|
90 | return dist;
|
---|
91 | }
|
---|
92 |
|
---|
93 | // This function is called several times.
|
---|
94 | float3 Hit( float3 x, float3 R, samplerCUBE mp )
|
---|
95 | {
|
---|
96 | float rl = readDistanceCubeMap( mp, R); // |r|
|
---|
97 |
|
---|
98 | float ppp = length( x ) / readDistanceCubeMap( mp, x); // |p|/|p|
|
---|
99 | float dun = 0, pun = ppp, dov = 0, pov = 0;
|
---|
100 | float dl = rl * ( 1 - ppp ); // eq. 2
|
---|
101 | float3 l = x + R * dl; // ray equation
|
---|
102 |
|
---|
103 | // iteration
|
---|
104 | for( int i = 0; i < 6; i++ ) // 2 !!!!!!!!!!!!!!!!!!!!!!!
|
---|
105 | {
|
---|
106 | float llp = length( l ) / readDistanceCubeMap( mp, l); // |l|/|l|
|
---|
107 | if ( llp < 0.999f ) // undershooting
|
---|
108 | {
|
---|
109 | dun = dl; pun = llp; // last undershooting
|
---|
110 | dl += ( dov == 0 ) ? rl * ( 1 - llp ) : // eq. 2
|
---|
111 | ( dl - dov ) * ( 1 - llp ) / ( llp - pov ); // eq. 3
|
---|
112 | } else if ( llp > 1.001f ) // overshooting
|
---|
113 | {
|
---|
114 | dov = dl; pov = llp; // last overshooting
|
---|
115 | dl += ( dl -dun ) * ( 1 - llp ) / ( llp - pun );// eq. 3
|
---|
116 | }
|
---|
117 | l = x + R * dl; // ray equation
|
---|
118 | }
|
---|
119 | return l; // computed hit point
|
---|
120 | }
|
---|
121 |
|
---|
122 | float4 metal_reflectivity(float3 L, float3 N, float3 V)
|
---|
123 | {
|
---|
124 |
|
---|
125 |
|
---|
126 | float ctheta_in = dot(N,L);
|
---|
127 | float ctheta_out = dot(N,V);
|
---|
128 |
|
---|
129 | float4 intens = 0;
|
---|
130 |
|
---|
131 | // F,P,G számítása
|
---|
132 | if ( ctheta_in > 0 && ctheta_out > 0 )
|
---|
133 | {
|
---|
134 | float3 H = normalize(L + V); // felezõvektor
|
---|
135 | float calpha = dot(N,H);
|
---|
136 | float cbeta = dot(H,L);
|
---|
137 |
|
---|
138 | float3 F = ( (n-1)*(n-1) + pow(1-cbeta,5) * 4*n + k*k) / ( (n+1)*(n+1) + k*k );
|
---|
139 |
|
---|
140 | float m = 0.8;
|
---|
141 | float m2 = m*m;
|
---|
142 | float PI = 3.14159f;
|
---|
143 |
|
---|
144 | float calpha2 = calpha*calpha;
|
---|
145 | float salpha2 = 1-calpha2;
|
---|
146 |
|
---|
147 | float P = exp( -( salpha2 / calpha2 / m2 )) / (m2 * PI * calpha * calpha2);
|
---|
148 |
|
---|
149 | float f1 = 2*calpha*ctheta_out/cbeta;
|
---|
150 | float f2 = 2*calpha*ctheta_in /cbeta;
|
---|
151 | float G = min(1, min( f1, f2 )) / 4 / ctheta_in / ctheta_out;
|
---|
152 | //float GG = 1 / (4*cbeta*cbeta);
|
---|
153 |
|
---|
154 | //F*P*G*ctheta_in
|
---|
155 | intens += float4(F, 1) * P * G * ctheta_in;
|
---|
156 | }
|
---|
157 |
|
---|
158 | return 3*intens;
|
---|
159 | }
|
---|
160 |
|
---|
161 | float3 expand(float3 v) |
---|
162 | { |
---|
163 | return (v - 0.5) * 2; |
---|
164 | } |
---|
165 |
|
---|
166 | float2 PARALLAX_MAPPING(sampler2D heightMap, float2 TexCoord, float3 View) |
---|
167 | { |
---|
168 | float HEIGHT_SCALE = 0.06; |
---|
169 | float HEIGHT_BIAS = -0.12; |
---|
170 | float h = tex2D(heightMap, TexCoord).r * HEIGHT_SCALE + HEIGHT_BIAS; |
---|
171 | return TexCoord + h * View.xy / View.z; |
---|
172 | }
|
---|
173 |
|
---|
174 | struct VS_INPUT { |
---|
175 | float4 Position : POSITION; // point in modeling space |
---|
176 | float2 TexCoord : TEXCOORD0; // texture coordinates |
---|
177 | float3 Tangent : TEXCOORD1; // model space tangent vector |
---|
178 | float3 Normal : NORMAL; // model space triangle normal vector |
---|
179 | }; |
---|
180 | |
---|
181 | struct VS_OUTPUT { |
---|
182 | float4 hPosition : POSITION; // point in normalized device space before homogeneous division |
---|
183 | float2 TexCoord : TEXCOORD0; // texture coordinates |
---|
184 | float3 Normal : TEXCOORD1; // model space triangle normal vector
|
---|
185 | float3 wPosition : TEXCOORD2; // model space tangent vector
|
---|
186 | float3 Tangent : TEXCOORD3; // model space tangent vector |
---|
187 | float3 Binormal : TEXCOORD4; // model space binormal vector |
---|
188 | };
|
---|
189 |
|
---|
190 | VS_OUTPUT LocalizedBumpVS(VS_INPUT IN,
|
---|
191 | uniform float4x4 worldViewProj,
|
---|
192 | uniform float4x4 worldViewIT,
|
---|
193 | uniform float4x4 world)
|
---|
194 | {
|
---|
195 | VS_OUTPUT OUT;
|
---|
196 | OUT.hPosition = mul(worldViewProj, IN.Position);
|
---|
197 | OUT.wPosition = mul(world, IN.Position).xyz;
|
---|
198 | //OUT.Normal = mul(worldViewIT, IN.Normal);
|
---|
199 | OUT.Normal = IN.Normal;
|
---|
200 | OUT.TexCoord = IN.TexCoord;
|
---|
201 | OUT.Tangent = IN.Tangent;
|
---|
202 | OUT.Binormal = cross(IN.Tangent, IN.Normal);
|
---|
203 |
|
---|
204 | return OUT;
|
---|
205 | }
|
---|
206 |
|
---|
207 | //////////////
|
---|
208 | //Localized reflection with bump
|
---|
209 | //////////////
|
---|
210 | /*
|
---|
211 | VS_OUTPUT BaseVS(VS_INPUT IN)
|
---|
212 | {
|
---|
213 | VS_OUTPUT OUT;
|
---|
214 |
|
---|
215 |
|
---|
216 | OUT.Tangent = IN.Tangent;
|
---|
217 | OUT.Binormal = IN.Binormal;
|
---|
218 | OUT.Normal = IN.Normal;
|
---|
219 |
|
---|
220 | // vertex position before homogenious division
|
---|
221 | OUT.hPosition = mul(IN.Position, WorldViewProj);
|
---|
222 | // tex coordinates passed to pixel shader
|
---|
223 | OUT.TexCoord = IN.TexCoord0;
|
---|
224 |
|
---|
225 | return OUT;
|
---|
226 | }
|
---|
227 | float4 BumpPS(VS_OUTPUT IN) : COLOR |
---|
228 | { |
---|
229 | |
---|
230 | // get model space normal vector |
---|
231 | float3x3 ModelToTangent = TransfModelToTangent(IN.Tangent, IN.Binormal, IN.Normal ); |
---|
232 | // get model space normal vector |
---|
233 | float3 tNormal = tex2D(BumpMapSampler, IN.TexCoord).rgb; |
---|
234 | // Normal vector should be transformed with the inverse transpose of TangentToModel |
---|
235 | // which is the transpose of ModelToTangent |
---|
236 | float3 mNormal = normalize( mul( tNormal, ModelToTangent ) ); |
---|
237 | |
---|
238 | }
|
---|
239 | */
|
---|
240 |
|
---|
241 | void LocalizedBumpPS( VS_OUTPUT IN,
|
---|
242 | uniform float3 cameraPos,
|
---|
243 | uniform samplerCUBE CubeMap : register(s0),
|
---|
244 | uniform samplerCUBE DistanceMap : register(s1),
|
---|
245 | uniform sampler2D NormalMap : register(s2),
|
---|
246 | uniform sampler2D DisplacementMap : register(s3),
|
---|
247 | uniform float3 lastCenter,
|
---|
248 | uniform float3 lightPosition,
|
---|
249 | out float4 Color :COLOR0)
|
---|
250 | {
|
---|
251 | // get model space normal vector |
---|
252 | float3x3 ModelToTangent = TransfModelToTangent(IN.Tangent, IN.Binormal, IN.Normal ); |
---|
253 | // get model space normal vector |
---|
254 | |
---|
255 | //parallax |
---|
256 | /* |
---|
257 | float3 tView = mul(ModelToTangent, IN.wPosition ); |
---|
258 | float2 ParallaxTex = PARALLAX_MAPPING(DisplacementMap, IN.TexCoord, tView); |
---|
259 | float3 tNormal = tex2D(NormalMap, ParallaxTex).rgb; |
---|
260 | */ |
---|
261 | |
---|
262 | float3 tNormal = tex2D(NormalMap, IN.TexCoord).rgb; |
---|
263 | float3 mNormal = normalize( mul( tNormal, ModelToTangent ) );
|
---|
264 |
|
---|
265 | //Color = float4(tex2D(DisplacementMap, IN.TexCoord).rgb, 1 + lastCenter.x * 0.000000001);
|
---|
266 | Color = float4(1,1,1,1);
|
---|
267 |
|
---|
268 | float3 RR, TT;
|
---|
269 | float3 mPos = IN.wPosition - lastCenter;
|
---|
270 | float3 V = normalize(IN.wPosition - cameraPos);
|
---|
271 | float3 R = (reflect( V, mNormal));
|
---|
272 |
|
---|
273 | float3 T = refract(V, mNormal, 0.9);
|
---|
274 |
|
---|
275 | RR = R; TT = T;
|
---|
276 | RR = Hit(mPos, R, DistanceMap);
|
---|
277 | TT = Hit(mPos, T, DistanceMap);
|
---|
278 |
|
---|
279 | float4 reflectcolor = readCubeMap(CubeMap, RR );
|
---|
280 | float4 refractcolor = readCubeMap(CubeMap, TT );
|
---|
281 |
|
---|
282 | float cos_theta = -dot(V, mNormal);
|
---|
283 | float sFresnel = 0.4;
|
---|
284 | float F = (sFresnel + pow(1-cos_theta, 5.0f) * (1-sFresnel));
|
---|
285 |
|
---|
286 | float3 L = normalize(lightPosition - IN.wPosition);
|
---|
287 | float3 H = normalize(L+V);
|
---|
288 | float4 lighting = lit(dot(mNormal, L),dot(mNormal, H), 30);
|
---|
289 | Color = (F * reflectcolor + (1-F) * refractcolor)/* + lighting.z *1000*/;
|
---|
290 | }
|
---|
291 |
|
---|
292 |
|
---|
293 | //////////////
|
---|
294 | //Metal
|
---|
295 | //////////////
|
---|
296 | void LocalizedMetalPS( float2 texCoord : TEXCOORD0,
|
---|
297 | float3 wPos : TEXCOORD1,
|
---|
298 | float3 mNormal : TEXCOORD2,
|
---|
299 | uniform float3 cameraPos,
|
---|
300 | uniform samplerCUBE CubeMap : register(s0),
|
---|
301 | uniform samplerCUBE DistanceMap : register(s1),
|
---|
302 | uniform float3 lastCenter,
|
---|
303 | uniform float3 lightPosition,
|
---|
304 | out float4 Color :COLOR0)
|
---|
305 | {
|
---|
306 |
|
---|
307 | Color = float4(1,1,1,1);
|
---|
308 |
|
---|
309 | mNormal = normalize(mNormal);
|
---|
310 | float3 newTexCoord;
|
---|
311 | float3 mPos = wPos - lastCenter;
|
---|
312 | float3 V = normalize(wPos - cameraPos);
|
---|
313 | float3 R = normalize(reflect( V, mNormal));
|
---|
314 |
|
---|
315 | newTexCoord = R;
|
---|
316 |
|
---|
317 | newTexCoord = Hit(mPos, R, DistanceMap);
|
---|
318 |
|
---|
319 | Color = readCubeMap(CubeMap, newTexCoord );
|
---|
320 |
|
---|
321 | float ctheta_in = dot(mNormal,R);
|
---|
322 | float ctheta_out = dot(mNormal,-V);
|
---|
323 |
|
---|
324 | float3 F = 0;
|
---|
325 |
|
---|
326 | // F,P,G számítása
|
---|
327 | if ( ctheta_in > 0 && ctheta_out > 0 )
|
---|
328 | {
|
---|
329 | float3 H = normalize(R - V); // felezõvektor
|
---|
330 | float cbeta = dot(H,R);
|
---|
331 | //F = ( (n-1)*(n-1) + pow(1-cbeta,5) * 4*n + k*k) / ( (n+1)*(n+1) + k*k );
|
---|
332 | //float3 F0 = ((n-1)*(n-1) + k*k) / ( (n+1)*(n+1) + k*k );
|
---|
333 | //float3 F1 = float3(1.0f,1.0f,1.0f) - F0;
|
---|
334 | F = F0 + (1-F0)*pow(1-cbeta,5);
|
---|
335 | }
|
---|
336 |
|
---|
337 | //Color *= metal_reflectivity(R, mNormal, -V);
|
---|
338 |
|
---|
339 | Color = Color * float4(F,1);
|
---|
340 | }
|
---|