/**
  \file 
  \brief Performs DirectX initialization via DXUT callback functions. Adds some additional helper functions to
  \brief support screenshot capturing.

  - Performs DirectX initialization via DXUT callback functions

  - Adds some additional helper functions to support screenshot capturing.

  \author Istvan Lazanyi, TU Budapest
  \date   2006-04-26
*/

//--------------------------------------------------------------------------------------
// Main.cpp:
// - DirectX initialization
// - create resources (textures)
//--------------------------------------------------------------------------------------

#include "dxstdafx.h" 
#include "resource.h" 
#include <math.h>
#include <stdio.h>
#include <time.h>

//#define DEBUG_VS   // Uncomment this line to debug vertex shaders 
//#define DEBUG_PS   // Uncomment this line to debug pixel shaders  

#include "Cube.h"
#include "Mesh.h"
#include "Parameters.h"
#include "EnvMap.h"

const int WIDTH = 640;
const int HEIGHT = 640;
const int CHARBUFFER_SIZE = 200;

//--------------------------------------------------------------------------------------
// Global variables
//--------------------------------------------------------------------------------------

IDirect3DDevice9*			g_pd3dDevice;
ID3DXEffect*				g_pEffect;

CDXUTDialogResourceManager	g_DialogResourceManager;	///< Manager for shared resources of dialogs
CD3DSettingsDlg				g_SettingsDlg;				///< Device settings dialog
CDXUTDialog					g_HUD;						///< Dialog for sample specific controls

ID3DXFont*					g_pFont;					///< Font for drawing text
ID3DXSprite*				g_pTextSprite;				///< Sprite for batching draw text calls

IDirect3DSurface9*			g_pSaveSurface;				///< surface for screenshot capturing
bool						bSavingScreenshot = false;	///< boolean for screenshot capturing
int							counter = 0;				///< counter for screenshots (see GenerateNewFileName())

HRESULT hr;

EnvMap* envmapRenderer = new EnvMap();	///< problem-specific stuff
Parameters pp;							///< managing parameters of the algorithm

CModelViewerCamera camera;				///< camera


//--------------------------------------------------------------------------------------
// Forward declarations (CALLBACK)
//--------------------------------------------------------------------------------------
bool    CALLBACK IsDeviceAcceptable( D3DCAPS9* pCaps, D3DFORMAT AdapterFormat, D3DFORMAT BackBufferFormat, bool bWindowed, void* pUserContext );
bool	CALLBACK ModifyDeviceSettings( DXUTDeviceSettings* pDeviceSettings, const D3DCAPS9* pCaps, void* pUserContext );
HRESULT CALLBACK OnCreateDevice( IDirect3DDevice9* g_pd3dDevice, const D3DSURFACE_DESC* pBackBufferSurfaceDesc, void* pUserContext );
HRESULT CALLBACK OnResetDevice( IDirect3DDevice9* g_pd3dDevice, const D3DSURFACE_DESC* pBackBufferSurfaceDesc, void* pUserContext );
void    CALLBACK OnFrameMove( IDirect3DDevice9* g_pd3dDevice, double fTime, float fElapsedTime, void* pUserContext );
void    CALLBACK OnFrameRender( IDirect3DDevice9* g_pd3dDevice, double fTime, float fElapsedTime, void* pUserContext );
LRESULT CALLBACK MsgProc( HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam, bool* pbNoFurtherProcessing, void* pUserContext );
void    CALLBACK KeyboardProc( UINT nChar, bool bKeyDown, bool bAltDown, void* pUserContext );
void    CALLBACK OnGUIEvent( UINT nEvent, int nControlID, CDXUTControl* pControl, void* pUserContext );
void    CALLBACK OnLostDevice( void* pUserContext );
void    CALLBACK OnDestroyDevice( void* pUserContext );
void	InitParams();
void	RenderText(); 

//--------------------------------------------------------------------------------------
// Forward declarations 
//--------------------------------------------------------------------------------------

void SaveCameraPosition( char* fileName );
void LoadCameraPosition( char* fileName );
int GenerateNewFileName( int& counter );

//--------------------------------------------------------------------------------------
/// \brief Entry point to the program. 
/// 
/// Initializes everything and goes into a message processing loop. Idle time is used to render the scene.
//--------------------------------------------------------------------------------------

INT WINAPI WinMain( HINSTANCE, HINSTANCE, LPSTR, int )
{
    // Enable run-time memory check for debug builds.
#if defined(DEBUG) | defined(_DEBUG)
    _CrtSetDbgFlag( _CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF );
#endif

    DXUTSetCallbackDeviceCreated( OnCreateDevice );
    DXUTSetCallbackDeviceReset( OnResetDevice );
    DXUTSetCallbackDeviceLost( OnLostDevice );
    DXUTSetCallbackDeviceDestroyed( OnDestroyDevice );
    DXUTSetCallbackMsgProc( MsgProc );
    DXUTSetCallbackKeyboard( KeyboardProc );
    DXUTSetCallbackFrameRender( OnFrameRender );
    DXUTSetCallbackFrameMove( OnFrameMove );

	InitParams();

	// Show the cursor and clip it when in full screen
    DXUTSetCursorSettings( true, true );

	DXUTInit( true, true, true ); // Parse the command line, handle the default hotkeys, and show msgboxes
    DXUTCreateWindow( L"Environment Mapping Demo" );
    DXUTCreateDevice( D3DADAPTER_DEFAULT, true, WIDTH, HEIGHT, IsDeviceAcceptable, ModifyDeviceSettings );

	camera.SetButtonMasks( 0, MOUSE_WHEEL, MOUSE_LEFT_BUTTON );

    DXUTMainLoop();

    return DXUTGetExitCode();
}

/// \brief DXUT callback (called by the framework in case of GUI events). 
void CALLBACK OnGUIEvent( UINT nEvent, int nControlID, CDXUTControl* pControl, void* pUserContext )
{
	pp.UpdateFromHUD( nControlID );
}

void OnLoad() {
	LoadCameraPosition( ".matrix" );
}

void OnSave() {
	SaveCameraPosition( ".matrix" );
	bSavingScreenshot = true;
}

void OnReset() {}

float Exponent(float f) { 
	return 0.01f * pow(50.0f, 2*f);
}

void OnChangeCubeMap() { 
	//bool bEnable = !pp.Get( bUseIrradianceMap ) && !pp.Get( bCubeMapFromFile ) ;
	//pp.SetEnabled( bUseImpostors, bEnable );

	envmapRenderer->InvalidateCubeMap();
}

void OnChangeShininess() { 

	envmapRenderer->InvalidateShininess();
}

//--------------------------------------------------------------------------------------
/// \brief Defines application-specific parameters and creates GUI controls (sliders, checkboxes) for them.
/// 
/// Finally, loads initial values for the parameters from file called <b>.params0</b> (Reset).
//--------------------------------------------------------------------------------------
void InitParams()
{
	g_SettingsDlg.Init( &g_DialogResourceManager );
	g_HUD.Init( &g_DialogResourceManager );
	g_HUD.SetCallback( OnGUIEvent );	// Event handling

	//pp.Setup( &g_HUD );
	pp.Setup( &g_HUD, OnReset, OnSave, OnLoad );	// you can add callbacks to these actions

	//typedef enum { bShowHelp, bUseImpostors, LAST_BOOL } bool_t;
	//typedef enum { iShowCubeMap, sFresnel, refractionIndex, /*iLoadedCenterObjectMeshID,LAST_NUMBER } number_t;

	pp.Add( bShowHelp, "Help [F1]", VK_F1 );				// checkboxes
	pp.Add( bCubeMapFromFile, "CubeMapFrom[F]ile", 'F', OnChangeCubeMap );
	pp.Add( bAutoGenCubeMap, "[A]utoGenCubeMap", 'A' );
	//pp.Add( bLocalize, "L[O]CALIZE LOOKUPS", 'O' );
	//pp.Add( bUseCosTexture, "[G]eometric factor with texture lookup", 'O' /*, OnChangeCubeMap*/ );
	
	pp.Add( iWhichMethod, "WhichMethod [TAB,Q]", 4, VK_TAB, 'Q', noconvert, OnChangeCubeMap );	// sliders
	pp.Add( iWhichMetal, "WhichMetal [M]", 4, 'M' );	// sliders
	pp.Add( iShowCubeMap, "ShowCubeMap [C]", 3, 'C' );	// sliders
	pp.Add( sFresnel, "Fresnel [W,E]", 100, 'W', 'E' );
	pp.Add( refractionIndex, "RefractionIndex [I,O]", 100, 'I', 'O' );
	pp.Add( fIntensity, "Intensity [+,-]", 100, VK_SUBTRACT, VK_ADD, Exponent );
	pp.Add( iShininess, "shininess [/,*]", 30, VK_DIVIDE, VK_MULTIPLY, noconvert, OnChangeShininess );

	//pp.SetEnabled( bUseImpostors, false );
	//pp.SetEnabled( sFresnel, false );

	pp.UpdateFromHUD( IDC_RESET_BUTTON );	// do a reset
}

//--------------------------------------------------------------------------------------
/// \brief DXUT callback (Rejects any devices that aren't acceptable by returning false)
///
/// DXUT callback. Rejects any devices that aren't acceptable by returning false.
//--------------------------------------------------------------------------------------
bool CALLBACK IsDeviceAcceptable( D3DCAPS9* pCaps, D3DFORMAT AdapterFormat, 
                                  D3DFORMAT BackBufferFormat, bool bWindowed, void* pUserContext )
{
    // Skip backbuffer formats that don't support alpha blending
    IDirect3D9* pD3D = DXUTGetD3DObject(); 
    if( FAILED( pD3D->CheckDeviceFormat( pCaps->AdapterOrdinal, pCaps->DeviceType,
                    AdapterFormat, D3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING, 
                    D3DRTYPE_TEXTURE, BackBufferFormat ) ) )
        return false;

    return true;
}

//--------------------------------------------------------------------------------------
/// \brief DXUT callback (Before a device is created, modifies the device settings as needed)
//--------------------------------------------------------------------------------------
bool CALLBACK ModifyDeviceSettings( DXUTDeviceSettings* pDeviceSettings, const D3DCAPS9* pCaps, void* pUserContext )
{
	// VSync off
	pDeviceSettings->pp.PresentationInterval = D3DPRESENT_INTERVAL_IMMEDIATE;

    // If device doesn't support HW T&L or doesn't support 1.1 vertex shaders in HW 
    // then switch to SWVP.
    if( (pCaps->DevCaps & D3DDEVCAPS_HWTRANSFORMANDLIGHT) == 0 ||
         pCaps->VertexShaderVersion < D3DVS_VERSION(1,1) )
		pDeviceSettings->BehaviorFlags = D3DCREATE_SOFTWARE_VERTEXPROCESSING;
    else
		pDeviceSettings->BehaviorFlags = D3DCREATE_HARDWARE_VERTEXPROCESSING;

    // This application is designed to work on a pure device by not using 
    // IDirect3D9::Get*() methods, so create a pure device if supported and using HWVP.
    if ((pCaps->DevCaps & D3DDEVCAPS_PUREDEVICE) != 0 && 
        (pDeviceSettings->BehaviorFlags & D3DCREATE_HARDWARE_VERTEXPROCESSING) != 0 )
        pDeviceSettings->BehaviorFlags |= D3DCREATE_PUREDEVICE;

    // Debugging vertex shaders requires either REF or software vertex processing 
    // and debugging pixel shaders requires REF.  
#ifdef DEBUG_VS
    if( pDeviceSettings->DeviceType != D3DDEVTYPE_REF )
    {
        pDeviceSettings->BehaviorFlags &= ~D3DCREATE_HARDWARE_VERTEXPROCESSING;
        pDeviceSettings->BehaviorFlags &= ~D3DCREATE_PUREDEVICE;                            
        pDeviceSettings->BehaviorFlags |= D3DCREATE_SOFTWARE_VERTEXPROCESSING;
    }
#endif
#ifdef DEBUG_PS
    pDeviceSettings->DeviceType = D3DDEVTYPE_REF;
#endif

	// For the first device created if its a REF device, optionally display a warning dialog box
    static bool s_bFirstTime = true;
    if( s_bFirstTime )
    {
        s_bFirstTime = false;
        if( pDeviceSettings->DeviceType == D3DDEVTYPE_REF )
            DXUTDisplaySwitchingToREFWarning();
    }
	return true;
}

//--------------------------------------------------------------------------------------
/// @brief DXUT callback (You should create any D3DPOOL_MANAGED resources here)
///
/// Compiles the effect file (EnvMap.fx) and displays error message if compilation fails. 
/// Finally, forwards call to EnvMap::OnCreateDevice.
//--------------------------------------------------------------------------------------
HRESULT CALLBACK OnCreateDevice( IDirect3DDevice9* pd3dDevice, const D3DSURFACE_DESC* pBackBufferSurfaceDesc, void* pUserContext )
{
	::g_pd3dDevice = pd3dDevice;

	HRESULT hr;

    V_RETURN( g_DialogResourceManager.OnCreateDevice( g_pd3dDevice ) );
    V_RETURN( g_SettingsDlg.OnCreateDevice( g_pd3dDevice ) );

    // Initialize the font
    V_RETURN( D3DXCreateFont( g_pd3dDevice, 15, 0, FW_BOLD, 1, FALSE, DEFAULT_CHARSET, 
                         OUT_DEFAULT_PRECIS, DEFAULT_QUALITY, DEFAULT_PITCH | FF_DONTCARE, 
                         L"Arial", &g_pFont ) );

	
	// ----------- fx compilation options -----------

	LPCWSTR fileName = L"EnvMap.fx";

	DWORD dwShaderFlags = 0;
    #ifdef DEBUG_VS
        dwShaderFlags |= D3DXSHADER_FORCE_VS_SOFTWARE_NOOPT; 
    #endif
    #ifdef DEBUG_PS
        dwShaderFlags |= D3DXSHADER_FORCE_PS_SOFTWARE_NOOPT;
    #endif

	dwShaderFlags |= D3DXSHADER_SKIPOPTIMIZATION;

	// ----------- compiling fx file -----------

	long clock1 = clock();

	ID3DXBuffer* errBuff;	// buffer for error message

	if (FAILED(hr = D3DXCreateEffectFromFile( g_pd3dDevice, fileName, NULL, NULL, dwShaderFlags, 
                                        NULL, &g_pEffect, &errBuff )))	// if compilation error occurs
	{
		int BufSize = errBuff->GetBufferSize();

		wchar_t* wbuf = new wchar_t[BufSize];
		mbstowcs( wbuf, (const char*)errBuff->GetBufferPointer(), BufSize );
		MessageBox(NULL, wbuf, L".fx Compilation Error", MB_ICONERROR);		// error message

		delete wbuf;
		exit(-1);
	}

	long clock2 = clock();
	float tb = (float)(clock2-clock1)/CLOCKS_PER_SEC;

	wchar_t wbuf[100];
	swprintf( wbuf, L"Compilation took %f sec", tb );
    //MessageBox(NULL, wbuf, L"Info", MB_ICONINFORMATION);

	envmapRenderer->OnCreateDevice( g_pd3dDevice, g_pEffect );

	float initialEyeDist = 6.82;
	D3DXVECTOR3 vecEye(0, 0, -initialEyeDist);
	D3DXVECTOR3 vecAt (0.0f, 0.0f, -0.0f);
	camera.SetViewParams( &vecEye, &vecAt );

	return S_OK;
}

//--------------------------------------------------------------------------------------
/// \brief DXUT callback (You should release resources created in the OnCreateDevice callback here)
///
/// Forwards call to EnvMap::OnDestroyDevice.
//--------------------------------------------------------------------------------------
void CALLBACK OnDestroyDevice( void* pUserContext )
{
    g_DialogResourceManager.OnDestroyDevice();
    g_SettingsDlg.OnDestroyDevice();

    SAFE_RELEASE(g_pEffect);
    SAFE_RELEASE(g_pFont);

	envmapRenderer->OnDestroyDevice();
}


//--------------------------------------------------------------------------------------
/// \brief DXUT callback (You should create any D3DPOOL_DEFAULT resources here)
///
/// Resets camera and HUD elements. Initializes #g_pSaveSurface according to the 
/// current screen resolution. 
/// Then it forwards call to EnvMap::OnResetDevice.
//--------------------------------------------------------------------------------------
HRESULT CALLBACK OnResetDevice( IDirect3DDevice9* g_pd3dDevice, const D3DSURFACE_DESC* pBackBufferSurfaceDesc, void* pUserContext )
{ 
    HRESULT hr;

    V_RETURN( g_DialogResourceManager.OnResetDevice() );
    V_RETURN( g_SettingsDlg.OnResetDevice() );

    if( g_pFont )   V_RETURN( g_pFont->OnResetDevice() );
    if( g_pEffect ) V_RETURN( g_pEffect->OnResetDevice() );

    // Create a sprite to help batch calls when drawing many lines of text
    V_RETURN( D3DXCreateSprite( g_pd3dDevice, &g_pTextSprite ) );

	// Create a surface to save screenshots
	IDirect3DTexture9* pSaveTexture	= NULL;

	V( D3DXCreateTexture( g_pd3dDevice, pBackBufferSurfaceDesc->Width, pBackBufferSurfaceDesc->Height, 1, 
	//V( D3DXCreateTexture( g_pd3dDevice, 64, 64, 1, 
		D3DUSAGE_RENDERTARGET, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, &pSaveTexture) );
	pSaveTexture->GetSurfaceLevel( 0, &g_pSaveSurface );
	SAFE_RELEASE( pSaveTexture );

	// Setup the camera's projection parameters
    float fAspectRatio = pBackBufferSurfaceDesc->Width / (FLOAT)pBackBufferSurfaceDesc->Height;

	camera.SetProjParams( D3DX_PI/4, fAspectRatio, 0.1, 100 );
    camera.SetWindow( pBackBufferSurfaceDesc->Width, pBackBufferSurfaceDesc->Height );

	envmapRenderer->OnResetDevice();

    // Position the on-screen dialog
    g_HUD.SetLocation( 0, 0 );
    g_HUD.SetSize( pBackBufferSurfaceDesc->Width, pBackBufferSurfaceDesc->Height );

    return S_OK;
}

//--------------------------------------------------------------------------------------
/// DXUT callback (You should release resources created in the OnResetDevice callback here) 
//--------------------------------------------------------------------------------------
void CALLBACK OnLostDevice( void* pUserContext )
{
    g_DialogResourceManager.OnLostDevice();
    g_SettingsDlg.OnLostDevice();

    if( g_pFont )	g_pFont->OnLostDevice();
    if( g_pEffect )	g_pEffect->OnLostDevice();

    SAFE_RELEASE( g_pTextSprite );
	SAFE_RELEASE( g_pSaveSurface );

	envmapRenderer->OnLostDevice();
}

//--------------------------------------------------------------------------------------
/// \brief DXUT callback (Message processing). 
/// 
/// Forwards messages to the DirectX settings window, the GUI controls or the camera, respecively.
//--------------------------------------------------------------------------------------
LRESULT CALLBACK MsgProc( HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam, bool* pbNoFurtherProcessing, void* pUserContext )
{
    // Always allow dialog resource manager calls to handle global messages
    // so GUI state is updated correctly
    *pbNoFurtherProcessing = g_DialogResourceManager.MsgProc( hWnd, uMsg, wParam, lParam );
    if( *pbNoFurtherProcessing )
        return 0;

    if( g_SettingsDlg.IsActive() )
    {
        g_SettingsDlg.MsgProc( hWnd, uMsg, wParam, lParam );
        return 0;
    }

	// Give the dialogs a chance to handle the message first
    *pbNoFurtherProcessing = g_HUD.MsgProc( hWnd, uMsg, wParam, lParam );
    if( *pbNoFurtherProcessing )
        return 0;

    // Pass all remaining windows messages to camera so it can respond to user input
	camera.HandleMessages( hWnd, uMsg, wParam, lParam );

    return 0;
}

//--------------------------------------------------------------------------------------
/// \brief DXUT callback (Handle updates to the scene)
//--------------------------------------------------------------------------------------
void CALLBACK OnFrameMove( IDirect3DDevice9* g_pd3dDevice, double fTime, float fElapsedTime, void* pUserContext )
{
    camera.FrameMove( fElapsedTime );
}

//--------------------------------------------------------------------------------------
/// \brief DXUT callback (Render the scene). Also responsible for screenshot taking.
///
/// If a screenshot is being taken (#bSavingScreenshot), sets #g_pSaveSurface as the render target
/// and saves it to a non-existent file (GenerateNewFileName()). Also saves current camera parameters (SaveCameraPosition()).
///
/// To perform actual rendering, it forwards call to EnvMap::OnFrameRender with current camera matrices.
//--------------------------------------------------------------------------------------
void CALLBACK OnFrameRender( IDirect3DDevice9* g_pd3dDevice, double fTime, float fElapsedTime, void* pUserContext )
{
    // If the settings dialog is being shown, then
    // render it instead of rendering the app's scene
    if( g_SettingsDlg.IsActive() )
    {
        g_SettingsDlg.OnRender( fElapsedTime );
        return;
    }

	IDirect3DSurface9* oldRenderTarget = NULL;
	if (bSavingScreenshot) {
		V( g_pd3dDevice->GetRenderTarget(0, &oldRenderTarget) );
		V( g_pd3dDevice->SetRenderTarget(0, g_pSaveSurface) );
	}


	V( g_pd3dDevice->BeginScene() );


		D3DXMATRIXA16 mView = *camera.GetViewMatrix();
		D3DXMATRIXA16 mProj = *camera.GetProjMatrix();

		envmapRenderer->camera = &camera;
		envmapRenderer->OnFrameRender( g_pd3dDevice, mView, mProj );
		
		if (!bSavingScreenshot)
		{
			RenderText();
			V( g_HUD.OnRender( fElapsedTime ) );
		}

	V( g_pd3dDevice->EndScene() );


	if (bSavingScreenshot)
	{
		// saving surface
		char buf[CHARBUFFER_SIZE];
		wchar_t wbuf[CHARBUFFER_SIZE];

		GenerateNewFileName( counter );
		sprintf(buf, "shots\\%03i.png", counter);
		mbstowcs( wbuf, buf, CHARBUFFER_SIZE );

		D3DXSaveSurfaceToFileW(wbuf, D3DXIFF_PNG, g_pSaveSurface, NULL, NULL);

		sprintf(buf, "shots\\%03i", counter);
		pp.SaveToFile( buf );

		sprintf(buf, "shots\\%03i.matrix", counter);
		SaveCameraPosition( buf );

		g_pd3dDevice->SetRenderTarget(0, oldRenderTarget);
		bSavingScreenshot = false;
	}
}

//--------------------------------------------------------------------------------------
/// \brief Generates a non-existing filename to store the screenshot in the <b>shots</b> directory.
///
/// Generated file names are shots/000.png, shots/001.png, ...
//--------------------------------------------------------------------------------------

int GenerateNewFileName( int& counter )
{
	char buf[CHARBUFFER_SIZE];
	FILE* f;
	do {
		sprintf(buf, "shots\\%03i.png", counter);
		if ( (f = fopen(buf, "rt")) != NULL )
		{
			fclose( f );
			counter++;
		}
	} while (f != NULL);
	return counter;
}

//--------------------------------------------------------------------------------------
/// \brief DXUT callback (Keystroke messages)
//--------------------------------------------------------------------------------------
void CALLBACK KeyboardProc( UINT nChar, bool bKeyDown, bool bAltDown, void* pUserContext )
{
	envmapRenderer->KeyboardProc( nChar, bKeyDown, bAltDown );
}

//--------------------------------------------------------------------------------------
/// \brief Writes current camera settings to file. 
///
/// Writes current #camera settings (world matrix and camera position) to file.
/// Useful when capturing multiple screenshots from the same view.
/// \param fileName the name of the file to be created
//--------------------------------------------------------------------------------------

void SaveCameraPosition( char* fileName )
{
	// save parameters to file:
	// world matrix (4x4)
	// camera position (3)

	// save world matrix
	D3DXMATRIXA16 W = *camera.GetViewMatrix();

	FILE* f;

	if ((f = fopen(fileName, "wt")) == NULL)
	{
		wchar_t wbuf[CHARBUFFER_SIZE];
		mbstowcs( wbuf, fileName, CHARBUFFER_SIZE );
        MessageBox(NULL, wbuf, L"File creation failed!", MB_ICONEXCLAMATION);
		return;
	}

	fprintf(f, "\n");
	fprintf(f, "World matrix:\n");
	fprintf(f, "%10.4g %10.4g %10.4g %10.4g\n", W._11, W._12, W._13, W._14);
	fprintf(f, "%10.4g %10.4g %10.4g %10.4g\n", W._21, W._22, W._23, W._24);
	fprintf(f, "%10.4g %10.4g %10.4g %10.4g\n", W._31, W._32, W._33, W._34);
	fprintf(f, "%10.4g %10.4g %10.4g %10.4g\n", W._41, W._42, W._43, W._44);

	// save camera position
	fprintf(f, "\n");
	fprintf(f, "Camera position:\n");
	const D3DXVECTOR3* eye = camera.GetEyePt();
	fprintf(f, "%10g %10g %10g", eye->x, eye->y, eye->z);
	fprintf(f, "\n");

	fclose(f);
}

//--------------------------------------------------------------------------------------
/// \brief Loads camera settings from file. 
///
/// Loads #camera settings (world matrix and camera position) from an existing file.
/// Useful when capturing multiple screenshots from the same view.
/// \param fileName the name of the file to load from.
//--------------------------------------------------------------------------------------

void LoadCameraPosition( char* fileName )
{
	FILE* f; 

	if ((f = fopen(fileName, "rt")) == NULL) {
		wchar_t wbuf[CHARBUFFER_SIZE];
		mbstowcs( wbuf, fileName, CHARBUFFER_SIZE );
        MessageBox(NULL, wbuf, L"File not found!", MB_ICONEXCLAMATION);
		return;
	}

	const int BufSize = 500;	// size of char buffers 
	char buf[BufSize];
	D3DXMATRIXA16 W;

	fgets(buf, BufSize, f);		// skip comment
	fgets(buf, BufSize, f);		// skip comment
	fgets(buf, BufSize, f);		sscanf(buf, "%f %f %f %f", &W._11, &W._12, &W._13, &W._14);
	fgets(buf, BufSize, f);		sscanf(buf, "%f %f %f %f", &W._21, &W._22, &W._23, &W._24);
	fgets(buf, BufSize, f);		sscanf(buf, "%f %f %f %f", &W._31, &W._32, &W._33, &W._34);
	fgets(buf, BufSize, f);		sscanf(buf, "%f %f %f %f", &W._41, &W._42, &W._43, &W._44);

	// load camera position
	D3DXVECTOR3 vecAt(0.0f, 0.0f, 0.0f);
	D3DXVECTOR3 vecEye;
	fgets(buf, BufSize, f);		// skip comment
	fgets(buf, BufSize, f);		// skip comment
	fgets(buf, BufSize, f);		sscanf(buf, "%f %f %f", &vecEye.x, &vecEye.y, &vecEye.z);

	fclose(f);

	camera.SetViewParams( &vecEye, &vecAt );

	D3DXQUATERNION q;
	D3DXQuaternionRotationMatrix(&q, &W);
	camera.SetViewQuat(q);
}

//--------------------------------------------------------------------------------------
/// \brief Util function. Creates an empty texture that shall be used as render target.
///
/// Note that render targets (D3DUSAGE_RENDERTARGET) must be created in the default memory pool (D3DPOOL_DEFAULT).
/// @param size size of the new texture
/// @param format format of the new texture (eg. D3DFMT_A32B32G32R32F)
//--------------------------------------------------------------------------------------
IDirect3DTexture9* CreateTexture( int size, D3DFORMAT Format )
{
	HRESULT hr;
	IDirect3DTexture9* pTexture;
	V( g_pd3dDevice->CreateTexture(	size, size,		// dimensions
									1,				// mipmap levels
									D3DUSAGE_RENDERTARGET, // usage
									Format,			
									D3DPOOL_DEFAULT,// memory pool
									&pTexture, NULL ) );
	return pTexture;
}

//--------------------------------------------------------------------------------------
/// \brief Util function. Creates an empty cubemap texture that shall be used as render target.
///
/// @param size size of the new texture
/// @param format format of the new texture (eg. D3DFMT_A32B32G32R32F)
//--------------------------------------------------------------------------------------

IDirect3DCubeTexture9* CreateCubeTexture( int size, D3DFORMAT Format )
{
	HRESULT hr;
	IDirect3DCubeTexture9* pCubeTexture;
	V( g_pd3dDevice->CreateCubeTexture(	size, 1, D3DUSAGE_RENDERTARGET,
										Format, D3DPOOL_DEFAULT, &pCubeTexture, NULL ) );
	return pCubeTexture;
}

//--------------------------------------------------------------------------------------
/// \brief Renders help and statistics text and displays algorithmic-specific parameters.
///
/// - Statistics: FPS value, screen resolution
///
/// - Help: displays avaliable keyboard shortcuts after the user presses F1.
///
/// - Algorithmic-specific parameters: describes the currently selected method and 
/// displays its most important parameters.
//--------------------------------------------------------------------------------------
void RenderText()
{
	const D3DSURFACE_DESC* backBufferDesc = DXUTGetBackBufferSurfaceDesc();

    CDXUTTextHelper txtHelper( g_pFont, g_pTextSprite, 15 );
    txtHelper.Begin();

	txtHelper.SetInsertionPos( 5, 5 );
	txtHelper.SetForegroundColor( D3DXCOLOR( 1.0f, 1.0f, 0.0f, 1.0f ) );

	txtHelper.DrawFormattedTextLine( L"%.2f fps @ %i x %i", 
		DXUTGetFPS(), backBufferDesc->Width, backBufferDesc->Height );
	//txtHelper.DrawTextLine( DXUTGetFrameStats() );
	txtHelper.DrawTextLine( DXUTGetDeviceStats() );
	txtHelper.DrawTextLine( L"" );
	
	txtHelper.SetInsertionPos( 30, 180 );
	txtHelper.SetForegroundColor( D3DXCOLOR( 1.0f, 1.0f, 1.0f, 1.0f ) );
	
	switch (pp.GetInt( iWhichMethod )) {
		case IDEAL:	
		case IDEAL_LOCALIZED:	
			if ( pp.GetInt( iWhichMethod ) == IDEAL ) {
				txtHelper.DrawFormattedTextLine( L"Method : Ideal reflection / refr."); break;
			}
			else
			if (!pp.Get( bCubeMapFromFile ))
				 txtHelper.DrawFormattedTextLine( L"Method : Ideal reflection / refr. using depth impostors"); 
			else txtHelper.DrawFormattedTextLine( L"Method : Ideal reflection / refr. (no depth info. available from file!)"); break;
		case DIFFUSE_SPECULAR:	
			if (pp.GetInt( iShininess ) > 0)
				txtHelper.DrawFormattedTextLine( L"Method : Specular reflections"); 
			else
				txtHelper.DrawFormattedTextLine( L"Method : Diffuse reflections"); 
			break;
		case DIFFUSE_SPECULAR_LOCALIZED:
			if (pp.GetInt( iShininess ) > 0)
				txtHelper.DrawFormattedTextLine( L"Method : Specular reflections with localization"); 
			else
				txtHelper.DrawFormattedTextLine( L"Method : Diffuse reflections with localization"); 
			break;
		case DIFFUSE_SPECULAR_LOCALIZED_COSTEX:
			if (pp.GetInt( iShininess ) > 0)
				txtHelper.DrawFormattedTextLine( L"Method : Specular reflections with localization and cos.texture"); 
			else
				txtHelper.DrawFormattedTextLine( L"Method : Diffuse reflections with localization and cos.texture"); 
			break;	}

	txtHelper.DrawFormattedTextLine( L"IOR : %.2f Fresnel : %.2f", pp.Get( refractionIndex ), pp.Get( sFresnel ));
	txtHelper.DrawFormattedTextLine( L"Shininess (s) : %i Intensity multiplier : %.2f", pp.GetInt( iShininess ), pp.Get( fIntensity ));

	D3DXVECTOR3 ref = envmapRenderer->GetReferencePos();
	txtHelper.DrawFormattedTextLine( L"Reference_pos: %.2g %.2g %.2g", ref.x, ref.y, ref.z);

	if (pp.GetInt( iWhichMethod ) == IDEAL)
	{
		switch (pp.GetInt( iWhichMetal )) {
			case 0: txtHelper.DrawFormattedTextLine( L""); break;
			case 1: txtHelper.DrawFormattedTextLine( L"Metal: COPPER"); break;
			case 2: txtHelper.DrawFormattedTextLine( L"Metal: GOLD"); break;
			case 3: txtHelper.DrawFormattedTextLine( L"Metal: SILVER"); break;
			case 4: txtHelper.DrawFormattedTextLine( L"Metal: ALUMINUM"); break;
		}
	}
	else txtHelper.DrawFormattedTextLine( L""); 

	txtHelper.SetForegroundColor( D3DXCOLOR( 1.0f, 1.0f, 0.0f, 1.0f ) );

	if ( pp.Get( bShowHelp ) )
	{
		txtHelper.SetInsertionPos( backBufferDesc->Width - 260, backBufferDesc->Height-24*15 );

		txtHelper.DrawTextLine( 
				L"Controls (F1 to hide):\n"
				L"___________________________________\n"
				L"                     GENERAL CONTROLS\n"
				L"Left click drag: Rotate mesh\n"
				L"Mouse wheel: Zoom\n"
				L"Arrow keys: Move object\n"
				//L"F2: Settings\n"
				//L"F3: Switch to REF device\n"
				L"F8: Switch to Wireframe mode\n"
				L"___________________________________\n"
				L"                             ALGORITHM\n"
				L"0-9: choose object mesh\n"
				L"TAB,Q: choose shading method\n"
				L"C: choose visualized cube map\n"
				L"A: refresh cube maps for every frame\n"
				L"L: LOCALIZE cube map lookups\n"
				L"SPACE: refresh cube maps MANUALLY\n"
				L"I,O: adjust Index of refraction (IOR)\n"
				L"W,E: adjust Fresnel term\n"
				L"gray +,-: adjust intensity\n"
				L"gray /,*: adjust specular shininess\n"
				L"___________________________________\n"
				L"                             UTILITIES\n"
				L"L: [L]oad params\n"
				L"S: [S]ave params & take SCREENSHOT\n"
				L"R: [R]eset params\n"
				L"___________________________________\n"
				L"                             Quit: ESC");
	}
	else
	{
		txtHelper.DrawTextLine( L"Press F1 for help" );
	}

	txtHelper.End();
}