source: GTP/trunk/App/Games/Jungle_Rumble/src/shaders/RayTraceEffects.fx @ 1378

Revision 1378, 12.2 KB checked in by giegl, 18 years ago (diff)

GTPD - Jungle Rumble - integrate into GTP SVN structure

Line 
1//----------------------------------------------
2// GLOBAL VARIABLES
3//---------------------------------------------
4
5int              g_iNumberOfIteration;                          // Number of iteration
6int              face;
7
8float    g_fFresnelFactor;                                      // Fresnel factor
9float    g_fPower;                                                      // Power of light source
10float    g_fRefractionIndex;                            // Refraction index                             
11
12float3   g_vCameraPos3f;                                        // Camera position
13float3   g_vLightPos3f;                                         // Light source position
14
15//Gauss Stuff
16const float4 horSamples[7] = {
17        -3.0, 0.0, 0, 1.0/64.0,
18        -2.0, 0.0, 0, 6.0/64.0,
19        -1.0, 0.0, 0, 15.0/64.0,
20        0.0, 0.0, 0, 20.0/64.0,
21        1.0, 0.0, 0, 15.0/64.0,
22        2.0, 0.0, 0, 6.0/64.0,
23        3.0, 0.0, 0, 1.0/64.0
24};
25
26const float4 verSamples[7] = {
27        0.0, -3.0, 0, 1.0/64.0,
28        0.0, -2.0, 0, 6.0/64.0,
29        0.0, -1.0, 0, 15.0/64.0,
30        0.0, 0.0, 0, 20.0/64.0,
31        0.0, 1.0, 0, 15.0/64.0,
32        0.0, 2.0, 0, 6.0/64.0,
33        0.0, 3.0, 0, 1.0/64.0
34};
35
36
37float4x4 g_mWorldView;                                          // WorldView transformation matrix
38float4x4 g_mProj;                                                       // ProjectionMatrix
39float4x4 g_mView;                                                       // ViewMatrix
40float4x4 g_mWorldViewProjection;                        // WorldViewProjection transformation matrix
41float4x4 g_mWorldCenterObject;                          // World transformation matrix of CenterObject
42float4x4 g_mCenterObjectRot;                            // Rotation Matrix of CenterObject
43float4x4 g_mWorldCenterObjectRotation;          // Contains only the rotation of the CenterObject
44float4x4 g_mLightViewTexBias;                           // Light space transformation matrix
45
46texture  g_txRoomColorDistanceCubeMap;          // Contain the color and distance information in a CubeMap
47texture  g_txTempRoomColorDistanceCubeMap;              // Contain the color and distance information in a CubeMap
48texture  g_txCurrentTexture;                            //Aktuelle Textur mit der Gerade gerendert wird.
49
50//-----------------------------------------------------------------------------
51// SAMPLERS
52// Each texture must have its own sampler
53//-----------------------------------------------------------------------------
54
55//-----------------------------------------------------------------------------
56// macro definition for filtered samplers
57//-----------------------------------------------------------------------------
58
59#define SAMPLER_LINEAR(g_samplerMap, g_txMap);  \
60        sampler2D g_samplerMap = sampler_state {        \
61    Texture = <g_txMap>;                                                \
62    MinFilter = Linear;                                                 \
63    MagFilter = Linear;                                                 \
64    MipFilter = Linear;                                                 \
65    AddressU  = BORDER;                                                 \
66    AddressV  = BORDER;                                                 \
67};
68
69SAMPLER_LINEAR(g_samplerCurrentTexture,         g_txCurrentTexture);
70
71//-----------------------------------------------------------------------------
72// macro definition for non-filtered samplers
73//-----------------------------------------------------------------------------
74
75#define SAMPLER_POINT(g_samplerMap, g_txMap);   \
76        sampler2D g_samplerMap = sampler_state {        \
77    Texture = <g_txMap>;                                                \
78    MinFilter = Point;                                                  \
79    MagFilter = Point;                                                  \
80    MipFilter = Point;                                                  \
81    AddressU  = BORDER;                                                 \
82    AddressV  = BORDER;                                                 \
83};
84
85samplerCUBE g_samplerRoomColorDistanceCubeMap = sampler_state
86{
87    Texture = <g_txRoomColorDistanceCubeMap>;
88    MinFilter = Linear;
89    MagFilter = Linear;
90    MipFilter = Linear;
91    AddressU  = BORDER;
92    AddressV  = BORDER;
93};
94
95samplerCUBE g_samplerTempRoomColorDistanceCubeMap = sampler_state
96{
97    Texture = <g_txRoomColorDistanceCubeMap>;
98    MinFilter = Linear;
99    MagFilter = Linear;
100    MipFilter = Linear;
101    AddressU  = BORDER;
102    AddressV  = BORDER;
103};
104
105//-----------------------------------------------------------------------------
106// FUNCTIONS
107//-----------------------------------------------------------------------------
108
109// This function is called several times.
110float3 Hit( float3 x, float3 R, samplerCUBE mp )
111{
112        float rl = texCUBE( mp, R ).a;                                                  // |r|
113        float ppp = length( x ) / texCUBE( mp, x ).a;                   // |p|/|p’|
114        float dun = 0, pun = ppp, dov = 0, pov;
115        float dl = rl * ( 1 - ppp );                                                    // eq. 2
116        float3 l = x + R * dl;                                                                  // ray equation
117
118        // iteration
119        for( int i = 0; i < g_iNumberOfIteration; i++ )
120        {
121                float llp = length( l ) / texCUBE( mp,l ).a;            // |l|/|l’|
122                if ( llp < 0.999f )                                                                     // undershooting
123                {
124                        dun = dl; pun = llp;                                                    // last undershooting
125                        dl += ( dov == 0 ) ? rl * ( 1 - llp ) :                 // eq. 2
126                                ( dl - dov ) * ( 1 - llp ) / ( llp - pov );     // eq. 3
127                } else if ( llp > 1.001f )                                                      // overshooting
128                {
129                        dov = dl; pov = llp;                                                    // last overshooting
130                        dl += ( dl -dun ) * ( 1 - llp ) / ( llp - pun );// eq. 3
131                }
132                l = x + R * dl;                                                                         // ray equation
133        }
134        return l;                                                                                               // computed hit point
135}
136
137//-----------------------------------------------------------------------------
138// SHADERS
139// Here are the different shaders.
140//-----------------------------------------------------------------------------
141
142
143//*****************************************************************************
144//-----------------------------------------------------------------------------
145// RenderRoomColorDistance
146// This shader stores the viewable object's color and its distance from the CenterObject's position.
147// The result is stored in a CubeMap.
148//-----------------------------------------------------------------------------
149void ColorDistanceVS(
150        float4 Pos     : POSITION,
151        float2 Tex     : TEXCOORD0,
152    out float4 outhPos : POSITION,
153    out float2 outTex  : TEXCOORD0,
154    out float4 outPos  : TEXCOORD1 )
155{
156    outhPos = mul( Pos, g_mWorldViewProjection );
157    outTex  = Tex;
158    // Calculate the world position
159    outPos  = mul( Pos, g_mWorldView );
160}
161// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
162
163float4 ColorDistancePS(
164        float2 Tex : TEXCOORD0,
165        float4 Pos : TEXCOORD1 ) : COLOR
166{
167    // The color of the viewable object in the current pixel.
168    // In the scene there are 2 different textured object. (the room, and the Columns)
169    // Every column has the same brdf texture.
170    float3 retColor = float4(0,0,0,0);
171   
172    retColor = float4(tex2D(g_samplerCurrentTexture, Tex).xyz, 1);
173    // The distance from the CenterObject
174    float Distance;
175        Distance = (float) ( length( Pos.xyz ) );
176    return float4(retColor, Distance);          // Color(x,y,z) + Distance(w)
177}
178//*****************************************************************************
179   
180//-----------------------------------------------------------------------------
181// RenderRefractObjectScreen
182// This shader calculates the color of the CenterObject with Hit function.
183// It has reflection and refraction effect.
184// The result is displayed on the screen.
185//-----------------------------------------------------------------------------
186void RefractObjectVS(
187                float4 Pos     : POSITION,
188        float3 Normal  : NORMAL,
189        float2 Tex         : TEXCOORD0,
190    out float4 outhPos : POSITION,
191    out float2 outTex  : TEXCOORD0,
192    out float3 outPos  : TEXCOORD1,
193    out float3 outN    : TEXCOORD2,
194    out float3 outV    : TEXCOORD3 )
195{
196        outTex = Tex;
197    outhPos = mul( Pos, g_mWorldViewProjection );
198    outPos  = mul( Pos, g_mCenterObjectRot );
199    outN = normalize(mul(Normal, g_mCenterObjectRot));
200    float4 tempPos = mul(Pos, g_mWorldCenterObject);
201    outV    = normalize( tempPos - g_vCameraPos3f );
202}
203// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
204
205float4 RefractObjectPS(
206           float2 Tex : TEXCOORD0,
207       float3 p0  : TEXCOORD1,
208       float3 N   : TEXCOORD2,
209       float3 V   : TEXCOORD3 ) : COLOR
210{       
211        V = normalize( V );
212        N = normalize( N );
213
214        // Calculate reflection
215        float3 R = reflect( V, N );
216        float3 RR = Hit(p0, R, g_samplerRoomColorDistanceCubeMap);
217       
218        // Calculate refraction
219        float3 T = refract(V, N, g_fRefractionIndex);
220        float3 TT = Hit(p0, T, g_samplerRoomColorDistanceCubeMap);
221
222        // Calculate reflected color
223        float4 reflectColor = texCUBE( g_samplerRoomColorDistanceCubeMap, RR );
224       
225        // Calculate refracted color
226        float4 refractColor = texCUBE( g_samplerRoomColorDistanceCubeMap, TT );
227       
228          // Calculate return color modified by Fresnel function.
229        float F = g_fFresnelFactor + ( 1 - g_fFresnelFactor ) * pow( 1 - dot( N, -V ), 5 );
230        return float4( F * reflectColor + ( 1 - F ) * refractColor );
231        //return refractColor;
232}
233//*****************************************************************************
234
235
236//-----------------------------------------------------------------------------
237// RenderRefractObjectScreenClassic
238// This shader calculates the color of the CenterObject with classical method.
239// It has reflection and refraction effect.
240// The result is displayed on the screen.
241//-----------------------------------------------------------------------------
242void RefractObjectClassicVS(
243                float4 Pos     : POSITION,
244        float3 Normal  : NORMAL,
245        float2 Tex         : TEXCOORD0,
246    out float4 outhPos : POSITION,
247    out float3 outPos  : TEXCOORD1,
248    out float3 outN    : TEXCOORD2,
249    out float3 outV    : TEXCOORD3 )
250{
251        //outTex = Tex;
252    outhPos = mul( Pos, g_mWorldViewProjection );
253    outPos  = mul( Pos, g_mCenterObjectRot );
254    outN = normalize(mul(Normal, g_mCenterObjectRot));
255    float4 tempPos = mul(Pos, g_mWorldCenterObject);
256    outV    = normalize( tempPos - g_vCameraPos3f );
257}
258// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
259
260float4 RefractObjectClassicPS(
261        float3 p0 : TEXCOORD1,
262        float3 N  : TEXCOORD2,
263        float3 V  : TEXCOORD3 ) : COLOR
264{       
265        V = normalize( V );
266        N = normalize( N );
267
268        // Calculate reflection
269        float3 RR = reflect( V, N );
270
271        // Calculate refraction
272        float3 TT = refract(V, N, g_fRefractionIndex);
273
274
275        // Calculate reflected color
276        float4 reflectColor = texCUBE( g_samplerRoomColorDistanceCubeMap, RR ); // UV position where the Atlas must be read
277
278        // Calculate refracted color
279        float4 refractColor = texCUBE( g_samplerRoomColorDistanceCubeMap, TT );
280
281        // Calculate return color modified by Fresnel function.
282        float F = g_fFresnelFactor + ( 1 - g_fFresnelFactor ) * pow( 1 - dot( N, -V ), 5 );
283        return float4( F * reflectColor + ( 1 - F ) * refractColor);
284}
285//*****************************************************************************
286
287void gaussHorizontalVS(
288                float4 Pos     : POSITION,
289                float2 Tex         : TEXCOORD0,
290    out float4 outhPos : POSITION,
291    out float2 outTex  : TEXCOORD0 )
292{
293    outhPos = Pos;
294    outTex = Tex;
295}
296// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
297
298float4 gaussHorizontalPS(
299                float2 Tex : TEXCOORD0 ) : COLOR
300{
301        float4 retColor = float4(0,0,0,0);
302        for(int i=0;i<7;i++) {
303                retColor+=horSamples[i].w*tex2D(g_samplerCurrentTexture, Tex + horSamples[i].x);
304        }
305        retColor = texCUBE(g_samplerRoomColorDistanceCubeMap, float3(Tex , 1));
306        return retColor;       
307}
308
309void gaussVertikalVS(
310                float4 Pos     : POSITION,
311                float2 Tex         : TEXCOORD0,
312    out float4 outhPos : POSITION,
313    out float2 outTex  : TEXCOORD0 )
314{
315    outhPos = Pos;
316    outTex = Tex;
317}
318// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
319
320float4 gaussVertikalPS(
321                float2 Tex : TEXCOORD0 ) : COLOR
322{
323        float4 retColor = float4(0,0,0,0);
324        for(int i=0;i<7;i++) {
325                retColor+=verSamples[i].w*tex2D(g_samplerCurrentTexture, Tex + verSamples[i].y);
326        }
327        retColor = texCUBE(g_samplerTempRoomColorDistanceCubeMap, float3(Tex , 1));
328        return retColor;       
329}
330
331
332
333
334//-----------------------------------------------------------------------------
335// TECHNIQUES
336// Here are the different Techniques.
337//-----------------------------------------------------------------------------
338
339// Technique(AnyRenderPass):
340//              VertexShader = compile vs_3_0 AnyRenderPassVS()
341//              PixelShader  = compile vs_3_0 AnyRenderPassPS()
342
343// if using the name convention above to name vertex/pixel shaders,
344// you can use the following macro definition to quickly define a technique:
345
346// note: ## stands for concatenation
347
348#define Technique(name);                                                                \
349        technique name                                                                          \
350        {                                                                                                       \
351            pass p0                                                                                     \
352            {                                                                                           \
353                    VertexShader = compile vs_3_0 name##VS();   \
354                    PixelShader  = compile ps_3_0 name##PS();   \
355                }                                                                                               \
356        }
357       
358Technique( ColorDistance );
359Technique( RefractObject );
360Technique( RefractObjectClassic );
361Technique( gaussHorizontal );
362Technique( gaussVertikal );
Note: See TracBrowser for help on using the repository browser.