Context Navigation

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

Revision 1488, 29.1 KB checked in by szirmay, 18 years ago (diff)

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

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

Download in other formats: