source: GTP/trunk/App/Demos/Illum/Ogre/Media/materials/programs/GameTools_Localized_EnvMap.hlsl @ 1487

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