Context Navigation

source: GTP/trunk/App/Demos/Illum/Envmap/EnvMap.cpp @ 877

Revision 877, 28.0 KB checked in by szirmay, 18 years ago (diff)

Line
1
2	#include "dxstdafx.h"
3	#include "resource.h"
4	#include <time.h>
5
6	#include "Cube.h"
7	#include "Mesh.h"
8	#include "Parameters.h"
9	#include "EnvMap.h"
10
11	//--------------------------------------------------------------------------------------
12	// Media
13	//--------------------------------------------------------------------------------------
14
15	#define MESH0 L"Media\\Objects\\room.x"
16	#define MESH1 L"Media\\Objects\\sphere.x"
17	#define MESH2 L"Media\\Objects\\column.x"
18	#define MESH3 L"Media\\Objects\\teapot.x"
19	#define MESH4 L"Media\\Objects\\lamp01.x"
20	#define MESH5 L"Media\\Objects\\chair29.x"
21	#define MESH6 L"Media\\Objects\\couch01.x"
22	#define MESH7 L"Media\\Objects\\tiger.x"
23	#define MESH8 L"Media\\Objects\\bunny.x"
24	#define MESH9 L"Media\\Objects\\skullocc.x"
25
26	#define TEX0 L"Media\\Maps\\white.png"
27	#define TEX1 L"Media\\Maps\\pixel-grid-gy.png"
28	#define TEX2 L"Media\\Maps\\column.png"
29	#define ROOM_TEXTURE L"Media\\Maps\\pixel-grid-b.png"
30	//#define ROOM_TEXTURE L"Media\\Maps\\checker1.png" // checker
31
32	//--------------------------------------------------------------------------------------
33	// Constants
34	//--------------------------------------------------------------------------------------
35
36	// size of the cube map taken from the reference point of the object
37	#define CUBEMAP_SIZE 128 // 256
38	// size of the cube map for diffuse/glossy reflections
39	#define LR_CUBEMAP_SIZE 4
40	#define M 10 //25 // number of samples when precomputing geometric factors
41
42	extern Parameters pp;
43
44
45	void EnvMap::OnCreateDevice( IDirect3DDevice9* pd3dDevice, ID3DXEffect* g_pEffect )
46	{
47	this->pd3dDevice = pd3dDevice;
48	this->g_pEffect = g_pEffect;
49
50	// init mesh array
51	meshCount = 0;
52	// room
53	meshes[meshCount++] = new Mesh(MESH0, TEX0, 0, D3DXVECTOR3(0,0,0)); // room
54	/*meshes[meshCount++] = new Mesh(MESH2, TEX2, 0.7, D3DXVECTOR3(1.5,-1.3,1.5)); // columns
55	meshes[meshCount++] = new Mesh(MESH2, TEX2, 0.7, D3DXVECTOR3(1.5,-1.3,-1.5));
56	meshes[meshCount++] = new Mesh(MESH2, TEX2, 0.7, D3DXVECTOR3(-1.5,-1.3,1.5));
57	meshes[meshCount++] = new Mesh(MESH2, TEX2, 0.7, D3DXVECTOR3(-1.5,-1.3,-1.5));*/
58
59	// central mesh
60	mesh = new Mesh(MESH1, TEX0, 1, D3DXVECTOR3(0,0,0));
61	bCubeMapIsValid = false;
62	//ChooseMesh(whichMesh);
63	}
64
65	void EnvMap::OnDestroyDevice()
66	{
67	// central mesh
68	delete mesh;
69
70	// destroy mesh array
71	for (int i=0; i<meshCount; i++)
72	delete meshes[i];
73	meshCount = 0;
74	}
75
76	void EnvMap::OnResetDevice()
77	{
78	// 1: mipmapping disabled, (1 level only)
79	// D3DX_DEFAULT: mipmapping enabled
80	V( D3DXCreateTextureFromFileExW( pd3dDevice, ROOM_TEXTURE,
81	D3DX_DEFAULT, D3DX_DEFAULT, 1/1 or D3DX_DEFAULT=all/, 0, D3DFMT_A16B16G16R16F, D3DPOOL_MANAGED,
82	D3DX_DEFAULT, D3DX_DEFAULT, 0, NULL, NULL,
83	&pRoomTexture ) );
84
85	// pCubeTextureFromFile
86	if( FAILED(hr = D3DXCreateCubeTextureFromFile(pd3dDevice, L"Media\\Maps\\uffizi_cross.dds", &pCubeTextureFromFile)))
87	//if( FAILED(hr = D3DXCreateCubeTextureFromFile(pd3dDevice, L"Media\\Maps\\skybox02.dds", &pCubeTextureFromFile )))
88	{
89	MessageBox(NULL, L"Could not create cube texture!", L"Media\\Maps\\skybox02.dds", MB_OK\|MB_TOPMOST);
90	exit(-1);
91	}
92
93	pCubeTexture = CreateCubeTexture( CUBEMAP_SIZE, D3DFMT_A16B16G16R16F );
94	pCubeTextureSmall = CreateCubeTexture( LR_CUBEMAP_SIZE, D3DFMT_A16B16G16R16F );
95	pCubeTexturePreConvolved = CreateCubeTexture( LR_CUBEMAP_SIZE, D3DFMT_A16B16G16R16F );
96
97	InitFullScreenQuad();
98	cube = new Cube(pd3dDevice);
99	}
100
101	void EnvMap::OnLostDevice()
102	{
103	SAFE_RELEASE( pRoomTexture );
104	//SAFE_RELEASE( pBoxTexture );
105	SAFE_RELEASE( pCubeTexture );
106	SAFE_RELEASE( pCubeTextureFromFile );
107	SAFE_RELEASE( pCubeTextureSmall );
108	SAFE_RELEASE( pCubeTexturePreConvolved );
109	SAFE_RELEASE( pCosValuesTexture );
110	SAFE_RELEASE( pVertexBuffer ); // fullscreen quad
111	cube->Destroy();
112	delete cube;
113
114	bCubeMapIsValid = false;
115	}
116
117	void EnvMap::ChooseMesh(int whichMesh)
118	{
119	switch (whichMesh)
120	{
121	case 0: mesh->Load(MESH0); break;
122	case 1: mesh->Load(MESH1); break;
123	case 2: mesh->Load(MESH2); break;
124	case 3: mesh->Load(MESH3); break;
125	case 4: mesh->Load(MESH4); break;
126	case 5: mesh->Load(MESH5); break;
127	case 6: mesh->Load(MESH6); break;
128	case 7: mesh->Load(MESH7); break;
129	case 8: mesh->Load(MESH8); break;
130	case 9: mesh->Load(MESH9); break;
131	}
132
133	bCubeMapIsValid = false; // ask for cubemap redraw
134	}
135
136	void EnvMap::KeyboardProc( UINT nChar, bool bKeyDown, bool bAltDown )
137	{
138	if( bKeyDown )
139	{
140	float step = 0.2f;
141	//float max = roomSize-1.02f;
142
143	if ( nChar >= '0' && nChar <= '9' ) {
144	whichMesh = nChar-'0';
145	ChooseMesh(whichMesh); // load mesh
146	}
147	else switch( nChar )
148	{
149	case VK_RIGHT: mesh->Move( D3DXVECTOR3( step,0,0) ); break;
150	case VK_LEFT: mesh->Move( D3DXVECTOR3(-step,0,0) ); break;
151	case VK_UP: mesh->Move( D3DXVECTOR3(0, step,0) ); break;
152	case VK_DOWN: mesh->Move( D3DXVECTOR3(0,-step,0) ); break;
153	case VK_PRIOR: mesh->Move( D3DXVECTOR3(0,0, step) ); break;
154	case VK_NEXT: mesh->Move( D3DXVECTOR3(0,0,-step) ); break;
155	case 32: bCubeMapIsValid = false; break;
156
157	} // switch
158	}
159	}
160
161	void EnvMap::OnFrameRender( IDirect3DDevice9* pd3dDevice, D3DXMATRIXA16& mView, D3DXMATRIXA16& mProj )
162	{
163	if (pp.Get( bAutoGenCubeMap )) // calculate cube maps for each frame
164	{
165	bCubeMapIsValid = false;
166	}
167
168	// regenerate cube maps if necessary
169	if ( !bCubeMapIsValid )
170	{
171	long clock1 = clock();
172
173	// (to avoid warnings)
174	V( g_pEffect->SetTexture( "EnvironmentMap", NULL ) );
175
176	if ( !pp.Get( bCubeMapFromFile ) )
177	{
178	// to be precise: offsetting to the center of the (DirectX) texel
179	V( g_pEffect->SetFloat( "texel_size", 1 / (float)CUBEMAP_SIZE ) );
180	// I had to call it 2 times to render the environment completely
181	RenderCubeMap( pCubeTexture );
182	RenderCubeMap( pCubeTexture ); // don't ask why
183	}
184
185	//V( g_pEffect->SetFloat( "texel_size", 0 ) );
186
187	if ( pp.GetInt( iWhichMethod ) == DIFFUSE_SPECULAR
188	\|\| pp.GetInt( iWhichMethod ) == DIFFUSE_SPECULAR_LOCALIZED
189	\|\| pp.GetInt( iWhichMethod ) == DIFFUSE_SPECULAR_LOCALIZED_COSTEX )
190	{
191	ReduceCubeMapSize( pp.Get( bCubeMapFromFile ) ? pCubeTextureFromFile : pCubeTexture,
192	pCubeTextureSmall);
193
194	bShininessIsValid = false;
195	}
196
197	long clock2 = clock();
198	float tb = (float)(clock2-clock1)/CLOCKS_PER_SEC;
199
200	bCubeMapIsValid = true;
201	}
202
203	if ( !bShininessIsValid )
204	// refresh cos texture
205	{
206	if ( pp.GetInt( iWhichMethod ) == DIFFUSE_SPECULAR \|\| pp.GetInt( iWhichMethod ) == DIFFUSE_SPECULAR_LOCALIZED )
207	PreConvolve(pCubeTextureSmall, pCubeTexturePreConvolved);
208	else if ( pp.GetInt( iWhichMethod ) == DIFFUSE_SPECULAR_LOCALIZED_COSTEX )
209	GenerateCosTextureIfNotFound();
210
211	bShininessIsValid = true;
212	}
213
214	// Render the scene
215	DoRendering(mView, mProj);
216	}
217
218	void EnvMap::DoRendering(D3DXMATRIXA16& mView, D3DXMATRIXA16& mProj)
219	{
220	UINT uPasses;
221
222	D3DCOLOR backgroundColor = D3DCOLOR_ARGB(0, 66, 75, 121);
223	V( pd3dDevice->Clear(0, NULL, D3DCLEAR_TARGET \| D3DCLEAR_ZBUFFER, backgroundColor, 1.0f, 0) );
224
225	D3DXVECTOR3 eye = *camera->GetEyePt();
226	D3DXVECTOR4 eyePos(eye.x, eye.y, eye.z, 1);
227	D3DXVECTOR4 refPos(reference_pos.x, reference_pos.y, reference_pos.z, 1);
228
229	V( g_pEffect->SetTexture( "EnvironmentMap",
230	pp.Get( bCubeMapFromFile ) ? pCubeTextureFromFile : pCubeTexture ) );
231	V( g_pEffect->SetTexture( "SmallEnvironmentMap", pCubeTextureSmall ) );
232	//V( g_pEffect->SetTexture( "Decoration", pBoxTexture ) ); // crate texture
233
234	V( g_pEffect->SetVector ( "eyePos", &eyePos ) );
235	V( g_pEffect->SetVector ( "reference_pos", &refPos ) );
236	//V( g_pEffect->SetFloat ( "roomSize", roomSize ));
237	V( g_pEffect->SetFloat ( "refractionIndex", pp.Get( refractionIndex )));
238	V( g_pEffect->SetFloat ( "intensity", pp.Get( fIntensity ) ));
239	V( g_pEffect->SetFloat ( "sFresnel", pp.Get( sFresnel ))); // Fresnel refraction param.
240
241	//metal:
242	D3DXVECTOR4 n, k; // R 700 nm, G 550 nm, B 435 nm
243
244	if (pp.GetInt( iWhichMetal ) == 1)
245	{
246	// copper
247	n = D3DXVECTOR4(0.21f, 0.96f, 1.17f, 1);
248	k = D3DXVECTOR4(4.16f, 2.57f, 2.32f, 1);
249	}
250	else if (pp.GetInt( iWhichMetal ) == 2)
251	{
252	// gold
253	n = D3DXVECTOR4(0.16f, 0.35f, 1.6f, 1);
254	k = D3DXVECTOR4(3.98f, 2.71f, 1.92f, 1);
255	}
256	else if (pp.GetInt( iWhichMetal ) == 3)
257	{
258	// silver
259	n = D3DXVECTOR4(0.142f, 0.124f, 0.158f, 1);
260	k = D3DXVECTOR4(4.52f, 3.33f, 2.32f, 1);
261	}
262	else if (pp.GetInt( iWhichMetal ) == 4)
263	{
264	// alu
265	n = D3DXVECTOR4(1.83f, 0.96f, 0.577f, 1);
266	k = D3DXVECTOR4(8.31f, 6.69f, 5.288f, 1);
267	}
268
269	V( g_pEffect->SetVector( "nMetal", &n ));
270	V( g_pEffect->SetVector( "kMetal", &k ));
271	//V( g_pEffect->SetInt ( "iWhichMetal", pp.GetInt( iWhichMetal )) );
272
273	//if (pp.GetInt( iWhichMethod ) == DIFFUSE_SPECULAR \|\|
274	//pp.GetInt( iWhichMethod ) == DIFFUSE_SPECULAR_LOCALIZED )
275
276	float s = (float)pp.GetInt( iShininess );
277	V( g_pEffect->SetFloat ( "shininess", s));
278
279	// ------------------------- choose technique -------------------------
280
281	switch (pp.GetInt( iWhichMethod )) {
282	case IDEAL:
283	case IDEAL_LOCALIZED:
284	if (pp.GetInt( iWhichMethod ) == IDEAL \|\| pp.Get( bCubeMapFromFile) )
285	// no localization chosen
286	// or no depth info is available since the env is loaded from a DDS file
287	{
288	if ( pp.GetInt( iWhichMetal ) > 0 )
289	{ V( g_pEffect->SetTechnique( "EnvMapClassicMetal" ) ); }
290	else
291	{ V( g_pEffect->SetTechnique( "EnvMapClassic" ) ); }
292	}
293	else
294	{
295	if ( pp.GetInt( iWhichMetal ) > 0 )
296	{ V( g_pEffect->SetTechnique( "EnvMapImpostorMetal" ) ); }
297	else
298	{ V( g_pEffect->SetTechnique( "EnvMapImpostor" ) ); }
299	}
300	break;
301	case DIFFUSE_SPECULAR:
302	V( g_pEffect->SetTechnique( "EnvMapDiffuse" ) );
303	V( g_pEffect->SetTexture( "PreconvolvedEnvironmentMap", pCubeTexturePreConvolved ) );
304	break;
305	case DIFFUSE_SPECULAR_LOCALIZED:
306	V( g_pEffect->SetTechnique( "EnvMapDiffuseLocalized" ) );
307	break;
308	case DIFFUSE_SPECULAR_LOCALIZED_COSTEX:
309	V( g_pEffect->SetTechnique( "EnvMapDiffuseLocalizedWithCosLookup" ) );
310	V( g_pEffect->SetTexture( "Decoration", pCosValuesTexture ) );
311	break;
312	}
313
314	// ------------------------ end choose technique ------------------------
315
316
317	V( g_pEffect->Begin( &uPasses, 0 ) );
318	V( g_pEffect->BeginPass( 0 ) ); // csak 1 db PASS wan
319
320	DrawCenterObjects( mView, mProj );
321
322	V( g_pEffect->EndPass() );
323	V( g_pEffect->End() );
324
325	switch (pp.GetInt( iShowCubeMap ))
326	{
327	case 0:
328	case 1: V( g_pEffect->SetTexture( "EnvironmentMap",
329	pp.Get( bCubeMapFromFile ) ? pCubeTextureFromFile : pCubeTexture ) ); break;
330	case 2: V( g_pEffect->SetTexture( "EnvironmentMap", pCubeTextureSmall ) ); break;
331	case 3: V( g_pEffect->SetTexture( "EnvironmentMap", pCubeTexturePreConvolved) ); break;
332	}
333
334	// draw environment objects (room)
335	V( g_pEffect->SetTechnique( "IlluminatedScene" ) );
336	V( g_pEffect->Begin( &uPasses, 0 ) );
337	V( g_pEffect->BeginPass( 0 ) );
338
339	DrawEnvObjects( mView, mProj );
340
341	V( g_pEffect->EndPass() );
342	V( g_pEffect->End() );
343
344	V( g_pEffect->SetInt ( "iShowCubeMap", 0 ));
345	}
346
347	// ------------------------------------------------------------------------
348	// DRAW CENTRAL OBJECTS (SPHERE, ETC.)
349	// ------------------------------------------------------------------------
350
351	void EnvMap::DrawCenterObjects( D3DXMATRIXA16& mView, D3DXMATRIXA16& mProj )
352	{
353	D3DXVECTOR4 objColor(1,1,0,1);
354
355	objColor = D3DXVECTOR4(1,1,1,1);
356	V( g_pEffect->SetVector( "objColor", &objColor ) );
357
358	float scale = mesh->GetMeshScale();
359	D3DXVECTOR3 offset = mesh->GetMeshPosition();
360	SetWorldViewProj( ScaleAndOffset( scale, offset ), mView, mProj );
361
362	mesh->Draw();
363	}
364
365	// ------------------------------------------------------------------------
366	// DRAW OBJECTS IN THE ENVIRONMENT (BOX, LAMP, ETC.)
367	// ------------------------------------------------------------------------
368	void EnvMap::DrawEnvObjects( D3DXMATRIXA16& mView, D3DXMATRIXA16& mProj )
369	{
370	if (!pp.Get( bCubeMapFromFile ))
371	{
372	for (int i=1; i<meshCount; i++)
373	{
374	V( g_pEffect->SetTexture( "Decoration", meshes[i]->GetTexture() ) );
375
376	float scale = meshes[i]->GetMeshScale();
377	D3DXVECTOR3 offset = meshes[i]->GetMeshPosition();
378	SetWorldViewProj( ScaleAndOffset( scale, offset ), mView, mProj );
379
380	meshes[i]->Draw();
381	}
382	}
383
384	V( g_pEffect->SetTexture( "Decoration", pRoomTexture ) );
385
386	D3DXVECTOR4 objColor(1,1,0,1);
387
388	// ----------------------------------------
389	// draw a room of size [-roomSize..roomSize]
390	// ----------------------------------------
391	bool bLargeEnvCube = pp.Get( bCubeMapFromFile ) && pp.Get( iShowCubeMap ) == 0;
392	float roomSizeCurr = bLargeEnvCube ? roomSize*5 : roomSize;
393
394	cube->PrepareDrawing();
395	SetWorldViewProj( ScaleAndOffset( roomSizeCurr, D3DXVECTOR3(0,0,0) ), mView, mProj );
396
397	// flip normals so that the room is visible from its inside
398	V( pd3dDevice->SetRenderState(D3DRS_CULLMODE, D3DCULL_CW) );
399	V( g_pEffect->SetTexture( "Decoration", pRoomTexture ) );
400	V( g_pEffect->SetFloat( "brightness", 2.8f ));
401	V( g_pEffect->SetInt ( "iShowCubeMap", 0 ));
402
403	// decide if the room should visualize one of the cube maps
404	if ( bCubeMapIsValid && pp.GetInt( iShowCubeMap ) > 0)
405	V( g_pEffect->SetInt ( "iShowCubeMap", pp.GetInt( iShowCubeMap ) ));
406	if ( bCubeMapIsValid && pp.GetInt( iShowCubeMap ) == 0 && pp.Get( bCubeMapFromFile ))
407	V( g_pEffect->SetInt ( "iShowCubeMap", 1 ));
408
409	for( int i=0; i<6; i++ )
410	{
411	objColor = D3DXVECTOR4(0.4f-i0.1f, i0.1f, (i%2)*0.4f, 1); // a colorful room
412	g_pEffect->SetVector( "objColor", &objColor );
413	g_pEffect->CommitChanges();
414
415	cube->DrawFace(i);
416	}
417
418	pd3dDevice->SetRenderState(D3DRS_CULLMODE, D3DCULL_CCW);
419	V( g_pEffect->SetInt ( "iShowCubeMap", 0 ));
420	//V( g_pEffect->SetInt( "shininess", 2));
421	V( g_pEffect->SetFloat( "brightness", 1.0f ));
422
423	//V( g_pEffect->SetTexture( "Decoration", pBoxTexture ) );
424
425	objColor = D3DXVECTOR4(1, 1, 1, 1);
426	V( g_pEffect->SetVector( "objColor", &objColor ));
427
428	g_pEffect->CommitChanges();
429	}
430
431	/**
432	Sets the given scaling and offset.
433	@return The resulting world transformation matrix.
434	*/
435	D3DXMATRIXA16 EnvMap::ScaleAndOffset(D3DXVECTOR3 vScale, D3DXVECTOR3 vOffset)
436	{
437	D3DXMATRIXA16 mScale, mOffset;
438	D3DXMatrixIdentity(&mScale);
439	D3DXMatrixIdentity(&mOffset);
440
441	D3DXMatrixTranslation( &mOffset, vOffset.x, vOffset.y, vOffset.z );
442	D3DXMatrixScaling( &mScale, vScale.x, vScale.y, vScale.z );
443
444	return mScale * mOffset;
445	}
446
447	/**
448	Sets the given uniform scaling and an offset.
449	@return The resulting world transformation matrix.
450	*/
451	D3DXMATRIXA16 EnvMap::ScaleAndOffset(float fScale, D3DXVECTOR3 vOffset)
452	{
453	return ScaleAndOffset( D3DXVECTOR3(fScale,fScale,fScale), vOffset );
454	}
455
456	/**
457	\brief Uploads the specified world/view/projection transformation matrices to the GPU.
458	*/
459	void EnvMap::SetWorldViewProj(D3DXMATRIXA16& mWorld, D3DXMATRIXA16& mView, D3DXMATRIXA16& mProj )
460	{
461	D3DXMATRIXA16 mWorldView = mWorld * mView;
462	D3DXMATRIXA16 mWorldViewProjection = mWorldView * mProj;
463
464	D3DXMATRIXA16 mWorldViewI, mWorldViewIT, mWorldI, mWorldIT;
465	D3DXMatrixInverse(&mWorldViewI, NULL, &mWorldView);
466	D3DXMatrixTranspose(&mWorldViewIT, &mWorldViewI);
467
468	D3DXMatrixInverse(&mWorldI, NULL, &mWorld);
469	D3DXMatrixTranspose(&mWorldIT, &mWorldI);
470
471	V( g_pEffect->SetMatrix( "World", &mWorld ) );
472	V( g_pEffect->SetMatrix( "WorldIT", &mWorldIT ) );
473	V( g_pEffect->SetMatrix( "WorldView", &mWorldView ) );
474	//V( g_pEffect->SetMatrix( "WorldViewIT", &mWorldViewIT ) );
475
476	V( g_pEffect->SetMatrix( "WorldViewProjection", &mWorldViewProjection ) );
477	V( g_pEffect->CommitChanges() );
478	}
479
480	/// \brief Renders the environment into the specified cubemap.
481	///
482	/// The camera is placed into #reference_pos. Uses technique IlluminatedScenePS() for rendering.
483	void EnvMap::RenderCubeMap(IDirect3DCubeTexture9* pCubeTexture)
484	{
485	IDirect3DSurface9* oldRenderTarget;
486	IDirect3DSurface9* oldDepthStencil;
487	IDirect3DSurface9* newDepthStencil;
488
489	// create a CUBEMAP_SIZE x CUBEMAP_SIZE size depth buffer
490	pd3dDevice->CreateDepthStencilSurface(CUBEMAP_SIZE, CUBEMAP_SIZE, D3DFMT_D16,
491	D3DMULTISAMPLE_NONE, 0, true, &newDepthStencil, NULL);
492
493	// replace old depth buffer
494	pd3dDevice->GetDepthStencilSurface(&oldDepthStencil);
495	pd3dDevice->SetDepthStencilSurface(newDepthStencil);
496
497	pd3dDevice->GetRenderTarget(0,&oldRenderTarget);
498
499	UINT uPasses;
500	for (int i = 0; i < 6; i++)
501	{
502	IDirect3DSurface9* pFace;
503	V( pCubeTexture->GetCubeMapSurface((D3DCUBEMAP_FACES)i, 0, &pFace) );
504	V( pd3dDevice->SetRenderTarget(0, pFace) );
505
506	V( g_pEffect->SetTechnique( "IlluminatedScene" ) );
507	V( g_pEffect->SetTexture( "Decoration", pRoomTexture ) );
508
509	V( g_pEffect->Begin( &uPasses, 0 ) );
510	V( g_pEffect->BeginPass( 0 ) );
511
512	V( pd3dDevice->Clear(0, NULL, D3DCLEAR_TARGET \| D3DCLEAR_ZBUFFER,
513	D3DCOLOR_ARGB(0,/i==0 ? 255 : /0,0,0), 1.0f, 0) );
514
515	// mView
516	D3DXMATRIXA16 mView, mProj;
517
518	// looking toward the cube map faces _from the origin_
519	// mView = DXUTGetCubeMapViewMatrix( i );
520
521	//float scale = mesh->GetMeshScale();
522	//D3DXVECTOR3 offset = mesh->GetMeshPosition();
523
524	D3DXVECTOR3 vecEye(0,0,0);
525	D3DXVECTOR3 vecAt(0.0f, 0.0f, 0.0f);
526	D3DXVECTOR3 vecUp(0.0f, 0.0f, 0.0f);
527
528	switch( i )
529	{
530	case D3DCUBEMAP_FACE_POSITIVE_X:
531	vecAt = D3DXVECTOR3( 1, 0, 0 );
532	vecUp = D3DXVECTOR3( 0.0f, 1.0f, 0.0f );
533	break;
534	case D3DCUBEMAP_FACE_NEGATIVE_X:
535	vecAt = D3DXVECTOR3(-1.0f, 0.0f, 0.0f );
536	vecUp = D3DXVECTOR3( 0.0f, 1.0f, 0.0f );
537	break;
538	case D3DCUBEMAP_FACE_POSITIVE_Y:
539	vecAt = D3DXVECTOR3( 0.0f, 1.0f, 0.0f );
540	vecUp = D3DXVECTOR3( 0.0f, 0.0f,-1.0f );
541	break;
542	case D3DCUBEMAP_FACE_NEGATIVE_Y:
543	vecAt = D3DXVECTOR3( 0.0f,-1.0f, 0.0f );
544	vecUp = D3DXVECTOR3( 0.0f, 0.0f, 1.0f );
545	break;
546	case D3DCUBEMAP_FACE_POSITIVE_Z:
547	vecAt = D3DXVECTOR3( 0.0f, 0.0f, 1.0f );
548	vecUp = D3DXVECTOR3( 0.0f, 1.0f, 0.0f );
549	break;
550	case D3DCUBEMAP_FACE_NEGATIVE_Z:
551	vecAt = D3DXVECTOR3( 0.0f, 0.0f,-1.0f );
552	vecUp = D3DXVECTOR3( 0.0f, 1.0f, 0.0f );
553	break;
554	}
555
556	// reference point is the current object position
557	reference_pos = mesh->GetMeshPosition();
558	vecEye += reference_pos;
559	vecAt += reference_pos;
560
561	D3DXMatrixLookAtLH(&mView, &vecEye, &vecAt, &vecUp);
562	D3DXMatrixPerspectiveFovLH( &mProj, D3DX_PI/2, 1, 0.1, 100 );
563
564	DrawEnvObjects(mView, mProj);
565
566	V( g_pEffect->EndPass() );
567	V( g_pEffect->End() );
568
569	SAFE_RELEASE( pFace );
570	}
571
572	// restore old rendertarget & depth buffer
573	pd3dDevice->SetRenderTarget(0, oldRenderTarget);
574	pd3dDevice->SetDepthStencilSurface(oldDepthStencil);
575	SAFE_RELEASE( oldDepthStencil );
576	SAFE_RELEASE( oldRenderTarget );
577	SAFE_RELEASE( newDepthStencil );
578	}
579
580	void EnvMap::ReduceCubeMapSize(IDirect3DCubeTexture9* pSourceCube, IDirect3DCubeTexture9* pDestCube)
581	{
582	IDirect3DSurface9* oldRenderTarget;
583	IDirect3DSurface9* oldDepthStencil;
584	IDirect3DSurface9* newDepthStencil;
585
586	// create a LR_CUBEMAP_SIZE x LR_CUBEMAP_SIZE size depth buffer
587	V( pd3dDevice->CreateDepthStencilSurface(LR_CUBEMAP_SIZE, LR_CUBEMAP_SIZE, D3DFMT_D16,
588	D3DMULTISAMPLE_NONE, 0, true, &newDepthStencil, NULL));
589
590	// replace old depth buffer
591	pd3dDevice->GetDepthStencilSurface(&oldDepthStencil);
592	pd3dDevice->SetDepthStencilSurface(newDepthStencil);
593	pd3dDevice->GetRenderTarget(0, &oldRenderTarget);
594
595	for(int i=0; i<6; i++)
596	{
597	V( g_pEffect->SetTexture( "EnvironmentMap", pSourceCube ) );
598	V( g_pEffect->SetInt( "nFace", i ) );
599
600	// set a face of 'pDestCube' as rendertarget
601	IDirect3DSurface9* pDestCubeFace;
602	V( pDestCube->GetCubeMapSurface((D3DCUBEMAP_FACES)i, 0, &pDestCubeFace) );
603	V( pd3dDevice->SetRenderTarget(0, pDestCubeFace) );
604
605	// begin drawing
606	V( g_pEffect->SetTechnique( "ReduceTexture" ) );
607
608	UINT uPasses;
609	V( g_pEffect->Begin( &uPasses, 0 ) );
610	V( g_pEffect->BeginPass( 0 ) );
611
612	V( pd3dDevice->Clear(0, NULL, D3DCLEAR_TARGET \| D3DCLEAR_ZBUFFER,
613	D3DCOLOR_ARGB(0,255,0,0), 1.0f, 0) );
614
615	// draw a square
616	DrawFullScreenQuad();
617
618	V( g_pEffect->EndPass() );
619	V( g_pEffect->End() );
620
621	SAFE_RELEASE( pDestCubeFace );
622	}
623
624	// restore old rendertarget & depth buffer
625	pd3dDevice->SetRenderTarget(0, oldRenderTarget);
626	pd3dDevice->SetDepthStencilSurface(oldDepthStencil);
627	SAFE_RELEASE( oldDepthStencil );
628	SAFE_RELEASE( oldRenderTarget );
629	SAFE_RELEASE( newDepthStencil );
630	}
631
632	/// \brief Calculates the irradiance map by convolution.
633	///
634	/// Convolves data from the source cubemap and stores the result in the target cubemap. Uses ConvolutionPS().
635	void EnvMap::PreConvolve(IDirect3DCubeTexture9* pSourceCube, IDirect3DCubeTexture9* pDestCube)
636	{
637	IDirect3DSurface9* oldRenderTarget;
638	IDirect3DSurface9* oldDepthStencil;
639	IDirect3DSurface9* newDepthStencil;
640
641	// create a LR_CUBEMAP_SIZE x LR_CUBEMAP_SIZE size depth buffer
642	pd3dDevice->CreateDepthStencilSurface(LR_CUBEMAP_SIZE, LR_CUBEMAP_SIZE, D3DFMT_D16,
643	D3DMULTISAMPLE_NONE, 0, true, &newDepthStencil, NULL);
644
645	// replace old depth buffer
646	pd3dDevice->GetDepthStencilSurface(&oldDepthStencil);
647	pd3dDevice->SetDepthStencilSurface(newDepthStencil);
648	pd3dDevice->GetRenderTarget(0, &oldRenderTarget);
649
650	V( g_pEffect->SetTexture( "SmallEnvironmentMap", pSourceCube ) );
651
652	float s = (float)pp.GetInt( iShininess );
653	V( g_pEffect->SetFloat ( "shininess", s));
654
655	for(int i=0; i<6; i++)
656	{
657	V( g_pEffect->SetInt( "nFace", i ) );
658
659	// set a face of 'pDestCube' as rendertarget
660	IDirect3DSurface9* pDestCubeFace;
661	V( pDestCube->GetCubeMapSurface((D3DCUBEMAP_FACES)i, 0, &pDestCubeFace) );
662	V( pd3dDevice->SetRenderTarget(0, pDestCubeFace) );
663
664	// begin drawing
665	V( g_pEffect->SetTechnique( "Convolution" ) );
666
667	UINT uPasses;
668	V( g_pEffect->Begin( &uPasses, 0 ) );
669	V( g_pEffect->BeginPass( 0 ) );
670
671	V( pd3dDevice->Clear(0, NULL, D3DCLEAR_TARGET \| D3DCLEAR_ZBUFFER,
672	D3DCOLOR_ARGB(0,255,255,255), 1.0f, 0) );
673
674	// draw a square
675	DrawFullScreenQuad();
676
677	V( g_pEffect->EndPass() );
678	V( g_pEffect->End() );
679	SAFE_RELEASE( pDestCubeFace );
680	}
681
682	//SaveCubeMap( pDestCube, "ha", "");
683
684	// restore old rendertarget & depth buffer
685	pd3dDevice->SetRenderTarget(0, oldRenderTarget);
686	pd3dDevice->SetDepthStencilSurface(oldDepthStencil);
687	SAFE_RELEASE( oldDepthStencil );
688	SAFE_RELEASE( oldRenderTarget );
689	SAFE_RELEASE( newDepthStencil );
690	}
691
692	/void EnvMap::RenderToCubeTexture(IDirect3DCubeTexture9 pDestCube)
693	{
694	IDirect3DSurface9* m_backBuffer=NULL;
695	pd3dDevice->GetRenderTarget(0, &m_backBuffer);
696
697	for(int i=0; i<6; i++)
698	{
699	V( g_pEffect->SetInt( "nFace", i ) );
700
701	// set a face of 'pDestCube' as rendertarget
702	IDirect3DSurface9* pDestCubeFace;
703	V( pDestCube->GetCubeMapSurface((D3DCUBEMAP_FACES)i, 0, &pDestCubeFace) );
704	V( pd3dDevice->SetRenderTarget(0, pDestCubeFace) );
705
706	// begin drawing
707	UINT uPasses;
708	V( g_pEffect->Begin( &uPasses, 0 ) );
709	V( g_pEffect->BeginPass( 0 ) );
710
711	V( pd3dDevice->Clear(0, NULL, D3DCLEAR_TARGET \| D3DCLEAR_ZBUFFER,
712	D3DCOLOR_ARGB(0,255,255,0), 1.0f, 0) );
713
714	// draw a square
715	DrawFullScreenQuad();
716
717	V( g_pEffect->EndPass() );
718	V( g_pEffect->End() );
719	SAFE_RELEASE( pDestCubeFace );
720	}
721
722	pd3dDevice->SetRenderTarget(0,m_backBuffer);
723	}*/
724
725	void EnvMap::SaveCubeMap(IDirect3DCubeTexture9* pCubeTexture, char* FileNamePrefix, char* FileNameSuffix)
726	{
727	char buf[100];
728	wchar_t wbuf[100];
729
730	for(int i=0;i<6;i++)
731	{
732	sprintf(buf, "%s%i%s.png", FileNamePrefix, i, FileNameSuffix);
733	mbstowcs( wbuf, buf, 100 );
734
735	IDirect3DSurface9* pFace;
736	V( pCubeTexture->GetCubeMapSurface((D3DCUBEMAP_FACES)i, 0, &pFace) );
737	D3DXSaveSurfaceToFile(wbuf, D3DXIFF_PNG, pFace, NULL,NULL);
738	}
739	}
740
741	/// \brief Calls GenerateCosTexture() if the specified texture is not yet calculated
742	/// and stored as a texture in the <b>cos</b> subdirectory.
743
744	void EnvMap::GenerateCosTextureIfNotFound()
745	// precomputing geometric factors
746	{
747	wchar_t wCosTextureName[100];
748	swprintf( wCosTextureName, L"cos\\cos_s%02i.png", pp.GetInt( iShininess ) );
749
750	// try to open
751	hr = D3DXCreateTextureFromFile( pd3dDevice, wCosTextureName, &pCosValuesTexture);
752	if ( FAILED( hr ) )
753	{
754	// generate
755	pCosValuesTexture = GenerateCosTexture();
756
757	// save
758	IDirect3DSurface9* pSurface = NULL;
759	V( pCosValuesTexture->GetSurfaceLevel( 0, &pSurface ) );
760	D3DXSaveSurfaceToFile( wCosTextureName, D3DXIFF_PNG, pSurface, NULL,NULL);
761	SAFE_RELEASE( pSurface );
762	}
763	}
764
765	/// Generates precomputed texture to store values for the reflectivity integral. Uses the eval() function.
766	IDirect3DTexture9* EnvMap::GenerateCosTexture()
767	{
768	const int X = 64;
769	const int Y = 128;
770
771	IDirect3DDevice9* pd3dDevice = DXUTGetD3DDevice();
772
773	// Create a temporary texture
774	LPDIRECT3DTEXTURE9 texTemp;
775	V( pd3dDevice->CreateTexture( X, Y, 1,
776	D3DUSAGE_DYNAMIC, D3DFMT_A32B32G32R32F,
777	D3DPOOL_DEFAULT, &texTemp, NULL ) );
778
779	// Fill in the gaussian texture data
780	D3DLOCKED_RECT Rect;
781	V( texTemp->LockRect(0, &Rect, 0, 0) );
782
783	int u, v;
784	float dx, dy, I;
785	float* pBits;
786
787	FILE* f = fopen( "cos_progress", "wt");
788	fprintf(f, "");
789	fclose( f );
790
791	long clock1 = clock();
792
793	//int multiplier = getMultiplier();
794	//float values[X*Y];
795	//evalAll( values );
796
797	for( v=0; v < Y; ++v )
798	{
799	pBits = (float)((char)(Rect.pBits)+v*Rect.Pitch);
800
801	for( u=0; u < X; ++u )
802	{
803	dx = u/(float)X; // 0..1
804	dy = v/(float)Y; // 0..1
805
806	*(pBits++) = 0; // intensity
807
808	(pBits++) = eval( 2dx-1, dy23.14159f ) / 3; // old: intensity
809	//(pBits++) = values[ vX + u ] / 50; // intensity
810
811	*(pBits++) = 0; // intensity
812	*(pBits++) = 0; // intensity
813	}
814
815	if ( v > 0 && v % (Y/10) == 0)
816	{
817	FILE* f = fopen( "cos_progress", "at"); // some silly progress bar:
818	fprintf(f, "#"); // write a # for each 10% done
819	fclose( f );
820	}
821	}
822
823	long clock2 = clock();
824	float time = (float)(clock2-clock1)/CLOCKS_PER_SEC;
825
826	f = fopen( "cos_progress", "at");
827	fprintf(f, "\ntime:%.3g secs", time);
828	fclose( f );
829
830	texTemp->UnlockRect(0);
831
832	return texTemp;
833	}
834
835	/// \brief Calculates the reflectivity integral for a given texel.
836	///
837	/// The angle between the surface normal and texel center is described by cos_theta
838	/// and the solid angle occupied by the texel is denoted by dw.
839	///
840	/// Instead of evaluating the reflectivity integral with only one sample belongig to the texel center
841	/// (that would give us a result of cos_theta x dw), we use 2 #M x 2 #M x #M regulary spaced samples, and
842	/// discard those that lie outside the unit hemisphere. The remaining samples are regulary distributed over the
843	/// hemisphere.
844	///
845	/// For each sample, we check if it lies inside the cone of the specified solid angle.
846	/// If yes, its contribution is considered.
847
848	float EnvMap::eval( float cos_theta, float dw )
849	{
850	const float PI = 3.14159f;
851
852	float sum = 0;
853	int counter = 0;
854	int shininess = pp.GetInt( iShininess );
855
856	float sin_theta = sqrt(1-cos_theta*cos_theta);
857
858	D3DXVECTOR3 center( sin_theta, 0, cos_theta );
859	D3DXVECTOR3 up( 0, 0, 1 );
860
861	float cos_min = 1 - dw / 2 / PI;
862
863	for (int x = -M; x <= M; x++)
864	for (int y = -M; y <= M; y++)
865	for (int z = /-M/ 0; z <= M; z++) // z == up
866	{
867	D3DXVECTOR3 w(0,0,0);
868	w.x = x / (float)M; // -1..1
869	w.y = y / (float)M; // -1..1
870	w.z = z / (float)M; // 0..1
871
872	float len = D3DXVec3Length( &w );
873	if ( len > 0 && len <= 1 ) // inside the hemisphere
874	{
875	w /= len; // normalize
876
877	float cos_curr = D3DXVec3Dot( &w, &center );
878	if ( cos_curr >= cos_min ) // w is inside the 'cone' of the given solid angle
879	{
880	sum += pow( D3DXVec3Dot( &w, &up ), shininess );
881	//sum += D3DXVec3Dot( &w, &up );
882	}
883
884	counter++; // number of samples
885	}
886	}
887
888	return sum * (2PI / counter) ((shininess+2) / PI);
889	//return dx;
890	}

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

Download in other formats: