source: GTP/trunk/App/Demos/Illum/Ogre/Media/materials/GTPAdvancedEnvMap/multibounce/GTPMultipleReflection_good.hlsl @ 2175

Revision 2175, 7.0 KB checked in by szirmay, 17 years ago (diff)
Line 
1float4 readCubeMap(samplerCUBE cm, float3 coord)               
2{
3        float4 color = texCUBElod( cm, float4(coord.xy, - coord.z,0) );
4        return color;
5}
6
7float readDistanceCubeMap(samplerCUBE dcm, float3 coord)               
8{
9        float dist = texCUBElod(dcm, float4(coord.xy, - coord.z,0)).a;
10        return dist;
11}
12
13#define MAX_LIN_ITERATIONCOUNT 50  //80
14#define MIN_LIN_ITERATIONCOUNT 30  //60
15#define SECANT_ITERATIONCOUNT 1
16#define MAX_RAY_DEPTH 2
17
18void linearSearch(  float3 x, float3 R, float3 N, samplerCUBE mp,
19                    out float3 p,
20                    out float dl,
21                    out float dp,
22                    out float llp,
23                    out float ppp)
24{
25 float3 Ra = abs(R), xa = abs(x);
26 float xm =  max(max(xa.x,xa.y),xa.z);
27 float Rm = max(max(Ra.x,Ra.y),Ra.z);
28 float a = xm / Rm;
29 
30 int shootL = 0, shootP = 0;         
31 bool found = false;
32 
33 float dt =  length(x / xm - R / Rm) * MAX_LIN_ITERATIONCOUNT;
34 dt = max(dt, MIN_LIN_ITERATIONCOUNT);
35 dt = 1.0 / dt;
36   
37 float t = 0.01;//dt;
38 float pa;
39 
40 //Linear iteration
41 while(t <= 1.0 && !found)
42 {
43   dp = a * t / (1 - t);
44   p = x + R * dp;
45   pa = readDistanceCubeMap(mp, p);
46     
47   if(pa > 0)
48   {
49    ppp = length(p) / pa;
50    if(ppp < 1)
51      shootP = -1;
52    else
53      shootP = 1;     
54    if(shootL * shootP == -1)
55      found = true;
56    else
57    {
58      shootL = shootP;
59      dl = dp;
60      llp = ppp;
61    }
62   }
63   else
64     shootL = 0;
65     
66   t += dt; 
67 }
68
69 if(!found)
70  p = float3(0,0,0);
71}
72
73
74void secantSearch(float3 x, float3 R, samplerCUBE mp,
75                       float dl,
76                       float dp,
77                       float llp,
78                       float ppp,
79                       out float3 p)
80{
81  for(int i= 0; i < SECANT_ITERATIONCOUNT; i++)
82  {
83   float dnew;
84   dnew = dl + (dp - dl) * (1 - llp) / (ppp - llp);
85   p = x + R * dnew;
86   half pppnew = length(p) / readDistanceCubeMap(mp, p);
87   if(pppnew < 1)
88   {
89    llp = pppnew;
90    dl = dnew;
91   }
92   else
93   {
94    ppp = pppnew;
95    dp = dnew;
96   }
97  }
98}
99
100float3 Hit(float3 x, float3 R, float3 N,
101           samplerCUBE mp1,
102           samplerCUBE mp2,
103           samplerCUBE mp3Color,
104           samplerCUBE mp3Dist,
105           out float4 Il, out float3 Nl)
106{
107 float dl1 = 0, dp1, llp1, ppp1;
108 float3 p1;
109 linearSearch(x, R, N, mp1, p1, dl1, dp1, llp1, ppp1);
110 float dl2 = 0, dp2, llp2, ppp2;
111 float3 p2;
112 linearSearch(x, R, N, mp2, p2, dl2, dp2, llp2, ppp2);
113 
114 bool valid1 = dot(p1,p1) != 0;
115 bool valid2 = dot(p2,p2) != 0;
116               
117 float dl, dp, llp, ppp;
118 float3 p;
119 
120 if(!valid1 && ! valid2)
121 {
122    linearSearch(x, R, N, mp3Dist, p, dl, dp, llp, ppp);
123    Il.a = 1;
124    secantSearch(x, R, mp3Dist, dl, dp, llp, ppp, p);
125    Il.rgb =  Nl.rgb = readCubeMap(mp3Color, p).rgb; 
126 }
127 else
128 {
129    if( !valid2 || (valid1 && dp1 < dp2))
130    {
131     secantSearch(x, R, mp1, dl1, dp1, llp1, ppp1, p1);
132     Il.rgb =  Nl.rgb = readCubeMap(mp1, p1).rgb;
133     p = p1;
134    }
135    else
136    {
137     secantSearch(x, R, mp2, dl2, dp2, llp2, ppp2, p2);
138     Il.rgb =  Nl.rgb = readCubeMap(mp2, p2).rgb;
139     p = p2;
140    }
141    Il.a = 0;   
142 }
143 
144 return p;
145}
146
147struct Shaded_OUT
148{
149 float4 vPos : POSITION;
150 float4 wNormal : TEXCOORD0;
151 float4 wPos    : TEXCOORD1;
152};
153
154float4 MultipleReflectionPS(Shaded_OUT IN,
155                                                        uniform samplerCUBE CubeMap : register(s0),
156                                                        uniform samplerCUBE DistanceMap : register(s1),
157                                                        uniform samplerCUBE NormDistMap1 : register(s2),
158                                                        uniform samplerCUBE NormDistMap2 : register(s3),
159                                                        uniform float3 cameraPos,
160                                                        uniform float3 lastCenter) : COLOR0
161{       
162         float4 I = float4(0,0,0,0);
163                       
164         float3 N = normalize(IN.wNormal.xyz);
165         float3 x = IN.wPos.xyz - lastCenter;
166         float3 V  = (IN.wPos.xyz - cameraPos);
167         
168         V = normalize(V);
169         float3 l;
170
171               
172        //return readCubeMap(NormDistMap2, x).a /2.0 + 0.000000000001 * x.x;
173         
174         int depth = 0;
175       
176         while(depth < MAX_RAY_DEPTH)
177         {
178           float3 R; 
179           R = normalize(reflect( V, N));         
180               
181           float3 Nl;
182           float4 Il = 0;
183           l = Hit(x, R, N, NormDistMap1, NormDistMap2, CubeMap, DistanceMap, Il, Nl);
184           if(Il.a == 0)
185           {       
186                  depth += 1;           
187           }
188           else
189           {
190                   I = Il;
191                   depth = MAX_RAY_DEPTH;
192           }
193           x = l;         
194           N = Nl;
195           V = R;   
196           
197        }
198        if(I.a == 0)
199           I = readCubeMap(CubeMap, l);
200       
201        return I;
202}
203
204float4 MultipleRefractionPS(Shaded_OUT IN,
205                                                        uniform samplerCUBE CubeMap : register(s0),
206                                                        uniform samplerCUBE DistanceMap : register(s1),
207                                                        uniform samplerCUBE NormDistMap1 : register(s2),
208                                                        uniform samplerCUBE NormDistMap2 : register(s3),
209                                                        uniform float3 cameraPos,
210                                                        uniform float3 lastCenter,
211                                                        uniform float sFresnel,
212                                                        uniform float refIndex ) : COLOR0
213{
214         float4 I = float4(0,0,0,0);
215                       
216         float3 N = normalize(IN.wNormal.xyz);
217         float3 x = IN.wPos.xyz - lastCenter;
218         float3 V  = (IN.wPos.xyz - cameraPos);
219          V = normalize(V);
220         
221         float F;
222         int depth = 0;
223        F = sFresnel + pow(1 - dot(N, -V), 5) * (1 - sFresnel); 
224       
225        while(depth < MAX_RAY_DEPTH)
226        {
227          float3 R; 
228                 
229          float ri = refIndex;   
230          if(dot(V,N) > 0)
231          {
232                ri = 1.0 / ri;
233                N = -N;     
234          }
235          R = refract( V, N, ri);
236          if(dot(R,R) == 0) R = reflect( V, N);
237                                               
238          float3 Nl;
239          float4 Il;
240          float3 l = Hit(x, R, N, NormDistMap1, NormDistMap2, CubeMap, DistanceMap, Il, Nl);
241          if(Il.a == 0)
242          {               
243                   depth += 1;           
244          }
245          else
246          {
247                   I = Il;
248                   depth = MAX_RAY_DEPTH;
249          }
250          x = l;           
251          N = normalize(Nl);
252          V = R;                   
253        }
254               
255        if(I.a == 0)
256        {
257         float ri = refIndex;   
258         if(dot(V,N) > 0)
259         {
260                ri = 1.0 / ri;
261                N = -N;     
262         }
263         float3 R = refract( V, N, ri);
264         if(dot(R,R) == 0) R = reflect( V, N);
265         I = readCubeMap(CubeMap, R);
266        }
267       
268        I *= (1.0 - F);
269   
270        return I;
271}
272
273float4 MultipleRefractionPhotonMap_PS(Shaded_OUT IN,
274                                                                        uniform samplerCUBE DistanceMap  : register(s0),
275                                                                        uniform samplerCUBE NormDistMap1 : register(s1),
276                                                                        uniform samplerCUBE NormDistMap2 : register(s2),
277                                                                        uniform samplerCUBE CubeMap      : register(s3), //NOT USED
278                                                                        uniform float3 cameraPos,
279                                                                        uniform float3 lastCenter,
280                                                                        uniform float refIndex) : COLOR0
281{
282         float4 I = 0;         
283         float3 N = normalize(IN.wNormal.xyz);
284         float3 x = IN.wPos.xyz - lastCenter;
285         float3 V  = (IN.wPos.xyz - cameraPos);
286         V = normalize(V);
287         
288        int depth = 0;
289        float3 l;
290       
291        while(depth < MAX_RAY_DEPTH)
292        {
293          float3 R; 
294                 
295          float ri = refIndex;   
296          if(dot(V,N) > 0)
297          {
298                ri = 1.0 / ri;
299                N = -N;     
300          }
301          R = refract( V, N, ri);
302          if(dot(R,R) == 0) R = reflect( V, N);
303                                               
304          float3 Nl;
305          float4 Il;
306          l = Hit(x, R, N, NormDistMap1, NormDistMap2, CubeMap, DistanceMap, Il, Nl);
307          if(Il.a == 0)
308          {
309                  depth += 1;           
310          }
311          else
312          {
313                  I = Il;
314                  depth = MAX_RAY_DEPTH;
315          }
316          x = l;           
317          N = normalize(Nl);
318          V = R;                   
319        } 
320        if(I.a == 0)
321                I = float4(V,1);
322        else
323                I = float4(l,1);
324       
325        return I;
326}
Note: See TracBrowser for help on using the repository browser.