Context Navigation

RayTraceEffects.cpp @ 2494

Revision 2494, 93.2 KB checked in by szirmay, 17 years ago (diff)

Rev	Line
[754]	1	SHADERBOL KIVENNI A TEXTURA HASZNALATOT
	2
	3	#include "dxstdafx.h"
	4	#include "resource.h"
	5
	6	// Define X files path
	7	#define BUNNY L"Media\\Objects\\bunny.x"
	8	#define COLUMN L"Media\\Objects\\column.x"
	9	#define ROOM L"Media\\Objects\\room.x"
	10	#define SKULL L"Media\\Objects\\skull.x"
	11	#define SPHERE L"Media\\Objects\\sphere.x"
	12	#define TEAPOT L"Media\\Objects\\teapot.x"
	13	#define TIGER L"Media\\Objects\\tiger.x"
	14
	15
	16	//#define D3D_DEBUG_INFO
	17
	18	//#define DEBUG_VS // Uncomment this line to debug vertex shaders
	19	//#define DEBUG_PS // Uncomment this line to debug pixel shaders
	20
	21
	22	// Define texture sizes
	23	#define CUBEMAP_SIZE 512 // size of CubeMaps
	24	#define ATLASMAP_SIZE 512 // size of Atlases (Room, Columns)
	25	#define SHADOWMAP_SIZE 512 // size of ShadowMap
	26	#define PHOTONMAP_MAX_SIZE 256 // The max size of the PhotonMap
	27	#define SNIPPET_MAX_SIZE 5 // The max size of the snippet
	28
	29	#define STEP 0.1f // The size of a movement between two step
	30	#define CENTEROBJECTRADIUS 2.0f // radius of the center object
	31	#define LIGHTRADIUS 0.3f // radius of the light object
	32
	33	//--------------------------------------------------------------------------------------
	34	// UI control IDs
	35	//--------------------------------------------------------------------------------------
	36
	37	#define IDC_TOGGLEFULLSCREEN 1
	38	#define IDC_TOGGLEREF 2
	39	#define IDC_CHANGEDEVICE 3
	40	#define WINDOW_SIZE_X 640 // Size of the screen
	41	#define WINDOW_SIZE_Y 640 // Size of the screen
	42
	43	// HUD IDs
	44	#define IDC_SHADOW_CHECK_BOX 10
	45	#define IDC_CAUSTICS_CHECK_BOX 11
	46	#define IDC_CENTEROBJ_CHECK_BOX 12
	47	#define IDC_SNIPPET_SIZE_IS_CONSTANT_CHECK_BOX 13
	48	#define IDC_SHOW_PHOTON_MAP_CHECK_BOX 14
	49
	50
	51	#define IDC_CLASSIC_METHOD 20
	52	#define IDC_DISTANCE_IMPOSTOR_METHOD 21
	53
	54	#define IDC_NUMBER_OF_ITERATION_SLIDER 30
	55	#define IDC_FRESNEL_FACTOR_SLIDER 31
	56	#define IDC_REFRACTION_INDEX_SLIDER 32
	57	#define IDC_SHADOW_INTENSITY_SLIDER 33
	58	#define IDC_CAUSTICS_INTENSITY_SLIDER 34
	59	#define IDC_PHOTON_MAP_SIZE_SLIDER 35
	60	#define IDC_SNIPPET_SIZE_SLIDER 36
	61
	62	#define IDC_RESET_PARAMETERS_BUTTON 40
	63
	64	// These constants will be used as arguments for the RenderScene(..., int, ..) function
	65	// They are used to switch between the different shaders
	66	enum { RENDER_ROOM_COLOR_DISTANCE, RENDER_ROOM_UV, RENDER_ROOM_AND_COLUMNS_SCREEN, RENDER_PHOTON_UV_MAP, RENDER_PHOTON_HIT,
	67	RENDER_REFRACT_OBJECT_SCREEN, RENDER_LIGHT_SCREEN, RENDER_UMBRA, RENDER_SHADOW, RENDER_FULLSCREENQUAD, RENDER_PHOTON_MAP_SCREEN };
	68
	69
	70	// The next two float array pairs define the Snippet's light intensity and its size.
	71	// These values (light intensity and size) depend on the PhotonMapSize.
	72	// The bigger PhotonMapSize defines bigger texture and that defines more photon.
	73	// The more photons need smaller intensity and size.
	74	// PhotonMapSize = 1 2 4 8 16 32 64 128 256
	75	// Tries to fill the same area with constant intensity.
	76	float g_fIntensityOfSnippet[9] = { 0.05f, 0.06f, 0.08f, 0.11f, 0.185f, 0.27f, 0.53f, 1.00f, 1.65f };
	77	float g_fSizeOfSnippet[9] = { 0.05f, 0.10f, 0.14f, 0.17f, 0.25f, 0.32f, 0.64f, 1.28f, 2.56f };
	78
	79	// Tries to fill the same area with texture's size independent Snippet's size.
	80	float g_fIntensityOfSnippetWithIndependentSnippetSize[9] =
	81	{ 0.05f, 0.05f, 0.05f, 0.065f, 0.13f, 0.27f, 0.53f, 1.00f, 1.65f };
	82	float g_fSizeOfSnippetWithIndependentSnippetSize[9] =
	83	{ 0.01f, 0.02f, 0.04f, 0.08f, 0.16f, 0.32f, 0.64f, 1.28f, 2.56f };
	84
	85
	86
	87	//--------------------------------------------------------------------------------------
	88	// Structs
	89	//--------------------------------------------------------------------------------------
	90	// Vertex structure for a photon hit (called snippet)
	91	D3DVERTEXELEMENT9 g_aSnippetVertex[] =
	92	{
	93	{ 0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0 },
	94	{ 0, 12, D3DDECLTYPE_FLOAT4, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_COLOR, 0 },
	95	{ 0, 28, D3DDECLTYPE_FLOAT2, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 0 },
	96	D3DDECL_END()
	97	};
	98
	99	// Vertex structure for the fullscreene quad
	100	D3DVERTEXELEMENT9 g_aFullScreneQuadVertex[] =
	101	{
	102	{ 0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0 },
	103	D3DDECL_END()
	104	};
	105
	106	// Define a snippet
	107	struct SnippetVertexStruct
	108	{
	109	float x, y, z;
	110	float r, g, b, a;
	111	float u, v;
	112	};
	113
	114	struct FullScreenQuadVertexStruct
	115	{
	116	FLOAT x, y, z, rhw; // The transformed position for the vertex.
	117	};
	118
	119	#define D3DFVF_FULLSCREENQUADVERTEX (D3DFVF_XYZRHW)
	120
	121	FullScreenQuadVertexStruct fullscreen[] =
	122	{
	123	{ -1.0f, -1.0f, 0.5f, 1.0f, }, // x, y, z, rhw
	124	{ 1.0f, -1.0f, 0.5f, 1.0f, },
	125	{ 1.0f, 1.0f, 0.5f, 1.0f, },
	126	{ -1.0f, -1.0f, 0.5f, 1.0f, },
	127	{ 1.0f, 1.0f, 0.5f, 1.0f, },
	128	{ -1.0f, 1.0f, 0.5f, 1.0f, },
	129	};
	130
	131
	132	//--------------------------------------------------------------------------------------
	133	// Global variables
	134	//--------------------------------------------------------------------------------------
	135	IDirect3DDevice9* g_pd3dDevice = NULL; // RenderDevice
	136
	137	ID3DXFont* g_pFont = NULL; // Font for drawing text
	138	ID3DXSprite* g_pTextSprite = NULL; // Sprite for batching draw text calls
	139	ID3DXEffect* g_pEffect = NULL; // D3DX effect interface
	140
	141	CModelViewerCamera g_Camera; // A model viewing camera
	142
	143	CDXUTDialog g_HUD; // Dialog for sample specific controls
	144
	145
	146	// Textures
	147	LPDIRECT3DTEXTURE9 g_pPhotonUVTexture = NULL; // Texture where the Photon map is rendered
	148	LPDIRECT3DTEXTURE9 g_pPowerOfSnippetTexelTexture = NULL; // Texture to contain the power of the snippet Texels
	149	LPDIRECT3DTEXTURE9 g_pRoomModifyTexture = NULL; // Room's Texture, this has viewable black edges
	150	LPDIRECT3DTEXTURE9 g_pRoomLastTexture = NULL; // Room's Texture, this contains the original brdf,
	151	// the Caustics Effect and the shadow
	152	LPDIRECT3DTEXTURE9 g_pColumnModifyTexture[4]; // Columns Texture
	153	LPDIRECT3DTEXTURE9 g_pColumnLastTexture[5]; // Columns Texture, the last one contains the original brdf
	154	LPDIRECT3DTEXTURE9 g_pRoomTexture = NULL; // Room's original Texture (brdf)
	155	LPDIRECT3DTEXTURE9 g_pShadowMapTexture = NULL; // Shadow map's texture. This is used for shadow generation.
	156
	157	// Surfaces for the textures
	158	LPDIRECT3DSURFACE9 g_pColumnsModifySurface[4]; // Columns Atlas
	159	LPDIRECT3DSURFACE9 g_pColumnsLastSurface[5]; // Columns Atlas
	160	LPDIRECT3DSURFACE9 g_pRoomLastSurface = NULL; // Room's Atlas
	161	LPDIRECT3DSURFACE9 g_pRoomModifySurface = NULL; // Room's Atlas
	162	LPDIRECT3DSURFACE9 g_pRoomSurface = NULL; // Room's Atlas
	163	LPDIRECT3DSURFACE9 g_pPhotonMapDepthStencilSurface = NULL; // Used to render Photon map
	164	LPDIRECT3DSURFACE9 g_pPhotonUVMapSurface = NULL; // Photon map's UV surface
	165	LPDIRECT3DSURFACE9 g_pShadowMapSurface = NULL; // Shadow map's surface
	166	LPDIRECT3DSURFACE9 g_pShadowMapDepthStencilSSurface = NULL; // Shadow DS's Z surface
	167
	168	LPDIRECT3DSURFACE9 g_pRenderTargetSurfaceOld = NULL; // Store the original Screen's surface
	169	LPDIRECT3DSURFACE9 g_pDepthStencilSurfaceOld = NULL; // Store the original Screen's DSS
	170
	171	// Cube map textures
	172	IDirect3DCubeTexture9* g_pRoomCubeMapColorDistTexture = NULL; // CubeMap for store: Color + Distance
	173	IDirect3DCubeTexture9* g_pRoomCubeMapUVTexture = NULL; // CubeMap for store: UV + ObjectID
	174
	175	IDirect3DSurface9* g_pRoomCubeMapDepthStencilSurface = NULL; // Depth-stencil buffer for rendering to cube texture
	176	IDirect3DSurface9* g_pDepthStencilSurface = NULL; // Depth-stencil buffer for Room Texture
	177
	178	IDirect3DVertexDeclaration9* g_pSnippetVertexDeclaration = NULL; // Vertex declaration for the snippet
	179	IDirect3DVertexDeclaration9* g_pFullScreenQuadVertexDeclaration = NULL; // Vertex declaration for the fullscreen quad
	180
	181	LPDIRECT3DVERTEXBUFFER9 g_pFullScreenQuadVertexBuffer = NULL; // Contains vertex data for the fullscreen quad
	182	LPDIRECT3DVERTEXBUFFER9 g_bSnippetVertexBuffer = NULL; // Contains vertex data for the snippets
	183
	184	// Meshes
	185	ID3DXMesh* g_pCenterObjectMesh = NULL; // Mesh for the center object
	186	ID3DXMesh* g_pRoomMesh = NULL; // Mesh representing room (wall, floor, ceiling)
	187	ID3DXMesh* g_pColumnMesh = NULL; // Mesh representing one Column
	188	ID3DXMesh* g_pLightMesh = NULL; // Mesh for the light object
	189
	190	// Flags
	191	bool g_bShowHelp = false; // If true, it renders the UI control text
	192	bool g_bInitialization = true; // Initialization is in progress
	193	bool g_bRunGenerateCaustics = false; // Rerender Caustics Effect
	194	bool g_bShadowON = true; // Calculate shadow yes/no.
	195	bool g_bCausticsON = true; // Calculate caustics yes/no.
	196	bool g_bShowVariables = true; // Show the values of the algorithm's variables
	197	bool g_bShowVariablesUserSet = true; // The user sets to show the variables.
	198	bool g_bRenderCenterObjectWithBrdfON = true; // Render Center Objectum with normal texture or diffuse color.
	199	bool g_bShowHUD = true; // Show HUD
	200	bool g_bSaveTexture = false; // Just for debug.
	201	bool g_bSnippetSizeIsConstant = false; // The fSnippetSize is independent of the size of PhotonMap.
	202	// Its size is constant in world space.
	203	bool g_bShowPhotonMap = true; // Show PhotonMap on screen
	204
	205	// Matrices
	206	D3DXMATRIXA16 g_mWorldCenterObject; // World matrix of the Center Object (scaling & offset)
	207	D3DXMATRIXA16 g_mWorldViewLight; // Light's worldview matrix
	208	D3DXMATRIXA16 g_mProjLight; // Light's projection matrix
	209	D3DXMATRIXA16 g_mTexScaleBiasMat; // Special texture matrix for ShadowMapping
	210	D3DXMATRIXA16 g_mLightViewTexBias; // Light view matrix multiplied by g_mTexScaleBiasMat
	211
	212
	213	// Floats
	214	float g_fFresnelFactor = 0.05f; // The Fresnel factor
	215	float g_fRefractionIndex = 0.9f; // The Refraction index
	216	float g_fShadowIntensity = 0.25f; // The intensity of the shadow
	217	float g_fCausticsIntensity = 0.05f; // The intensity of a caustics snippet
	218	float g_fCenterObjectSize = 1.0; // The scale of the CenterObject
	219	float g_fSnippetSize = 3.0f; // The size of a snippet;
	220	float g_dDepthBias = 0.0002f; // Depth bias value
	221	float g_dBiasSlope = 2.0f; // Bias slope
	222
	223
	224	// Vectors
	225	D3DXVECTOR3 g_vLightPos; // Define the position of light
	226	D3DXVECTOR3 g_vLightPosLast; // Light position at the last Caustic Effect generation
	227	D3DXVECTOR3 g_vCenterObjectPosInitial; // Define the offset of the center object in the X file
	228	D3DXVECTOR3 g_vCenterObjectPos; // Define the offset of the center object
	229	D3DXVECTOR3 g_vCenterObjectPosLast; // CenterObj position at the last Caustic Effect generation
	230
	231	int g_iNumberOfIteration = 10; // The number of the iteration of the algorithm.
	232	int g_iObjectID = -1; // The identifier of the object in the scene.
	233	// Every object has its own ID.
	234	int g_iAlgorithmMethod = 1; // Here you can switch between the classical and our distance impstor method.
	235	int g_iPhotonMapSize = 64; // Size of the PhotonMap
	236
	237
	238	//--------------------------------------------------------------------------------------
	239	// Forward declarations
	240	//--------------------------------------------------------------------------------------
	241	bool CALLBACK IsDeviceAcceptable( D3DCAPS9* pCaps, D3DFORMAT AdapterFormat, D3DFORMAT BackBufferFormat, bool bWindowed );
	242	void CALLBACK ModifyDeviceSettings( DXUTDeviceSettings* pDeviceSettings, const D3DCAPS9* pCaps );
	243
	244	// This function creates the vertex buffer for the snippets,
	245	// controls the compiler properties,
	246	// loads the effect file and the meshes and
	247	// sets up the matrices.
	248	HRESULT CALLBACK OnCreateDevice( IDirect3DDevice9* pd3dDevice, const D3DSURFACE_DESC* pBackBufferSurfaceDesc );
	249
	250	// This function contains the texture generation.
	251	HRESULT CALLBACK OnResetDevice( IDirect3DDevice9* pd3dDevice, const D3DSURFACE_DESC* pBackBufferSurfaceDesc );
	252
	253	void CALLBACK OnFrameMove( IDirect3DDevice9* pd3dDevice, double fTime, float fElapsedTime );
	254
	255	// This is the most important function. It is called at every frame. Steps:
	256	// - some initialization
	257	// At the first call we make the initialization. This runs just once, when the program starts.
	258	// - update caustics if necessary
	259	// Then it decides whether the caustics effect should be rerendered or not.
	260	// Re-rendering the caustic effect is requested if there were some major changes (movements) in the scene.
	261	// - render to screen
	262	// The last task is to render the objects of the scene to the screen.
	263	void CALLBACK OnFrameRender( IDirect3DDevice9* pd3dDevice, double fTime, float fElapsedTime );
	264
	265	LRESULT CALLBACK MsgProc( HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam, bool* pbNoFurtherProcessing );
	266
	267	// This function handles keyboard events (user inputs).
	268	void CALLBACK KeyboardProc( UINT nChar, bool bKeyDown, bool bAltDown );
	269
	270	// The next two functions clear the variables from the memory.
	271	void CALLBACK OnLostDevice();
	272	void CALLBACK OnDestroyDevice();
	273
	274	// This function displays the values of the algorithm's variables and the help text.
	275	void RenderText();
	276
	277	// It loads a mesh from the specified X file and - after determining its size and bounding box -
	278	// centers it on the screen.
	279	HRESULT LoadMesh( WCHAR* strFileName, ID3DXMesh** ppMesh, bool bComputeBoundingBox );
	280
	281	// This function creates the cube maps.
	282	// The first cube map stores color and distance values, created from the CenterObject's position. (g_pRoomCubeMapColorDistTexture)
	283	// The second one is created from the same position. (g_pRoomCubeMapUVTexture)
	284	// It stores at every pixel the viewable object's ID and UV.
	285	void RenderScenePreProcessing();
	286
	287	// This function generates the caustics effect.
	288	// At first it creates a photon map created from the light's position.
	289	// This map stores the viewable ObjectID and UV at every pixel.
	290	// This information is gathered from the second (g_pRoomCubeMapUVTexture) CubeMap.
	291	// The second step is to create the shadow map (g_pShadowMapTexture). This map contains depth values.
	292	// This map is generated from the light's position.
	293	// The last step is to blend caustics snippets and generate shadow into the room's and the columns's atlases at the right places.
	294	void GenerateCaustics();
	295
	296	// This function contains the GPU calls.
	297	// It calculates and sets up the values of the variables which are needed for the actual technique.
	298	void RenderScene( D3DXMATRIXA16 mWorld, D3DXMATRIXA16 mProj, int method );
	299
	300	// This function binds the texture to the GPU.
	301	void RenderSceneInitialization();
	302
	303	// Functions to crate different type of textures.
	304	IDirect3DTexture9* CreateTexture( int size, D3DFORMAT Format );
	305	IDirect3DCubeTexture9* CreateCubeTexture( int size, D3DFORMAT Format );
	306	IDirect3DSurface9* CreateDepthStencilSurface( int size );
	307
	308	// This function creates vertex buffer.
	309	void CreateVertexBuffer();
	310
	311	void InitializeHUD();
	312	void CALLBACK OnGUIEvent( UINT nEvent, int nControlID, CDXUTControl* pControl );
	313
	314	//--------------------------------------------------------------------------------------
	315	// Entry point to the program. Initializes everything and goes into a message processing
	316	// loop. Idle time is used to render the scene.
	317	//--------------------------------------------------------------------------------------
	318	INT WINAPI WinMain( HINSTANCE, HINSTANCE, LPSTR, int )
	319	{
	320	// Set the callback functions. These functions allow the sample framework to notify
	321	// the application about device changes, user input, and windows messages. The
	322	// callbacks are optional so you need only set callbacks for events you're interested
	323	// in. However, if you don't handle the device reset/lost callbacks then the sample
	324	// framework won't be able to reset your device since the application must first
	325	// release all device resources before resetting. Likewise, if you don't handle the
	326	// device created/destroyed callbacks then the sample framework won't be able to
	327	// recreate your device resources.
	328	DXUTSetCallbackDeviceCreated( OnCreateDevice );
	329	DXUTSetCallbackDeviceReset( OnResetDevice );
	330	DXUTSetCallbackDeviceLost( OnLostDevice );
	331	DXUTSetCallbackDeviceDestroyed( OnDestroyDevice );
	332	DXUTSetCallbackMsgProc( MsgProc );
	333	DXUTSetCallbackKeyboard( KeyboardProc );
	334	DXUTSetCallbackFrameRender( OnFrameRender );
	335	DXUTSetCallbackFrameMove( OnFrameMove );
	336
	337	// Show the cursor and clip it when in full screen
	338	DXUTSetCursorSettings( true, true );
	339
	340
	341
	342	// Initialize the sample framework and create the desired Win32 window and Direct3D
	343	// device for the application. Calling each of these functions is optional, but they
	344	// allow you to set several options which control the behavior of the framework.
	345	DXUTInit( true, true, true ); // Parse the command line, handle the default hotkeys, and show msgboxes
	346	DXUTCreateWindow( L"RayTraceEffects" );
	347	DXUTCreateDevice( D3DADAPTER_DEFAULT, true, WINDOW_SIZE_X, WINDOW_SIZE_Y, IsDeviceAcceptable, ModifyDeviceSettings );
	348
	349	// Pass control to the sample framework for handling the message pump and
	350	// dispatching render calls. The sample framework will call your FrameMove
	351	// and FrameRender callback when there is idle time between handling window messages.
	352	DXUTMainLoop();
	353
	354	// Perform any application-level cleanup here. Direct3D device resources are released within the
	355	// appropriate callback functions and therefore don't require any cleanup code here.
	356
	357	return DXUTGetExitCode();
	358	}
	359
	360	//--------------------------------------------------------------------------------------
	361	// Initialize the app
	362	//--------------------------------------------------------------------------------------
	363	void InitializeHUD()
	364	{
	365	// Initialize dialog
	366	int posX = 350;
	367	int posY = 35;
	368	int sliderWidth = 120;
	369	int sliderHeight = 14;
	370	g_HUD.SetCallback( OnGUIEvent );
	371
	372	g_HUD.AddSlider( IDC_NUMBER_OF_ITERATION_SLIDER, posX, posY += 16, sliderWidth, sliderHeight, 0,
	373	20, g_iNumberOfIteration );
	374
	375	g_HUD.AddSlider( IDC_FRESNEL_FACTOR_SLIDER, posX, posY += 16, sliderWidth, sliderHeight, 0,
	376	100, (int)( g_fFresnelFactor * 100.0f ) );
	377
	378	g_HUD.AddSlider( IDC_REFRACTION_INDEX_SLIDER, posX, posY += 16, sliderWidth, sliderHeight, 0,
	379	100, (int)( g_fRefractionIndex * 100.0f + 1 ) );
	380
	381	g_HUD.AddSlider( IDC_SHADOW_INTENSITY_SLIDER, posX, posY += 16, sliderWidth, sliderHeight, 0,
	382	100, (int)( g_fShadowIntensity * 100.0f ) );
	383
	384	g_HUD.AddSlider( IDC_CAUSTICS_INTENSITY_SLIDER, posX, posY += 16, sliderWidth, sliderHeight, -4000,
	385	500, (int)( log( g_fCausticsIntensity ) / log ( 1.2f ) * 100.0f ) );
	386
	387	g_HUD.AddSlider( IDC_PHOTON_MAP_SIZE_SLIDER, posX, posY += 16, sliderWidth, sliderHeight, 0,
	388	(int)( log( (float)PHOTONMAP_MAX_SIZE ) / log( 2.0f ) ), (int)( log( (float)g_iPhotonMapSize ) / log( 2.0f ) ) );
	389
	390	g_HUD.AddSlider( IDC_SNIPPET_SIZE_SLIDER, posX, posY += 16, sliderWidth, sliderHeight, 0,
	391	SNIPPET_MAX_SIZE * 100, (int)( g_fSnippetSize * 100.0f ) );
	392
	393	// --------------------------------------------------------------------------------------------
	394
	395	posX = 0;
	396	posY = 35;
	397
	398	g_HUD.AddCheckBox( IDC_SHADOW_CHECK_BOX, L"Shadow ON/OFF", posX, posY += 20, 125, 16, g_bShadowON, 'S' );
	399	g_HUD.AddCheckBox( IDC_CAUSTICS_CHECK_BOX, L"Caustics ON/OFF", posX, posY += 20, 125, 16, g_bCausticsON, 'C' );
	400	g_HUD.AddCheckBox( IDC_CENTEROBJ_CHECK_BOX, L"CenterObj ON/OFF", posX, posY += 20, 125, 16, g_bRenderCenterObjectWithBrdfON, 'X' );
	401	g_HUD.AddCheckBox( IDC_SNIPPET_SIZE_IS_CONSTANT_CHECK_BOX, L"Indep. Snippet size?", posX, posY += 20, 125, 16, g_bSnippetSizeIsConstant, 'V' );
	402	g_HUD.AddCheckBox( IDC_SHOW_PHOTON_MAP_CHECK_BOX, L"Show Ph.Map ON/OFF", posX, posY += 20, 125, 16, g_bShowPhotonMap, 'M' );
	403
	404
	405	g_HUD.AddRadioButton( IDC_CLASSIC_METHOD, 1, L"Classic method", posX, posY += 30, 125, 16, false );
	406	g_HUD.AddRadioButton( IDC_DISTANCE_IMPOSTOR_METHOD, 1, L"Dist. imp. method", posX, posY += 20, 125, 16, true );
	407
	408	g_HUD.AddButton( IDC_RESET_PARAMETERS_BUTTON, L"Reset parameters", posX, posY += 30, 125, 16, 'Y' );
	409	}
	410
	411
	412	//--------------------------------------------------------------------------------------
	413	// Called during device initialization, this code checks the device for some
	414	// minimum set of capabilities, and rejects those that don't pass by returning false.
	415	//--------------------------------------------------------------------------------------
	416	bool CALLBACK IsDeviceAcceptable( D3DCAPS9* pCaps, D3DFORMAT AdapterFormat,
	417	D3DFORMAT BackBufferFormat, bool bWindowed )
	418	{
	419	// Skip backbuffer formats that don't support alpha blending
	420	IDirect3D9* pD3D = DXUTGetD3DObject();
	421	if( FAILED( pD3D->CheckDeviceFormat( pCaps->AdapterOrdinal, pCaps->DeviceType,
	422	AdapterFormat, D3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING,
	423	D3DRTYPE_TEXTURE, BackBufferFormat ) ) )
	424	return false;
	425
	426	// Must support cube textures
	427	if( !( pCaps->TextureCaps & D3DPTEXTURECAPS_CUBEMAP ) )
	428	return false;
	429
	430	// Must support pixel shader 3.0
	431	if( pCaps->PixelShaderVersion < D3DPS_VERSION( 3, 0 ) )
	432	return false;
	433
	434	// need to support D3DFMT_A32B32G32R32F render target
	435	if( FAILED( pD3D->CheckDeviceFormat( pCaps->AdapterOrdinal, pCaps->DeviceType,
	436	AdapterFormat, D3DUSAGE_RENDERTARGET,
	437	D3DRTYPE_CUBETEXTURE, D3DFMT_A32B32G32R32F ) ) )
	438	return false;
	439
	440	return true;
	441	}
	442
	443
	444	//--------------------------------------------------------------------------------------
	445	// This callback function is called immediately before a device is created to allow the
	446	// application to modify the device settings. The supplied pDeviceSettings parameter
	447	// contains the settings that the framework has selected for the new device, and the
	448	// application can make any desired changes directly to this structure. Note however that
	449	// the sample framework will not correct invalid device settings so care must be taken
	450	// to return valid device settings, otherwise IDirect3D9::CreateDevice() will fail.
	451	//--------------------------------------------------------------------------------------
	452	void CALLBACK ModifyDeviceSettings( DXUTDeviceSettings* pDeviceSettings, const D3DCAPS9* pCaps )
	453	{
	454	// If device doesn't support HW T&L or doesn't support 1.1 vertex shaders in HW then switch to SWVP.
	455	if( (pCaps->DevCaps & D3DDEVCAPS_HWTRANSFORMANDLIGHT) == 0 \|\|
	456	pCaps->VertexShaderVersion < D3DVS_VERSION(1,1) )
	457	{
	458	pDeviceSettings->BehaviorFlags = D3DCREATE_SOFTWARE_VERTEXPROCESSING;
	459	}
	460	else
	461	{
	462	pDeviceSettings->BehaviorFlags = D3DCREATE_HARDWARE_VERTEXPROCESSING;
	463	}
	464
	465	// This application is designed to work on a pure device by not using
	466	// IDirect3D9::Get*() methods, so create a pure device if supported and using HWVP.
	467	if ((pCaps->DevCaps & D3DDEVCAPS_PUREDEVICE) != 0 &&
	468	(pDeviceSettings->BehaviorFlags & D3DCREATE_HARDWARE_VERTEXPROCESSING) != 0 )
	469	pDeviceSettings->BehaviorFlags \|= D3DCREATE_PUREDEVICE;
	470
	471	// Debugging vertex shaders requires either REF or software vertex processing
	472	// and debugging pixel shaders requires REF.
	473	#ifdef DEBUG_VS
	474	if( pDeviceSettings->DeviceType != D3DDEVTYPE_REF )
	475	{
	476	pDeviceSettings->BehaviorFlags &= ~D3DCREATE_HARDWARE_VERTEXPROCESSING;
	477	pDeviceSettings->BehaviorFlags &= ~D3DCREATE_PUREDEVICE;
	478	pDeviceSettings->BehaviorFlags \|= D3DCREATE_SOFTWARE_VERTEXPROCESSING;
	479	}
	480	#endif
	481	#ifdef DEBUG_PS
	482	pDeviceSettings->DeviceType = D3DDEVTYPE_REF;
	483	#endif
	484	}
	485
	486
	487
	488	// Creates VertexBuffer
	489	void CreateVertexBuffer()
	490	{
	491	HRESULT hr;
	492
	493	SAFE_RELEASE( g_bSnippetVertexBuffer );
	494
	495	V( g_pd3dDevice->CreateVertexBuffer( (sizeof(float) * 54 * g_iPhotonMapSize * g_iPhotonMapSize ),
	496	D3DUSAGE_WRITEONLY, D3DFVF_XYZ \| D3DFVF_DIFFUSE \| D3DFVF_TEX0 \| D3DFVF_TEXCOORDSIZE2( 2 ),
	497	D3DPOOL_DEFAULT, &g_bSnippetVertexBuffer, NULL ) );
	498
	499	void* pData;
	500	V ( g_bSnippetVertexBuffer->Lock( 0, 0, &pData, 0 ) );
	501	float* pVertexBuffer = (float*)pData;
	502	for ( int i = 0; i < g_iPhotonMapSize; i++ )
	503	{
	504	for ( int j = 0; j < g_iPhotonMapSize; j++ )
	505	{
	506	// Determines the exponent of the PhotonMap size.
	507	// It is used as an index to look up from g_fSizeOfSnippet array.
	508	int iPhotonMapSizeExponent = (int)(log( (float)g_iPhotonMapSize ) / log ( 2.0f ) + 0.5f ); // 0..8
	509
	510	// By default the fSnippetSize is not constant in world space
	511	float fSnippetSize = g_fSizeOfSnippet[ iPhotonMapSizeExponent ] * g_fSnippetSize / g_iPhotonMapSize;
	512	// Decides wether the Snippet size is constant in world space or not.
	513	if ( g_bSnippetSizeIsConstant )
	514	// If constant
	515	fSnippetSize = g_fSizeOfSnippetWithIndependentSnippetSize[ iPhotonMapSizeExponent ] * g_fSnippetSize / g_iPhotonMapSize;
	516
	517	float number = (float)( i * g_iPhotonMapSize + j );
	518
	519	float u = (float) i / g_iPhotonMapSize;
	520	float v = (float) j / g_iPhotonMapSize;
	521
	522	SnippetVertexStruct snippetVertices[] =
	523	{
	524	// x, y, z, r, g,b,a, u, v,
	525	{ -fSnippetSize, -fSnippetSize, 0, number, 0,1,0, u, v },
	526	{ -fSnippetSize, fSnippetSize, 0, number, 0,0,0, u, v },
	527	{ fSnippetSize, fSnippetSize, 0, number, 1,0,0, u, v },
	528	{ fSnippetSize, fSnippetSize, 0, number, 1,0,0, u, v },
	529	{ fSnippetSize, -fSnippetSize, 0, number, 1,1,0, u, v },
	530	{ -fSnippetSize, -fSnippetSize, 0, number, 0,1,0, u, v },
	531	};
	532
	533	memcpy( pVertexBuffer, snippetVertices, sizeof( snippetVertices ) );
	534	pVertexBuffer += 54;
	535	}
	536	}
	537	V (g_bSnippetVertexBuffer->Unlock() );
	538
	539	SAFE_RELEASE( g_pPhotonMapDepthStencilSurface );
	540	SAFE_RELEASE( g_pPhotonUVTexture );
	541	SAFE_RELEASE( g_pPhotonUVMapSurface );
	542
	543	g_pPhotonMapDepthStencilSurface = CreateDepthStencilSurface( g_iPhotonMapSize );
	544	g_pPhotonUVTexture = CreateTexture( g_iPhotonMapSize, D3DFMT_A32B32G32R32F );
	545	V( g_pPhotonUVTexture->GetSurfaceLevel( 0, &g_pPhotonUVMapSurface ) );
	546
	547	// Sends the new texture parameters to the GPU.
	548	RenderSceneInitialization();
	549	}
	550
	551
	552	D3DXMATRIXA16 ScaleAndOffset(float fScale, D3DXVECTOR3 vOffset)
	553	{
	554	D3DXMATRIXA16 mScale, mOffset;
	555	D3DXMatrixIdentity(&mScale);
	556	D3DXMatrixIdentity(&mOffset);
	557
	558	D3DXMatrixTranslation( &mOffset, vOffset.x, vOffset.y, vOffset.z );
	559	D3DXMatrixScaling( &mScale, fScale, fScale, fScale );
	560
	561	return mScale * mOffset;
	562	}
	563
	564	//--------------------------------------------------------------------------------------
	565	// This callback function will be called immediately after the Direct3D device has been
	566	// created, which will happen during application initialization and windowed/full screen
	567	// toggles. This is the best location to create D3DPOOL_MANAGED resources since these
	568	// resources need to be reloaded whenever the device is destroyed. Resources created
	569	// here should be released in the OnDestroyDevice callback.
	570	//--------------------------------------------------------------------------------------
	571	HRESULT CALLBACK OnCreateDevice( IDirect3DDevice9* pd3dDevice, const D3DSURFACE_DESC* pBackBufferSurfaceDesc )
	572	{
	573	HRESULT hr;
	574
	575	// Make the device available as a global variable.
	576	g_pd3dDevice = pd3dDevice;
	577
	578	// Initialize the font
	579	V_RETURN( D3DXCreateFont( pd3dDevice, 15, 0, FW_BOLD, 1, FALSE, DEFAULT_CHARSET,
	580	OUT_DEFAULT_PRECIS, DEFAULT_QUALITY, DEFAULT_PITCH \| FF_DONTCARE,
	581	L"Arial", &g_pFont ) );
	582
	583	// Define DEBUG_VS and/or DEBUG_PS to debug vertex and/or pixel shaders with the
	584	// shader debugger. In this case shaders will be unoptimized and forced into software.
	585	DWORD dwShaderFlags = D3DXSHADER_PREFER_FLOW_CONTROL \| D3DXSHADER_SKIPOPTIMIZATION;
	586	#ifdef DEBUG_VS
	587	dwShaderFlags \|= D3DXSHADER_FORCE_VS_SOFTWARE_NOOPT;
	588	#endif
	589	#ifdef DEBUG_PS
	590	dwShaderFlags \|= D3DXSHADER_FORCE_PS_SOFTWARE_NOOPT;
	591	#endif
	592
	593	// Read the D3DX effect file
	594	WCHAR str[MAX_PATH];
	595	V_RETURN( DXUTFindDXSDKMediaFileCch( str, MAX_PATH, L"RayTraceEffects.fx" ) );
	596
	597	ID3DXBuffer* errBuff = NULL;
	598	if (FAILED(D3DXCreateEffectFromFile( pd3dDevice, str, NULL, NULL, dwShaderFlags, NULL, &g_pEffect, &errBuff )))
	599	{
	600	const int BufSize = 500;
	601	wchar_t wbuf[BufSize];
	602	mbstowcs( wbuf, (const char*)errBuff->GetBufferPointer(), BufSize );
	603	MessageBox(NULL, wbuf, L".fx compilation error", MB_ICONERROR);
	604	exit(-1);
	605	}
	606
	607
	608	// --- Initialize the matrices ---------------------------------------------------------------
	609
	610	// World transform to identity
	611	D3DXMATRIXA16 mIdent;
	612	D3DXMatrixIdentity( & mIdent );
	613	V_RETURN( pd3dDevice->SetTransform( D3DTS_WORLD, &mIdent ) );
	614
	615	// Setup the camera's view parameters
	616	D3DXVECTOR3 vEyePt( -4.0f, 5.0f, -11.0f );
	617	D3DXVECTOR3 vLookatPt( 0.0f, 0.0f, 0.0f );
	618	g_Camera.SetViewParams( &vEyePt, &vLookatPt );
	619
	620	// Initialize the position of light
	621	g_vLightPos = D3DXVECTOR3( 0.0f, 4.9f, -4.9f );
	622
	623	// For shadow mapping
	624	// Set special texture matrix for shadow mapping
	625	float fOffsetX = 0.5f + (0.5f / (float)SHADOWMAP_SIZE);
	626	float fOffsetY = 0.5f + (0.5f / (float)SHADOWMAP_SIZE);
	627	float range = 1; //note different scale in DX9!
	628	//float fBias = -0.001f * range;
	629	float fBias = 0.0f;
	630	g_mTexScaleBiasMat = D3DXMATRIXA16( 0.5f, 0.0f, 0.0f, 0.0f,
	631	0.0f, -0.5f, 0.0f, 0.0f,
	632	0.0f, 0.0f, range, 0.0f,
	633	fOffsetX, fOffsetY, fBias, 1.0f );
	634
	635
	636	// The matrices must be initialized before mesh loading!
	637	// --- Load objects -----------------------------------------------------------------------------------
	638
	639	// load default center object
[2494]	640	if( FAILED( LoadMesh( SKULL, &g_pCenterObjectMesh, true ) ) ) return DXUTERR_MEDIANOTFOUND;
[754]	641
	642	// load room
	643	if( FAILED( LoadMesh( ROOM, &g_pRoomMesh, false ) ) ) return DXUTERR_MEDIANOTFOUND;
	644
	645	// load light object
	646	if( FAILED( LoadMesh( SPHERE, &g_pLightMesh, false ) ) ) return DXUTERR_MEDIANOTFOUND;
	647
	648	// load light object
	649	if( FAILED( LoadMesh( COLUMN, &g_pColumnMesh, false ) ) ) return DXUTERR_MEDIANOTFOUND;
	650
	651	// --- Load objects ends ------------------------------------------------------------------------------
	652
	653
	654	g_pRoomCubeMapColorDistTexture = CreateCubeTexture( CUBEMAP_SIZE, D3DFMT_A16B16G16R16F ); // Because 32 can not use linear filtering.
	655	g_pRoomCubeMapUVTexture = CreateCubeTexture( CUBEMAP_SIZE, D3DFMT_A16B16G16R16F ); // Because 32 can not use linear filtering.
	656
	657	g_pShadowMapTexture = CreateTexture( SHADOWMAP_SIZE, D3DFMT_A16B16G16R16F ); // Because we use the alpha channel.
	658	g_pRoomTexture = CreateTexture( ATLASMAP_SIZE, D3DFMT_A16B16G16R16F );
	659	g_pRoomModifyTexture = CreateTexture( ATLASMAP_SIZE, D3DFMT_A16B16G16R16F ); // Because 32 can not use BLEND function.
	660	g_pRoomLastTexture = CreateTexture( ATLASMAP_SIZE, D3DFMT_A16B16G16R16F );
	661
	662
	663	V( g_pShadowMapTexture->GetSurfaceLevel( 0, &g_pShadowMapSurface ) );
	664	V( g_pRoomTexture->GetSurfaceLevel( 0, &g_pRoomSurface ) );
	665	V( g_pRoomModifyTexture->GetSurfaceLevel( 0, &g_pRoomModifySurface ) );
	666	V( g_pRoomLastTexture->GetSurfaceLevel( 0, &g_pRoomLastSurface ) );
	667
	668
	669	V( D3DXLoadSurfaceFromFile( g_pRoomSurface, NULL, NULL, L"Media\\Maps\\RoomTextMap.png", NULL, D3DX_FILTER_NONE, 0xFFFFFFFF, NULL ));
	670
	671	// Creates ColumnsTextureArray and surfaces. Load the original map from file to the last one.
	672	// The last one is used always as a source.
	673	for( int i = 0; i < 4; i++ )
	674	{
	675	g_pColumnModifyTexture[i] = CreateTexture( ATLASMAP_SIZE, D3DFMT_A16B16G16R16F ); // Because 32 can not use BLEND function.
	676	V( g_pColumnModifyTexture[i]->GetSurfaceLevel( 0, &g_pColumnsModifySurface[i] ) );
	677	}
	678
	679	for( int i = 0; i < 5; i++ )
	680	{
	681	g_pColumnLastTexture[i] = CreateTexture( ATLASMAP_SIZE, D3DFMT_A16B16G16R16F ); // Because 32 can not use BLEND function.
	682	V( g_pColumnLastTexture[i]->GetSurfaceLevel( 0, &g_pColumnsLastSurface[i] ) );
	683	}
	684
	685	D3DXLoadSurfaceFromFile( g_pColumnsLastSurface[4], NULL, NULL, L"Media\\Maps\\ColumnMap.png", NULL, D3DX_FILTER_NONE, 0xFFFFFFFF, NULL );
	686
	687
	688	g_pShadowMapDepthStencilSSurface = CreateDepthStencilSurface( SHADOWMAP_SIZE );
	689	g_pDepthStencilSurface = CreateDepthStencilSurface( ATLASMAP_SIZE );
	690	g_pRoomCubeMapDepthStencilSurface = CreateDepthStencilSurface( CUBEMAP_SIZE );
	691
	692	// Creates Snippet Texture, and loads from file
	693	D3DXCreateTextureFromFile( pd3dDevice, L"Media\\Maps\\PowerOfSnippetTexel.dds", &g_pPowerOfSnippetTexelTexture);
	694
	695	RenderSceneInitialization();
	696
	697	return S_OK;
	698	}
	699
	700
	701	//--------------------------------------------------------------------------------------
	702	// LoadMesh from file
	703	//--------------------------------------------------------------------------------------
	704	HRESULT LoadMesh( WCHAR* strFileName, ID3DXMesh** ppMesh, bool bComputeBoundingBox )
	705	{
	706	ID3DXMesh* pMesh = NULL;
	707	WCHAR str[MAX_PATH];
	708	D3DXVECTOR3 minPos, maxPos;
	709	HRESULT hr;
	710
	711	// Load the mesh with D3DX and get back a ID3DXMesh*. For this
	712	// sample we'll ignore the X file's embedded materials since we know
	713	// exactly the model we're loading. See the mesh samples such as
	714	// "OptimizedMesh" for a more generic mesh loading example.
	715	V_RETURN( DXUTFindDXSDKMediaFileCch( str, MAX_PATH, strFileName ) );
	716	V_RETURN( D3DXLoadMeshFromX(str, D3DXMESH_MANAGED, g_pd3dDevice, NULL, NULL, NULL, NULL, &pMesh) );
	717
	718	if ( bComputeBoundingBox )
	719	{
	720	// Lock the vertex buffer, to generate a simple bounding box
	721	IDirect3DVertexBuffer9* pMeshVB = NULL;
	722	void* pVertices;
	723	hr = pMesh->GetVertexBuffer( &pMeshVB );
	724	if( SUCCEEDED( hr ) )
	725	{
	726	hr = pMeshVB->Lock( 0, 0, &pVertices, D3DLOCK_NOSYSLOCK );
	727	if( SUCCEEDED(hr) )
	728	{
	729	D3DXComputeBoundingBox( ( D3DXVECTOR3*)pVertices, pMesh->GetNumVertices(),
	730	D3DXGetFVFVertexSize( pMesh->GetFVF() ),
	731	&minPos, &maxPos );
	732	pMeshVB->Unlock();
	733	}
	734	pMeshVB->Release();
	735
	736	// If an Object was previously loaded, it removes its offset from WorldCenterObject matrix.
	737	g_vCenterObjectPos += g_vCenterObjectPosInitial * g_fCenterObjectSize;
	738
	739	// mesh: center-size .. center+size
	740	g_vCenterObjectPosInitial = ( minPos + maxPos ) / 2.0f;
	741
	742	// The size of the Center Object
	743	D3DXVECTOR3 vCenterObjectSize = ( maxPos - minPos ) / 2.0f;
	744
	745	// The diameter of the center object
	746	float fCenterObjectDiameter = sqrt( vCenterObjectSize.x * vCenterObjectSize.x +
	747	vCenterObjectSize.y * vCenterObjectSize.y +
	748	vCenterObjectSize.z * vCenterObjectSize.z ) / 1.732f;
	749
	750	// Center Object size
	751	g_fCenterObjectSize = (float)CENTEROBJECTRADIUS / fCenterObjectDiameter;
	752
	753	// Eliminate the offset defined by the X file
	754	//g_vCenterObjectPos = D3DXVECTOR3(0,0,0);
	755	g_vCenterObjectPos -= g_vCenterObjectPosInitial * g_fCenterObjectSize;
	756
	757	// Center Object scale
	758	g_mWorldCenterObject = ScaleAndOffset(g_fCenterObjectSize, g_vCenterObjectPos);
	759	}
	760	}
	761
	762	DWORD *rgdwAdjacency = NULL;
	763
	764	// Make sure there are normals which are required for lighting
	765	if( !(pMesh->GetFVF() & D3DFVF_NORMAL) )
	766	{
	767	ID3DXMesh* pTempMesh;
	768	V( pMesh->CloneMeshFVF( pMesh->GetOptions(),
	769	pMesh->GetFVF() \| D3DFVF_NORMAL,
	770	g_pd3dDevice, &pTempMesh ) );
	771	V( D3DXComputeNormals( pTempMesh, NULL ) );
	772
	773	SAFE_RELEASE( pMesh );
	774	pMesh = pTempMesh;
	775	}
	776
	777	// Optimize the mesh for this graphics card's vertex cache
	778	// so when rendering the mesh's triangle list the vertices will
	779	// cache hit more often so it won't have to re-execute the vertex shader
	780	// on those vertices so it will improve perf.
	781	rgdwAdjacency = new DWORD[pMesh->GetNumFaces() * 3];
	782	if( rgdwAdjacency == NULL )
	783	return E_OUTOFMEMORY;
	784	V( pMesh->ConvertPointRepsToAdjacency(NULL, rgdwAdjacency) );
	785	V( pMesh->OptimizeInplace(D3DXMESHOPT_VERTEXCACHE, rgdwAdjacency, NULL, NULL, NULL) );
	786	delete []rgdwAdjacency;
	787
	788	*ppMesh = pMesh;
	789
	790	return S_OK;
	791	}
	792
	793	//--------------------------------------------------------------------------------------
	794	// Util function.
	795	// Creates an empty texture. These textures will be used as render targets, therefore
	796	// the Usage flag is set to D3DUSAGE_RENDERTARGET and consequently, the assigned
	797	// memory pool is D3DPOOL_DEFAULT.
	798	// Params: size and format (eg. D3DFMT_A32B32G32R32F) of the new texture.
	799	//--------------------------------------------------------------------------------------
	800	IDirect3DTexture9* CreateTexture( int size, D3DFORMAT Format )
	801	{
	802	HRESULT hr;
	803	IDirect3DTexture9* pTexture;
	804	V( g_pd3dDevice->CreateTexture( size, size, 1, D3DUSAGE_RENDERTARGET,
	805	Format, D3DPOOL_DEFAULT, &pTexture, NULL ) );
	806	return pTexture;
	807	}
	808
	809	//--------------------------------------------------------------------------------------
	810	// Util function.
	811	// Creates an empty cubemap texture of the given resolution and format.
	812	//--------------------------------------------------------------------------------------
	813
	814	IDirect3DCubeTexture9* CreateCubeTexture( int size, D3DFORMAT Format )
	815	{
	816	HRESULT hr;
	817	IDirect3DCubeTexture9* pCubeTexture;
	818	V( g_pd3dDevice->CreateCubeTexture( size, 1, D3DUSAGE_RENDERTARGET,
	819	Format, D3DPOOL_DEFAULT, &pCubeTexture, NULL ) );
	820	return pCubeTexture;
	821	}
	822
	823	//--------------------------------------------------------------------------------------
	824	// Util function.
	825	// Creates a Depth stencil surface (DSS) of the given size.
	826	//--------------------------------------------------------------------------------------
	827	IDirect3DSurface9* CreateDepthStencilSurface( int size )
	828	{
	829	HRESULT hr;
	830	IDirect3DSurface9* pDSSurface;
	831	V( g_pd3dDevice->CreateDepthStencilSurface( size, size,
	832	DXUTGetDeviceSettings().pp.AutoDepthStencilFormat,
	833	D3DMULTISAMPLE_NONE, 0, TRUE, &pDSSurface, NULL ) );
	834	return pDSSurface;
	835	}
	836
	837
	838	//--------------------------------------------------------------------------------------
	839	// This callback function will be called immediately after the Direct3D device has been
	840	// reset, which will happen after a lost device scenario. This is the best location to
	841	// create D3DPOOL_DEFAULT resources since these resources need to be reloaded whenever
	842	// the device is lost. Resources created here should be released in the OnLostDevice
	843	// callback.
	844	//--------------------------------------------------------------------------------------
	845	HRESULT CALLBACK OnResetDevice( IDirect3DDevice9* pd3dDevice,
	846	const D3DSURFACE_DESC* pBackBufferSurfaceDesc )
	847	{
	848	HRESULT hr;
	849	g_pd3dDevice = pd3dDevice;
	850
	851	if( g_pFont )
	852	V_RETURN( g_pFont->OnResetDevice() );
	853	if( g_pEffect )
	854	V_RETURN( g_pEffect->OnResetDevice() );
	855
	856	// Create a sprite to help batch calls when drawing many lines of text
	857	V_RETURN( D3DXCreateSprite( pd3dDevice, &g_pTextSprite ) );
	858
	859
	860	// --- Vertex declarations ------------------------------------------------------------------
	861
	862	// Create vertex declaration for the snippets
	863	V_RETURN( pd3dDevice->CreateVertexDeclaration( g_aSnippetVertex, &g_pSnippetVertexDeclaration ) );
	864	CreateVertexBuffer();
	865
	866	// Create vertex declaration for the fullscreen quad
	867	V( pd3dDevice->CreateVertexDeclaration( g_aFullScreneQuadVertex, &g_pFullScreenQuadVertexDeclaration ) );
	868	V_RETURN( pd3dDevice->CreateVertexBuffer( 6 * sizeof( FullScreenQuadVertexStruct ),
	869	D3DUSAGE_WRITEONLY, D3DFVF_FULLSCREENQUADVERTEX, D3DPOOL_DEFAULT, &g_pFullScreenQuadVertexBuffer, NULL ) );
	870
	871	void* pVertices;
	872	V( g_pFullScreenQuadVertexBuffer->Lock( 0, sizeof( fullscreen ), (void**)&pVertices, 0 ) );
	873	memcpy( pVertices, fullscreen, sizeof( fullscreen ) );
	874	g_pFullScreenQuadVertexBuffer->Unlock();
	875	// --- Vertex declarations ------------------------------------------------------------------
	876
	877	// Setup the camera's projection parameters
	878	float fAspectRatio = pBackBufferSurfaceDesc->Width / (FLOAT)pBackBufferSurfaceDesc->Height;
	879	g_Camera.SetProjParams( D3DX_PI/4, fAspectRatio, 0.1f, 1000.0f );
	880	g_Camera.SetWindow( pBackBufferSurfaceDesc->Width, pBackBufferSurfaceDesc->Height );
	881	g_Camera.SetButtonMasks( 0, MOUSE_WHEEL, MOUSE_LEFT_BUTTON );
	882
	883	g_HUD.SetLocation( 50, 0 );
	884	g_HUD.SetSize( 250, 250 );
	885
	886	//DXUTDeviceSettings d3dSettings = DXUTGetDeviceSettings();
	887	InitializeHUD();
	888	RenderSceneInitialization();
	889
	890	return S_OK;
	891	}
	892
	893	//--------------------------------------------------------------------------------------
	894	// This callback function will be called once at the beginning of every frame. This is the
	895	// best location for your application to handle updates to the scene, but is not
	896	// intended to contain actual rendering calls, which should instead be placed in the
	897	// OnFrameRender callback.
	898	//--------------------------------------------------------------------------------------
	899	void CALLBACK OnFrameMove( IDirect3DDevice9* pd3dDevice, double fTime, float fElapsedTime )
	900	{
	901	// Update the camera's position based on user input
	902	g_Camera.FrameMove( fElapsedTime );
	903	}
	904
	905	//--------------------------------------------------------------------------------------
	906	// This callback function will be called at the end of every frame to perform all the
	907	// rendering calls for the scene, and it will also be called if the window needs to be
	908	// repainted. After this function has returned, the sample framework will call
	909	// IDirect3DDevice9::Present to display the contents of the next buffer in the swap chain
	910	//--------------------------------------------------------------------------------------
	911	void CALLBACK OnFrameRender( IDirect3DDevice9* pd3dDevice, double fTime, float fElapsedTime )
	912	{
	913	HRESULT hr;
	914	D3DXMATRIXA16 mScaleLightObjSize, mWorldViewLight, mWorldViewCausticGenerator;
	915	g_pd3dDevice = pd3dDevice;
	916
	917	//------------------------------------------------------------------------
	918	// This is an initialization. This part of the code runs just once.
	919	// CubeMaps are created and basic setup is done here.
	920	//------------------------------------------------------------------------
	921	if ( g_bInitialization )
	922	{
	923	RenderSceneInitialization();
	924	RenderScenePreProcessing();
	925	g_bInitialization = false;
	926	}
	927
	928	//------------------------------------------------------------------------
	929	// This part of the code calculates whether the Caustics should be recalculated or not.
	930	// Calculate the size of movement between the last Caustics generation and the current position
	931	//------------------------------------------------------------------------
	932	float fSumDist = ( abs( g_vLightPos.x - g_vLightPosLast.x ) +
	933	abs( g_vLightPos.y - g_vLightPosLast.y ) +
	934	abs( g_vLightPos.z - g_vLightPosLast.z ) +
	935	abs( g_vCenterObjectPos.x - g_vCenterObjectPosLast.x ) +
	936	abs( g_vCenterObjectPos.y - g_vCenterObjectPosLast.y ) +
	937	abs( g_vCenterObjectPos.z - g_vCenterObjectPosLast.z ) );
	938
	939	float fEpsilon = 0.01f; // Tolerance of the max move size between two Caustics generation step
	940	if ( fSumDist > fEpsilon \|\| g_bRunGenerateCaustics )
	941	{
	942	// If the movement is too big, or at least one property is changed
	943	// the Caustic effect is recalculated
	944	// Generate Caustics effect
	945	GenerateCaustics();
	946
	947	// Refreshes Position data
	948	g_vLightPosLast = g_vLightPos;
	949	g_vCenterObjectPosLast = g_vCenterObjectPos;
	950
	951	// Turns off the Caustics Generation
	952	g_bRunGenerateCaustics = false;
	953	}
	954
	955	//------------------------------------------------------------------------
	956	// This part of the code renders the visible objects in the scene.
	957	//------------------------------------------------------------------------
	958	D3DXMATRIXA16 mWorldCamera = *g_Camera.GetWorldMatrix();
	959	D3DXMATRIXA16 mViewCamera = *g_Camera.GetViewMatrix();
	960	D3DXMATRIXA16 mProjCamera = *g_Camera.GetProjMatrix();
	961
	962	D3DXMATRIXA16 mWorldLight = ScaleAndOffset(1, g_vLightPos);
	963
	964	D3DXMATRIXA16 mWorldViewCamera;
	965	D3DXMatrixMultiply( &mWorldViewCamera, &mWorldCamera, &mViewCamera );
	966	D3DXMatrixScaling( &mScaleLightObjSize, LIGHTRADIUS, LIGHTRADIUS, LIGHTRADIUS );
	967	mWorldViewLight = mScaleLightObjSize * mWorldLight * mWorldViewCamera;
	968	mWorldViewCausticGenerator = g_mWorldCenterObject * mWorldViewCamera;
	969
	970	V( pd3dDevice->Clear( 0L, NULL, D3DCLEAR_TARGET \| D3DCLEAR_ZBUFFER, 0x000000ff, 1.0f, 0L ) );
	971
	972	if( SUCCEEDED( pd3dDevice->BeginScene() ) )
	973	{
	974	// Renders Room and Columns objects
	975	RenderScene( &mWorldViewCamera, &mProjCamera, RENDER_ROOM_AND_COLUMNS_SCREEN );
	976
	977	// Renders light source
	978	RenderScene( &mWorldViewLight, &mProjCamera, RENDER_LIGHT_SCREEN );
	979
	980	// Renders CenterObject (Caustic generator)
	981	RenderScene( &mWorldViewCausticGenerator, &mProjCamera, RENDER_REFRACT_OBJECT_SCREEN );
	982
	983	if( g_bShowPhotonMap )
	984	{
	985	// Renders the PhotonMap into the screen
	986	RenderScene( &mWorldViewCausticGenerator, &mProjCamera, RENDER_PHOTON_MAP_SCREEN );
	987	}
	988
	989	// Renders stats and help text
	990	RenderText();
	991
	992	// Show HUD
	993	if( g_bShowHUD ) g_HUD.OnRender( fElapsedTime );
	994
	995	pd3dDevice->EndScene();
	996	}
	997	}
	998
	999	// The next part will run just once ( the initialization )
	1000	void RenderScenePreProcessing()
	1001	{
	1002	HRESULT hr;
	1003
	1004	D3DXMATRIXA16 mProj_90_Degrees; // projection matrix
	1005	D3DXMATRIXA16 mWorldView; // worldview matrix
	1006	D3DXMATRIXA16 mViewCubeMap;
	1007	LPDIRECT3DSURFACE9 pCubeMapDistSurf, pCubeMapUVSurf;
	1008
	1009	D3DXMATRIXA16 g_mWorldCenterObjectMinus = ScaleAndOffset(1, -g_vCenterObjectPos);
	1010
	1011	// The projection matrix has a FOV of 90 degrees and asp ratio of 1
	1012	D3DXMatrixPerspectiveFovLH( &mProj_90_Degrees, D3DX_PI * 0.5f, 1.0f, 0.001f, 1000.0f );
	1013
	1014	//----------------------------------------------------------------------------------------------
	1015	// Saves original settings
	1016	//----------------------------------------------------------------------------------------------
	1017	V( g_pd3dDevice->GetRenderTarget( 0, &g_pRenderTargetSurfaceOld ) );
	1018	if( SUCCEEDED( g_pd3dDevice->GetDepthStencilSurface( &g_pDepthStencilSurfaceOld ) ) )
	1019	{
	1020	// If the device has a depth-stencil buffer, use the depth stencil buffer created for the cube textures.
	1021	V( g_pd3dDevice->SetDepthStencilSurface( g_pRoomCubeMapDepthStencilSurface ) );
	1022	}
	1023
	1024	//----------------------------------------------------------------------------------------------
	1025	// creates: CubeMap from the position of the CenterObject (RoomCubeMapColorDistanceTexture)
	1026	// stores: COLOR(x,y,z) + DISTANCE(w)
	1027	//----------------------------------------------------------------------------------------------
	1028	for( int nFace = 0; nFace < 6; ++nFace )
	1029	{
	1030	V( g_pRoomCubeMapColorDistTexture->GetCubeMapSurface( (D3DCUBEMAP_FACES)nFace, 0, &pCubeMapDistSurf ) );
	1031	V( g_pd3dDevice->SetRenderTarget( 0, pCubeMapDistSurf ) );
	1032	V( g_pd3dDevice->Clear( 0L, NULL, D3DCLEAR_TARGET\|D3DCLEAR_ZBUFFER, 0x00000000, 1.0f, 0L ) );
	1033
	1034	if( SUCCEEDED( g_pd3dDevice->BeginScene() ) )
	1035	{
	1036	mViewCubeMap = DXUTGetCubeMapViewMatrix( nFace );
	1037	mWorldView = g_mWorldCenterObjectMinus * mViewCubeMap;
	1038	RenderScene( &mWorldView, &mProj_90_Degrees, RENDER_ROOM_COLOR_DISTANCE );
	1039
	1040	g_pd3dDevice->EndScene();
	1041	}
	1042	SAFE_RELEASE( pCubeMapDistSurf );
	1043	}
	1044
	1045	//----------------------------------------------------------------------------------------------
	1046	// creates: CubeMap from the position of the CenterObject (RoomCubeMapUVTexture)
	1047	// stores: UV(x,y) + ObjectID(z) + 1
	1048	//----------------------------------------------------------------------------------------------
	1049	for( int nFace = 0; nFace < 6; ++nFace )
	1050	{
	1051	V( g_pRoomCubeMapUVTexture->GetCubeMapSurface( (D3DCUBEMAP_FACES)nFace, 0, &pCubeMapUVSurf ) );
	1052	V( g_pd3dDevice->SetRenderTarget( 0, pCubeMapUVSurf ) );
	1053	V( g_pd3dDevice->Clear( 0L, NULL, D3DCLEAR_TARGET\|D3DCLEAR_ZBUFFER, 0x00000000, 1.0f, 0L ) );
	1054
	1055	if( SUCCEEDED( g_pd3dDevice->BeginScene() ) )
	1056	{
	1057	mViewCubeMap = DXUTGetCubeMapViewMatrix( nFace );
	1058	mWorldView = g_mWorldCenterObjectMinus * mViewCubeMap;
	1059	RenderScene( &mWorldView, &mProj_90_Degrees, RENDER_ROOM_UV );
	1060
	1061	g_pd3dDevice->EndScene();
	1062	}
	1063	SAFE_RELEASE( pCubeMapUVSurf );
	1064	}
	1065
	1066	//----------------------------------------------------------------------------------------------
	1067	// Restores depth-stencil buffer and render target
	1068	//----------------------------------------------------------------------------------------------
	1069	if( g_pDepthStencilSurfaceOld )
	1070	{
	1071	V( g_pd3dDevice->SetDepthStencilSurface( g_pDepthStencilSurfaceOld ) );
	1072	SAFE_RELEASE( g_pDepthStencilSurfaceOld );
	1073	}
	1074	V( g_pd3dDevice->SetRenderTarget( 0, g_pRenderTargetSurfaceOld ) );
	1075	SAFE_RELEASE( g_pRenderTargetSurfaceOld );
	1076	}
	1077
	1078
	1079	void GenerateCaustics()
	1080	{
	1081	HRESULT hr;
	1082
	1083
	1084	//----------------------------------------------------------------------------------------------
	1085	// save original settings
	1086	//----------------------------------------------------------------------------------------------
	1087	V( g_pd3dDevice->GetRenderTarget( 0, &g_pRenderTargetSurfaceOld ) );
	1088	if( SUCCEEDED( g_pd3dDevice->GetDepthStencilSurface( &g_pDepthStencilSurfaceOld ) ) )
	1089	{
	1090	// If the device has a depth-stencil buffer, use the depth stencil buffer created for the cube textures.
	1091	V( g_pd3dDevice->SetDepthStencilSurface( g_pRoomCubeMapDepthStencilSurface ) );
	1092	}
	1093
	1094
	1095	//----------------------------------------------------------------------------------------------
	1096	// creates: PhotonMap from light position
	1097	// stores: UV(x,y) + ObjectID(z) + "1"
	1098	//----------------------------------------------------------------------------------------------
	1099
	1100	// Calculate the light's worldview transformation and take picture from there
	1101	D3DXVECTOR3 vUpPt( 0.0f, 1.0f, 0.0f );
	1102	D3DXMatrixLookAtLH( &g_mWorldViewLight, &g_vLightPos, &g_vCenterObjectPos, &vUpPt );
	1103
	1104	// Calculate FOV of the light
	1105	float radiusCenter = CENTEROBJECTRADIUS * 1.03f; // The radius of the CenterObject
	1106
	1107	D3DXVECTOR3 vDiff = g_vLightPos - g_vCenterObjectPos;
	1108	float dist = sqrt ( vDiff.x * vDiff.x + // The distance between
	1109	vDiff.y * vDiff.y + // light source and CenterObject
	1110	vDiff.z * vDiff.z );
	1111
	1112	float fovLight = atan ( radiusCenter / dist ) * 2; // fov[rad]
	1113
	1114	D3DXMATRIXA16 mLightProj; // projection matrix for the light
	1115	D3DXMatrixPerspectiveFovLH( &mLightProj, fovLight, 1.0f, 0.001f, 1000.0f );
	1116
	1117	// Skip this part of code if Caustic effect is not used
	1118	if ( g_bCausticsON )
	1119	{
	1120	V( g_pd3dDevice->SetDepthStencilSurface( g_pPhotonMapDepthStencilSurface ) );
	1121	V( g_pd3dDevice->SetRenderTarget( 0, g_pPhotonUVMapSurface ) );
	1122	V( g_pd3dDevice->Clear( 0L, NULL, D3DCLEAR_TARGET\|D3DCLEAR_ZBUFFER, 0x00000000, 1.0f, 0L ) );
	1123
	1124	if( SUCCEEDED( g_pd3dDevice->BeginScene() ) )
	1125	{
	1126	RenderScene( &g_mWorldViewLight, &mLightProj, RENDER_PHOTON_UV_MAP );
	1127	g_pd3dDevice->EndScene();
	1128	}
	1129	}
	1130
	1131	// -- DEBUG ----------------------------------------------------------------------------------------------
	1132	if( g_bSaveTexture )
	1133	{
	1134	D3DXSaveSurfaceToFile( L"PhotonMap.png", D3DXIFF_PNG, g_pPhotonUVMapSurface, NULL,NULL);
	1135
	1136	g_bSaveTexture = false;
	1137	}
	1138	// -- DEBUG END ----------------------------------------------------------------------------------------------
	1139
	1140
	1141	//----------------------------------------------------------------------------------------------
	1142	// creates: ShadowMap from light position
	1143	// stores: Distance(x)
	1144	//----------------------------------------------------------------------------------------------
	1145	// Skip this part of code if Shadow is not used
	1146	if ( g_bShadowON )
	1147	{
	1148	V( g_pd3dDevice->SetDepthStencilSurface( g_pShadowMapDepthStencilSSurface ) );
	1149	V( g_pd3dDevice->SetRenderTarget( 0, g_pShadowMapSurface ) );
	1150	V( g_pd3dDevice->Clear( 0L, NULL, D3DCLEAR_TARGET\|D3DCLEAR_ZBUFFER, 0x00000000, 1.0f, 0L ) );
	1151
	1152	// Sets depth bias to a predefined value
	1153	g_pd3dDevice->SetRenderState(D3DRS_DEPTHBIAS, (DWORD)g_dDepthBias);
	1154	g_pd3dDevice->SetRenderState(D3DRS_SLOPESCALEDEPTHBIAS, (DWORD)g_dBiasSlope);
	1155	// The projection of the ShadowMap is 80 degree.
	1156	D3DXMatrixPerspectiveFovLH( &g_mProjLight, D3DXToRadian( 80.0f ), 1.0f, 1.0f, 20.0f );
	1157
	1158	if( SUCCEEDED( g_pd3dDevice->BeginScene() ) )
	1159	{
	1160	RenderScene( &g_mWorldViewLight, &g_mProjLight, RENDER_SHADOW );
	1161	g_pd3dDevice->EndScene();
	1162	}
	1163
	1164	// Sets back the depth bias to "0"
	1165	g_pd3dDevice->SetRenderState( D3DRS_DEPTHBIAS, (DWORD)0.0f );
	1166	g_pd3dDevice->SetRenderState( D3DRS_SLOPESCALEDEPTHBIAS, (DWORD)0.0f );
	1167	}
	1168
	1169	//--------------------------------------------------------------------------------------------
	1170	// creates: RoomLastTexture, and ColumnTexture[0,1,2,3]
	1171	// They will be used as source textures when the Room and Columns are rendered in the visible scene
	1172	// stores: Color(r,g,b,a)
	1173	//--------------------------------------------------------------------------------------------
	1174	D3DXMATRIXA16 mWorldViewCamera = *g_Camera.GetViewMatrix();
	1175	D3DXMATRIXA16 mProjCamera = *g_Camera.GetProjMatrix();
	1176
	1177	// Render Room with Shadow and Caustics
	1178	V( g_pd3dDevice->SetRenderTarget( 0, g_pRoomModifySurface ) );
	1179	V( g_pd3dDevice->SetDepthStencilSurface( g_pDepthStencilSurface ) );
	1180	V( g_pd3dDevice->Clear( 0L, NULL, D3DCLEAR_TARGET\|D3DCLEAR_ZBUFFER, 0x00000000, 1.0f, 0L ) );
	1181
	1182	if( SUCCEEDED( g_pd3dDevice->BeginScene() ) )
	1183	{
	1184	// Renders Room with Shadow and Caustics
	1185	g_iObjectID = -1; // The ID of the Room Object = -1
	1186	RenderScene( &mWorldViewCamera, &mProjCamera, RENDER_UMBRA );
	1187	if ( g_bCausticsON )
	1188	RenderScene( &mWorldViewCamera, &mProjCamera, RENDER_PHOTON_HIT );
	1189	g_pd3dDevice->EndScene();
	1190	}
	1191
	1192	V( g_pd3dDevice->SetRenderTarget( 0, g_pRoomLastSurface ) );
	1193	V( g_pd3dDevice->Clear( 0L, NULL, D3DCLEAR_TARGET\|D3DCLEAR_ZBUFFER, 0x00000000, 1.0f, 0L ) );
	1194
	1195	if( SUCCEEDED( g_pd3dDevice->BeginScene() ) )
	1196	{
	1197	// Removes the black edges. Enlarges the usefull content of the atlas with one texel
	1198	RenderScene( &mWorldViewCamera, &mProjCamera, RENDER_FULLSCREENQUAD );
	1199	g_pd3dDevice->EndScene();
	1200	}
	1201
	1202	// Renders Columns with Shadow and Caustics
	1203	for (int i = 0; i < 4; i++)
	1204	{
	1205	// Renders one Column with Shadow and Caustics
	1206	V( g_pd3dDevice->SetRenderTarget( 0, g_pColumnsModifySurface[i] ) );
	1207	V( g_pd3dDevice->Clear( 0L, NULL, D3DCLEAR_TARGET\|D3DCLEAR_ZBUFFER, 0x00000000, 1.0f, 0L ) );
	1208
	1209	if( SUCCEEDED( g_pd3dDevice->BeginScene() ) )
	1210	{
	1211	g_iObjectID = i; // The ID of a Column
	1212	RenderScene( &mWorldViewCamera, &mProjCamera, RENDER_UMBRA );
	1213	if ( g_bCausticsON )
	1214	RenderScene( &mWorldViewCamera, &mProjCamera, RENDER_PHOTON_HIT );
	1215	g_pd3dDevice->EndScene();
	1216	}
	1217
	1218	V( g_pd3dDevice->SetRenderTarget( 0, g_pColumnsLastSurface[i] ) );
	1219	V( g_pd3dDevice->Clear( 0L, NULL, D3DCLEAR_TARGET\|D3DCLEAR_ZBUFFER, 0x00000000, 1.0f, 0L ) );
	1220
	1221	if( SUCCEEDED( g_pd3dDevice->BeginScene() ) )
	1222	{
	1223	// Removes the black edges. Enlarges the usefull content of the atlas with one texel
	1224	RenderScene( &mWorldViewCamera, &mProjCamera, RENDER_FULLSCREENQUAD );
	1225	g_pd3dDevice->EndScene();
	1226	}
	1227	}
	1228
	1229	/*
	1230
	1231	// -- DEBUG ----------------------------------------------------------------------------------------------
	1232	if( g_bSaveTexture )
	1233	{
	1234	D3DXSaveSurfaceToFile( L"RoomMod.png", D3DXIFF_PNG, g_pRoomModifySurface, NULL,NULL);
	1235	D3DXSaveSurfaceToFile( L"RoomLast.png", D3DXIFF_PNG, g_pRoomLastSurface, NULL,NULL);
	1236
	1237	D3DXSaveSurfaceToFile( L"ColumnMod0.png", D3DXIFF_PNG, g_pColumnsModifySurface[0], NULL,NULL);
	1238	//D3DXSaveSurfaceToFile( L"ColumnMod1.png", D3DXIFF_PNG, g_pColumnsModifySurface[1], NULL,NULL);
	1239	//D3DXSaveSurfaceToFile( L"ColumnMod2.png", D3DXIFF_PNG, g_pColumnsModifySurface[2], NULL,NULL);
	1240	//D3DXSaveSurfaceToFile( L"ColumnMod3.png", D3DXIFF_PNG, g_pColumnsModifySurface[3], NULL,NULL);
	1241
	1242	D3DXSaveSurfaceToFile( L"ColumnLast0.png", D3DXIFF_PNG, g_pColumnsLastSurface[0], NULL,NULL);
	1243	//D3DXSaveSurfaceToFile( L"ColumnLast1.png", D3DXIFF_PNG, g_pColumnsLastSurface[1], NULL,NULL);
	1244	//D3DXSaveSurfaceToFile( L"ColumnLast2.png", D3DXIFF_PNG, g_pColumnsLastSurface[2], NULL,NULL);
	1245	//D3DXSaveSurfaceToFile( L"ColumnLast3.png", D3DXIFF_PNG, g_pColumnsLastSurface[3], NULL,NULL);
	1246
	1247	g_bSaveTexture = false;
	1248	}
	1249	// -- DEBUG END ----------------------------------------------------------------------------------------------
	1250	*/
	1251
	1252	//----------------------------------------------------------------------
	1253	// Restores depth-stencil buffer and render target
	1254	//---------------------------------------------------------------------
	1255	if( g_pDepthStencilSurfaceOld )
	1256	{
	1257	V( g_pd3dDevice->SetDepthStencilSurface( g_pDepthStencilSurfaceOld ) );
	1258	SAFE_RELEASE( g_pDepthStencilSurfaceOld );
	1259	}
	1260	V( g_pd3dDevice->SetRenderTarget( 0, g_pRenderTargetSurfaceOld ) );
	1261	SAFE_RELEASE( g_pRenderTargetSurfaceOld );
	1262	}
	1263
	1264
	1265	// Sends texture parameters to the GPU.
	1266	void RenderSceneInitialization()
	1267	{
	1268	HRESULT hr;
	1269
	1270	// Bind textures
	1271	V( g_pEffect->SetTexture( "g_txRoomMap", g_pRoomTexture ) );
	1272	V( g_pEffect->SetTexture( "g_txRoomCubeMapColorDistanceMap", g_pRoomCubeMapColorDistTexture ) );
	1273	V( g_pEffect->SetTexture( "g_txRoomCubeMapUVMap", g_pRoomCubeMapUVTexture ) );
	1274	V( g_pEffect->SetTexture( "g_txRoomModifyMap", g_pRoomModifyTexture ) );
	1275	V( g_pEffect->SetTexture( "g_txRoomLastMap", g_pRoomLastTexture ) );
	1276
	1277	V( g_pEffect->SetTexture( "g_txPhotonUVMap", g_pPhotonUVTexture ) );
	1278	V( g_pEffect->SetTexture( "g_txPowerOfSnippetMap", g_pPowerOfSnippetTexelTexture ) );
	1279
	1280	V( g_pEffect->SetTexture( "g_txColumnModifyTexture0", g_pColumnModifyTexture[0] ) );
	1281	V( g_pEffect->SetTexture( "g_txColumnModifyTexture1", g_pColumnModifyTexture[1] ) );
	1282	V( g_pEffect->SetTexture( "g_txColumnModifyTexture2", g_pColumnModifyTexture[2] ) );
	1283	V( g_pEffect->SetTexture( "g_txColumnModifyTexture3", g_pColumnModifyTexture[3] ) );
	1284	V( g_pEffect->SetTexture( "g_txColumnLastTexture0", g_pColumnLastTexture[0] ) );
	1285	V( g_pEffect->SetTexture( "g_txColumnLastTexture1", g_pColumnLastTexture[1] ) );
	1286	V( g_pEffect->SetTexture( "g_txColumnLastTexture2", g_pColumnLastTexture[2] ) );
	1287	V( g_pEffect->SetTexture( "g_txColumnLastTexture3", g_pColumnLastTexture[3] ) );
	1288	V( g_pEffect->SetTexture( "g_txColumnOriginalTexture", g_pColumnLastTexture[4] ) );
	1289
	1290	V( g_pEffect->SetTexture( "g_txShadowMap", g_pShadowMapTexture ) );
	1291	}
	1292
	1293
	1294	// This function renders the Room mesh.
	1295	void RenderRoom(D3DXMATRIXA16 mWorldView, D3DXMATRIXA16 mProj)
	1296	{
	1297	HRESULT hr;
	1298	D3DXMATRIXA16 mWorldViewProjection;
	1299
	1300	V( g_pd3dDevice->SetRenderState( D3DRS_CULLMODE, D3DCULL_CW ) );
	1301
	1302	D3DXMatrixMultiply( &mWorldViewProjection, mWorldView, mProj );
	1303	V( g_pEffect->SetMatrix( "g_mWorldView", mWorldView ) );
	1304	V( g_pEffect->SetMatrix( "g_mWorldViewProjection", &mWorldViewProjection ) );
	1305	V( g_pEffect->SetMatrix( "g_mLightViewTexBias", &mWorldViewProjection ) );
	1306	V( g_pEffect->SetInt( "g_iObjectID", -1 ) );
	1307	V( g_pEffect->CommitChanges() );
	1308
	1309	V( g_pRoomMesh->DrawSubset( 0 ) );
	1310
	1311	V( g_pd3dDevice->SetRenderState( D3DRS_CULLMODE, D3DCULL_CCW ) );
	1312	}
	1313
	1314
	1315	// This function renders the Columns mesh.
	1316	void RenderColumns(D3DXMATRIXA16 mWorldView, D3DXMATRIXA16 mProj)
	1317	{
	1318	HRESULT hr;
	1319	D3DXMATRIXA16 mWorldOffset, mWorldViewProjection;
	1320
	1321	for (int i = 0; i < 4; i++)
	1322	{
	1323	if (i==0) D3DXMatrixTranslation( &mWorldOffset, 3.75f ,0 , 3.75f );
	1324	if (i==1) D3DXMatrixTranslation( &mWorldOffset, -3.75f ,0 , 3.75f );
	1325	if (i==2) D3DXMatrixTranslation( &mWorldOffset, 3.75f ,0 ,-3.75f );
	1326	if (i==3) D3DXMatrixTranslation( &mWorldOffset, -3.75f ,0 ,-3.75f );
	1327	D3DXMatrixMultiply( &mWorldOffset, &mWorldOffset, mWorldView);
	1328	D3DXMatrixMultiply( &mWorldViewProjection, &mWorldOffset, mProj);
	1329
	1330	V( g_pEffect->SetMatrix( "g_mWorldView", &mWorldOffset ) );
	1331	V( g_pEffect->SetMatrix( "g_mWorldViewProjection", &mWorldViewProjection ) );
	1332	V( g_pEffect->SetMatrix( "g_mLightViewTexBias", &mWorldViewProjection ) );
	1333	V( g_pEffect->SetInt( "g_iObjectID", i ) );
	1334	V( g_pEffect->CommitChanges() );
	1335
	1336	V( g_pColumnMesh->DrawSubset( 0 ) );
	1337	}
	1338	}
	1339
	1340	// Sets the techniques.
	1341	// Calculates and sends parameters to the GPU.
	1342	void RenderScene(D3DXMATRIXA16 mWorldView, D3DXMATRIXA16 mProj, int method )
	1343	{
	1344	HRESULT hr;
	1345	UINT cPass;
	1346	D3DXMATRIXA16 mWorldViewProjection, mWorldOffset;
	1347
	1348	D3DXMatrixMultiply( &mWorldViewProjection, mWorldView, mProj );
	1349	V( g_pEffect->SetMatrix( "g_mWorldViewProjection", &mWorldViewProjection ) );
	1350	V( g_pEffect->SetMatrix( "g_mWorldView", mWorldView ) );
	1351
	1352	V( g_pd3dDevice->SetRenderState( D3DRS_CULLMODE, D3DCULL_CW ) );
	1353
	1354
	1355	//----------------------------------------------------------------------
	1356	// It renders Room and Columns from the CenterObject position
	1357	// and stores them in a CubeMap: g_pRoomCubeMapColorDistTexture.
	1358	// Contains: COLOR(x,y,z) + Distance(w)
	1359	//----------------------------------------------------------------------
	1360	if ( method == RENDER_ROOM_COLOR_DISTANCE )
	1361	{
	1362	V( g_pEffect->SetTechnique( "RenderRoomColorDistance" ) );
	1363	V( g_pEffect->Begin( &cPass, 0 ) );
	1364	V( g_pEffect->BeginPass( 0 ) );
	1365
	1366	// Render Room
	1367	RenderRoom( mWorldView, mProj );
	1368
	1369	// Render Columns
	1370	RenderColumns( mWorldView, mProj );
	1371
	1372	V( g_pEffect->EndPass() );
	1373	V( g_pEffect->End() );
	1374	}
	1375
	1376
	1377	//----------------------------------------------------------------------
	1378	// It renders Room and Columns from the center object position
	1379	// and stores them in a CubeMap: g_pRoomCubeMapUVTexture.
	1380	// Contains: UV(x,y) + ObjectID(z) + "1"
	1381	//----------------------------------------------------------------------
	1382	if ( method == RENDER_ROOM_UV )
	1383	{
	1384	V( g_pEffect->SetTechnique( "RenderRoomUV" ) );
	1385	V( g_pEffect->Begin( &cPass, 0 ) );
	1386	V( g_pEffect->BeginPass( 0 ) );
	1387
	1388	// Render Room
	1389	RenderRoom( mWorldView, mProj );
	1390
	1391	// Render Columns
	1392	RenderColumns( mWorldView, mProj );
	1393
	1394	V( g_pEffect->EndPass() );
	1395	V( g_pEffect->End() );
	1396	}
	1397
	1398
	1399	//----------------------------------------------------------------------
	1400	// It renders Room and Columns from the center object position
	1401	// and stores them in their Atlases.
	1402	// Contains: Color(r,g,b,a )
	1403	//----------------------------------------------------------------------
	1404	if ( method == RENDER_UMBRA )
	1405	{
	1406	V( g_pd3dDevice->SetRenderState( D3DRS_CULLMODE, D3DCULL_CCW ) );
	1407
	1408	V( g_pEffect->SetTechnique( "RenderUmbra" ) );
	1409	V( g_pEffect->Begin( &cPass, 0 ) );
	1410
	1411	g_mLightViewTexBias = g_mWorldViewLight * g_mProjLight * g_mTexScaleBiasMat;
	1412	V( g_pEffect->SetMatrix( "g_mLightViewTexBias", &g_mLightViewTexBias ) );
	1413	V( g_pEffect->SetBool( "g_bShadowON", g_bShadowON ) );
	1414	V( g_pEffect->SetBool( "g_bShowHelp", g_bShowHelp ) );
	1415	V( g_pEffect->SetFloatArray( "g_vLightPos3f", g_vLightPos, 3 ) );
	1416	V( g_pEffect->SetFloat( "g_fShadowIntensity", 1-g_fShadowIntensity ));
	1417	V( g_pEffect->SetFloat( "g_fCausticsIntensity", g_fCausticsIntensity ));
	1418
	1419	V( g_pEffect->BeginPass( 0 ) );
	1420	if (g_iObjectID == -1)
	1421	{
	1422	// Render Room
	1423	V( g_pEffect->SetInt( "g_iObjectID", -1 ) );
	1424	V( g_pEffect->CommitChanges() );
	1425	V( g_pRoomMesh->DrawSubset( 0 ) );
	1426	} else
	1427	{
	1428	// Render Columns
	1429	if (g_iObjectID==0) D3DXMatrixTranslation( &mWorldOffset, 3.75f ,0 , 3.75f );
	1430	if (g_iObjectID==1) D3DXMatrixTranslation( &mWorldOffset, -3.75f ,0 , 3.75f );
	1431	if (g_iObjectID==2) D3DXMatrixTranslation( &mWorldOffset, 3.75f ,0 ,-3.75f );
	1432	if (g_iObjectID==3) D3DXMatrixTranslation( &mWorldOffset, -3.75f ,0 ,-3.75f );
	1433	V( g_pEffect->SetMatrix( "g_mWorldView", &mWorldOffset ) );
	1434	V( g_pEffect->SetInt( "g_iObjectID", g_iObjectID ) );
	1435	V( g_pEffect->CommitChanges() );
	1436	V( g_pColumnMesh->DrawSubset( 0 ) );
	1437	}
	1438	V( g_pEffect->EndPass() );
	1439	V( g_pEffect->End() );
	1440	}
	1441
	1442
	1443	//----------------------------------------------------------------------
	1444	// It renders Room and Columns from the camera position
	1445	// and shows them on the screen.
	1446	// Contains: Color(r,g,b,a)
	1447	//----------------------------------------------------------------------
	1448	if ( method == RENDER_ROOM_AND_COLUMNS_SCREEN )
	1449	{
	1450	V( g_pEffect->SetTechnique( "RenderRoomAndColumnsScreen" ) );
	1451	V( g_pEffect->Begin( &cPass, 0 ) );
	1452	V( g_pEffect->BeginPass( 0 ) );
	1453
	1454	// Render Room
	1455	RenderRoom( mWorldView, mProj );
	1456
	1457	// Render Columns
	1458	RenderColumns( mWorldView, mProj );
	1459
	1460	V( g_pEffect->EndPass() );
	1461	V( g_pEffect->End() );
	1462	}
	1463
	1464
	1465	//----------------------------------------------------------------------
	1466	// It renders CenterObject from the light position
	1467	// and stores it in g_pPhotonUVTexture.
	1468	// Contains: UV(x,y) + ObjectID(1) + "1" or "-1"
	1469	//----------------------------------------------------------------------
	1470	if ( method == RENDER_PHOTON_UV_MAP )
	1471	{
	1472	V( g_pd3dDevice->SetRenderState( D3DRS_CULLMODE, D3DCULL_CCW ) );
	1473
	1474	if( g_iAlgorithmMethod == 0 )
	1475	// Uses classic method
	1476	V( g_pEffect->SetTechnique( "RenderPhotonUVMapClassic" ) );
	1477	if( g_iAlgorithmMethod == 1 )
	1478	// Uses distance impostor
	1479	V( g_pEffect->SetTechnique( "RenderPhotonUVMap" ) );
	1480
	1481	D3DXMatrixMultiply( &mWorldViewProjection, mWorldView, mProj );
	1482	D3DXMatrixMultiply( &mWorldViewProjection, &g_mWorldCenterObject, &mWorldViewProjection );
	1483	V( g_pEffect->SetMatrix( "g_mWorldViewProjection", &mWorldViewProjection ) );
	1484	V( g_pEffect->SetMatrix( "g_mWorldCenterObject", &g_mWorldCenterObject ) );
	1485	V( g_pEffect->SetFloatArray( "g_vLightPos3f", g_vLightPos, 3 ) );
	1486	V( g_pEffect->SetInt( "g_iNumberOfIteration", g_iNumberOfIteration) );
	1487	V( g_pEffect->SetInt( "g_iPhotonMapSize", g_iPhotonMapSize) );
	1488	V( g_pEffect->SetFloat( "g_fRefractionIndex", g_fRefractionIndex ) );
	1489
	1490	V( g_pEffect->Begin( &cPass, 0 ) );
	1491	V( g_pEffect->BeginPass( 0 ) );
	1492	V( g_pEffect->CommitChanges() );
	1493
	1494	V( g_pCenterObjectMesh->DrawSubset( 0 ) );
	1495
	1496	V( g_pEffect->EndPass() );
	1497	V( g_pEffect->End() );
	1498	}
	1499
	1500
	1501	//----------------------------------------------------------------------
	1502	// It renders CenterObject from the camera position
	1503	// and shows it on the screen.
	1504	// Contains: Color(r,g,b,a)
	1505	//----------------------------------------------------------------------
	1506	if ( method == RENDER_REFRACT_OBJECT_SCREEN )
	1507	{
	1508	V( g_pd3dDevice->SetRenderState( D3DRS_CULLMODE, D3DCULL_CCW ) );
	1509
	1510	if( g_bRenderCenterObjectWithBrdfON )
	1511	{
	1512	if( g_iAlgorithmMethod == 0 )
	1513	// Uses classic method
	1514	V( g_pEffect->SetTechnique( "RenderRefractObjectScreenClassic" ) );
	1515	if( g_iAlgorithmMethod == 1 )
	1516	// Uses distance impostor
	1517	V( g_pEffect->SetTechnique( "RenderRefractObjectScreen" ) );
	1518	}
	1519	else
	1520	// Uses diffuse color
	1521	V( g_pEffect->SetTechnique( "RenderLightScreen" ) );
	1522
	1523	V( g_pEffect->Begin( &cPass, 0 ) );
	1524
	1525	D3DXVECTOR3 vWorldCameraEye = *g_Camera.GetEyePt();
	1526
	1527	V( g_pEffect->SetMatrix( "g_mWorldCenterObject", &g_mWorldCenterObject ) );
	1528	V( g_pEffect->SetFloatArray( "g_vCameraPos3f", vWorldCameraEye, 3 ) );
	1529	V( g_pEffect->SetInt( "g_iNumberOfIteration", g_iNumberOfIteration));
	1530	V( g_pEffect->SetFloat( "g_fFresnelFactor", g_fFresnelFactor));
	1531	V( g_pEffect->SetFloat( "g_fRefractionIndex", g_fRefractionIndex ));
	1532
	1533	V( g_pEffect->BeginPass( 0 ) );
	1534	V( g_pEffect->CommitChanges() );
	1535	V( g_pCenterObjectMesh->DrawSubset( 0 ) );
	1536	V( g_pEffect->EndPass() );
	1537	V( g_pEffect->End() );
	1538	}
	1539
	1540
	1541	//----------------------------------------------------------------------
	1542	// It renders and blends impostors into the Atlases of Room and Columns
	1543	// Contains: Color(r,g,b,a)
	1544	//----------------------------------------------------------------------
	1545	if ( method == RENDER_PHOTON_HIT )
	1546	{
	1547	V( g_pd3dDevice->SetRenderState( D3DRS_CULLMODE, D3DCULL_CCW ) );
	1548
	1549	g_pd3dDevice->SetRenderState(D3DRS_SRCBLEND, D3DBLEND_ONE);
	1550	g_pd3dDevice->SetRenderState(D3DRS_DESTBLEND,D3DBLEND_ONE);
	1551	g_pd3dDevice->SetRenderState(D3DRS_ALPHABLENDENABLE, true);
	1552	g_pd3dDevice->SetRenderState(D3DRS_ALPHATESTENABLE, false);
	1553
	1554	V( g_pEffect->SetTechnique( "RenderPhotonHit" ) );
	1555	V( g_pEffect->Begin( &cPass, 0 ) );
	1556
	1557	float x = g_vLightPos.x - g_vCenterObjectPos.x;
	1558	float y = g_vLightPos.y - g_vCenterObjectPos.y;
	1559	float z = g_vLightPos.z - g_vCenterObjectPos.z;
	1560	float gll2 = x * x + y * y + z * z;
	1561
	1562
	1563	//float POWER = CENTEROBJECTRADIUS * CENTEROBJECTRADIUS / 10;//45 * CENTEROBJECTRADIUS * CENTEROBJECTRADIUS * 4 / (SNIPPET_SIZE * SNIPPET_SIZE);
	1564	//float POWER = 45 * CENTEROBJECTRADIUS * CENTEROBJECTRADIUS * 4 / (g_iPhotonMapSize * g_iPhotonMapSize);
	1565	//float POWER = 45 * CENTEROBJECTRADIUS * CENTEROBJECTRADIUS * 4 / g_iPhotonMapSize;
	1566
	1567	// Determines the exponent of the PhotonMap size.
	1568	// It is used as an index to look up from g_fIntensityOfSnippet array.
	1569	int iPhotonMapSizeExponent = (int)( log( (float)g_iPhotonMapSize ) / log ( 2.0f ) + 0.5 ); // 0..8
	1570
	1571	// By default the fSnippetSize is not constant in world space
	1572	float fSnippetIntensity = g_fIntensityOfSnippet[ iPhotonMapSizeExponent ];
	1573	if( g_bSnippetSizeIsConstant ) // if it is constant
	1574	fSnippetIntensity = g_fIntensityOfSnippetWithIndependentSnippetSize[ iPhotonMapSizeExponent ];
	1575
	1576	// The intensity value of one snippet
	1577	float POWER = 10 * CENTEROBJECTRADIUS * CENTEROBJECTRADIUS /
	1578	( g_fSnippetSize * g_fSnippetSize *
	1579	fSnippetIntensity * fSnippetIntensity );
	1580
	1581	V( g_pEffect->BeginPass( 0 ) );
	1582	V( g_pEffect->SetInt( "g_iObjectID", g_iObjectID ) );
	1583	V( g_pEffect->SetFloat( "g_fPower", POWER / gll2 ) );
	1584	V( g_pEffect->SetFloat( "g_fCausticsIntensity", g_fCausticsIntensity ) );
	1585	V( g_pEffect->CommitChanges() );
	1586	V( g_pd3dDevice->SetVertexDeclaration( g_pSnippetVertexDeclaration ) );
	1587	V( g_pd3dDevice->SetStreamSource( 0, g_bSnippetVertexBuffer, 0, (sizeof(float)* 9 ) ) );
	1588	V( g_pd3dDevice->DrawPrimitive( D3DPT_TRIANGLELIST, 0, ( g_iPhotonMapSize * g_iPhotonMapSize * 2 ) ) );
	1589	V( g_pEffect->EndPass() );
	1590	V( g_pEffect->End() );
	1591
	1592	g_pd3dDevice->SetRenderState(D3DRS_ALPHABLENDENABLE, false);
	1593	}
	1594
	1595
	1596	//----------------------------------------------------------------------
	1597	// It renders Light Object from the camera position
	1598	// and shows it on the screen.
	1599	// Contains: Color(r,g,b,a)
	1600	//----------------------------------------------------------------------
	1601	if ( method == RENDER_LIGHT_SCREEN )
	1602	{
	1603	V( g_pd3dDevice->SetRenderState( D3DRS_CULLMODE, D3DCULL_NONE ) );
	1604
	1605	V( g_pEffect->SetTechnique( "RenderLightScreen" ) );
	1606	V( g_pEffect->Begin( &cPass, 0 ) );
	1607	V( g_pEffect->BeginPass( 0 ) );
	1608	V( g_pEffect->CommitChanges() );
	1609
	1610	V( g_pLightMesh->DrawSubset( 0 ) );
	1611
	1612	V( g_pEffect->EndPass() );
	1613	V( g_pEffect->End() );
	1614	}
	1615
	1616
	1617	//----------------------------------------------------------------------
	1618	// It renders CenterObject, Columns and Room from light position
	1619	// and stores them in g_pShadowMapTexture.
	1620	// Contains: Depth(x)
	1621	//----------------------------------------------------------------------
	1622	if ( method == RENDER_SHADOW )
	1623	{
	1624	V( g_pd3dDevice->SetRenderState( D3DRS_CULLMODE, D3DCULL_NONE ) );
	1625
	1626	V( g_pEffect->SetTechnique( "RenderShadow" ) );
	1627
	1628	D3DXMatrixMultiply( &mWorldViewProjection, &g_mWorldCenterObject, &mWorldViewProjection );
	1629	V( g_pEffect->SetMatrix( "g_mWorldViewProjection", &mWorldViewProjection ) );
	1630	V( g_pEffect->SetMatrix( "g_mLightViewTexBias", &mWorldViewProjection ) );
	1631
	1632	V( g_pEffect->Begin( &cPass, 0 ) );
	1633	V( g_pEffect->BeginPass( 0 ) );
	1634
	1635	// Render CenterObject
	1636	V( g_pEffect->CommitChanges() );
	1637	V( g_pCenterObjectMesh->DrawSubset( 0 ) );
	1638
	1639	// Render Columns
	1640	RenderColumns( mWorldView, mProj );
	1641
	1642	// Render Room
	1643	RenderRoom( mWorldView, mProj );
	1644
	1645	V( g_pEffect->EndPass() );
	1646	V( g_pEffect->End() );
	1647	}
	1648
	1649	//----------------------------------------------------------------------
	1650	// It renders a fullscreen quad
	1651	// and modifies the Room and Columns atlases.
	1652	// Contains: Color(r,g,b,a)
	1653	//----------------------------------------------------------------------
	1654	if ( method == RENDER_FULLSCREENQUAD )
	1655	{
	1656	V( g_pd3dDevice->SetRenderState( D3DRS_CULLMODE, D3DCULL_NONE ) );
	1657
	1658	V( g_pEffect->SetTechnique( "FullScreenQuad" ) );
	1659	V( g_pEffect->Begin( &cPass, 0 ) );
	1660	V( g_pEffect->BeginPass( 0 ) );
	1661
	1662	V( g_pEffect->SetInt( "g_iObjectID", g_iObjectID ) );
	1663	V( g_pEffect->CommitChanges() );
	1664
	1665	V( g_pd3dDevice->SetVertexDeclaration( g_pFullScreenQuadVertexDeclaration ) );
	1666	V( g_pd3dDevice->SetStreamSource( 0, g_pFullScreenQuadVertexBuffer, 0, sizeof(FullScreenQuadVertexStruct) ) );
	1667	V( g_pd3dDevice->DrawPrimitive( D3DPT_TRIANGLELIST, 0, 2 ) );
	1668
	1669	V( g_pEffect->EndPass() );
	1670	V( g_pEffect->End() );
	1671	}
	1672
	1673	if ( method == RENDER_PHOTON_MAP_SCREEN )
	1674	{
	1675	V( g_pd3dDevice->SetRenderState( D3DRS_CULLMODE, D3DCULL_NONE ) );
	1676
	1677	V( g_pEffect->SetTechnique( "PhotonMapScreen" ) );
	1678	V( g_pEffect->Begin( &cPass, 0 ) );
	1679	V( g_pEffect->BeginPass( 0 ) );
	1680	V( g_pEffect->CommitChanges() );
	1681
	1682	V( g_pd3dDevice->SetVertexDeclaration( g_pFullScreenQuadVertexDeclaration ) );
	1683	V( g_pd3dDevice->SetStreamSource( 0, g_pFullScreenQuadVertexBuffer, 0, sizeof(FullScreenQuadVertexStruct) ) );
	1684	V( g_pd3dDevice->DrawPrimitive( D3DPT_TRIANGLELIST, 0, 2 ) );
	1685
	1686	V( g_pEffect->EndPass() );
	1687	V( g_pEffect->End() );
	1688	}
	1689	}
	1690
	1691	//--------------------------------------------------------------------------------------
	1692	// Render the help and statistics text. This function uses the ID3DXFont interface for
	1693	// efficient text rendering.
	1694	//--------------------------------------------------------------------------------------
	1695	void RenderText()
	1696	{
	1697	// The helper object simply helps keep track of text position, and color
	1698	// and then it calls pFont->DrawText( m_pSprite, strMsg, -1, &rc, DT_NOCLIP, m_clr );
	1699	// If NULL is passed in as the sprite object, then it will work however the
	1700	// pFont->DrawText() will not be batched together. Batching calls will improves performance.
	1701	const D3DSURFACE_DESC* pd3dsdBackBuffer = DXUTGetBackBufferSurfaceDesc();
	1702	CDXUTTextHelper txtHelper( g_pFont, g_pTextSprite, 16 );
	1703
	1704	// Output statistics
	1705	txtHelper.Begin();
	1706	txtHelper.SetInsertionPos( 10, 5 );
	1707	txtHelper.SetForegroundColor( D3DXCOLOR( 1.0f, 1.0f, 1.0f, 1.0f ) );
	1708
	1709	/*TCHAR sz[50];
	1710	sz[49] = 0;
	1711	_sntprintf( sz, 50, L"%.2f fps", DXUTGetFPS() );
	1712	txtHelper.DrawTextLine( sz );*/
	1713
	1714	txtHelper.DrawTextLine( DXUTGetFrameStats() );
	1715	//txtHelper.DrawTextLine( DXUTGetDeviceStats() );
	1716
	1717	if (!g_bShowHelp)
	1718	txtHelper.DrawTextLine( L"Press F1 for help" );
	1719
	1720	// Show algorithm's parameters
	1721	if ( g_bShowVariables )
	1722	{
	1723	txtHelper.SetInsertionPos( 200, 50 );
	1724
	1725	txtHelper.DrawTextLine( L"Number of iteration" );
	1726	txtHelper.DrawTextLine( L"Fresnel factor" );
	1727	txtHelper.DrawTextLine( L"Refraction index" );
	1728	txtHelper.DrawTextLine( L"Shadow intensity" );
	1729	txtHelper.DrawTextLine( L"Caustics intensity" );
	1730	txtHelper.DrawTextLine( L"PhotonMap size" );
	1731	txtHelper.DrawTextLine( L"Snippet size" );
	1732
	1733	txtHelper.SetInsertionPos( 330, 50 );
	1734
	1735	TCHAR sz0[50], sz1[50], sz2[50], sz3[50], sz4[50], sz5[50], sz6[50];
	1736	sz0[49] = sz1[49] = sz2[49] = sz3[49] = sz4[49] = sz5[49] = sz6[49] = 0;
	1737
	1738	_sntprintf( sz0, 50, L"%i", g_iNumberOfIteration );
	1739	_sntprintf( sz1, 50, L"%.2f", g_fFresnelFactor );
	1740	_sntprintf( sz2, 50, L"%.2f", g_fRefractionIndex );
	1741	_sntprintf( sz3, 50, L"%.2f", g_fShadowIntensity );
	1742	_sntprintf( sz4, 50, L"%.2f", g_fCausticsIntensity );
	1743	_sntprintf( sz5, 50, L"%i", g_iPhotonMapSize );
	1744	_sntprintf( sz6, 50, L"%.2f", g_fSnippetSize );
	1745
	1746	txtHelper.DrawTextLine( sz0 );
	1747	txtHelper.DrawTextLine( sz1 );
	1748	txtHelper.DrawTextLine( sz2 );
	1749	txtHelper.DrawTextLine( sz3 );
	1750	txtHelper.DrawTextLine( sz4 );
	1751	txtHelper.DrawTextLine( sz5 );
	1752	txtHelper.DrawTextLine( sz6 );
	1753	}
	1754
	1755	// Draw help
	1756	if ( g_bShowHelp )
	1757	{
	1758	const D3DSURFACE_DESC* backBufferDesc = DXUTGetBackBufferSurfaceDesc();
	1759	txtHelper.SetInsertionPos( backBufferDesc->Width - 220, backBufferDesc->Height-24 * 16 );
	1760
	1761	txtHelper.DrawTextLine(
	1762	L"Controls (F1 to hide):\n\n"
	1763	L"____________________________\n"
	1764	L" GENERAL CONTROLS\n"
	1765	L"Left click drag: Rotate mesh\n"
	1766	L"Mouse wheel: Zoom\n"
	1767	L"Arrow keys: Move center object\n"
	1768	L"Alt+Arrow keys: Move light object\n"
	1769	L"F2: Settings\n"
	1770	L"F3: Switch to REF device\n"
	1771	L"F4: Show parameters ON/OFF\n"
	1772	L"F5: Show HUD ON/OFF\n"
	1773	L"F8: Switch to Wireframe mode\n"
	1774	L"____________________________\n"
	1775	L" ALGORITHM\n"
	1776	L"1-5: Choose mesh\n"
	1777	L"C: Caustics Effect ON/OFF\n"
	1778	L"S: Shadow ON/OFF\n"
	1779	L"X: Center Objectum render ON/OFF\n"
	1780	L"D: Switch classic / dist. imp. meth.\n"
	1781	L"Y: Reset parameters\n"
	1782	L"V: Indep. Snippet size?\n"
	1783	L"M: Show PhotonMap ON/OFF\n"
	1784	L"____________________________\n"
	1785	L" Quit: ESC");
	1786
	1787	if( g_bShowHUD )
	1788	txtHelper.SetInsertionPos( 540, 50 );
	1789	else
	1790	txtHelper.SetInsertionPos( 370, 50 );
	1791
	1792	if ( g_bShowVariables )
	1793	{
	1794	txtHelper.DrawTextLine( L"Key: +, -" );
	1795	txtHelper.DrawTextLine( L"Key: Q, W" );
	1796	txtHelper.DrawTextLine( L"Key: E, R" );
	1797	txtHelper.DrawTextLine( L"Key: T, Z" );
	1798	txtHelper.DrawTextLine( L"Key: U, I" );
	1799	txtHelper.DrawTextLine( L"Key: O, P" );
	1800	txtHelper.DrawTextLine( L"Key: K, L" );
	1801	txtHelper.DrawTextLine( L"+ 'Alt' key:");
	1802	txtHelper.DrawTextLine( L" quick change" );
	1803	}
	1804	}
	1805
	1806	// Draws the title of the PhotonMap
	1807	if ( g_bShowPhotonMap )
	1808	{
	1809	const D3DSURFACE_DESC* backBufferDesc = DXUTGetBackBufferSurfaceDesc();
	1810	txtHelper.SetInsertionPos( 65, backBufferDesc->Height - 180 );
	1811	txtHelper.DrawTextLine( L"PhotonMap" );
	1812	}
	1813
	1814	txtHelper.End();
	1815	}
	1816
	1817
	1818	//--------------------------------------------------------------------------------------
	1819	// Before handling window messages, the sample framework passes incoming windows
	1820	// messages to the application through this callback function. If the application sets
	1821	// *pbNoFurtherProcessing to TRUE, then the sample framework will not process this message.
	1822	//--------------------------------------------------------------------------------------
	1823	LRESULT CALLBACK MsgProc( HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam, bool* pbNoFurtherProcessing )
	1824	{
	1825	// Give the dialogs a chance to handle the message first
	1826	*pbNoFurtherProcessing = g_HUD.MsgProc( hWnd, uMsg, wParam, lParam );
	1827	if( *pbNoFurtherProcessing )
	1828	return 0;
	1829
	1830	// Pass all remaining windows messages to camera so it can respond to user input
	1831	g_Camera.HandleMessages( hWnd, uMsg, wParam, lParam );
	1832
	1833	return 0;
	1834	}
	1835
	1836
	1837	//--------------------------------------------------------------------------------------
	1838	// As a convenience, the sample framework inspects the incoming windows messages for
	1839	// keystroke messages and decodes the message parameters to pass relevant keyboard
	1840	// messages to the application. The framework does not remove the underlying keystroke
	1841	// messages, which are still passed to the application's MsgProc callback.
	1842	//--------------------------------------------------------------------------------------
	1843	void CALLBACK KeyboardProc( UINT nChar, bool bKeyDown, bool bAltDown )
	1844	{
	1845	HRESULT hr;
	1846	D3DXVECTOR3 movement(0,0,0);
	1847
	1848	if( bKeyDown )
	1849	{
	1850	switch( nChar )
	1851	{
	1852	// Save Objects Last Texture Atlas
	1853	case 'A':
	1854	g_bSaveTexture = true;
	1855	g_bRunGenerateCaustics = true;
	1856	break;
	1857
	1858	// Show Help
	1859	case VK_F1:
	1860	g_bShowHelp = !g_bShowHelp;
	1861	if (!g_bShowVariablesUserSet) g_bShowVariables = g_bShowHelp \|\| g_bShowHUD;
	1862	g_bRunGenerateCaustics = true;
	1863	break;
	1864
	1865	// Show the values of the algorithm's variables
	1866	case VK_F4:
	1867	g_bShowVariables = !g_bShowVariables;
	1868	g_bShowVariablesUserSet = !g_bShowVariablesUserSet;
	1869	break;
	1870
	1871	// Show HUD
	1872	case VK_F5:
	1873	g_bShowHUD = !g_bShowHUD;
	1874	if (!g_bShowVariablesUserSet) g_bShowVariables = g_bShowHelp \|\| g_bShowHUD;
	1875	break;
	1876
	1877	// Change the Mesh of CenterObject
	1878	case '1':
	1879	SAFE_RELEASE( g_pCenterObjectMesh );
	1880	V( LoadMesh( SPHERE, &g_pCenterObjectMesh, true ) );
	1881	g_bRunGenerateCaustics = true;
	1882	break;
	1883
	1884	case '2':
	1885	SAFE_RELEASE( g_pCenterObjectMesh );
	1886	V( LoadMesh( SKULL, &g_pCenterObjectMesh, true ) );
	1887	g_bRunGenerateCaustics = true;
	1888	break;
	1889
	1890	case '3':
	1891	SAFE_RELEASE( g_pCenterObjectMesh );
	1892	V( LoadMesh( BUNNY, &g_pCenterObjectMesh, true ) );
	1893	g_bRunGenerateCaustics = true;
	1894	break;
	1895
	1896	case '4':
	1897	SAFE_RELEASE( g_pCenterObjectMesh );
	1898	V( LoadMesh( TEAPOT, &g_pCenterObjectMesh, true ) );
	1899	g_bRunGenerateCaustics = true;
	1900	break;
	1901
	1902	case '5':
	1903	SAFE_RELEASE( g_pCenterObjectMesh );
	1904	V( LoadMesh( TIGER, &g_pCenterObjectMesh, true ) );
	1905	g_bRunGenerateCaustics = true;
	1906	break;
	1907
	1908	// Switch between the classical and our new distance impostor method
	1909	case 'D':
	1910	g_iAlgorithmMethod = 1 - g_iAlgorithmMethod;
	1911
	1912	if ( g_iAlgorithmMethod == 0 )
	1913	g_HUD.GetRadioButton( IDC_CLASSIC_METHOD )->SetChecked( true );
	1914	else g_HUD.GetRadioButton( IDC_DISTANCE_IMPOSTOR_METHOD )->SetChecked( true );
	1915
	1916	g_bRunGenerateCaustics = true;
	1917	break;
	1918
	1919	// Change the number of iteration.
	1920	case VK_ADD:
	1921	if( g_iNumberOfIteration < 20 ) g_iNumberOfIteration++;
	1922	g_HUD.GetSlider( IDC_NUMBER_OF_ITERATION_SLIDER )->SetValue( g_iNumberOfIteration );
	1923	g_bRunGenerateCaustics = true;
	1924	break;
	1925
	1926	case VK_SUBTRACT:
	1927	if ( g_iNumberOfIteration > 0 ) g_iNumberOfIteration--;
	1928	g_HUD.GetSlider( IDC_NUMBER_OF_ITERATION_SLIDER )->SetValue( g_iNumberOfIteration );
	1929	g_bRunGenerateCaustics = true;
	1930	break;
	1931
	1932
	1933	// Change the intensity of the shadow
	1934	case 'Z':
	1935	g_fShadowIntensity += bAltDown ? 0.1f : 0.01f;
	1936	if ( g_fShadowIntensity > 1 ) g_fShadowIntensity = 1;
	1937	g_HUD.GetSlider( IDC_SHADOW_INTENSITY_SLIDER )->SetValue( (int)g_fShadowIntensity * 100 );
	1938	g_bRunGenerateCaustics = true;
	1939	break;
	1940
	1941	case 'T':
	1942	g_fShadowIntensity -= bAltDown ? 0.1f : 0.01f;
	1943	if ( g_fShadowIntensity < 0 ) g_fShadowIntensity = 0;
	1944	g_HUD.GetSlider( IDC_SHADOW_INTENSITY_SLIDER )->SetValue( (int)g_fShadowIntensity * 100 );
	1945
	1946	g_bRunGenerateCaustics = true;
	1947	break;
	1948
	1949
	1950	// Change the intensity of the caustics snippet
	1951	case 'U':
	1952	g_fCausticsIntensity -= bAltDown ? 0.1f : 0.01f;
	1953	if ( g_fCausticsIntensity < 0 ) g_fCausticsIntensity = 0;
	1954
	1955	//g_fCausticsIntensity = pow ( 2.0f, g_HUD.GetSlider( IDC_CAUSTICS_INTENSITY_SLIDER )->GetValue() / 100.0f );
	1956	g_HUD.GetSlider( IDC_CAUSTICS_INTENSITY_SLIDER )->SetValue( (int)( log( g_fCausticsIntensity ) / log ( 1.2f ) ) * 100 );
	1957
	1958	g_bRunGenerateCaustics = true;
	1959	break;
	1960
	1961	case 'I':
	1962	g_fCausticsIntensity += bAltDown ? 0.1f : 0.01f;
	1963	g_HUD.GetSlider( IDC_CAUSTICS_INTENSITY_SLIDER )->SetValue( (int)(log( g_fCausticsIntensity ) / log ( 1.2f ) ) * 100 );
	1964	g_bRunGenerateCaustics = true;
	1965	break;
	1966
	1967
	1968	// Change the refraction index
	1969	case 'E':
	1970	g_fRefractionIndex -= bAltDown ? 0.1f : 0.01f;
	1971	if (g_fRefractionIndex < 0) g_fRefractionIndex = 0;
	1972	g_HUD.GetSlider( IDC_REFRACTION_INDEX_SLIDER )->SetValue( (int)g_fRefractionIndex * 100 );
	1973
	1974	g_bRunGenerateCaustics = true;
	1975	break;
	1976
	1977	case 'R':
	1978	g_fRefractionIndex += bAltDown ? 0.1f : 0.01f;
	1979	if (g_fRefractionIndex > 1) g_fRefractionIndex = 1;
	1980	g_HUD.GetSlider( IDC_REFRACTION_INDEX_SLIDER )->SetValue( (int)g_fRefractionIndex * 100 );
	1981
	1982	g_bRunGenerateCaustics = true;
	1983	break;
	1984
	1985
	1986	// Change Fresnel factor
	1987	case 'Q':
	1988	g_fFresnelFactor -= bAltDown ? 0.1f : 0.01f;
	1989	if (g_fFresnelFactor < 0) g_fFresnelFactor = 0;
	1990	g_HUD.GetSlider( IDC_FRESNEL_FACTOR_SLIDER )->SetValue( (int)g_fFresnelFactor * 100 );
	1991
	1992	g_bRunGenerateCaustics = true;
	1993	break;
	1994	case 'W':
	1995	g_fFresnelFactor += bAltDown ? 0.1f : 0.01f;
	1996	if (g_fFresnelFactor > 1) g_fFresnelFactor = 1;
	1997	g_HUD.GetSlider( IDC_FRESNEL_FACTOR_SLIDER )->SetValue( (int)g_fFresnelFactor * 100 );
	1998
	1999	g_bRunGenerateCaustics = true;
	2000	break;
	2001
	2002
	2003	// Change PhotonMap size
	2004	case 'O':
	2005	if( g_iPhotonMapSize > 1 )
	2006	{
	2007	g_iPhotonMapSize /= 2;
	2008	g_HUD.GetSlider( IDC_PHOTON_MAP_SIZE_SLIDER )->SetValue( (int) ( log( (float)g_iPhotonMapSize ) / log( 2.0f ) ) );
	2009	CreateVertexBuffer();
	2010	g_bRunGenerateCaustics = true;
	2011	}
	2012	break;
	2013
	2014	case 'P':
	2015	if( g_iPhotonMapSize < PHOTONMAP_MAX_SIZE )
	2016	{
	2017	g_iPhotonMapSize *= 2;
	2018	g_HUD.GetSlider( IDC_PHOTON_MAP_SIZE_SLIDER )->SetValue( (int) ( log( (float)g_iPhotonMapSize ) / log( 2.0f ) ) );
	2019	CreateVertexBuffer();
	2020	g_bRunGenerateCaustics = true;
	2021	}
	2022	break;
	2023
	2024	// Change the size of the snippet
	2025	case 'K':
	2026	g_fSnippetSize -= bAltDown ? 0.1f : 0.01f;
	2027	if( g_fSnippetSize < 0 ) g_fSnippetSize = 0;
	2028	g_HUD.GetSlider( IDC_SNIPPET_SIZE_SLIDER )->SetValue( (int)g_fSnippetSize * 100 );
	2029
	2030	CreateVertexBuffer();
	2031	g_bRunGenerateCaustics = true;
	2032	break;
	2033	case 'L':
	2034	g_fSnippetSize += bAltDown ? 0.1f : 0.01f;
	2035	if( (int)g_fSnippetSize > SNIPPET_MAX_SIZE ) g_fSnippetSize = SNIPPET_MAX_SIZE;
	2036	g_HUD.GetSlider( IDC_SNIPPET_SIZE_SLIDER )->SetValue( (int)g_fSnippetSize * 100 );
	2037
	2038	CreateVertexBuffer();
	2039	g_bRunGenerateCaustics = true;
	2040	break;
	2041
	2042
	2043	// Move CenterObject / Light Source
	2044	case VK_RIGHT: movement.x += STEP; break;
	2045	case VK_LEFT: movement.x -= STEP; break;
	2046	case VK_UP: movement.z += STEP; break;
	2047	case VK_DOWN: movement.z -= STEP; break;
	2048	case VK_PRIOR: movement.y += STEP; break;
	2049	case VK_NEXT: movement.y -= STEP; break;
	2050	}
	2051
	2052	// Move Light Source
	2053	if (bAltDown)
	2054	{
	2055	g_vLightPos += movement;
	2056	}
	2057	// Move CenterObject
	2058	else
	2059	{
	2060	g_vCenterObjectPos += movement;
	2061
	2062	// Refresh scaled World matrix of Center Mesh
	2063	g_mWorldCenterObject = ScaleAndOffset(g_fCenterObjectSize, g_vCenterObjectPos);
	2064	}
	2065	}
	2066	}
	2067
	2068
	2069	//--------------------------------------------------------------------------------------
	2070	// Handles the GUI events
	2071	//--------------------------------------------------------------------------------------
	2072	void CALLBACK OnGUIEvent( UINT nEvent, int nControlID, CDXUTControl* pControl )
	2073	{
	2074	switch( nControlID )
	2075	{
	2076	case IDC_TOGGLEFULLSCREEN: DXUTToggleFullScreen(); break;
	2077	case IDC_TOGGLEREF: DXUTToggleREF(); break;
	2078	case IDC_CHANGEDEVICE: DXUTSetShowSettingsDialog( !DXUTGetShowSettingsDialog() ); break;
	2079
	2080	case IDC_NUMBER_OF_ITERATION_SLIDER:
	2081	g_iNumberOfIteration = g_HUD.GetSlider( IDC_NUMBER_OF_ITERATION_SLIDER )->GetValue();
	2082	break;
	2083
	2084	case IDC_FRESNEL_FACTOR_SLIDER:
	2085	g_fFresnelFactor = g_HUD.GetSlider( IDC_FRESNEL_FACTOR_SLIDER )->GetValue() / 100.0f;
	2086	break;
	2087
	2088	case IDC_REFRACTION_INDEX_SLIDER:
	2089	g_fRefractionIndex = g_HUD.GetSlider( IDC_REFRACTION_INDEX_SLIDER )->GetValue() / 100.0f;
	2090	break;
	2091
	2092	case IDC_SHADOW_INTENSITY_SLIDER:
	2093	g_fShadowIntensity = g_HUD.GetSlider( IDC_SHADOW_INTENSITY_SLIDER )->GetValue() / 100.0f;
	2094	break;
	2095
	2096	case IDC_CAUSTICS_INTENSITY_SLIDER:
	2097	//g_fCausticsIntensity = g_HUD.GetSlider( IDC_CAUSTICS_INTENSITY_SLIDER )->GetValue() / 100.0f;
	2098	g_fCausticsIntensity = pow ( 1.2f, g_HUD.GetSlider( IDC_CAUSTICS_INTENSITY_SLIDER )->GetValue() / 100.0f );
	2099	break;
	2100
	2101	case IDC_SHADOW_CHECK_BOX:
	2102	g_bShadowON = ( g_HUD.GetCheckBox( IDC_SHADOW_CHECK_BOX )->GetChecked() );
	2103	break;
	2104
	2105	case IDC_CAUSTICS_CHECK_BOX:
	2106	g_bCausticsON = (g_HUD.GetCheckBox( IDC_CAUSTICS_CHECK_BOX )->GetChecked() );
	2107	break;
	2108
	2109	case IDC_CENTEROBJ_CHECK_BOX:
	2110	g_bRenderCenterObjectWithBrdfON = ( g_HUD.GetCheckBox( IDC_CENTEROBJ_CHECK_BOX )->GetChecked() );
	2111	break;
	2112
	2113	case IDC_SNIPPET_SIZE_IS_CONSTANT_CHECK_BOX:
	2114	g_bSnippetSizeIsConstant = ( g_HUD.GetCheckBox( IDC_SNIPPET_SIZE_IS_CONSTANT_CHECK_BOX )->GetChecked() );
	2115
	2116	CreateVertexBuffer();
	2117	break;
	2118
	2119	case IDC_SHOW_PHOTON_MAP_CHECK_BOX:
	2120	g_bShowPhotonMap = ( g_HUD.GetCheckBox( IDC_SHOW_PHOTON_MAP_CHECK_BOX )->GetChecked() );
	2121
	2122	break;
	2123
	2124	case IDC_CLASSIC_METHOD:
	2125	case IDC_DISTANCE_IMPOSTOR_METHOD:
	2126
	2127	if ( g_HUD.GetRadioButton( IDC_DISTANCE_IMPOSTOR_METHOD )->GetChecked() )
	2128	g_iAlgorithmMethod = 1;
	2129	else
	2130	g_iAlgorithmMethod = 0;
	2131	break;
	2132
	2133	case IDC_PHOTON_MAP_SIZE_SLIDER:
	2134	g_iPhotonMapSize = (int)pow( 2.0f, g_HUD.GetSlider( IDC_PHOTON_MAP_SIZE_SLIDER )->GetValue() );
	2135
	2136	CreateVertexBuffer();
	2137	break;
	2138
	2139	case IDC_SNIPPET_SIZE_SLIDER:
	2140	g_fSnippetSize = g_HUD.GetSlider( IDC_SNIPPET_SIZE_SLIDER )->GetValue() / 100.0f;
	2141
	2142	CreateVertexBuffer();
	2143	break;
	2144
	2145	case IDC_RESET_PARAMETERS_BUTTON:
	2146	// Reset the parameters of the algorithm
	2147	g_bShadowON = true;
	2148	g_bCausticsON = true;
	2149	g_bRenderCenterObjectWithBrdfON = true;
	2150	g_bShowPhotonMap = true;
	2151
	2152	g_fFresnelFactor = 0.05f;
	2153	g_fRefractionIndex = 0.9f;
	2154	g_fShadowIntensity = 0.25f;
	2155	g_fCausticsIntensity = 0.05f;
	2156	g_fSnippetSize = 3.0f;
	2157
	2158	g_iNumberOfIteration = 10;
	2159	g_iAlgorithmMethod = 1;
	2160	g_iPhotonMapSize = 64;
	2161
	2162	// Reset the HUD
	2163	g_HUD.GetCheckBox( IDC_SHADOW_CHECK_BOX )->SetChecked( g_bShadowON );
	2164	g_HUD.GetCheckBox( IDC_CAUSTICS_CHECK_BOX )->SetChecked( g_bCausticsON );
	2165	g_HUD.GetCheckBox( IDC_CENTEROBJ_CHECK_BOX )->SetChecked( g_bRenderCenterObjectWithBrdfON );
	2166	g_HUD.GetCheckBox( IDC_SNIPPET_SIZE_IS_CONSTANT_CHECK_BOX )->SetChecked( g_bSnippetSizeIsConstant );
	2167	g_HUD.GetCheckBox( IDC_SHOW_PHOTON_MAP_CHECK_BOX )->SetChecked( g_bShowPhotonMap );
	2168
	2169	g_HUD.GetRadioButton( IDC_DISTANCE_IMPOSTOR_METHOD )->SetChecked( true );
	2170
	2171	g_HUD.GetSlider( IDC_NUMBER_OF_ITERATION_SLIDER )->SetValue( g_iNumberOfIteration );
	2172	g_HUD.GetSlider( IDC_FRESNEL_FACTOR_SLIDER )->SetValue( (int)( g_fFresnelFactor * 100 ) );
	2173	g_HUD.GetSlider( IDC_REFRACTION_INDEX_SLIDER )->SetValue( (int)( g_fRefractionIndex * 100 + 1 ) );
	2174	g_HUD.GetSlider( IDC_SHADOW_INTENSITY_SLIDER )->SetValue( (int)( g_fShadowIntensity * 100 ) );
	2175	g_HUD.GetSlider( IDC_CAUSTICS_INTENSITY_SLIDER )->SetValue( (int)( ( log( g_fCausticsIntensity ) / log ( 1.2f ) ) * 100.0f ) );
	2176	g_HUD.GetSlider( IDC_SNIPPET_SIZE_SLIDER )->SetValue( (int)g_fSnippetSize * 100 );
	2177	g_HUD.GetSlider( IDC_PHOTON_MAP_SIZE_SLIDER )->SetValue( (int)( log( (float)g_iPhotonMapSize ) / log( 2.0f ) ) );
	2178
	2179
	2180	CreateVertexBuffer();
	2181	g_bRunGenerateCaustics = true;
	2182	break;
	2183	}
	2184
	2185	// Regenerate caustics to show changes
	2186	g_bRunGenerateCaustics = true;
	2187	}
	2188
	2189
	2190	//--------------------------------------------------------------------------------------
	2191	// This callback function will be called immediately after the Direct3D device has
	2192	// entered a lost state and before IDirect3DDevice9::Reset is called. Resources created
	2193	// in the OnResetDevice callback should be released here, which generally includes all
	2194	// D3DPOOL_DEFAULT resources. See the "Lost Devices" section of the documentation for
	2195	// information about lost devices.
	2196	//--------------------------------------------------------------------------------------
	2197	void CALLBACK OnLostDevice()
	2198	{
	2199	if( g_pFont )
	2200	g_pFont->OnLostDevice();
	2201	if( g_pEffect )
	2202	g_pEffect->OnLostDevice();
	2203
	2204	SAFE_RELEASE( g_pTextSprite );
	2205
	2206
	2207	SAFE_RELEASE( g_pRoomCubeMapColorDistTexture );
	2208	SAFE_RELEASE( g_pPowerOfSnippetTexelTexture );
	2209	SAFE_RELEASE( g_pRoomCubeMapUVTexture );
	2210	SAFE_RELEASE( g_pShadowMapTexture );
	2211	SAFE_RELEASE( g_pRoomLastTexture );
	2212	SAFE_RELEASE( g_pRoomModifyTexture );
	2213	SAFE_RELEASE( g_pPhotonUVTexture );
	2214	SAFE_RELEASE( g_pRoomTexture );
	2215
	2216	for(int i = 0; i < 4; i++)
	2217	{
	2218	SAFE_RELEASE( g_pColumnModifyTexture[i] );
	2219	}
	2220	for(int i = 0; i < 5; i++)
	2221	{
	2222	SAFE_RELEASE( g_pColumnLastTexture[i] );
	2223	}
	2224
	2225	SAFE_RELEASE( g_pDepthStencilSurface );
	2226	SAFE_RELEASE( g_pRoomCubeMapDepthStencilSurface );
	2227	SAFE_RELEASE( g_pShadowMapDepthStencilSSurface );
	2228	SAFE_RELEASE( g_pPhotonUVMapSurface );
	2229	SAFE_RELEASE( g_pShadowMapSurface );
	2230	SAFE_RELEASE( g_pPhotonMapDepthStencilSurface );
	2231	SAFE_RELEASE( g_pRoomLastSurface );
	2232	SAFE_RELEASE( g_pRoomModifySurface );
	2233	SAFE_RELEASE( g_pRoomSurface );
	2234
	2235	for(int i = 0; i < 4; i++)
	2236	{
	2237	SAFE_RELEASE( g_pColumnsModifySurface[i] );
	2238	}
	2239	for(int i = 0; i < 5; i++)
	2240	{
	2241	SAFE_RELEASE( g_pColumnsLastSurface[i] );
	2242	}
	2243
	2244	SAFE_RELEASE( g_pFullScreenQuadVertexDeclaration );
	2245	SAFE_RELEASE( g_pFullScreenQuadVertexBuffer );
	2246	SAFE_RELEASE( g_pSnippetVertexDeclaration );
	2247	SAFE_RELEASE( g_bSnippetVertexBuffer );
	2248	}
	2249
	2250	//--------------------------------------------------------------------------------------
	2251	// This callback function will be called immediately after the Direct3D device has
	2252	// been destroyed, which generally happens as a result of application termination or
	2253	// windowed/full screen toggles. Resources created in the OnCreateDevice callback
	2254	// should be released here, which generally includes all D3DPOOL_MANAGED resources.
	2255	//--------------------------------------------------------------------------------------
	2256	void CALLBACK OnDestroyDevice()
	2257	{
	2258	SAFE_RELEASE( g_pFullScreenQuadVertexDeclaration );
	2259	SAFE_RELEASE( g_pFullScreenQuadVertexBuffer );
	2260	SAFE_RELEASE( g_pSnippetVertexDeclaration );
	2261	SAFE_RELEASE( g_bSnippetVertexBuffer );
	2262	SAFE_RELEASE( g_pCenterObjectMesh );
	2263	SAFE_RELEASE( g_pColumnMesh );
	2264	SAFE_RELEASE( g_pLightMesh );
	2265	SAFE_RELEASE( g_pRoomMesh );
	2266	SAFE_RELEASE( g_pEffect );
	2267	SAFE_RELEASE( g_pFont );
	2268	}

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

Context Navigation

source: GTP/trunk/App/Demos/Illum/RayTraceEffects/RayTraceEffects.cpp @ 2494

Download in other formats: