source: GTP/trunk/App/Games/CarDriving_BME/Media/materials/programs/GameTools_Localized_EnvMap.hlsl @ 2514

Revision 2514, 11.3 KB checked in by szirmay, 17 years ago (diff)
Line 
1#define EFFECTS
2#define LOCALIZATION
3
4//metal:
5float3 n, k;    // R 700 nm, G 550 nm, B 435 nm
6float REDUCED_CUBEMAP_SIZE = 4;
7
8float3 F0;
9/*
10       
11        if (iWhichMetal == 1) { // copper       
12                n = float3(0.21f, 0.96f, 1.17f);       
13                k = float3(4.16f, 2.57f, 2.32f); }
14        else if (iWhichMetal == 2) { // gold
15                n = float3(0.16f, 0.35f, 1.6f);         
16                k = float3(3.98f, 2.71f, 1.92f); }
17        else if (iWhichMetal == 3) { // silver
18                n = float3(0.142f, 0.124f, 0.158f);     
19                k = float3(4.52f,  3.33f, 2.32f); }
20        else if (iWhichMetal == 4) { // alu
21                n = float3(1.83f, 0.96f, 0.577f);
22                k = float3(8.31f,  6.69f, 5.288f); }
23
24*/     
25
26float4 readCubeMap(samplerCUBE cm, float3 coord)               
27{
28        float4 color = texCUBE( cm, float3(coord.xy, - coord.z) );
29        return color;
30}
31
32float readDistanceCubeMap(samplerCUBE dcm, float3 coord)               
33{
34        float dist = texCUBE(dcm, float3(coord.xy, - coord.z)).r;
35        if(dist == 0) dist = 40; ///sky
36        return dist;
37}
38
39/*
40float3 Hit( float3 x, float3 R, samplerCUBE mp )
41{
42 
43        float rl = readDistanceCubeMap(mp, R); // |r|
44       
45        float dp = rl - dot(x, R);              // parallax
46       
47        float3 p = x + R * dp;
48        return p;
49}*/
50
51
52
53
54// This function is called several times.
55float3 Hit( float3 x, float3 R, samplerCUBE mp )
56{
57        float rl = readDistanceCubeMap( mp, R);                         // |r|
58       
59        float ppp = length( x ) /  readDistanceCubeMap( mp, x);                 // |p|/|p’|
60        float dun = 0, pun = ppp, dov = 0, pov = 0;
61        float dl = rl * ( 1 - ppp );                                                    // eq. 2
62        float3 l = x + R * dl;                                                                  // ray equation
63
64        // iteration
65        for( int i = 0; i < 2; i++ )    // 2 !!!!!!!!!!!!!!!!!!!!!!!
66        {
67                float llp = length( l ) / readDistanceCubeMap( mp, l);          // |l|/|l’|
68                if ( llp < 0.999f )                                                                     // undershooting
69                {
70                        dun = dl; pun = llp;                                                    // last undershooting
71                        dl += ( dov == 0 ) ? rl * ( 1 - llp ) :                 // eq. 2
72                                ( dl - dov ) * ( 1 - llp ) / ( llp - pov );     // eq. 3
73                } else if ( llp > 1.001f )                                                      // overshooting
74                {
75                        dov = dl; pov = llp;                                                    // last overshooting
76                        dl += ( dl -dun ) * ( 1 - llp ) / ( llp - pun );// eq. 3
77                }
78                l = x + R * dl;                                                                         // ray equation
79        }
80        return l;                                                                                               // computed hit point
81}
82
83void LocalizedVS(float4 position : POSITION,
84                out float3 wPos : TEXCOORD1,                           
85                float2 texCoord : TEXCOORD0,
86                out float2 otexCoord : TEXCOORD0,
87                float3 normal   : NORMAL,
88                out float3 mNormal  : TEXCOORD2,
89                out float4 hPos : POSITION,             
90                uniform float4x4 worldViewProj,
91                uniform float4x4 world,
92                uniform float4x4 worldIT)
93{
94 
95  hPos = mul(worldViewProj, position);
96  wPos = mul(world, position).xyz; 
97  mNormal = mul(normal, worldIT);
98 // mNormal = normal;
99  otexCoord = texCoord;
100}
101//////////////
102//Localized reflection
103//////////////
104void LocalizedPS(  float2 texCoord : TEXCOORD0,
105                float3 wPos     : TEXCOORD1,   
106                float3 mNormal  : TEXCOORD2,
107                uniform float3 cameraPos,
108                uniform samplerCUBE CubeMap : register(s0),
109                uniform samplerCUBE DistanceMap : register(s1),
110                uniform float3 lastCenter,
111                uniform float3 lightPosition,           
112                out float4 Color :COLOR0)
113{
114       
115        Color = float4(1,1,1,1);
116       
117        mNormal = normalize(mNormal);
118        float3 RR, TT; 
119        float3 mPos = wPos - lastCenter;
120        float3 V = normalize(wPos - cameraPos);
121        float3 R = normalize(reflect( V, mNormal));
122       
123        float3 T =  normalize(refract(V, mNormal, 0.9));
124               
125        RR = R; TT = T;
126       
127        //RR += 0.000001 * lastCenter.x;
128       
129        RR = Hit(mPos, R, DistanceMap);
130        TT = Hit(mPos, T, DistanceMap);
131       
132        float4 reflectcolor = readCubeMap(CubeMap, RR );               
133        float4 refractcolor = readCubeMap(CubeMap, TT );               
134       
135        float cos_theta = -dot(V, mNormal);
136        float sFresnel = 0.2;
137        float F = (sFresnel + pow(1-cos_theta, 5.0f) * (1-sFresnel));
138 
139
140        Color = (F * reflectcolor + (1-F) * refractcolor) ;     
141}
142
143
144
145//////////////
146//Metal
147//////////////
148void LocalizedMetalPS(  float2 texCoord : TEXCOORD0,
149                float3 wPos     : TEXCOORD1,   
150                float3 mNormal  : TEXCOORD2,
151                uniform float3 cameraPos,
152                uniform samplerCUBE CubeMap : register(s0),
153                uniform samplerCUBE DistanceMap : register(s1),
154                uniform float3 lastCenter,
155                uniform float3 lightPosition,                           
156                out float4 Color :COLOR0)
157{
158       
159        Color = float4(1,1,1,1);
160       
161        mNormal = normalize(mNormal);
162        float3 newTexCoord;     
163        float3 mPos = wPos - lastCenter;
164        float3 V = normalize(wPos - cameraPos);
165
166        float3 R = normalize(reflect( V, mNormal));
167               
168#ifdef EFFECTS
169        newTexCoord = R;       
170#ifdef LOCALIZATION
171        newTexCoord = Hit(mPos, R, DistanceMap);
172#endif
173        Color = readCubeMap(CubeMap, newTexCoord );
174#else
175        Color = 1;     
176#endif
177
178        //Color = float4(mNormal + lastCenter.x*0.0000001, 1); 
179       
180        float ctheta_in = dot(mNormal,R);
181        float ctheta_out = dot(mNormal,-V);
182
183        float3 F = 0;
184       
185        // F,P,G számítása
186        if ( ctheta_in > 0 && ctheta_out > 0 )
187        {
188                float3 H = normalize(R - V);    // felezõvektor
189                float cbeta  = dot(H,R);               
190                //F = ( (n-1)*(n-1) + pow(1-cbeta,5) * 4*n + k*k) / ( (n+1)*(n+1) + k*k );
191                //float3 F0 = ((n-1)*(n-1) + k*k) / ( (n+1)*(n+1) + k*k );
192                //float3 F1 = float3(1.0f,1.0f,1.0f) - F0;
193                F = F0 + (1-F0)*pow(1-cbeta,5);
194        }       
195       
196        Color = Color * float4(F,1);   
197        //Color = length(lastCenter.xyz) * 0.1;
198}
199//////////////
200//PhotonMap
201//////////////
202/*void PhotonMapPS(  float2 texCoord : TEXCOORD0,
203                float3 wPos     : TEXCOORD1,   
204                float3 mNormal  : TEXCOORD2,
205                uniform float3 cameraPos,
206                uniform samplerCUBE UVMap : register(s0),
207                uniform samplerCUBE DistanceMap : register(s1),
208                uniform float3 lastCenter,
209                out float4 Color :COLOR0)
210{
211       
212        Color = float4(1,1,1,1);
213       
214        mNormal = normalize(mNormal);
215        float3 newTexCoord;     
216        float3 mPos = wPos - lastCenter;
217        float3 V = normalize(wPos - cameraPos);
218        float3 R = normalize(reflect( V, mNormal));
219               
220        newTexCoord = R;       
221       
222        newTexCoord = Hit(mPos, R, DistanceMap);
223       
224        Color = readCubeMap(UVMap, newTexCoord );
225        //Color = float4(1,0,0,1);             
226}*/
227
228float4 PhotonMapCausticPS(  float2 texCoord : TEXCOORD0,
229                float3 wPos     : TEXCOORD1,   
230                float3 mNormal  : TEXCOORD2,
231                uniform float3 cameraPos,
232                uniform samplerCUBE DistanceMap : register(s0),
233                uniform float3 lastCenter):COLOR0
234{
235       
236        float4 Color = float4(1,1,1,1);
237       
238        mNormal = normalize(mNormal);
239        float3 newTexCoord;     
240        float3 mPos = wPos - lastCenter;
241        float3 V = normalize(wPos - cameraPos);
242        float3 R = normalize(reflect( V, mNormal ));
243               
244        newTexCoord = R;       
245       
246        newTexCoord = Hit(mPos, R, DistanceMap);
247               
248        Color = float4(normalize(newTexCoord),1);
249       
250        //Color = 0.0001 * Color +  float4(0,0,1,1);
251        //Color += 0.0001 * lastCenter.x;
252        //if(dot(V,mNormal)>0)
253        //{
254        //      Color = float4(1,0,0,0);               
255        //}             
256        return Color;
257}
258
259void PhotonMapSoftShadowPS(  float2 texCoord : TEXCOORD0,
260                float3 wPos     : TEXCOORD1,   
261                float3 mNormal  : TEXCOORD2,
262                uniform float3 cameraPos,
263                uniform samplerCUBE DistanceMap : register(s0),
264                uniform float3 lastCenter,
265                out float4 Color :COLOR0)
266{
267       
268        Color = float4(1,1,1,1);
269       
270        mNormal = normalize(mNormal);
271        float3 newTexCoord;     
272        float3 mPos = wPos - lastCenter;
273        float3 V = normalize(wPos - cameraPos);
274        newTexCoord = V;       
275       
276        newTexCoord = Hit(mPos, V, DistanceMap);
277       
278        Color = float4(normalize(newTexCoord),1);
279}
280
281/////////////////////
282///// Diffuse
283///////////////////
284
285float4 GetContibution(float3 L, float3 pos, float3 N, float3 V, samplerCUBE SmallEnvMapSampler, samplerCUBE DistanceEnvMapSampler)      // Phong-Blinn
286// L: a hossza lényeges (az egységkocka faláig ér)
287{
288    REDUCED_CUBEMAP_SIZE = 4;
289   
290        float kd = 0.3; // 0.3
291        float ks = 0;   // 0.5
292        float shininess = 10;
293       
294        float l = length(L);
295        L = normalize(L);
296
297        //dw
298        float dw = 4 / (REDUCED_CUBEMAP_SIZE*REDUCED_CUBEMAP_SIZE*l*l*l + 4/3.1416f);
299        //Lin
300        float4 Lin = readCubeMap(SmallEnvMapSampler, L);
301        //r
302        float doy = readDistanceCubeMap(DistanceEnvMapSampler, L);
303        float dxy = length(L * doy - pos);     
304
305        //dws
306        float dws = (doy*doy * dw) / (dxy*dxy*(1 - dw/3.1416f) + doy*doy*dw/3.1416f);   // localization:
307        //float dws = dw;
308       
309        //L = L * doy - pos;    // L: x->y, az objektumtól induljon, ne a középpontból
310        L = normalize(L);
311        float3 H = normalize(L + V);    // felezõvektor
312
313        float a = kd * max(dot(N,L),0) +
314                          ks * pow(max(dot(N,H),0), shininess); // diffuse + specular
315
316        // 1.: eddigi
317        //return Lin * a * dws;
318       
319        float ctheta_in = dot(N,L);
320        float ctheta_out = dot(N,V);   
321       
322        return Lin * a * dws;           
323}
324
325void DiffuseVS( float4 position : POSITION,
326                float3 normal : NORMAL,
327                float2 Tex : TEXCOORD0,
328                uniform float4x4 worldViewProj,
329                                uniform float4x4 world,
330                                //uniform float3 lastCenter,    //LI//
331                                out float4 hposition : POSITION,
332                out float2 oTex : TEXCOORD0,
333                out float3 Normal : TEXCOORD1,
334                out float3 pos : TEXCOORD2 )
335{
336        pos = /*lastCenter + 0.01 * */mul( world, position ).xyz;
337        Normal = normal;
338    oTex = Tex;   
339    hposition = mul( worldViewProj, position );
340}
341
342
343float4 DiffusePS( float2 Tex : TEXCOORD0,
344           float3 pos : TEXCOORD1,
345           float3 N : TEXCOORD2,
346           uniform float3 cameraPos,
347           uniform float3 lastCenter,   //LI//
348           uniform half3 lightPosition,
349           uniform samplerCUBE SmallEnvMapSampler : register(s0),
350           uniform samplerCUBE DistanceEnvMapSampler : register(s1),
351                        uniform sampler2D ColorTexture : register(s2)
352            ) : COLOR0
353{
354    REDUCED_CUBEMAP_SIZE = 8;
355       
356    //V = /*-*/normalize( V );
357    float3 V = normalize(pos - cameraPos);      //
358    N = normalize( N );
359        float3 R = reflect(V, N);
360    pos -= lastCenter;
361
362       
363    //return float4(N,1);
364    //return float4(V,1);
365    //return float4(R,1);
366               
367        //return readCubeMap(SmallEnvMapSampler,R);
368       
369    //pos.xy += float2(1.0/LIGHT_TEXTURE_SIZE, -1.0/LIGHT_TEXTURE_SIZE);        // eltolás a pixel/texel középpontba
370    // x, y = -1..1
371    // z = 1
372   
373    float4 intens = 0;
374    /*
375        intens += GetContibution( R, pos, N, V, SmallEnvMapSampler);
376        intens = readCubeMap(SmallEnvMapSampler, R);
377        return intens;*/
378       
379        for (int x = 0; x < REDUCED_CUBEMAP_SIZE; x++)                  // az envmap minden texelére
380         for (int y = 0; y < REDUCED_CUBEMAP_SIZE; y++)
381        //int x = 0;            // az envmap 1 texelére
382        //int y = 0;
383        //if (x==LIGHT_TEXTURE_SIZE/2 && y==LIGHT_TEXTURE_SIZE/2)
384         {
385                // intenzitás kiolvasása az adott texelbõl
386               
387                float2 p, tpos;
388            tpos.x = x/(float)REDUCED_CUBEMAP_SIZE;     // 0..1
389            tpos.y = y/(float)REDUCED_CUBEMAP_SIZE;     // 0..1
390            tpos.xy += float2(0.5/REDUCED_CUBEMAP_SIZE, 0.5/REDUCED_CUBEMAP_SIZE);      // az adott texel középpont uv koordinátái
391           
392            p.x = tpos.x;
393            p.y = 1-tpos.y;
394            p.xy = 2*p.xy - 1;  // -1..1        // az adott texel középpont pozíciója
395           
396            float3 L;
397           
398                L = float3(p.x, p.y, 1);
399                intens += GetContibution( L, pos, N, V, SmallEnvMapSampler, DistanceEnvMapSampler);
400               
401                L = float3(p.x, p.y, -1);
402                intens += GetContibution( L, pos, N, V, SmallEnvMapSampler, DistanceEnvMapSampler);
403               
404                L = float3(p.x, 1, p.y);
405                intens += GetContibution( L, pos, N, V, SmallEnvMapSampler, DistanceEnvMapSampler);
406               
407                L = float3(p.x, -1, p.y);
408                intens += GetContibution( L, pos, N, V, SmallEnvMapSampler, DistanceEnvMapSampler);
409               
410                L = float3(1, p.x, p.y);
411                intens += GetContibution( L, pos, N, V, SmallEnvMapSampler, DistanceEnvMapSampler);
412               
413                L = float3(-1, p.x, p.y);
414                intens += GetContibution( L, pos, N, V, SmallEnvMapSampler, DistanceEnvMapSampler);
415        }
416
417        float4 retColor = intens;
418        retColor *= tex2D(ColorTexture, Tex);
419        return retColor;
420}
Note: See TracBrowser for help on using the repository browser.