Context Navigation

source: GTP/trunk/App/Demos/Illum/Glow/Main.cpp @ 846

Revision 846, 36.2 KB checked in by szirmay, 19 years ago (diff)

Rev	Line
[846]	1	//--------------------------------------------------------------------------------------
	2	// Main.cpp:
	3	// - DirectX initialization
	4	// - create resources (textures)
	5	//--------------------------------------------------------------------------------------
	6
	7	#include "dxstdafx.h"
	8	#include "resource.h"
	9	#include <math.h>
	10	#include <stdio.h>
	11	#include <D3dx9math.h>
	12
	13	//#define DEBUG_VS // Uncomment this line to debug vertex shaders
	14	//#define DEBUG_PS // Uncomment this line to debug pixel shaders
	15
	16	#include "Parameters.h"
	17	#include "ToneMap.h"
	18
	19	const int WIDTH = 720;
	20	const int HEIGHT = 480;
	21	const int CHARBUFFER_SIZE = 200;
	22
	23	//--------------------------------------------------------------------------------------
	24	// Global variables
	25	//--------------------------------------------------------------------------------------
	26
	27	IDirect3DDevice9* g_pd3dDevice = NULL;
	28
	29	CDXUTDialogResourceManager g_DialogResourceManager; // manager for shared resources of dialogs
	30	CD3DSettingsDlg g_SettingsDlg; // Device settings dialog
	31	CDXUTDialog g_HUD; // Dialog for sample specific controls
	32
	33	ID3DXFont* g_pFont = NULL; // Font for drawing text
	34	ID3DXSprite* g_pTextSprite = NULL; // Sprite for batching draw text calls
	35
	36	IDirect3DSurface9* g_pSaveSurface; // screenshot capturing support
	37	bool bSavingScreenshot = false;
	38	int counter = 0;
	39	// Dice mesh
	40	LPD3DXMESH g_pMesh = NULL; // Our mesh object in sysmem
	41	D3DMATERIAL9* g_pMeshMaterials = NULL; // Materials for our mesh
	42	LPDIRECT3DTEXTURE9* g_pMeshTextures = NULL; // Textures for our mesh
	43	DWORD g_dwNumMaterials = 0L; // Number of mesh materials
	44	LPD3DXBUFFER pD3DXMtrlBuffer;
	45
	46
	47	HRESULT hr;
	48
	49	Parameters pp; // managing parameters of the algorithm
	50	CModelViewerCamera camera; // camera
	51
	52	// ToneMapping object
	53	ToneMap *toneMap = new ToneMap();
	54	//Save texture
	55	IDirect3DTexture9* pSaveTexture = NULL;
	56
	57	// Final sourface
	58	LPDIRECT3DTEXTURE9 sourceTexture;
	59	LPDIRECT3DSURFACE9 sourceTextureSurface;
	60	LPDIRECT3DSURFACE9 targetSurface;
	61
	62	// Original cube
	63	LPDIRECT3DTEXTURE9 CubeTexture;
	64	LPDIRECT3DSURFACE9 CubeTextureSurface;
	65
	66	// Glow surface
	67	LPDIRECT3DTEXTURE9 CubeGlowTexture;
	68	LPDIRECT3DSURFACE9 CubeGlowTextureSurface;
	69
	70	// Temporary sourfaces for the glow calculation
	71	LPDIRECT3DTEXTURE9 TempTexture[3];
	72	LPDIRECT3DSURFACE9 TempTextureSurface[3];
	73
	74	// Glow history surface
	75	LPDIRECT3DTEXTURE9 blurTexture;
	76	LPDIRECT3DTEXTURE9 prevTexture;
	77	LPDIRECT3DSURFACE9 blurTargetSurface;
	78	LPDIRECT3DTEXTURE9 blurTargetTexture;
	79
	80	// Fullscreen triangle
	81	D3DVERTEX_1 rttVertices[3];
	82	LPDIRECT3DSURFACE9 rttDepthSurface;
	83	IDirect3DVertexDeclaration9* textureDecl;
	84	LPDIRECT3DVERTEXBUFFER9 pQuadVB;
	85
	86	IDirect3DSurface9* oldRenderTarget = NULL;
	87
	88	// Lighting
	89	D3DXVECTOR3 vecDir;
	90	D3DLIGHT9 light;
	91
	92
	93	// Rendering effects
	94	LPD3DXEFFECT CubeEffect;
	95
	96	//--------------------------------------------------------------------------------------
	97	// Forward declarations (CALLBACK)
	98	//--------------------------------------------------------------------------------------
	99	bool CALLBACK IsDeviceAcceptable( D3DCAPS9* pCaps, D3DFORMAT AdapterFormat, D3DFORMAT BackBufferFormat, bool bWindowed, void* pUserContext );
	100	bool CALLBACK ModifyDeviceSettings( DXUTDeviceSettings* pDeviceSettings, const D3DCAPS9* pCaps, void* pUserContext );
	101	HRESULT CALLBACK OnCreateDevice( IDirect3DDevice9* g_pd3dDevice, const D3DSURFACE_DESC* pBackBufferSurfaceDesc, void* pUserContext );
	102	HRESULT CALLBACK OnResetDevice( IDirect3DDevice9* g_pd3dDevice, const D3DSURFACE_DESC* pBackBufferSurfaceDesc, void* pUserContext );
	103	void CALLBACK OnFrameMove( IDirect3DDevice9* g_pd3dDevice, double fTime, float fElapsedTime, void* pUserContext );
	104	void CALLBACK OnFrameRender( IDirect3DDevice9* g_pd3dDevice, double fTime, float fElapsedTime, void* pUserContext );
	105	LRESULT CALLBACK MsgProc( HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam, bool* pbNoFurtherProcessing, void* pUserContext );
	106	void CALLBACK KeyboardProc( UINT nChar, bool bKeyDown, bool bAltDown, void* pUserContext );
	107	void CALLBACK OnGUIEvent( UINT nEvent, int nControlID, CDXUTControl* pControl, void* pUserContext );
	108	void CALLBACK OnLostDevice( void* pUserContext );
	109	void CALLBACK OnDestroyDevice( void* pUserContext );
	110	void InitApp();
	111	void RenderText();
	112
	113	//--------------------------------------------------------------------------------------
	114	// Forward declarations
	115	//--------------------------------------------------------------------------------------
	116
	117	void SaveCameraPosition( char* fileName );
	118	void LoadCameraPosition( char* fileName );
	119	int GenerateNewFileName( int& counter );
	120
	121	//-----------------------------------------------------------------------------
	122	// Name: InitGeometry()
	123	// Desc: Load the mesh and build the material and texture arrays
	124	//-----------------------------------------------------------------------------
	125	HRESULT InitGeometry()
	126	{
	127	// Load the mesh from the specified file
	128	if( FAILED( D3DXLoadMeshFromX( L"dobokocka.x", D3DXMESH_MANAGED,
	129	g_pd3dDevice, NULL,
	130	&pD3DXMtrlBuffer, NULL, &g_dwNumMaterials,
	131	&g_pMesh ) ) )
	132	{
	133	// If model is not in current folder, try parent folder
	134	if( FAILED( D3DXLoadMeshFromX( L"..\\dobokocka.x", D3DXMESH_MANAGED,
	135	g_pd3dDevice, NULL,
	136	&pD3DXMtrlBuffer, NULL, &g_dwNumMaterials,
	137	&g_pMesh ) ) )
	138	{
	139	MessageBox(NULL, L"Could not find dobokocka.x", L"Meshes.exe", MB_OK);
	140	return E_FAIL;
	141	}
	142	}
	143
	144
	145	// We need to extract the material properties and texture names from the
	146	// pD3DXMtrlBuffer
	147	D3DXMATERIAL* d3dxMaterials = (D3DXMATERIAL*)pD3DXMtrlBuffer->GetBufferPointer();
	148	g_pMeshMaterials = new D3DMATERIAL9[g_dwNumMaterials];
	149	if( g_pMeshMaterials == NULL )
	150	return E_OUTOFMEMORY;
	151	g_pMeshTextures = new LPDIRECT3DTEXTURE9[g_dwNumMaterials];
	152	if( g_pMeshTextures == NULL )
	153	return E_OUTOFMEMORY;
	154
	155	for( DWORD i=0; i<g_dwNumMaterials; i++ )
	156	{
	157	// Copy the material
	158	g_pMeshMaterials[i] = d3dxMaterials[i].MatD3D;
	159
	160	// Set the ambient color for the material (D3DX does not do this)
	161	g_pMeshMaterials[i].Ambient = g_pMeshMaterials[i].Diffuse;
	162
	163	g_pMeshTextures[i] = NULL;
	164	if( d3dxMaterials[i].pTextureFilename != NULL &&
	165	lstrlenA(d3dxMaterials[i].pTextureFilename) > 0 )
	166	{
	167	// Create the texture
	168	if( FAILED( D3DXCreateTextureFromFileA( g_pd3dDevice,
	169	d3dxMaterials[i].pTextureFilename,
	170	&g_pMeshTextures[i] ) ) )
	171	{
	172	// If texture is not in current folder, try parent folder
	173	const TCHAR* strPrefix = TEXT("..\\");
	174	TCHAR strTexture[MAX_PATH];
	175	StringCchCopy( strTexture, MAX_PATH, strPrefix );
	176	StringCchCatA( (char*)strTexture, MAX_PATH, d3dxMaterials[i].pTextureFilename );
	177	// If texture is not in current folder, try parent folder
	178	if( FAILED( D3DXCreateTextureFromFile( g_pd3dDevice,
	179	strTexture,
	180	&g_pMeshTextures[i] ) ) )
	181	{
	182	MessageBox(NULL, L"Could not find texture map", L"Meshes.exe", MB_OK);
	183	}
	184	}
	185	}
	186	}
	187
	188	// Done with the material buffer
	189	//pD3DXMtrlBuffer->Release();
	190
	191	return S_OK;
	192	}
	193
	194	//--------------------------------------------------------------------------------------
	195	// Entry point to the program. Initializes everything and goes into a message processing
	196	// loop. Idle time is used to render the scene.
	197	//--------------------------------------------------------------------------------------
	198	INT WINAPI WinMain( HINSTANCE, HINSTANCE, LPSTR, int )
	199	{
	200	// Enable run-time memory check for debug builds.
	201	#if defined(DEBUG) \| defined(_DEBUG)
	202	_CrtSetDbgFlag( _CRTDBG_ALLOC_MEM_DF \| _CRTDBG_LEAK_CHECK_DF );
	203	#endif
	204
	205	DXUTSetCallbackDeviceCreated( OnCreateDevice );
	206	DXUTSetCallbackDeviceReset( OnResetDevice );
	207	DXUTSetCallbackDeviceLost( OnLostDevice );
	208	DXUTSetCallbackDeviceDestroyed( OnDestroyDevice );
	209	DXUTSetCallbackMsgProc( MsgProc );
	210	DXUTSetCallbackKeyboard( KeyboardProc );
	211	DXUTSetCallbackFrameRender( OnFrameRender );
	212	DXUTSetCallbackFrameMove( OnFrameMove );
	213
	214	InitApp();
	215
	216	// Show the cursor and clip it when in full screen
	217	DXUTSetCursorSettings( true, true );
	218
	219	DXUTInit( true, true, true ); // Parse the command line, handle the default hotkeys, and show msgboxes
	220	DXUTCreateWindow( L"Glowing Dice Demo" );
	221	DXUTCreateDevice( D3DADAPTER_DEFAULT, true, WIDTH, HEIGHT, IsDeviceAcceptable, ModifyDeviceSettings );
	222
	223	camera.SetButtonMasks( 0, MOUSE_WHEEL, MOUSE_LEFT_BUTTON );
	224
	225	DXUTMainLoop();
	226	return DXUTGetExitCode();
	227	}
	228
	229	void CALLBACK OnGUIEvent( UINT nEvent, int nControlID, CDXUTControl* pControl, void* pUserContext )
	230	{
	231	pp.UpdateFromHUD( nControlID );
	232	}
	233
	234	void OnLoad() {
	235	LoadCameraPosition( ".matrix" );
	236	}
	237
	238	void OnSave() {
	239	SaveCameraPosition( ".matrix" );
	240	bSavingScreenshot = true;
	241	}
	242
	243	void OnReset() {}
	244
	245	void InitApp()
	246	{
	247	g_SettingsDlg.Init( &g_DialogResourceManager );
	248	g_HUD.Init( &g_DialogResourceManager );
	249	g_HUD.SetCallback( OnGUIEvent ); // Event handling
	250
	251	pp.Setup( &g_HUD, OnReset, OnSave, OnLoad); // you can add callbacks to these actions
	252
	253	// UI initialization
	254	pp.Add( bShowHelp, "bShowHelp", VK_F1 ); // checkboxes
	255	pp.Add( bShowHud, "Hud", VK_F2 );
	256
	257	pp.Add( iGain, "Gain", 800, VK_SUBTRACT, VK_ADD, myconvert ); // sliders
	258	pp.SetFloat(iGain, 0.5f);
	259	pp.Add( iPasses, "Passes", 400, VK_SUBTRACT, VK_ADD, myPassConvert );
	260	pp.Add( iGlowPasses, "GlowPasses", 400, VK_SUBTRACT, VK_ADD, myGlowConvert );
	261	pp.Add( iGlowGain, "GlowGain", 800, VK_SUBTRACT, VK_ADD, noconvert );
	262	pp.Add( iStretch, "GlowStretch", 1000, VK_SUBTRACT, VK_ADD, stretchconvert );
	263
	264	pp.UpdateFromHUD( IDC_RESET_BUTTON ); // do a reset
	265	}
	266
	267	//--------------------------------------------------------------------------------------
	268	// Rejects any devices that aren't acceptable by returning false
	269	//--------------------------------------------------------------------------------------
	270	bool CALLBACK IsDeviceAcceptable( D3DCAPS9* pCaps, D3DFORMAT AdapterFormat,
	271	D3DFORMAT BackBufferFormat, bool bWindowed, void* pUserContext )
	272	{
	273	// Skip backbuffer formats that don't support alpha blending
	274	IDirect3D9* pD3D = DXUTGetD3DObject();
	275	if( FAILED( pD3D->CheckDeviceFormat( pCaps->AdapterOrdinal, pCaps->DeviceType,
	276	AdapterFormat, D3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING,
	277	D3DRTYPE_TEXTURE, BackBufferFormat ) ) )
	278	return false;
	279
	280	return true;
	281	}
	282
	283	//--------------------------------------------------------------------------------------
	284	// Before a device is created, modify the device settings as needed
	285	//--------------------------------------------------------------------------------------
	286	bool CALLBACK ModifyDeviceSettings( DXUTDeviceSettings* pDeviceSettings, const D3DCAPS9* pCaps, void* pUserContext )
	287	{
	288	// VSync off
	289	pDeviceSettings->pp.PresentationInterval = D3DPRESENT_INTERVAL_IMMEDIATE;
	290
	291	// If device doesn't support HW T&L or doesn't support 1.1 vertex shaders in HW
	292	// then switch to SWVP.
	293	if( (pCaps->DevCaps & D3DDEVCAPS_HWTRANSFORMANDLIGHT) == 0 \|\|
	294	pCaps->VertexShaderVersion < D3DVS_VERSION(1,1) )
	295	pDeviceSettings->BehaviorFlags = D3DCREATE_SOFTWARE_VERTEXPROCESSING;
	296	else
	297	pDeviceSettings->BehaviorFlags = D3DCREATE_HARDWARE_VERTEXPROCESSING;
	298
	299	// This application is designed to work on a pure device by not using
	300	// IDirect3D9::Get*() methods, so create a pure device if supported and using HWVP.
	301	if ((pCaps->DevCaps & D3DDEVCAPS_PUREDEVICE) != 0 &&
	302	(pDeviceSettings->BehaviorFlags & D3DCREATE_HARDWARE_VERTEXPROCESSING) != 0 )
	303	pDeviceSettings->BehaviorFlags \|= D3DCREATE_PUREDEVICE;
	304
	305	// Debugging vertex shaders requires either REF or software vertex processing
	306	// and debugging pixel shaders requires REF.
	307	#ifdef DEBUG_VS
	308	if( pDeviceSettings->DeviceType != D3DDEVTYPE_REF )
	309	{
	310	pDeviceSettings->BehaviorFlags &= ~D3DCREATE_HARDWARE_VERTEXPROCESSING;
	311	pDeviceSettings->BehaviorFlags &= ~D3DCREATE_PUREDEVICE;
	312	pDeviceSettings->BehaviorFlags \|= D3DCREATE_SOFTWARE_VERTEXPROCESSING;
	313	}
	314	#endif
	315	#ifdef DEBUG_PS
	316	pDeviceSettings->DeviceType = D3DDEVTYPE_REF;
	317	#endif
	318
	319	// For the first device created if its a REF device, optionally display a warning dialog box
	320	static bool s_bFirstTime = true;
	321	if( s_bFirstTime )
	322	{
	323	s_bFirstTime = false;
	324	if( pDeviceSettings->DeviceType == D3DDEVTYPE_REF )
	325	DXUTDisplaySwitchingToREFWarning();
	326	}
	327	return true;
	328	}
	329
	330	//--------------------------------------------------------------------------------------
	331	// Create any D3DPOOL_MANAGED resources here
	332	//--------------------------------------------------------------------------------------
	333	HRESULT CALLBACK OnCreateDevice( IDirect3DDevice9* pd3dDevice, const D3DSURFACE_DESC* pBackBufferSurfaceDesc, void* pUserContext )
	334	{
	335	::g_pd3dDevice = pd3dDevice;
	336
	337	//InitGeometry();
	338
	339	HRESULT hr;
	340
	341	V_RETURN( g_DialogResourceManager.OnCreateDevice( g_pd3dDevice ) );
	342	V_RETURN( g_SettingsDlg.OnCreateDevice( g_pd3dDevice ) );
	343
	344	// Initialize the font
	345	V_RETURN( D3DXCreateFont( g_pd3dDevice, 15, 0, FW_BOLD, 1, FALSE, DEFAULT_CHARSET,
	346	OUT_DEFAULT_PRECIS, DEFAULT_QUALITY, DEFAULT_PITCH \| FF_DONTCARE,
	347	L"Arial", &g_pFont ) );
	348
	349	float initialEyeDist = 10;
	350	D3DXVECTOR3 vecEye(0, 0, -initialEyeDist);
	351	D3DXVECTOR3 vecAt (0.0f, 0.0f, -0.0f);
	352	camera.SetViewParams( &vecEye, &vecAt );
	353
	354	// Error Buffer
	355	LPD3DXBUFFER errBuff;
	356	DWORD effectCompileFlag = 0;
	357
	358	// Shader options for debuging
	359	#ifdef DEBUG_SHADER
	360	effectCompileFlag\|=D3DXSHADER_DEBUG;
	361	effectCompileFlag \|= D3DXSHADER_FORCE_PS_SOFTWARE_NOOPT;
	362	effectCompileFlag \|= D3DXSHADER_FORCE_VS_SOFTWARE_NOOPT;
	363	#endif
	364
	365	// Create the tone mapping effect from file
	366	hr = D3DXCreateEffectFromFile(g_pd3dDevice,L"Cube.fx",NULL,NULL,effectCompileFlag,NULL,&CubeEffect,&errBuff);
	367	if(hr!=S_OK){
	368	int BufSize = errBuff->GetBufferSize();
	369
	370	// displaying error message of arbitrary length
	371	wchar_t* wbuf = new wchar_t[BufSize];
	372	mbstowcs( wbuf, (const char*)errBuff->GetBufferPointer(), BufSize );
	373	MessageBox(NULL, wbuf, L".fx Compilation Error", MB_ICONERROR); // show error message
	374
	375	delete wbuf;
	376	return hr;
	377	}
	378	SAFE_RELEASE(errBuff);
	379
	380	rttVertices[0] = D3DVERTEX_1(-3,1,0,1, -1.0f, 0.0f);
	381	rttVertices[1] = D3DVERTEX_1(1,1,0,1, 1.0f, 0.0f);
	382	rttVertices[2] = D3DVERTEX_1(1, -3,0,1, 1.0f, 2.0f);
	383
	384	//Vertex declaration
	385	D3DVERTEXELEMENT9 _texturedecl[]=
	386	{
	387	{0,0,D3DDECLTYPE_FLOAT4, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION,0 },
	388	{0,16,D3DDECLTYPE_FLOAT2, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD,0 },
	389	D3DDECL_END()
	390	};
	391	V(pd3dDevice->CreateVertexDeclaration(_texturedecl,&textureDecl));
	392	V(pd3dDevice->CreateVertexBuffer(sizeof(D3DVERTEX_1)*3,D3DUSAGE_WRITEONLY,D3DFVF_CUSTOMVERTEX,D3DPOOL_MANAGED,&pQuadVB,NULL));
	393	void *pData;
	394
	395	pQuadVB->Lock(0,sizeof(pData),(void**)&pData,0);
	396	memcpy(pData,rttVertices,sizeof(D3DVERTEX_1)*3);
	397	pQuadVB->Unlock();
	398
	399	// fixed function lighting
	400	ZeroMemory( &light, sizeof(light) );
	401	light.Type = D3DLIGHT_DIRECTIONAL;
	402	light.Diffuse.r = 0.0f;
	403	light.Diffuse.g = 0.0f;
	404	light.Diffuse.b = 1.0f;
	405
	406	return S_OK;
	407	}
	408
	409	//--------------------------------------------------------------------------------------
	410	// Release resources created in the OnCreateDevice callback here
	411	//--------------------------------------------------------------------------------------
	412	void CALLBACK OnDestroyDevice( void* pUserContext )
	413	{
	414	g_DialogResourceManager.OnDestroyDevice();
	415	g_SettingsDlg.OnDestroyDevice();
	416	SAFE_RELEASE(g_pFont);
	417
	418	SAFE_RELEASE(CubeEffect);
	419
	420	SAFE_RELEASE(textureDecl);
	421	SAFE_RELEASE(pQuadVB);
	422	}
	423
	424
	425	//--------------------------------------------------------------------------------------
	426	// Create any D3DPOOL_DEFAULT resources here
	427	//--------------------------------------------------------------------------------------
	428	HRESULT CALLBACK OnResetDevice( IDirect3DDevice9* g_pd3dDevice, const D3DSURFACE_DESC* pBackBufferSurfaceDesc, void* pUserContext )
	429	{
	430	HRESULT hr;
	431
	432	InitGeometry();
	433
	434	V_RETURN( g_DialogResourceManager.OnResetDevice() );
	435	V_RETURN( g_SettingsDlg.OnResetDevice() );
	436
	437	if( g_pFont ) V_RETURN( g_pFont->OnResetDevice() );
	438
	439	// Create a sprite to help batch calls when drawing many lines of text
	440	V_RETURN( D3DXCreateSprite( g_pd3dDevice, &g_pTextSprite ) );
	441
	442	// Setup the camera's projection parameters
	443	float fAspectRatio = pBackBufferSurfaceDesc->Width / (FLOAT)pBackBufferSurfaceDesc->Height;
	444
	445	camera.SetProjParams( D3DX_PI/4, fAspectRatio, 0.1, 100 );
	446	camera.SetWindow( pBackBufferSurfaceDesc->Width, pBackBufferSurfaceDesc->Height );
	447
	448	// target description
	449	D3DSURFACE_DESC desc = *pBackBufferSurfaceDesc;
	450	//targetSurface->GetDesc(&desc);
	451
	452	// final image
	453	g_pd3dDevice->CreateTexture(desc.Width,desc.Height,0,D3DUSAGE_RENDERTARGET,D3DFMT_A16B16G16R16F,D3DPOOL_DEFAULT,&sourceTexture,NULL);
	454	sourceTexture->GetSurfaceLevel(0,&sourceTextureSurface);
	455
	456	// dice
	457	g_pd3dDevice->CreateTexture(desc.Width,desc.Height,0,D3DUSAGE_RENDERTARGET,D3DFMT_A16B16G16R16F,D3DPOOL_DEFAULT,&CubeTexture,NULL);
	458	CubeTexture->GetSurfaceLevel(0,&CubeTextureSurface);
	459
	460	// glow
	461	g_pd3dDevice->CreateTexture(desc.Width / 4,desc.Height / 4,0,D3DUSAGE_RENDERTARGET,D3DFMT_A16B16G16R16F,D3DPOOL_DEFAULT,&CubeGlowTexture,NULL);
	462	CubeGlowTexture->GetSurfaceLevel(0,&CubeGlowTextureSurface);
	463
	464	// temporary
	465	g_pd3dDevice->CreateTexture(desc.Width / 4,desc.Height / 4,0,D3DUSAGE_RENDERTARGET,D3DFMT_A16B16G16R16F,D3DPOOL_DEFAULT,&TempTexture[0],NULL);
	466	TempTexture[0]->GetSurfaceLevel(0,&TempTextureSurface[0]);
	467	g_pd3dDevice->CreateTexture(desc.Width / 4,desc.Height / 4,0,D3DUSAGE_RENDERTARGET,D3DFMT_A16B16G16R16F,D3DPOOL_DEFAULT,&TempTexture[1],NULL);
	468	TempTexture[1]->GetSurfaceLevel(0,&TempTextureSurface[1]);
	469	g_pd3dDevice->CreateTexture(desc.Width / 4,desc.Height / 4,0,D3DUSAGE_RENDERTARGET,D3DFMT_A16B16G16R16F,D3DPOOL_DEFAULT,&TempTexture[2],NULL);
	470	TempTexture[2]->GetSurfaceLevel(0,&TempTextureSurface[2]);
	471
	472	// clear glow history
	473
	474	V( g_pd3dDevice->GetRenderTarget(0, &oldRenderTarget) );
	475	g_pd3dDevice->SetRenderTarget(0, TempTextureSurface[2]);
	476	g_pd3dDevice->Clear( 0, NULL, D3DCLEAR_TARGET\|D3DCLEAR_ZBUFFER,
	477	D3DCOLOR_XRGB(0,0,0), 1.0f, 0 );
	478	g_pd3dDevice->SetRenderTarget(0, oldRenderTarget);
	479
	480
	481	V(g_pd3dDevice->CreateDepthStencilSurface(desc.Width,desc.Height,D3DFMT_D16,D3DMULTISAMPLE_NONE ,0,true,&rttDepthSurface,NULL));
	482
	483	CubeEffect->OnResetDevice();
	484
	485	// init tonemap
	486	toneMap->Init(g_pd3dDevice, sourceTexture, oldRenderTarget);
	487
	488
	489	return S_OK;
	490	}
	491
	492	//--------------------------------------------------------------------------------------
	493	// Release resources created in the OnResetDevice callback here
	494	//--------------------------------------------------------------------------------------
	495	void CALLBACK OnLostDevice( void* pUserContext )
	496	{
	497	g_DialogResourceManager.OnLostDevice();
	498	g_SettingsDlg.OnLostDevice();
	499
	500	if( g_pFont ) g_pFont->OnLostDevice();
	501	SAFE_RELEASE(g_pTextSprite);
	502
	503	if( g_pMesh != NULL )
	504	SAFE_RELEASE(g_pMesh);
	505
	506	pD3DXMtrlBuffer->Release();
	507
	508	if( g_pMeshTextures )
	509	{
	510	for( DWORD i = 0; i < g_dwNumMaterials; i++ )
	511	{
	512	if( g_pMeshTextures[i] )
	513	{
	514	SAFE_RELEASE(g_pMeshTextures[i]);
	515	}
	516	}
	517	}
	518	g_pMeshTextures = 0;
	519
	520	SAFE_RELEASE(sourceTextureSurface);
	521	SAFE_RELEASE(sourceTexture);
	522
	523	SAFE_RELEASE(CubeTexture);
	524	SAFE_RELEASE(CubeTextureSurface)
	525
	526	SAFE_RELEASE(CubeGlowTexture);
	527	SAFE_RELEASE(CubeGlowTextureSurface);
	528
	529	SAFE_RELEASE(TempTexture[0]);
	530	SAFE_RELEASE(TempTextureSurface[0]);
	531	SAFE_RELEASE(TempTexture[1]);
	532	SAFE_RELEASE(TempTextureSurface[1]);
	533	SAFE_RELEASE(TempTexture[2]);
	534	SAFE_RELEASE(TempTextureSurface[2]);
	535
	536	SAFE_RELEASE(rttDepthSurface);
	537
	538	SAFE_RELEASE(oldRenderTarget);
	539
	540	toneMap->Destroy();
	541	CubeEffect->OnLostDevice();
	542	}
	543
	544	LRESULT CALLBACK MsgProc( HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam, bool* pbNoFurtherProcessing, void* pUserContext )
	545	{
	546	// Always allow dialog resource manager calls to handle global messages
	547	// so GUI state is updated correctly
	548	*pbNoFurtherProcessing = g_DialogResourceManager.MsgProc( hWnd, uMsg, wParam, lParam );
	549	if( *pbNoFurtherProcessing )
	550	return 0;
	551
	552	if( g_SettingsDlg.IsActive() )
	553	{
	554	g_SettingsDlg.MsgProc( hWnd, uMsg, wParam, lParam );
	555	return 0;
	556	}
	557
	558	// Give the dialogs a chance to handle the message first
	559	*pbNoFurtherProcessing = g_HUD.MsgProc( hWnd, uMsg, wParam, lParam );
	560	if( *pbNoFurtherProcessing )
	561	return 0;
	562
	563	// Pass all remaining windows messages to camera so it can respond to user input
	564	camera.HandleMessages( hWnd, uMsg, wParam, lParam );
	565
	566	return 0;
	567	}
	568
	569	//--------------------------------------------------------------------------------------
	570	// Handle updates to the scene
	571	//--------------------------------------------------------------------------------------
	572	void CALLBACK OnFrameMove( IDirect3DDevice9* g_pd3dDevice, double fTime, float fElapsedTime, void* pUserContext )
	573	{
	574	camera.FrameMove( fElapsedTime );
	575	}
	576
	577	//--------------------------------------------------------------------------------------
	578	// Render the scene
	579	//--------------------------------------------------------------------------------------
	580	void CALLBACK OnFrameRender( IDirect3DDevice9* g_pd3dDevice, double fTime, float fElapsedTime, void* pUserContext )
	581	{
	582	// If the settings dialog is being shown, then
	583	// render it instead of rendering the app's scene
	584	if( g_SettingsDlg.IsActive() )
	585	{
	586	g_SettingsDlg.OnRender( fElapsedTime );
	587	return;
	588	}
	589
	590	// ligth rotating
	591	vecDir = D3DXVECTOR3(cosf(timeGetTime()/360.0f),
	592	0.0f,
	593	sinf(timeGetTime()/360.0f) );
	594	D3DXVec3Normalize( (D3DXVECTOR3*)&light.Direction, &vecDir );
	595	light.Range = 1000.0f;
	596	g_pd3dDevice->SetLight( 0, &light );
	597	g_pd3dDevice->LightEnable( 0, TRUE);
	598	g_pd3dDevice->SetRenderState( D3DRS_LIGHTING, TRUE );
	599	g_pd3dDevice->SetRenderState( D3DRS_AMBIENT, 0x00202020 );
	600
	601	// screen shot
	602	// IDirect3DSurface9* oldRenderTarget = NULL;
	603	if (bSavingScreenshot) {
	604	// V( g_pd3dDevice->GetRenderTarget(0, &oldRenderTarget) );
	605	V( g_pd3dDevice->SetRenderTarget(0, g_pSaveSurface) );
	606	}
	607
	608	// ModelViewProjection matrix
	609	D3DXMATRIXA16 mView = *camera.GetViewMatrix();
	610	D3DXMATRIXA16 mProj = *camera.GetProjMatrix();
	611	D3DXMATRIXA16 mMVP = mView * mProj;
	612
	613	// Original image
	614	g_pd3dDevice->SetRenderTarget(0, CubeTextureSurface);
	615	V( g_pd3dDevice->SetDepthStencilSurface(rttDepthSurface) );
	616
	617	// Clear the backbuffer and the zbuffer
	618	g_pd3dDevice->Clear( 0, NULL, D3DCLEAR_TARGET\|D3DCLEAR_ZBUFFER,
	619	D3DCOLOR_XRGB(0,0,0), 1.0f, 0 );
	620
	621	if( SUCCEEDED( g_pd3dDevice->BeginScene() ) )
	622	{
	623	UINT numberofPasses=0;
	624	D3DXHANDLE techniqueHandle = CubeEffect->GetTechniqueByName("Cube");
	625	V(CubeEffect->SetTechnique(techniqueHandle));
	626
	627	V(CubeEffect->SetMatrix("modelViewProjection", &mMVP));
	628	V(CubeEffect->Begin(&numberofPasses,0));
	629	for(UINT i = 0; i<numberofPasses; i++ )
	630	{
	631	V(CubeEffect->BeginPass(i));
	632
	633	// Meshes are divided into subsets, one for each material. Render them in
	634	// a loop
	635	for( DWORD i=0; i<g_dwNumMaterials; i++ )
	636	{
	637	// Set the material and texture for this subset
	638	g_pd3dDevice->SetMaterial( &g_pMeshMaterials[i] );
	639	//g_pd3dDevice->SetTexture( 0, g_pMeshTextures[i] );
	640	V(CubeEffect->SetTexture("SourceTexture", g_pMeshTextures[i]));
	641	CubeEffect->CommitChanges();
	642
	643	// Draw the mesh subset
	644	g_pMesh->DrawSubset( i );
	645	}
	646
	647	V(CubeEffect->EndPass());
	648	}
	649	V(CubeEffect->End());
	650	g_pd3dDevice->EndScene();
	651	}
	652
	653	// Glow texture
	654	g_pd3dDevice->SetRenderTarget(0, CubeGlowTextureSurface);
	655	V( g_pd3dDevice->SetDepthStencilSurface(rttDepthSurface) );
	656	g_pd3dDevice->Clear( 0, NULL, D3DCLEAR_TARGET\|D3DCLEAR_ZBUFFER,
	657	D3DCOLOR_XRGB(0,0,0), 1.0f, 0 );
	658	if( SUCCEEDED( g_pd3dDevice->BeginScene() ) )
	659	{
	660	UINT numberofPasses=0;
	661	D3DXHANDLE techniqueHandle = CubeEffect->GetTechniqueByName("CubeGlow");
	662	V(CubeEffect->SetTechnique(techniqueHandle));
	663
	664	V(CubeEffect->SetMatrix("modelViewProjection", &mMVP));
	665	V(CubeEffect->Begin(&numberofPasses,0));
	666	for(UINT i = 0; i<numberofPasses; i++ )
	667	{
	668	V(CubeEffect->BeginPass(i));
	669
	670	// Meshes are divided into subsets, one for each material. Render them in
	671	// a loop
	672	for( DWORD i=0; i<g_dwNumMaterials; i++ )
	673	{
	674	// Set the material and texture for this subset
	675	g_pd3dDevice->SetMaterial( &g_pMeshMaterials[i] );
	676	//g_pd3dDevice->SetTexture( 0, g_pMeshTextures[i] );
	677	V(CubeEffect->SetTexture("SourceTexture", g_pMeshTextures[i]));
	678	CubeEffect->CommitChanges();
	679
	680	// Draw the mesh subset
	681	g_pMesh->DrawSubset( i );
	682	}
	683
	684	V(CubeEffect->EndPass());
	685	}
	686	V(CubeEffect->End());
	687	g_pd3dDevice->EndScene();
	688	}
	689
	690	// Blurring
	691	// For each passes we cycle the temporary textures
	692	// At least two passes need, one for the horizontal and one for
	693	// the vertical blur
	694	int blurPass = 2;
	695	char* blurName = "Blur_h";
	696
	697	for (int i = 0; i< pp.Get(iGlowPasses); i++) {
	698	switch (blurPass) {
	699	case(0) : blurTargetSurface = TempTextureSurface[1];
	700	blurTargetTexture = TempTexture[1];
	701	blurTexture = TempTexture[0];
	702	blurPass = 1;
	703	blurName="Blur_h";
	704	break;
	705	case(1) : blurTargetSurface = TempTextureSurface[0];
	706	blurTargetTexture = TempTexture[0];
	707	blurTexture = TempTexture[1];
	708	blurPass = 0;
	709	blurName="Blur_v";
	710	break;
	711
	712	case(2) : blurTargetSurface = TempTextureSurface[0];
	713	blurTargetTexture = TempTexture[0];
	714	blurTexture = CubeGlowTexture;
	715	blurPass = 0;
	716	blurName="Blur_v";
	717	break;
	718	}
	719
	720
	721	D3DSURFACE_DESC desc;
	722	blurTargetSurface->GetDesc(&desc);
	723
	724	g_pd3dDevice->SetRenderTarget(0, blurTargetSurface);
	725	V( g_pd3dDevice->SetDepthStencilSurface(rttDepthSurface) );
	726	V( g_pd3dDevice->SetVertexDeclaration(textureDecl) );
	727	g_pd3dDevice->Clear( 0, NULL, D3DCLEAR_TARGET\|D3DCLEAR_ZBUFFER,
	728	D3DCOLOR_XRGB(0,0,0), 1.0f, 0 );
	729	if( SUCCEEDED( g_pd3dDevice->BeginScene() ) )
	730	{
	731	UINT numberofPasses=0;
	732	D3DXHANDLE techniqueHandle = CubeEffect->GetTechniqueByName(blurName);
	733	V(CubeEffect->SetTechnique(techniqueHandle));
	734
	735	D3DXMatrixIdentity(&mMVP);
	736	V(CubeEffect->SetMatrix("modelViewProjection", &mMVP));
	737	V(CubeEffect->SetTexture("OldGlow", TempTexture[2]));
	738	V(CubeEffect->SetTexture("Glow", blurTexture));
	739	V(CubeEffect->SetFloat("dsWidth", desc.Width));
	740	V(CubeEffect->SetFloat("dsHeight", desc.Height));
	741	V(CubeEffect->SetFloat("GlowPasses", pp.GetInt(iGlowPasses)));
	742	V(CubeEffect->SetFloat("GlowGain", pp.Get(iGlowGain)));
	743	V(CubeEffect->SetFloat("Stretch", pp.Get(iStretch)));
	744	V(CubeEffect->Begin(&numberofPasses,0));
	745	for(UINT i = 0; i<numberofPasses; i++ )
	746	{
	747	V(CubeEffect->BeginPass(i));
	748
	749	//Render triangle.
	750	V(g_pd3dDevice->SetStreamSource(0,pQuadVB,0,sizeof(D3DVERTEX_1)));
	751	V(g_pd3dDevice->DrawPrimitive(D3DPT_TRIANGLELIST,0,1));
	752
	753	V(CubeEffect->EndPass());
	754	}
	755	V(CubeEffect->End());
	756	g_pd3dDevice->EndScene();
	757	}
	758	}
	759
	760
	761
	762	// Final compositing
	763	// The final image is composed from the original image and
	764	// the additive glow image
	765	g_pd3dDevice->SetRenderTarget(0, sourceTextureSurface);
	766	V( g_pd3dDevice->SetDepthStencilSurface(rttDepthSurface) );
	767	V( g_pd3dDevice->SetVertexDeclaration(textureDecl) );
	768	g_pd3dDevice->Clear( 0, NULL, D3DCLEAR_TARGET\|D3DCLEAR_ZBUFFER,
	769	D3DCOLOR_XRGB(0,0,0), 1.0f, 0 );
	770	if( SUCCEEDED( g_pd3dDevice->BeginScene() ) )
	771	{
	772	UINT numberofPasses=0;
	773	D3DXHANDLE techniqueHandle = CubeEffect->GetTechniqueByName("Final");
	774	V(CubeEffect->SetTechnique(techniqueHandle));
	775
	776	D3DXMatrixIdentity(&mMVP);
	777	V(CubeEffect->SetMatrix("modelViewProjection", &mMVP));
	778	V(CubeEffect->SetTexture("Original", CubeTexture));
	779	V(CubeEffect->SetTexture("Glow", blurTargetTexture));
	780	//V(CubeEffect->SetTexture("Glow", CubeGlowTexture));
	781	V(CubeEffect->Begin(&numberofPasses,0));
	782	for(UINT i = 0; i<numberofPasses; i++ )
	783	{
	784	V(CubeEffect->BeginPass(i));
	785
	786	//Render triangle.
	787	V(g_pd3dDevice->SetStreamSource(0,pQuadVB,0,sizeof(D3DVERTEX_1)));
	788	V(g_pd3dDevice->DrawPrimitive(D3DPT_TRIANGLELIST,0,1));
	789
	790	V(CubeEffect->EndPass());
	791	}
	792	V(CubeEffect->End());
	793	g_pd3dDevice->EndScene();
	794	}
	795	// Saving the blur history
	796	g_pd3dDevice->StretchRect(blurTargetSurface, NULL, TempTextureSurface[2], NULL, D3DTEXF_LINEAR);
	797
	798	// Tone mapping
	799	toneMap->SetSource(sourceTexture);
	800	g_pd3dDevice->SetRenderTarget(0, oldRenderTarget);
	801	toneMap->SetGain(pp.Get(iGain));
	802	toneMap->SetPasses(pp.Get(iPasses));
	803	toneMap->Map();
	804
	805	// Screen shot
	806	if (!bSavingScreenshot && pp.Get(bShowHud))
	807	{
	808	RenderText();
	809	V( g_HUD.OnRender( fElapsedTime ) );
	810	}
	811
	812	if (bSavingScreenshot)
	813	{
	814	// saving surface
	815	char buf[CHARBUFFER_SIZE];
	816	wchar_t wbuf[CHARBUFFER_SIZE];
	817
	818	GenerateNewFileName( counter );
	819	sprintf(buf, "shots\\%03i.png", counter);
	820	mbstowcs( wbuf, buf, CHARBUFFER_SIZE );
	821
	822	D3DXSaveSurfaceToFileW(wbuf, D3DXIFF_PNG, g_pSaveSurface, NULL, NULL);
	823
	824	sprintf(buf, "shots\\%03i", counter);
	825	pp.SaveToFile( buf );
	826
	827	sprintf(buf, "shots\\%03i.matrix", counter);
	828	SaveCameraPosition( buf );
	829
	830	g_pd3dDevice->SetRenderTarget(0, oldRenderTarget);
	831	bSavingScreenshot = false;
	832	}
	833	}
	834
	835	int GenerateNewFileName( int& counter )
	836	{
	837	char buf[CHARBUFFER_SIZE];
	838	FILE* f;
	839	do {
	840	sprintf(buf, "shots\\%03i.png", counter);
	841	if ( (f = fopen(buf, "rt")) != NULL )
	842	{
	843	fclose( f );
	844	counter++;
	845	}
	846	} while (f != NULL);
	847	return counter;
	848	}
	849
	850	//--------------------------------------------------------------------------------------
	851	// The framework does not remove the underlying keystroke messages,
	852	// which are still passed to the application's MsgProc callback.
	853	//--------------------------------------------------------------------------------------
	854	void CALLBACK KeyboardProc( UINT nChar, bool bKeyDown, bool bAltDown, void* pUserContext )
	855	{
	856
	857	}
	858
	859	void SaveCameraPosition( char* fileName )
	860	{
	861	// save parameters to file:
	862	// world matrix (4x4)
	863	// camera position (3)
	864
	865	// save world matrix
	866	D3DXMATRIXA16 W = *camera.GetViewMatrix();
	867
	868	FILE* f;
	869
	870	if ((f = fopen(fileName, "wt")) == NULL)
	871	{
	872	wchar_t wbuf[CHARBUFFER_SIZE];
	873	mbstowcs( wbuf, fileName, CHARBUFFER_SIZE );
	874	MessageBox(NULL, wbuf, L"File creation failed!", MB_ICONEXCLAMATION);
	875	return;
	876	}
	877
	878	fprintf(f, "\n");
	879	fprintf(f, "World matrix:\n");
	880	fprintf(f, "%10.4g %10.4g %10.4g %10.4g\n", W._11, W._12, W._13, W._14);
	881	fprintf(f, "%10.4g %10.4g %10.4g %10.4g\n", W._21, W._22, W._23, W._24);
	882	fprintf(f, "%10.4g %10.4g %10.4g %10.4g\n", W._31, W._32, W._33, W._34);
	883	fprintf(f, "%10.4g %10.4g %10.4g %10.4g\n", W._41, W._42, W._43, W._44);
	884
	885	// save camera position
	886	fprintf(f, "\n");
	887	fprintf(f, "Camera position:\n");
	888	const D3DXVECTOR3* eye = camera.GetEyePt();
	889	fprintf(f, "%10g %10g %10g", eye->x, eye->y, eye->z);
	890	fprintf(f, "\n");
	891
	892	fclose(f);
	893	}
	894
	895	void LoadCameraPosition( char* fileName )
	896	{
	897	FILE* f;
	898
	899	if ((f = fopen(fileName, "rt")) == NULL) {
	900	wchar_t wbuf[CHARBUFFER_SIZE];
	901	mbstowcs( wbuf, fileName, CHARBUFFER_SIZE );
	902	MessageBox(NULL, wbuf, L"File not found!", MB_ICONEXCLAMATION);
	903	return;
	904	}
	905
	906	const int BufSize = 500; // size of char buffers
	907	char buf[BufSize];
	908	D3DXMATRIXA16 W;
	909
	910	fgets(buf, BufSize, f); // skip comment
	911	fgets(buf, BufSize, f); // skip comment
	912	fgets(buf, BufSize, f); sscanf(buf, "%f %f %f %f", &W._11, &W._12, &W._13, &W._14);
	913	fgets(buf, BufSize, f); sscanf(buf, "%f %f %f %f", &W._21, &W._22, &W._23, &W._24);
	914	fgets(buf, BufSize, f); sscanf(buf, "%f %f %f %f", &W._31, &W._32, &W._33, &W._34);
	915	fgets(buf, BufSize, f); sscanf(buf, "%f %f %f %f", &W._41, &W._42, &W._43, &W._44);
	916
	917	// load camera position
	918	D3DXVECTOR3 vecAt(0.0f, 0.0f, 0.0f);
	919	D3DXVECTOR3 vecEye;
	920	fgets(buf, BufSize, f); // skip comment
	921	fgets(buf, BufSize, f); // skip comment
	922	fgets(buf, BufSize, f); sscanf(buf, "%f %f %f", &vecEye.x, &vecEye.y, &vecEye.z);
	923
	924	fclose(f);
	925
	926	camera.SetViewParams( &vecEye, &vecAt );
	927
	928	D3DXQUATERNION q;
	929	D3DXQuaternionRotationMatrix(&q, &W);
	930	camera.SetViewQuat(q);
	931	}
	932
	933	//--------------------------------------------------------------------------------------
	934	// Util function.
	935	// Creates an empty texture. These textures will be used as render targets, therefore
	936	// the Usage flag is set to D3DUSAGE_RENDERTARGET and consequently, the assigned
	937	// memory pool is D3DPOOL_DEFAULT.
	938	// Params: size and format (eg. D3DFMT_A32B32G32R32F) of the new texture.
	939	//--------------------------------------------------------------------------------------
	940	IDirect3DTexture9* CreateTexture( int size, D3DFORMAT Format )
	941	{
	942	HRESULT hr;
	943	IDirect3DTexture9* pTexture;
	944	V( g_pd3dDevice->CreateTexture( size, size, // dimensions
	945	1, // mipmap levels
	946	D3DUSAGE_RENDERTARGET, // usage
	947	Format,
	948	D3DPOOL_DEFAULT,// memory pool
	949	&pTexture, NULL ) );
	950	return pTexture;
	951	}
	952
	953	//--------------------------------------------------------------------------------------
	954	// Util function.
	955	// Creates an empty cubemap texture of the given resolution and format.
	956	//--------------------------------------------------------------------------------------
	957
	958	IDirect3DCubeTexture9* CreateCubeTexture( int size, D3DFORMAT Format )
	959	{
	960	HRESULT hr;
	961	IDirect3DCubeTexture9* pCubeTexture;
	962	V( g_pd3dDevice->CreateCubeTexture( size, 1, D3DUSAGE_RENDERTARGET,
	963	Format, D3DPOOL_DEFAULT, &pCubeTexture, NULL ) );
	964	return pCubeTexture;
	965	}
	966
	967
	968	//--------------------------------------------------------------------------------------
	969	// Render the help and statistics text.
	970	//--------------------------------------------------------------------------------------
	971	void RenderText()
	972	{
	973	const D3DSURFACE_DESC* backBufferDesc = DXUTGetBackBufferSurfaceDesc();
	974
	975	CDXUTTextHelper txtHelper( g_pFont, g_pTextSprite, 15 );
	976	txtHelper.Begin();
	977
	978	txtHelper.SetInsertionPos( 5, 5 );
	979	txtHelper.SetForegroundColor( D3DXCOLOR( 1.0f, 1.0f, 0.0f, 1.0f ) );
	980
	981	txtHelper.DrawFormattedTextLine( L"%.2f fps @ %i x %i",
	982	DXUTGetFPS(), backBufferDesc->Width, backBufferDesc->Height );
	983	//txtHelper.DrawTextLine( DXUTGetFrameStats() );
	984	txtHelper.DrawTextLine( DXUTGetDeviceStats() );
	985	txtHelper.DrawTextLine( L"" );
	986
	987	txtHelper.SetInsertionPos( 5, 140 );
	988	txtHelper.SetForegroundColor( D3DXCOLOR( 1.0f, 1.0f, 1.0f, 1.0f ) );
	989
	990	if ( pp.Get( bShowHelp ) )
	991	{
	992	txtHelper.SetInsertionPos( backBufferDesc->Width - 260, backBufferDesc->Height-24*15 );
	993
	994	txtHelper.DrawTextLine(
	995	L"Controls (F1 to hide):\n\n"
	996	L"___________________________________\n"
	997	L" GENERAL CONTROLS\n"
	998	L"F2: Settings\n"
	999	L"F3: Switch to REF device\n"
	1000	L"F8: Switch to Wireframe mode\n"
	1001	L"___________________________________\n"
	1002	L" ALGORITHM\n"
	1003	L"Add and Subtract: adjust gain\n"
	1004	L"___________________________________\n"
	1005	L" Quit: ESC");
	1006	}
	1007	else
	1008	{
	1009	txtHelper.DrawTextLine( L"Press F1 for help" );
	1010	}
	1011
	1012	txtHelper.End();
	1013	}

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

Download in other formats: