source: GTP/trunk/App/Demos/Illum/Ogre/Media/materials/programs/GameTools_Diffuse.hlsl @ 1565

Revision 1565, 11.2 KB checked in by szirmay, 18 years ago (diff)
Line 
1float REDUCED_CUBEMAP_SIZE;
2
3float4 readCubeMap(samplerCUBE cm, float3 coord)               
4{
5        float4 color = texCUBE( cm, float3(coord.xy, -coord.z) );
6        color.a = 1;
7        return color;
8}
9
10float readDistanceCubeMap(samplerCUBE dcm, float3 coord)               
11{
12        float dist = texCUBE(dcm, float3(coord.xy, - coord.z)).r;
13        if(dist == 0) dist = 100000; ///sky
14        return dist;
15}
16
17// This function is called several times.
18float3 Hit( float3 x, float3 R, samplerCUBE mp )
19{
20        float rl = readDistanceCubeMap( mp, R);                         // |r|
21       
22        float ppp = length( x ) /  readDistanceCubeMap( mp, x);                 // |p|/|p’|
23        float dun = 0, pun = ppp, dov = 0, pov = 0;
24        float dl = rl * ( 1 - ppp );                                                    // eq. 2
25        float3 l = x + R * dl;                                                                  // ray equation
26
27        // iteration
28        for( int i = 0; i < 2; i++ )    // 2 !!!!!!!!!!!!!!!!!!!!!!!
29        {
30                float llp = length( l ) / readDistanceCubeMap( mp, l);          // |l|/|l’|
31                if ( llp < 0.999f )                                                                     // undershooting
32                {
33                        dun = dl; pun = llp;                                                    // last undershooting
34                        dl += ( dov == 0 ) ? rl * ( 1 - llp ) :                 // eq. 2
35                                ( dl - dov ) * ( 1 - llp ) / ( llp - pov );     // eq. 3
36                } else if ( llp > 1.001f )                                                      // overshooting
37                {
38                        dov = dl; pov = llp;                                                    // last overshooting
39                        dl += ( dl -dun ) * ( 1 - llp ) / ( llp - pun );// eq. 3
40                }
41                l = x + R * dl;                                                                         // ray equation
42        }
43        return l;                                                                                               // computed hit point
44}
45
46/////////////////////
47///// Diffuse
48///////////////////
49
50float4 GetContibution(float3 L1, float3 L2, float3 L3, float3 L4, float3 pos, float3 N, samplerCUBE SmallEnvMapSampler, float d)
51{
52/*
53        L1 = readDistanceCubeMap(DistanceEnvMapSampler, L1) * normalize(L1);
54        L2 = readDistanceCubeMap(DistanceEnvMapSampler, L2) * normalize(L2);
55        L3 = readDistanceCubeMap(DistanceEnvMapSampler, L3) *  normalize(L3);
56        L4 = readDistanceCubeMap(DistanceEnvMapSampler, L4) * normalize(L4);
57*/     
58
59        L1 = d * normalize(L1);
60        L2 = d * normalize(L2);
61        L3 = d *  normalize(L3);
62        L4 = d * normalize(L4);
63       
64       
65    float3 r1 = normalize(L1 - pos);   
66    float3 r2 = normalize(L2 - pos);
67    float3 r3 = normalize(L3 - pos);
68    float3 r4 = normalize(L4 - pos);
69   
70   
71        float kd = 0.3; // 0.3
72       
73        float tri1 = acos(dot(r1, r2)) * dot(cross(r1, r2), N);
74        float tri2 = acos(dot(r2, r3)) * dot(cross(r2, r3), N);
75        float tri3 = acos(dot(r3, r4)) * dot(cross(r3, r4), N);
76        float tri4 = acos(dot(r4, r1)) * dot(cross(r4, r1), N);
77       
78        return max(tri1 + tri2 + tri3 + tri4, 0);       
79}
80
81struct vertOUT
82{
83        float4 hPos :POSITION;
84        float3 wPos     :TEXCOORD1;
85        float2 texCoord :TEXCOORD0;
86        float3 mNormal :TEXCOORD2;
87};
88
89vertOUT DiffuseVS(float4 position : POSITION,
90                float3 normal   : NORMAL,
91                half3 tangent   : TEXCOORD1,
92                float2 texCoord : TEXCOORD0,                   
93                uniform float4x4 worldViewProj,
94                uniform float4x4 world)
95{
96  vertOUT OUT;
97  OUT.hPos = mul(worldViewProj, position);
98  OUT.wPos = mul(world, position).xyz; 
99  //mNormal = mul(normal, world_IT);
100  OUT.mNormal = normal;
101  OUT.texCoord = texCoord;
102  return OUT;
103}
104
105/*
106float4 DiffusePS( vertOUT IN,
107           uniform float3 cameraPos,
108           uniform float3 lastCenter,   //LI//
109           uniform samplerCUBE SmallEnvMapSampler : register(s0),
110           uniform samplerCUBE DistanceEnvMapSampler : register(s1),
111           uniform float4x4 world_IT
112            ) : COLOR0
113{
114    REDUCED_CUBEMAP_SIZE = 4;
115        float width = 1.0 /REDUCED_CUBEMAP_SIZE;
116   
117    normalize( V );
118    float3 V = normalize(IN.wPos - cameraPos);  //
119        float3 N = mul( float4(IN.mNormal,1), world_IT).xyz;
120    //float3 N = IN.mNormal;
121    N = normalize( N );
122        float3 R = reflect(V, N);
123    float3 pos = IN.wPos - lastCenter;
124     
125    float4 intens = 0;
126    //intens = readCubeMap(SmallEnvMapSampler, pos);
127       
128        float3 L1, L2, L3, L4, L;
129        float4 Le;
130        float d;
131         
132        for (int x = 0; x < REDUCED_CUBEMAP_SIZE - 1; x++)                      // az envmap minden texelére
133         for (int y = 0; y < REDUCED_CUBEMAP_SIZE - 1; y++)
134         {
135                float2 p, tpos;
136            tpos.x = (x + 0.5) /(float)REDUCED_CUBEMAP_SIZE;    // 0..1
137            tpos.y = (y + 0.5) /(float)REDUCED_CUBEMAP_SIZE;    // 0..1
138           
139            p.x = tpos.x;
140            p.y = 1-tpos.y;
141            p.xy = 2 * p.xy - 1;        // -1..1        // az adott texel középpont pozíciója
142                   
143                L1 = float3(p.x - width, p.y - width, 1);       
144                L2 = float3(p.x + width, p.y - width, 1);       
145                L3 = float3(p.x + width, p.y + width, 1);       
146                L4 = float3(p.x - width, p.y + width, 1);
147                L = float3(p.x, p.y, 1);
148                Le = readCubeMap(SmallEnvMapSampler, L);
149                d = readDistanceCubeMap(DistanceEnvMapSampler, L);     
150                intens += 0.5 * Le * GetContibution( L1, L2, L3, L4, pos, N, SmallEnvMapSampler, d);
151        }       
152       
153        for (int x = 0; x < REDUCED_CUBEMAP_SIZE - 1; x++)                      // az envmap minden texelére
154         for (int y = 0; y < REDUCED_CUBEMAP_SIZE - 1; y++)
155         {
156                float2 p, tpos;
157            tpos.x = (x + 0.5) /(float)REDUCED_CUBEMAP_SIZE;    // 0..1
158            tpos.y = (y + 0.5) /(float)REDUCED_CUBEMAP_SIZE;    // 0..1
159           
160            p.x = tpos.x;
161            p.y = 1-tpos.y;
162            p.xy = 2 * p.xy - 1;        // -1..1        // az adott texel középpont pozíciója
163               
164                L4 = float3(p.x - width, p.y - width, -1);     
165                L3 = float3(p.x + width, p.y - width, -1);     
166                L2 = float3(p.x + width, p.y + width, -1);     
167                L1 = float3(p.x - width, p.y + width, -1);
168                L = float3(p.x, p.y, -1);
169                Le = readCubeMap(SmallEnvMapSampler, L);
170                d = readDistanceCubeMap(DistanceEnvMapSampler, L);     
171                intens += 0.5 * Le * GetContibution( L1, L2, L3, L4, pos, N, SmallEnvMapSampler, d);
172        }
173       
174        for (int x = 0; x < REDUCED_CUBEMAP_SIZE - 1; x++)                      // az envmap minden texelére
175         for (int y = 0; y < REDUCED_CUBEMAP_SIZE - 1; y++)
176         {
177                float2 p, tpos;
178            tpos.x = (x + 0.5) /(float)REDUCED_CUBEMAP_SIZE;    // 0..1
179            tpos.y = (y + 0.5) /(float)REDUCED_CUBEMAP_SIZE;    // 0..1
180           
181            p.x = tpos.x;
182            p.y = 1-tpos.y;
183            p.xy = 2 * p.xy - 1;        // -1..1        // az adott texel középpont pozíciója
184               
185                L4 = float3(p.x - width, 1, p.y - width);
186                L3 = float3(p.x + width, 1, p.y - width);       
187                L2 = float3(p.x + width, 1, p.y + width);       
188                L1 = float3(p.x - width, 1, p.y + width);                       
189                L = float3(p.x, 1, p.y);
190                Le = readCubeMap(SmallEnvMapSampler, L);
191                d = readDistanceCubeMap(DistanceEnvMapSampler, L);     
192                intens += 0.5 * Le * GetContibution( L1, L2, L3, L4, pos, N, SmallEnvMapSampler, d);
193        }
194       
195        for (int x = 0; x < REDUCED_CUBEMAP_SIZE - 1; x++)                      // az envmap minden texelére
196         for (int y = 0; y < REDUCED_CUBEMAP_SIZE - 1; y++)
197         {
198                float2 p, tpos;
199            tpos.x = (x + 0.5) /(float)REDUCED_CUBEMAP_SIZE;    // 0..1
200            tpos.y = (y + 0.5) /(float)REDUCED_CUBEMAP_SIZE;    // 0..1
201           
202            p.x = tpos.x;
203            p.y = 1-tpos.y;
204            p.xy = 2 * p.xy - 1;        // -1..1        // az adott texel középpont pozíciója
205               
206                L1 = float3(p.x - width, -1, p.y - width);
207                L2 = float3(p.x + width, -1, p.y - width);     
208                L3 = float3(p.x + width, -1, p.y + width);     
209                L4 = float3(p.x - width, -1, p.y + width);                     
210                L = float3(p.x, -1, p.y);
211                Le = readCubeMap(SmallEnvMapSampler, L);
212                d = readDistanceCubeMap(DistanceEnvMapSampler, L);     
213                intens += 0.5 * Le * GetContibution( L1, L2, L3, L4, pos, N, SmallEnvMapSampler, d);
214        }
215       
216        for (int x = 0; x < REDUCED_CUBEMAP_SIZE - 1; x++)                      // az envmap minden texelére
217         for (int y = 0; y < REDUCED_CUBEMAP_SIZE - 1; y++)
218         {
219                float2 p, tpos;
220            tpos.x = (x + 0.5) /(float)REDUCED_CUBEMAP_SIZE;    // 0..1
221            tpos.y = (y + 0.5) /(float)REDUCED_CUBEMAP_SIZE;    // 0..1
222           
223            p.x = tpos.x;
224            p.y = 1-tpos.y;
225            p.xy = 2 * p.xy - 1;        // -1..1        // az adott texel középpont pozíciója
226               
227                L1 = float3(1, p.x - width, p.y - width);
228                L2 = float3(1, p.x + width, p.y - width);       
229                L3 = float3(1, p.x + width, p.y + width);       
230                L4 = float3(1, p.x - width, p.y + width);       
231                L = float3(1, p.x, p.y);
232                Le = readCubeMap(SmallEnvMapSampler, L);
233                d = readDistanceCubeMap(DistanceEnvMapSampler, L);     
234                intens += 0.5 * Le * GetContibution( L1, L2, L3, L4, pos, N, SmallEnvMapSampler, d);
235        }
236       
237        for (int x = 0; x < REDUCED_CUBEMAP_SIZE - 1; x++)                      // az envmap minden texelére
238         for (int y = 0; y < REDUCED_CUBEMAP_SIZE - 1; y++)
239         {
240                float2 p, tpos;
241            tpos.x = (x + 0.5) /(float)REDUCED_CUBEMAP_SIZE;    // 0..1
242            tpos.y = (y + 0.5) /(float)REDUCED_CUBEMAP_SIZE;    // 0..1
243           
244            p.x = tpos.x;
245            p.y = 1-tpos.y;
246            p.xy = 2 * p.xy - 1;        // -1..1        // az adott texel középpont pozíciója
247               
248                L4 = float3(-1, p.x - width, p.y - width);
249                L3 = float3(-1, p.x + width, p.y - width);     
250                L2 = float3(-1, p.x + width, p.y + width);     
251                L1 = float3(-1, p.x - width, p.y + width);     
252                L = float3(-1, p.x, p.y);
253                Le = readCubeMap(SmallEnvMapSampler, L);
254                d = readDistanceCubeMap(DistanceEnvMapSampler, L);     
255                intens += 0.5 * Le * GetContibution( L1, L2, L3, L4, pos, N, SmallEnvMapSampler, d);
256        }       
257       
258       
259        //return float4(pos, 1);
260        return intens;
261}
262
263*/
264
265
266float4 DiffusePS( vertOUT IN,
267           uniform float3 cameraPos,
268           uniform float3 lastCenter,   //LI//
269           uniform samplerCUBE SmallEnvMapSampler : register(s0),
270           uniform samplerCUBE DistanceEnvMapSampler : register(s1),
271           uniform float4x4 world_IT
272            ) : COLOR0
273{
274        float3 corner[] = {float3(1,-1,1),//  float3(0,0,1),
275                                        float3(-1,-1,-1),  // 0,0,-1
276                                        float3(-1,1,-1),   // 0,1,0
277                                        float3(-1,-1, 1),  // 0,-1,0
278                                        float3(1,-1,-1),   // 1,0,0
279                                        float3(-1,-1, 1)}; // -1,0,0
280                                         
281        float3 right[] = {float3(-1,0,0),
282                                        float3(1,0,0),
283                                        float3(1,0,0),
284                                        float3(-1,0,0),
285                                        float3(0,0,1),
286                                        float3(0,0,-1)};
287                                         
288        float3 up[] = {float3(0,1,0),
289                                        float3(0,1,0),
290                                        float3(0,0,1),
291                                        float3(0,0,1),
292                                        float3(0,1,0),
293                                        float3(0,1,0)};
294                                 
295    REDUCED_CUBEMAP_SIZE = 4;
296        float width = 1.0 /REDUCED_CUBEMAP_SIZE;
297   
298    //V = /*-*/normalize( V );
299    float3 V = normalize(IN.wPos - cameraPos);  //
300        float3 N = mul( float4(IN.mNormal,1), world_IT).xyz;
301    //float3 N = IN.mNormal;
302    N = normalize( N );
303        float3 R = reflect(V, N);
304    float3 pos = IN.wPos - lastCenter;
305     
306    float4 intens = 0;
307    //intens = readCubeMap(SmallEnvMapSampler, pos);
308       
309        float3 L1, L2, L3, L4, L;
310        float4 Le;
311        float d;
312        /* 
313        for (int x = 0; x < REDUCED_CUBEMAP_SIZE; x++)
314         for (int y = 0; y < REDUCED_CUBEMAP_SIZE; y++)
315                for (int f = 0; f < 6; f++)
316                {
317               
318                        float2 p, tpos;
319                        tpos.x = (x + 0.5) * 2 * width; // 0..2
320                        tpos.y = (y + 0.5) * 2 * width; // 0..2
321                   
322                        p = tpos;                       
323                           
324                        L = corner[0] + p.x * right[0] + p.y * up[0];                   
325                        L1 = normalize(L - width * right[f] + width * up[f]);
326                        L2 = normalize(L + width * right[f] + width * up[f]);   
327                        L3 = normalize(L + width * right[f] - width * up[f]);   
328                        L4 = normalize(L - width * right[f] - width * up[f]);
329                        Le = texCUBE(SmallEnvMapSampler, L);
330                        d = texCUBE(DistanceEnvMapSampler, L).r;
331                       
332                        L1 = d * L1;
333                        L2 = d * L2;
334                        L3 = d * L3;
335                        L4 = d * L4;   
336               
337                        float3 r1 = normalize(L1 - pos);   
338                        float3 r2 = normalize(L2 - pos);
339                        float3 r3 = normalize(L3 - pos);
340                        float3 r4 = normalize(L4 - pos);
341           
342                        float tri1 = acos(dot(r1, r2)) * dot(cross(r1, r2), N);
343                        float tri2 = acos(dot(r2, r3)) * dot(cross(r2, r3), N);
344                        float tri3 = acos(dot(r3, r4)) * dot(cross(r3, r4), N);
345                        float tri4 = acos(dot(r4, r1)) * dot(cross(r4, r1), N);
346               
347                //      intens += Le / 16.0 + pos.x*0.000000000001;
348                        intens += 0.5 * Le * max(tri1 + tri2 + tri3 + tri4, 0);
349                }*/     
350
351        return intens;
352}
Note: See TracBrowser for help on using the repository browser.