Context Navigation

_RayTraceEffects.fx @ 754

Revision 754, 35.6 KB checked in by szirmay, 19 years ago (diff)
Added a folder remotely

Line
1	#define SHADOWMAP_SIZE 512.0f // The size of ShadowMap
2
3	// Offsets in the ShadowMap
4	#define HALF 0.5f / SHADOWMAP_SIZE
5	#define ONE 1.0f / SHADOWMAP_SIZE
6	#define TWO 2.0f / SHADOWMAP_SIZE
7	#define THREE 3.0f / SHADOWMAP_SIZE
8	#define FIVE 5.0f / SHADOWMAP_SIZE
9	#define TEN 10.0f / SHADOWMAP_SIZE
10
11	#define AMB float4(0.5,0.5,0.5,1) // Power of the ambient light
12	#define FI 1000 // Summarized power of the light source
13
14	//----------------------------------------------
15	// GLOBAL VARIABLES
16	//---------------------------------------------
17	float3 g_vCameraPos3f; // Camera position
18	float3 g_vLightPos3f; // Light source position
19	int g_iNumberOfIteration; // Number of iteration
20	int g_iObjectID; // ID of the current object
21	int g_iPhotonMapSize; // PhotonMap size
22	float g_fFresnelFactor; // Fresnel factor
23	float g_fPower; // Power of light source
24	float g_fRefractionIndex; // Refraction index
25	float g_fShadowIntensity; // Shadow intensity
26	float g_fCausticsIntensity; // The intensity of a caustics snippet
27	bool g_bShadowON; // Shadow is used?
28	bool g_bShowHelp; // Darken the scene if help is on
29
30	float4x4 g_mWorldView; // WorldView transformation matrix
31	float4x4 g_mWorldViewProjection; // WorldViewProjection transformation matrix
32	float4x4 g_mWorldCenterObject; // World transformation matrix of CenterObject
33	float4x4 g_mLightViewTexBias; // Light space transformation matrix
34
35	texture g_txRoomMap; // Contains the original texture of the Room
36	texture g_txRoomCubeMapColorDistanceMap; // Contains the color and distance information in a CubeMap
37	texture g_txRoomCubeMapUVMap; // Contains the UV and ID of the object in a CubeMap
38	texture g_txPhotonUVMap; // Contains the photon hits UV and ID information
39	texture g_txPowerOfSnippetMap; // Contains the Gaussian filter
40	texture g_txRoomModifyMap; // Contains the texture of the Room with shadow and Caustics effect and black edges
41	texture g_txRoomLastMap; // Contains the texture of the Room
42
43	// Contain the textures of the Columns with shadow and Caustics effect
44	texture g_txColumnModifyTexture0, g_txColumnLastTexture0;
45	texture g_txColumnModifyTexture1, g_txColumnLastTexture1;
46	texture g_txColumnModifyTexture2, g_txColumnLastTexture2;
47	texture g_txColumnModifyTexture3, g_txColumnLastTexture3;
48
49	texture g_txColumnOriginalTexture; // Contains the original texture of a Column
50	texture g_txShadowMap; // Contains the shadowMap
51
52
53	//-----------------------------------------------------------------------------
54	// SAMPLERS
55	// Each texture must have its own sampler
56	//-----------------------------------------------------------------------------
57
58	//-----------------------------------------------------------------------------
59	// macro definition for filtered samplers
60	//-----------------------------------------------------------------------------
61
62	#define SAMPLER_LINEAR(g_samplerMap, g_txMap); \
63	sampler2D g_samplerMap = sampler_state { \
64	Texture = <g_txMap>; \
65	MinFilter = Linear; \
66	MagFilter = Linear; \
67	MipFilter = Linear; \
68	AddressU = BORDER; \
69	AddressV = BORDER; \
70	};
71
72	SAMPLER_LINEAR(g_samplerRoomMap, g_txRoomMap);
73	SAMPLER_LINEAR(g_samplerRoomLastMap, g_txRoomLastMap);
74	SAMPLER_LINEAR(g_samplerPhotonUVMap, g_txPhotonUVMap);
75	SAMPLER_LINEAR(g_samplerPowerOfSnippetMap, g_txPowerOfSnippetMap);
76	SAMPLER_LINEAR(g_samplerColumnLast0Map, g_txColumnLastTexture0);
77	SAMPLER_LINEAR(g_samplerColumnLast1Map, g_txColumnLastTexture1);
78	SAMPLER_LINEAR(g_samplerColumnLast2Map, g_txColumnLastTexture2);
79	SAMPLER_LINEAR(g_samplerColumnLast3Map, g_txColumnLastTexture3);
80	SAMPLER_LINEAR(g_samplerColumnOriginalMap, g_txColumnOriginalTexture);
81
82	//-----------------------------------------------------------------------------
83	// macro definition for non-filtered samplers
84	//-----------------------------------------------------------------------------
85
86	#define SAMPLER_POINT(g_samplerMap, g_txMap); \
87	sampler2D g_samplerMap = sampler_state { \
88	Texture = <g_txMap>; \
89	MinFilter = Point; \
90	MagFilter = Point; \
91	MipFilter = Point; \
92	AddressU = BORDER; \
93	AddressV = BORDER; \
94	};
95
96	SAMPLER_POINT(g_samplerRoomModifyMap, g_txRoomModifyMap); // must be point, it will be used for filtering
97	SAMPLER_POINT(g_samplerColumnModify0Map, g_txColumnModifyTexture0);
98	SAMPLER_POINT(g_samplerColumnModify1Map, g_txColumnModifyTexture1);
99	SAMPLER_POINT(g_samplerColumnModify2Map, g_txColumnModifyTexture2);
100	SAMPLER_POINT(g_samplerColumnModify3Map, g_txColumnModifyTexture3);
101
102	sampler2D g_samplerShadowMap = sampler_state
103	{
104	Texture = <g_txShadowMap>;
105	MinFilter = Linear;
106	MagFilter = Linear;
107	MipFilter = Linear;
108	AddressU = CLAMP;
109	AddressV = CLAMP;
110	};
111
112	samplerCUBE g_samplerRoomCubeMapColorDistanceMap = sampler_state
113	{
114	Texture = <g_txRoomCubeMapColorDistanceMap>;
115	MinFilter = Linear;
116	MagFilter = Linear;
117	MipFilter = Linear;
118	AddressU = BORDER;
119	AddressV = BORDER;
120	};
121
122	samplerCUBE g_samplerRoomCubeMapUVMap = sampler_state
123	{
124	Texture = <g_txRoomCubeMapUVMap>;
125	MinFilter = Linear;
126	MagFilter = Linear;
127	MipFilter = Linear;
128	AddressU = BORDER;
129	AddressV = BORDER;
130	};
131
132	samplerCUBE g_samplerRoomCubeMapUVMap_NO_FILTER = sampler_state
133	{
134	Texture = <g_txRoomCubeMapUVMap>;
135	MinFilter = Point;
136	MagFilter = Point;
137	MipFilter = Point;
138	AddressU = BORDER;
139	AddressV = BORDER;
140	};
141
142	//-----------------------------------------------------------------------------
143	// FUNCTIONS
144	//-----------------------------------------------------------------------------
145
146	// This function is called several times.
147	float3 Hit( float3 x, float3 R, samplerCUBE mp )
148	{
149	float rl = texCUBE( mp, R ).a; // \|r\|
150	float ppp = length( x ) / texCUBE( mp, x ).a; // \|p\|/\|p\|
151	float dun = 0, pun = ppp, dov = 0, pov;
152	float dl = rl * ( 1 - ppp ); // eq. 2
153	float3 l = x + R * dl; // ray equation
154
155	// iteration
156	for( int i = 0; i < g_iNumberOfIteration; i++ )
157	{
158	float llp = length( l ) / texCUBE( mp,l ).a; // \|l\|/\|l\|
159	if ( llp < 0.999f ) // undershooting
160	{
161	dun = dl; pun = llp; // last undershooting
162	dl += ( dov == 0 ) ? rl * ( 1 - llp ) : // eq. 2
163	( dl - dov ) * ( 1 - llp ) / ( llp - pov ); // eq. 3
164	} else if ( llp > 1.001f ) // overshooting
165	{
166	dov = dl; pov = llp; // last overshooting
167	dl += ( dl -dun ) * ( 1 - llp ) / ( llp - pun );// eq. 3
168	}
169	l = x + R * dl; // ray equation
170	}
171	return l; // computed hit point
172	}
173
174	//*****************************************************************************
175
176	// This function enlarges the usefull areas of the atlases.
177	float4 FlowLight( sampler2D mp, float2 Tex )
178	{
179	// Reads the current pixel
180	float4 preVal = tex2D( mp, Tex );
181	// If it is an unused pixel (.a=0)
182	if ( preVal.a == 0 )
183	{
184	float dist = ONE;
185	if( g_iObjectID != -1 ) dist *= 3.0f;
186
187	// Reads a neighbor
188	float2 modTex = Tex + float2( dist, 0.0 );
189	float4 candid = tex2D( mp, modTex );
190
191	// Calculate its intensity.
192	// If it is more intensive than the previous (original) one, it is stored.
193	if( dot( candid.xyz, candid.xyz ) > dot( preVal.xyz, preVal.xyz ) )
194	preVal = candid;
195
196	// Reads another neighbor
197	modTex += float2( -dist, dist );
198	candid = tex2D( mp, modTex );
199
200	// Calculate its intensity.
201	// If it is more intensive than the previous one, it is stored.
202	if( dot( candid.xyz, candid.xyz ) > dot( preVal.xyz, preVal.xyz ) )
203	preVal = candid;
204
205	// Reads another neighbor. If it is more intensive than the previous, it is stored.
206	modTex += float2( -dist, -dist );
207	candid = tex2D( mp, modTex );
208	if( dot( candid.xyz, candid.xyz ) > dot( preVal.xyz, preVal.xyz ) )
209	preVal = candid;
210
211	// Reads another neighbor. If it is more intensive than the previous, it is stored.
212	modTex += float2( dist, -dist );
213	candid = tex2D( mp, modTex );
214	if( dot( candid.xyz, candid.xyz ) > dot( preVal.xyz, preVal.xyz ) )
215	preVal = candid;
216	}
217	return preVal;
218	}
219
220
221	//-----------------------------------------------------------------------------
222	// SHADERS
223	// Here are the different shaders.
224	//-----------------------------------------------------------------------------
225
226
227	//*****************************************************************************
228	//-----------------------------------------------------------------------------
229	// RenderRoomColorDistance
230	// This shader stores the viewable object's color and its distance from the CenterObject's position.
231	// The result is stored in a CubeMap.
232	//-----------------------------------------------------------------------------
233	void RenderRoomColorDistanceVS(
234	float4 Pos : POSITION,
235	float2 Tex : TEXCOORD0,
236	out float4 outhPos : POSITION,
237	out float2 outTex : TEXCOORD0,
238	out float4 outPos : TEXCOORD1 )
239	{
240	outhPos = mul( Pos, g_mWorldViewProjection );
241	outTex = Tex;
242	// Calculates the world position
243	outPos = mul( Pos, g_mWorldView );
244	}
245	// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
246
247	float4 RenderRoomColorDistancePS(
248	float2 Tex : TEXCOORD0,
249	float4 Pos : TEXCOORD1 ) : COLOR
250	{
251	// The color of the viewable object in the current pixel.
252	// In the scene there are 2 different textured object. (the room, and the Columns)
253	// Every column has the same brdf texture.
254	float3 retColor = float4(0,0,0,0);
255	if ( g_iObjectID == -1 ) retColor = float4( tex2D( g_samplerRoomMap, Tex ).xyz, 1);
256	else retColor = float4( tex2D( g_samplerColumnOriginalMap, Tex ).xyz, 1);
257
258	// The distance from the Center object
259	float Distance = (float) ( length( Pos.xyz ) );
260	return float4( retColor, Distance ); // Color(x,y,z) + Distance(w)
261	}
262	//*****************************************************************************
263
264
265	//-----------------------------------------------------------------------------
266	// RenderRoomUV
267	// This shader stores the viewable object's UV and unique ObjectID.
268	// The ObjectID identify the object, because the UV pair is not enough.
269	// The result is stored in a CubeMap.
270	//-----------------------------------------------------------------------------
271	void RenderRoomUVVS(
272	float4 Pos : POSITION,
273	float2 Tex : TEXCOORD0,
274	out float4 outhPos : POSITION,
275	out float2 outTex : TEXCOORD0 )
276	{
277	outhPos = mul( Pos, g_mWorldViewProjection );
278	outTex = Tex;
279	}
280	// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
281
282	float4 RenderRoomUVPS(
283	float2 Tex : TEXCOORD0) : COLOR
284	{ // The UV value and the ID of the viewable object in the current pixel
285	// Here the "1" value is unnecessary
286	return float4( Tex, g_iObjectID, 1 ); // Tex(x,y) + g_iObjectID(z) + "1"(w)
287	}
288	//*****************************************************************************
289
290
291	//-----------------------------------------------------------------------------
292	// RenderUmbra
293	// This shader copies the brdf color from the original texture Atlas of the Object to the
294	// actual texture Atlas of the Object.
295	// It is needed, because the brdf value is modified with shadow.
296	// If the pixel is in shadow, the brdf value is decreased.
297	// The distance from the light source is also a modifying factor.
298	// The result is stored in a 2D map (Atlas).
299	//-----------------------------------------------------------------------------
300	void RenderUmbraVS(
301	float4 Pos : POSITION,
302	float2 Tex : TEXCOORD0,
303	float3 Normal : NORMAL,
304	out float4 outhPos : POSITION,
305	out float2 outTex : TEXCOORD0,
306	out float3 outPos : TEXCOORD1,
307	out float outCosT : TEXCOORD2,
308	out float4 outLPos : TEXCOORD3)
309	{
310	// The Room has no offset.
311	// The Columns have offset from the world's center position.
312	float4 PosWorld = Pos;
313	if ( g_iObjectID > -0.1f ) PosWorld = mul( Pos, g_mWorldView );
314	// Light vector
315	float3 L = normalize( g_vLightPos3f - PosWorld.xyz );
316
317	// Transformation between texture and screen space.
318	// HALF is an offset between the two space.
319	outhPos.x = Tex.x * 2.0f - 1.0f - HALF;
320	outhPos.y = 1.0f - Tex.y * 2.0f + HALF;
321	outhPos.z = 0;
322	outhPos.w = 1;
323
324	outTex = Tex;
325	outPos = PosWorld.xyz;
326	// The direction of the normal of the Room and the Columns are different.
327	if (g_iObjectID < -0.5f)
328	Normal = -Normal;
329	outCosT = dot( Normal, L );
330	outLPos = mul( PosWorld, g_mLightViewTexBias );
331	}
332	// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
333
334	float4 RenderUmbraPS(
335	float2 Tex : TEXCOORD0,
336	float3 Pos : TEXCOORD1,
337	float CosT : TEXCOORD2,
338	float4 LPos : TEXCOORD3 ) : COLOR
339	{
340	// return Color
341	float4 retColor = float4(0,0,0,0);
342	// ShadowMap distance values
343	float2 texDist, t051, t052, t053, t054, t101, t102, t103, t104, t031, t032, t033, t034;
344	texDist = t051 = t052 = t053 = t054 = t101 = t102 = t103 = t104 = t031 = t032 = t033 = t034 = 0.0f;
345
346	// Read the brdf from the atlas of the object
347	// The Room and the Columns have 2 different brdf Atlas.
348	if ( g_iObjectID == -1 )
349	retColor = float4( tex2D( g_samplerRoomMap, Tex ).xyz, 1);
350	else
351	retColor = float4( tex2D( g_samplerColumnOriginalMap, Tex ).xyz, 1);
352
353	// Use shadow?
354	if (g_bShadowON)
355	{
356	// Read the ShadowMap for the distance values
357	// and store the alpha value to decide wether its depth value is a real or zero from the ShadowMap border.
358	texDist = float2( LPos.z, 0.0f ) - tex2Dlod( g_samplerShadowMap, float4( LPos.xyz / LPos.w, 0 ) ).xw;
359
360	t031 = float2( LPos.z, 0.0f ) - tex2Dlod( g_samplerShadowMap, float4( ( LPos.xyz / LPos.w ) + float3( THREE, 0, 0 ), 0 ) ).xw;
361	t032 = float2( LPos.z, 0.0f ) - tex2Dlod( g_samplerShadowMap, float4( ( LPos.xyz / LPos.w ) + float3( -THREE,ONE, 0 ), 0 ) ).xw;
362	t033 = float2( LPos.z, 0.0f ) - tex2Dlod( g_samplerShadowMap, float4( ( LPos.xyz / LPos.w ) + float3( ONE, THREE, 0 ), 0 ) ).xw;
363	t034 = float2( LPos.z, 0.0f ) - tex2Dlod( g_samplerShadowMap, float4( ( LPos.xyz / LPos.w ) + float3( 0, -THREE, 0 ), 0 ) ).xw;
364
365	t051 = float2( LPos.z, 0.0f ) - tex2Dlod( g_samplerShadowMap, float4( ( LPos.xyz / LPos.w ) + float3( FIVE, ONE, 0 ), 0 ) ).xw;
366	t052 = float2( LPos.z, 0.0f ) - tex2Dlod( g_samplerShadowMap, float4( ( LPos.xyz / LPos.w ) + float3( -FIVE, 0, 0 ), 0 ) ).xw;
367	t053 = float2( LPos.z, 0.0f ) - tex2Dlod( g_samplerShadowMap, float4( ( LPos.xyz / LPos.w ) + float3( -ONE, FIVE, 0 ), 0 ) ).xw;
368	t054 = float2( LPos.z, 0.0f ) - tex2Dlod( g_samplerShadowMap, float4( ( LPos.xyz / LPos.w ) + float3( 0, -FIVE, 0 ), 0 ) ).xw;
369
370	t101 = float2( LPos.z, 0.0f ) - tex2Dlod( g_samplerShadowMap, float4( ( LPos.xyz / LPos.w ) + float3( TEN, THREE, 0 ), 0 ) ).xw;
371	t102 = float2( LPos.z, 0.0f ) - tex2Dlod( g_samplerShadowMap, float4( ( LPos.xyz / LPos.w ) + float3( -TEN, -ONE, 0 ), 0 ) ).xw;
372	t103 = float2( LPos.z, 0.0f ) - tex2Dlod( g_samplerShadowMap, float4( ( LPos.xyz / LPos.w ) + float3( -ONE, TEN, 0 ), 0 ) ).xw;
373	t104 = float2( LPos.z, 0.0f ) - tex2Dlod( g_samplerShadowMap, float4( ( LPos.xyz / LPos.w ) + float3( FIVE, -TEN, 0 ), 0 ) ).xw;
374
375	// Decrease the intensity of the brdf in the area of the shadow,
376	// and increase it if the pixel has an illuminated neighbor.
377
378
379	// This variable modifies the brdf.
380	float summarize = 1.0f;
381
382	// Decrease it if it is in shadow and it is a real depth value ( alpha = 1 )
383	if ( ( texDist.x > 0.05f ) && ( texDist.y < -0.5f ) )
384	summarize = g_fShadowIntensity;
385
386	// Increase it if it is in light.
387	// The power of effect of a neighbor pixel depends on the distance from the original pixel.
388	if ( t031.x < 0.05f && t031.y < -0.5f ) summarize += 0.85;
389	if ( t032.x < 0.05f && t032.y < -0.5f ) summarize += 0.85;
390	if ( t033.x < 0.05f && t033.y < -0.5f ) summarize += 0.85;
391	if ( t034.x < 0.05f && t034.y < -0.5f ) summarize += 0.85;
392	if ( t051.x < 0.05f && t051.y < -0.5f ) summarize += 0.42;
393	if ( t052.x < 0.05f && t052.y < -0.5f ) summarize += 0.42;
394	if ( t053.x < 0.05f && t053.y < -0.5f ) summarize += 0.42;
395	if ( t054.x < 0.05f && t054.y < -0.5f ) summarize += 0.42;
396	if ( t101.x < 0.05f && t101.y < -0.5f ) summarize += 0.10;
397	if ( t102.x < 0.05f && t102.y < -0.5f ) summarize += 0.10;
398	if ( t103.x < 0.05f && t103.y < -0.5f ) summarize += 0.10;
399	if ( t104.x < 0.05f && t104.y < -0.5f ) summarize += 0.10;
400
401	// The brdf can not be increased by the shadow computation.
402	if ( summarize > 1.0f ) summarize = 1.0;
403	if ( ( texDist.x < 0.05f ) && ( texDist.y < -0.5f ) ) summarize = 1.0;
404	retColor *= summarize;
405
406	if ( texDist.x > 0.05f ) retColor *= g_fShadowIntensity;
407	if ( g_fShadowIntensity > 0.999 ) retColor /= summarize;
408	}
409
410	// The intensity of the brdf depends on the position of the light source.
411
412	float3 L = g_vLightPos3f;
413	float pll2 = dot( ( Pos - L ), ( Pos - L ) );
414	retColor = AMB + ( FI / pll2 ) CosT * g_fCausticsIntensity;
415
416	if (g_bShowHelp) // light's effect is decreased to improve the visibility of help text
417	retColor *= 0.5f;
418
419	return retColor;
420	}
421	//*****************************************************************************
422
423
424	//-----------------------------------------------------------------------------
425	// RenderRoomAndColumnsScreen
426	// This shader render the scene's objects to the screen with their own atlas.
427	//-----------------------------------------------------------------------------
428	void RenderRoomAndColumnsScreenVS(
429
430	float4 Pos : POSITION,
431	float2 Tex : TEXCOORD0,
432	out float4 outhPos : POSITION,
433	out float2 outTex : TEXCOORD0 )
434	{
435	outhPos = mul( Pos, g_mWorldViewProjection );
436	outTex = Tex;
437	}
438	// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
439
440	float4 RenderRoomAndColumnsScreenPS(
441	float2 Tex : TEXCOORD0) : COLOR
442	{
443	float4 retColor = float4(1,1,1,1);
444
445	// Five different atlas for the five object.
446	if (g_iObjectID == -1 ) retColor = float4( tex2D( g_samplerRoomLastMap, Tex ).xyz, 1 );
447	if (g_iObjectID == 0 ) retColor = float4( tex2D( g_samplerColumnLast0Map, Tex ).xyz, 1 );
448	if (g_iObjectID == 1 ) retColor = float4( tex2D( g_samplerColumnLast1Map, Tex ).xyz, 1 );
449	if (g_iObjectID == 2 ) retColor = float4( tex2D( g_samplerColumnLast2Map, Tex ).xyz, 1 );
450	if (g_iObjectID == 3 ) retColor = float4( tex2D( g_samplerColumnLast3Map, Tex ).xyz, 1 );
451
452	return retColor;
453	}
454	//*****************************************************************************
455
456
457	//-----------------------------------------------------------------------------
458	// RenderPhotonUVMap
459	// This shader creates the PhotonUVTexture with Hit function.
460	// It is a 2D map with the photon hits. It is created from the position of the light source.
461	// Every pixel stores the UV, and ObjectID information.
462	// The result is stored in a 2D map.
463	//-----------------------------------------------------------------------------
464	void RenderPhotonUVMapVS(
465	float4 Pos : POSITION,
466	float3 Normal : NORMAL,
467	float3 Tex : TEXCOORD0,
468	out float4 outhPos : POSITION,
469	out float3 outTex : TEXCOORD0,
470	out float3 outPos : TEXCOORD1,
471	out float3 outN : TEXCOORD2,
472	out float3 outL : TEXCOORD3)
473	{
474	// The offset (+float4...) is needed to move the Center Object into the center of the PhotonMap.
475	outhPos = mul( Pos, g_mWorldViewProjection ) + float4( -4.0f / (float)g_iPhotonMapSize , 4.0f / (float)g_iPhotonMapSize , 0, 0 );
476
477	outTex = Tex;
478	outPos = mul( Pos, g_mWorldCenterObject );
479	outN = Normal;
480	outL = normalize( outPos - g_vLightPos3f );
481	}
482	// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
483
484	float4 RenderPhotonUVMapPS(
485	float3 Tex : TEXCOORD0,
486	float3 Pos : TEXCOORD1,
487	float3 N : TEXCOORD2,
488	float3 L : TEXCOORD3 ) : COLOR
489	{
490	// By default, there is no Hit.
491	float a = -1;
492	float4 hitSurf = float4(0,0,0,0);
493
494	if ( dot( L, N ) < -0.1 ){
495	L = normalize( L );
496	N = normalize( N );
497	float3 T = normalize( refract( L, N, g_fRefractionIndex ) );
498
499	// Look up from the CubeMap
500	// The return value is a vector. The CubeUVMap is read at that position.
501	float3 TT = Hit( Pos, T, g_samplerRoomCubeMapColorDistanceMap );
502	hitSurf = texCUBE( g_samplerRoomCubeMapUVMap, TT );
503	// There is a Hit.
504	a = 1;
505	}
506	return float4( hitSurf.xyz, a );
507	}
508	//*****************************************************************************
509
510
511	//-----------------------------------------------------------------------------
512	// RenderPhotonUVMapClassic
513	// This shader creates the PhotonUVTexture with classical method.
514	// It is a 2D map with the photon hits. It is created from the position of the light source.
515	// Every pixel stores the UV, and ObjectID information.
516	// The result is stored in a 2D map.
517	//-----------------------------------------------------------------------------
518	void RenderPhotonUVMapClassicVS(
519	float4 Pos : POSITION,
520	float3 Normal : NORMAL,
521	float3 Tex : TEXCOORD0,
522	out float4 outhPos : POSITION,
523	out float3 outTex : TEXCOORD0,
524	out float3 outPos : TEXCOORD1,
525	out float3 outN : TEXCOORD2,
526	out float3 outL : TEXCOORD3)
527	{
528	// The offset (+float4...) is needed to move the Center Object into the center of the PhotonMap.
529	outhPos = mul( Pos, g_mWorldViewProjection ) + float4( -4.0f / (float)g_iPhotonMapSize , 4.0f / (float)g_iPhotonMapSize , 0, 0 );
530
531	outTex = Tex;
532	outPos = mul( Pos, g_mWorldCenterObject );
533	outN = Normal;
534	outL = normalize( outPos - g_vLightPos3f );
535	}
536	// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
537
538	float4 RenderPhotonUVMapClassicPS(
539	float3 Tex : TEXCOORD0,
540	float3 Pos : TEXCOORD1,
541	float3 N : TEXCOORD2,
542	float3 L : TEXCOORD3 ) : COLOR
543	{
544	// By default, there is no Hit.
545	float a = -1;
546	float4 hitSurf = float4(0,0,0,0);
547
548	if ( dot( L, N ) < -0.1 ){
549	L = normalize( L );
550	N = normalize( N );
551	float3 TT = normalize( refract( L, N, g_fRefractionIndex ) );
552
553	hitSurf = texCUBE( g_samplerRoomCubeMapUVMap, TT );
554	// There is a Hit.
555	a = 1;
556	}
557	return float4( hitSurf.xyz, a );
558	}
559	//*****************************************************************************
560
561
562
563	//-----------------------------------------------------------------------------
564	// RenderPhotonHit
565	// This shader uses the PhotonUVTexture as an input.
566	// It renders as many snippets to the Object's atlas as many pixels the PhotonUVTexture has.
567	// If a pixel in the PhotonUVTexture is not connected to the actual Object (not the same ObjectID),
568	// it will not be rendered.
569	// The result is blended into the Object's Atlas.
570	//-----------------------------------------------------------------------------
571	void RenderPhotonHitVS(
572	float4 Pos : POSITION,
573	float4 Color : COLOR0,
574	float2 Tex : TEXCOORD0,
575	out float4 outhPos : POSITION,
576	//out float2 outTex : TEXCOORD0,
577	out float2 outTexFilter : TEXCOORD1,
578	out float outPower : TEXCOORD2,
579	out float4 outPos : TEXCOORD3,
580	out float4 outColor : TEXCOORD4 )
581	{
582	// Reads back the PhotonHit's UV position and the ObjectID
583	float4 ph = tex2Dlod(g_samplerPhotonUVMap, float4( Tex, 0, 0));
584
585	// This enlarges the snippet's size if it is rendered into a Column's atlas.
586	// It is needed because the Column's atlas contains more elements,
587	// and the same distance (in world space) is bigger in the Column's atlas.
588	if ( g_iObjectID > -0.5 ) Pos *= 3.3f;
589
590	// Adds the snippet's offset to the UV coordinates
591	outPos.x = ph.x + Pos.x / 2.0;
592	outPos.y = ph.y - Pos.y / 2.0;
593	outPos.z = 0;
594	outPos.w = 1;
595
596	// Transforms the texture coordinates to screen coordinates
597	// and adds the snippet's offset to it
598	outhPos.x = ( ph.x * 2 ) - 1 + Pos.x + HALF;
599	outhPos.y = 1 - ph.y * 2 + Pos.y - HALF;
600
601	// Is it a real Hit?
602	// and are we render the right Object?
603	if ( ( ph.a > 0 ) && ( ph.b == g_iObjectID ) )
604	{
605	// If YES
606	outhPos.z = 0;
607	}
608	// If NO
609	else outhPos.z = -100;
610
611	outhPos.w = 1;
612
613	//outTex = outhPos;
614	outTexFilter = Tex;
615	outPower = ph.w;
616	outColor = Color;
617	}
618	// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
619
620	float4 RenderPhotonHitPS(
621	//float2 Tex : TEXCOORD0,
622	float2 TexFilter : TEXCOORD1,
623	float Power : TEXCOORD2,
624	float4 Pos : TEXCOORD3,
625	float4 Color : TEXCOORD4 ) : COLOR
626	{
627	float4 retColor;
628	float4 brdf = float4(0,0,0,0);
629
630	// Room or Column?
631	if ( g_iObjectID == -1 ) brdf = tex2D( g_samplerRoomMap, Pos);
632	else brdf = tex2D( g_samplerColumnOriginalMap, Pos);
633
634	// The Gausian weight of a snippet.
635	float4 w = tex2D( g_samplerPowerOfSnippetMap, Color.yz );
636	// The color of the snippet's pixel.
637	retColor = g_fPower * brdf * w * g_fCausticsIntensity;
638	return float4( retColor.xyz, 0 );
639	}
640	//*****************************************************************************
641
642
643	//-----------------------------------------------------------------------------
644	// RenderRefractObjectScreen
645	// This shader calculates the color of the CenterObject with Hit function.
646	// It has reflection and refraction effect.
647	// The result is displayed on the screen.
648	//-----------------------------------------------------------------------------
649	void RenderRefractObjectScreenVS(
650	float4 Pos : POSITION,
651	float3 Normal : NORMAL,
652	float2 Tex : TEXCOORD0,
653	out float4 outhPos : POSITION,
654	out float3 outPos : TEXCOORD1,
655	out float3 outN : TEXCOORD2,
656	out float3 outV : TEXCOORD3 )
657	{
658	outhPos = mul( Pos, g_mWorldViewProjection );
659	outPos = mul( Pos, g_mWorldCenterObject );
660	outN = normalize( Normal );
661	outV = normalize( outPos - g_vCameraPos3f );
662	}
663	// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
664
665	float4 RenderRefractObjectScreenPS(
666	float3 p0 : TEXCOORD1,
667	float3 N : TEXCOORD2,
668	float3 V : TEXCOORD3 ) : COLOR
669	{
670	V = normalize( V );
671	N = normalize( N );
672
673	// Calculates reflection
674	float3 R = reflect( V, N );
675	float3 RR = Hit(p0, R, g_samplerRoomCubeMapColorDistanceMap);
676
677	// Calculates refraction
678	float3 T = refract(V, N, g_fRefractionIndex);
679	float3 TT = Hit(p0, T, g_samplerRoomCubeMapColorDistanceMap);
680
681	// Calculates reflected color
682	float4 hitSurf = texCUBE( g_samplerRoomCubeMapUVMap_NO_FILTER, RR ); // UV position where the Atlas must be read
683	float4 reflectColor = float4( 1,0,0,0 );
684	if (hitSurf.b == -1) reflectColor = tex2D( g_samplerRoomLastMap, hitSurf.xy );
685	if (hitSurf.b == 0) reflectColor = tex2D( g_samplerColumnLast0Map, hitSurf.xy );
686	if (hitSurf.b == 1) reflectColor = tex2D( g_samplerColumnLast1Map, hitSurf.xy );
687	if (hitSurf.b == 2) reflectColor = tex2D( g_samplerColumnLast2Map, hitSurf.xy );
688	if (hitSurf.b == 3) reflectColor = tex2D( g_samplerColumnLast3Map, hitSurf.xy );
689
690
691	// Calculates refracted color
692	hitSurf = texCUBE( g_samplerRoomCubeMapUVMap_NO_FILTER, TT );
693	float4 refractColor = float4( 1,0,0,0 );
694	if (hitSurf.b == -1) refractColor = tex2D( g_samplerRoomLastMap, hitSurf.xy );
695	if (hitSurf.b == 0) refractColor = tex2D( g_samplerColumnLast0Map, hitSurf.xy );
696	if (hitSurf.b == 1) refractColor = tex2D( g_samplerColumnLast1Map, hitSurf.xy );
697	if (hitSurf.b == 2) refractColor = tex2D( g_samplerColumnLast2Map, hitSurf.xy );
698	if (hitSurf.b == 3) refractColor = tex2D( g_samplerColumnLast3Map, hitSurf.xy );
699
700	// Calculates return color modified by Fresnel function.
701	float F = g_fFresnelFactor + ( 1 - g_fFresnelFactor ) * pow( 1 - dot( N, -V ), 5 );
702	return float4( F * reflectColor + ( 1 - F ) * refractColor );
703	}
704
705	//*****************************************************************************
706
707
708	//-----------------------------------------------------------------------------
709	// RenderRefractObjectScreenClassic
710	// This shader calculates the color of the CenterObject with classical method.
711	// It has reflection and refraction effect.
712	// The result is displayed on the screen.
713	//-----------------------------------------------------------------------------
714	void RenderRefractObjectScreenClassicVS(
715	float4 Pos : POSITION,
716	float3 Normal : NORMAL,
717	float2 Tex : TEXCOORD0,
718	out float4 outhPos : POSITION,
719	out float3 outPos : TEXCOORD1,
720	out float3 outN : TEXCOORD2,
721	out float3 outV : TEXCOORD3 )
722	{
723	outhPos = mul( Pos, g_mWorldViewProjection );
724	outPos = mul( Pos, g_mWorldCenterObject );
725	outN = normalize( Normal );
726	outV = normalize( outPos - g_vCameraPos3f );
727	}
728	// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
729
730	float4 RenderRefractObjectScreenClassicPS(
731	float3 p0 : TEXCOORD1,
732	float3 N : TEXCOORD2,
733	float3 V : TEXCOORD3 ) : COLOR
734	{
735	V = normalize( V );
736	N = normalize( N );
737
738	// Calculates reflection
739	float3 RR = reflect( V, N );
740
741	// Calculates refraction
742	float3 TT = refract(V, N, g_fRefractionIndex);
743
744
745	// Calculates reflected color
746	float4 hitSurf = texCUBE( g_samplerRoomCubeMapUVMap_NO_FILTER, RR ); // UV position where the Atlas must be read
747	float3 reflectColor = float4(0,0,0,0);
748	if (hitSurf.b == -1) reflectColor = tex2D( g_samplerRoomLastMap, hitSurf.xy );
749	if (hitSurf.b == 0) reflectColor = tex2D( g_samplerColumnLast0Map, hitSurf.xy );
750	if (hitSurf.b == 1) reflectColor = tex2D( g_samplerColumnLast1Map, hitSurf.xy );
751	if (hitSurf.b == 2) reflectColor = tex2D( g_samplerColumnLast2Map, hitSurf.xy );
752	if (hitSurf.b == 3) reflectColor = tex2D( g_samplerColumnLast3Map, hitSurf.xy );
753
754	// Calculates refracted color
755	hitSurf = texCUBE( g_samplerRoomCubeMapUVMap_NO_FILTER, TT );
756	float3 refractColor = float4(0,0,0,0);
757	if (hitSurf.b == -1) refractColor = tex2D( g_samplerRoomLastMap, hitSurf.xy );
758	if (hitSurf.b == 0) refractColor = tex2D( g_samplerColumnLast0Map, hitSurf.xy );
759	if (hitSurf.b == 1) refractColor = tex2D( g_samplerColumnLast1Map, hitSurf.xy );
760	if (hitSurf.b == 2) refractColor = tex2D( g_samplerColumnLast2Map, hitSurf.xy );
761	if (hitSurf.b == 3) refractColor = tex2D( g_samplerColumnLast3Map, hitSurf.xy );
762
763	// Calculates return color modified by Fresnel function.
764	float F = g_fFresnelFactor + ( 1 - g_fFresnelFactor ) * pow( 1 - dot( N, -V ), 5 );
765	return float4( F * reflectColor + ( 1 - F ) * refractColor, 1 );
766	}
767
768	//*****************************************************************************
769
770
771
772	//-----------------------------------------------------------------------------
773	// RenderLightScreen
774	// This shader renders the light source's object to the screen with a diffuse color.
775	//-----------------------------------------------------------------------------
776	void RenderLightScreenVS(
777	float4 Pos : POSITION,
778	out float4 outPos : POSITION )
779	{
780	outPos = mul( Pos, g_mWorldViewProjection );
781	}
782
783	// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
784
785	float4 RenderLightScreenPS() : COLOR
786	{
787	return float4( 1, 1, 0.7f, 1 );
788	}
789	//*****************************************************************************
790
791
792	//-----------------------------------------------------------------------------
793	// RenderShadow
794	// This shader calculates the ShadowMapTexture's depth values.
795	// The result is stored in g_pShadowMapTexture.
796	//-----------------------------------------------------------------------------
797	void RenderShadowVS(
798	float4 Pos : POSITION,
799	out float4 outhPos : POSITION,
800	out float2 outPos : TEXCOORD1 )
801	{
802	outhPos = mul( Pos, g_mWorldViewProjection );
803	outPos = mul( Pos, g_mLightViewTexBias ).zw;
804	}
805	// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
806
807	float4 RenderShadowPS(
808	float2 Pos : TEXCOORD1 ) : COLOR
809	{
810	return float4(Pos.x, 0, 0, 1);
811	}
812	//*****************************************************************************
813
814
815	//-----------------------------------------------------------------------------
816	// FullScreenQuad
817	// This shader modifies the atlases of Room and Columns.
818	// It removes the black edges from the atlases.
819	// The result is stored in the Object's atlas.
820	//-----------------------------------------------------------------------------
821	void FullScreenQuadVS(
822	float4 Pos : POSITION,
823	out float4 outhPos : POSITION,
824	out float2 outTex : TEXCOORD0 )
825	{
826	outhPos = float4( Pos.xy, 0, 1 );
827	outTex.x = Pos.x * 0.5f + 0.5f;
828	outTex.y = -Pos.y * 0.5f + 0.5f;
829	}
830	// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
831
832	float4 FullScreenQuadPS(
833	float2 Tex : TEXCOORD0 ) : COLOR
834	{
835	float4 preVal = float4(1,1,1,1);
836
837	if( g_iObjectID ==-1 ) preVal = FlowLight( g_samplerRoomModifyMap, Tex );
838	if( g_iObjectID == 0 ) preVal = FlowLight( g_samplerColumnModify0Map, Tex );
839	if( g_iObjectID == 1 ) preVal = FlowLight( g_samplerColumnModify1Map, Tex );
840	if( g_iObjectID == 2 ) preVal = FlowLight( g_samplerColumnModify2Map, Tex );
841	if( g_iObjectID == 3 ) preVal = FlowLight( g_samplerColumnModify3Map, Tex );
842
843	return preVal;
844	}
845	//*****************************************************************************
846
847
848	//-----------------------------------------------------------------------------
849	// PhotonMapScreen
850	// This shader renders the PhotonMap texture (g_txPhotonUVMap) into the screen lower left corner.
851	// This texture contains the PhotonHits positions and ObjectIDs.
852	// The result is displayed on the screen.
853	//-----------------------------------------------------------------------------
854
855	void PhotonMapScreenVS(
856	float4 Pos : POSITION,
857	out float4 outhPos : POSITION,
858	out float2 outTex : TEXCOORD0 )
859	{
860	outhPos = float4( Pos.xy * 0.2f + float2( -0.7f, -0.7f ), 0, 1 );
861	outTex.x = Pos.x * 0.5f + 0.5f;
862	outTex.y = -Pos.y * 0.5f + 0.5f;
863	}
864	// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
865
866	float4 PhotonMapScreenPS(
867	float2 Tex : TEXCOORD0 ) : COLOR
868	{
869	return tex2D( g_samplerPhotonUVMap, Tex );
870	}
871	//*****************************************************************************
872
873
874
875
876
877	//-----------------------------------------------------------------------------
878	// TECHNIQUES
879	// Here are the different Techniques.
880	//-----------------------------------------------------------------------------
881
882	// Technique(AnyRenderPass):
883	// VertexShader = compile vs_3_0 AnyRenderPassVS()
884	// PixelShader = compile vs_3_0 AnyRenderPassPS()
885
886	// if using the name convention above to name vertex/pixel shaders,
887	// you can use the following macro definition to quickly define a technique:
888
889	// note: ## stands for concatenation
890
891	#define Technique(name); \
892	technique name \
893	{ \
894	pass p0 \
895	{ \
896	VertexShader = compile vs_3_0 name##VS(); \
897	PixelShader = compile ps_3_0 name##PS(); \
898	} \
899	}
900
901	Technique( RenderRoomColorDistance );
902	Technique( RenderRoomUV );
903	Technique( RenderUmbra );
904	Technique( RenderRoomAndColumnsScreen );
905	Technique( RenderLightScreen );
906	Technique( RenderPhotonUVMap );
907	Technique( RenderPhotonUVMapClassic );
908	Technique( RenderPhotonHit );
909	Technique( RenderRefractObjectScreen );
910	Technique( RenderRefractObjectScreenClassic );
911	Technique( RenderShadow );
912	Technique( FullScreenQuad );
913	Technique( PhotonMapScreen );

Note: See TracBrowser for help on using the repository browser.

Download in other formats:

Original Format