bLois.cpp

//-----------------------------------------------------------------------------
// File: bLois.cpp
//
// Desc: DirectX window application created by the DirectX AppWizard
//-----------------------------------------------------------------------------
#define STRICT
#include <windows.h>
#include <commctrl.h>
#include <commdlg.h>
#include <basetsd.h>
#include <direct.h>
#include <math.h>
#include <stdio.h>
#include <d3dx9.h>
#include <dxerr9.h>
#include <tchar.h>
#include "DXUtil.h"
#include "D3DEnumeration.h"
#include "D3DSettings.h"
#include "D3DApp.h"
#include "D3DFont.h"
#include "D3DFile.h"
#include "D3DUtil.h"
#include "resource.h"
#include "bLois.h"
#include <algorithm>
#include <functional>

static float RandMinusOneToOne()
{
	return float( double(rand()) / double(RAND_MAX) * 2.0 - 1.0 );
}

static float RandZeroToOne()
{
	return float( double(rand()) / double(RAND_MAX) );
}

static const float kGravConst = 30.f;

class ClearVert
{
public:
	D3DXVECTOR3		m_Pos;
	D3DXVECTOR2		m_Uv;
};
static const int kVSize = sizeof(ClearVert);
static const DWORD kClearVertFVF = D3DFVF_XYZ | D3DFVF_TEX1 | D3DFVF_TEXCOORDSIZE2(0);


//-----------------------------------------------------------------------------
// Global access to the app (needed for the global WndProc())
//-----------------------------------------------------------------------------
CMyD3DApplication* g_pApp  = NULL;
HINSTANCE          g_hInst = NULL;




//-----------------------------------------------------------------------------
// Name: WinMain()
// Desc: 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 hInst, HINSTANCE, LPSTR, INT )
{
    CMyD3DApplication d3dApp;

    g_pApp  = &d3dApp;
    g_hInst = hInst;

    InitCommonControls();
    if( FAILED( d3dApp.Create( hInst ) ) )
        return 0;

    return d3dApp.Run();
}




//-----------------------------------------------------------------------------
// Name: CMyD3DApplication()
// Desc: Application constructor.   Paired with ~CMyD3DApplication()
//       Member variables should be initialized to a known state here.  
//       The application window has not yet been created and no Direct3D device 
//       has been created, so any initialization that depends on a window or 
//       Direct3D should be deferred to a later stage. 
//-----------------------------------------------------------------------------
CMyD3DApplication::CMyD3DApplication()
{
    m_dwCreationWidth           = 500;
    m_dwCreationHeight          = 375;
    m_strWindowTitle            = TEXT( "bLois" );
    m_d3dEnumeration.AppUsesDepthBuffer   = TRUE;
	m_bStartFullscreen			= false;
	m_bShowCursorWhenFullscreen	= false;

	m_bShowHelp = false;
	m_bSortWater = true;
	m_bDrawBump = false;
	m_LastToggle = 0.f;

    // Create a D3D font using d3dfont.cpp
    m_pFont                     = new CD3DFont( _T("Arial"), 12, D3DFONT_BOLD );
    m_bLoadingApp               = TRUE;

    memset(m_bKey, 0x00, sizeof(m_bKey));

    D3DXMatrixIdentity(&m_matView);
    D3DXMatrixIdentity(&m_matPosition);
    D3DXMatrixIdentity(&m_matProjection);

	m_CompCosinesEff = NULL;
	m_WaterEff = NULL;
	m_WaterMesh = NULL;
	m_LandMesh = NULL;
	m_PillarsMesh = NULL;

	m_EnvMap = NULL;
	m_LandTex = NULL;

	m_CosineLUT = NULL;
	m_BiasNoiseMap = NULL;
	
	m_BumpTex = NULL;
	m_BumpSurf = NULL;
	m_BumpRender = NULL;
	m_BumpVBuffer = NULL;

	m_WaterIndices = NULL;
	m_WaterFacePos = NULL;
	m_WaterSortData = NULL;


	ResetWater();
}




//-----------------------------------------------------------------------------
// Name: ~CMyD3DApplication()
// Desc: Application destructor.  Paired with CMyD3DApplication()
//-----------------------------------------------------------------------------
CMyD3DApplication::~CMyD3DApplication()
{
	delete [] m_WaterIndices;
	delete [] m_WaterFacePos;
	delete [] m_WaterSortData;
}




//-----------------------------------------------------------------------------
// Name: OneTimeSceneInit()
// Desc: Paired with FinalCleanup().
//       The window has been created and the IDirect3D9 interface has been
//       created, but the device has not been created yet.  Here you can
//       perform application-related initialization and cleanup that does
//       not depend on a device.
//-----------------------------------------------------------------------------
HRESULT CMyD3DApplication::OneTimeSceneInit()
{
    // TODO: perform one time initialization

    // Drawing loading status message until app finishes loading
    SendMessage( m_hWnd, WM_PAINT, 0, 0 );

    m_bLoadingApp = FALSE;

    // Misc stuff

	D3DXMatrixLookAtLH(&m_matView, 
		&D3DXVECTOR3(0.f, -150.f, 50.f),
		&D3DXVECTOR3(0.f, 0.f, 0.f),
		&D3DXVECTOR3(0.f, 0.f, 1.f));

    D3DXMatrixInverse(&m_matPosition, NULL, &m_matView);

    return S_OK;
}









//-----------------------------------------------------------------------------
// Name: ConfirmDevice()
// Desc: Called during device initialization, this code checks the display device
//       for some minimum set of capabilities
//-----------------------------------------------------------------------------
HRESULT CMyD3DApplication::ConfirmDevice( D3DCAPS9* pCaps, DWORD dwBehavior,
                                          D3DFORMAT Format )
{
    UNREFERENCED_PARAMETER( Format );
    UNREFERENCED_PARAMETER( dwBehavior );
    UNREFERENCED_PARAMETER( pCaps );
    
    BOOL bCapsAcceptable;

    // TODO: Perform checks to see if these display caps are acceptable.
    bCapsAcceptable = TRUE;

    if( bCapsAcceptable )         
        return S_OK;
    else
        return E_FAIL;
}




//-----------------------------------------------------------------------------
// Name: InitDeviceObjects()
// Desc: Paired with DeleteDeviceObjects()
//       The device has been created.  Resources that are not lost on
//       Reset() can be created here -- resources in D3DPOOL_MANAGED,
//       D3DPOOL_SCRATCH, or D3DPOOL_SYSTEMMEM.  Image surfaces created via
//       CreateImageSurface are never lost and can be created here.  Vertex
//       shaders and pixel shaders can also be created here as they are not
//       lost on Reset().
//-----------------------------------------------------------------------------
HRESULT CMyD3DApplication::InitDeviceObjects()
{
    // TODO: create device objects

    HRESULT hr;

    // Init the font
    m_pFont->InitDeviceObjects( m_pd3dDevice );

	if( FAILED(hr = CreateCosineLUT()) )
		return hr;

	if( FAILED(hr = CreateBiasNoiseMap()) )
		return hr;

	if( FAILED(hr = D3DXCreateCubeTextureFromFile( m_pd3dDevice, TEXT("nvlobby_new_cube_mipmap.dds"), &m_EnvMap)) )
        return DXTRACE_ERR( "EnvMap load", hr );

	if( FAILED(hr = D3DXCreateTextureFromFile( m_pd3dDevice, "Sandy.dds", &m_LandTex)) )
		return hr;

    if( FAILED(hr = D3DXLoadMeshFromX(TEXT("LandMesh.x"), D3DXMESH_MANAGED, m_pd3dDevice, NULL, NULL, NULL, NULL, &m_LandMesh)) )
		return hr;

    if( FAILED(hr = D3DXLoadMeshFromX(TEXT("pillars.x"), D3DXMESH_MANAGED, m_pd3dDevice, NULL, NULL, NULL, NULL, &m_PillarsMesh)) )
		return hr;

	ID3DXMesh* waterMesh = NULL;
    if( FAILED(hr = D3DXLoadMeshFromX(TEXT("WaterMesh.x"), D3DXMESH_MANAGED, m_pd3dDevice, NULL, NULL, NULL, NULL, &waterMesh)) )
		return hr;

	if( FAILED( hr = CreateWaterMesh(waterMesh)) )
		return hr;

	if( FAILED(hr = CreateClearBuffer()) )
		return hr;

    LPD3DXBUFFER pBufferErrors = NULL;
    if( FAILED( hr = D3DXCreateEffectFromFile( m_pd3dDevice, "CompCosines.fx", NULL, NULL,
                                            0, NULL, &m_CompCosinesEff, &pBufferErrors) ) )
    {
		char* errStr = (char*)pBufferErrors->GetBufferPointer();
		OutputDebugString(errStr);
        return hr;
    }
	GetCompCosineEffParams();

	if( FAILED(hr =  D3DXCreateEffectFromFile( m_pd3dDevice, "WaterRip.fx", NULL, NULL,
                                            0, NULL, &m_WaterEff, &pBufferErrors) ) )
    {
		char* errStr = (char*)pBufferErrors->GetBufferPointer();
		OutputDebugString(errStr);
        return hr;
    }
	GetWaterParams();

    return S_OK;
}

HRESULT CMyD3DApplication::CreateWaterMesh(ID3DXMesh* waterMesh)
{
	// All this should happen off line. In particular, note the assumption of even
	// spacing in calculating the edge lengths, which defeats the whole purpose.
	// Still, it's a demo, not a game.
	struct OutVert
	{
		D3DXVECTOR3		m_Pos;
		DWORD			m_Color;
	};

	const DWORD kWaterFVF = D3DFVF_XYZ | D3DFVF_DIFFUSE;
	HRESULT hr = waterMesh->CloneMeshFVF(D3DXMESH_MANAGED,
							kWaterFVF,
							m_pd3dDevice,
							&m_WaterMesh);

	SAFE_RELEASE(waterMesh);

	if( FAILED(hr) )
		return hr;

	const int nVerts = m_WaterMesh->GetNumVertices();

	OutVert* oVert;
	if( FAILED(hr = m_WaterMesh->LockVertexBuffer(0, (void**)&oVert)) )
		return hr;
	OutVert* origVert = oVert;

	D3DXVECTOR3 del = oVert[0].m_Pos - oVert[1].m_Pos;
	float dist = D3DXVec3Length(&del);
	if( dist < 1.f )
		dist = 1.f;
	UINT alpha = UINT(255.9f / dist);
	int i;
	for( i = 0; i < nVerts; i++ )
	{
		oVert->m_Color = alpha << 24 | 0x00ffffff;
		oVert++;
	}

	oVert = origVert;

	const int nFaces = m_WaterMesh->GetNumFaces();

	m_WaterIndices = new FaceIndices[nFaces];
	m_WaterFacePos = new D3DXVECTOR3[nFaces];
	m_WaterSortData = new FaceSortData[nFaces];

	DWORD* oIdx;
	if( FAILED(hr = m_WaterMesh->LockIndexBuffer(0, (void**)&oIdx)) )
	{
		m_WaterMesh->UnlockVertexBuffer();
		return hr;
	}
	memcpy(m_WaterIndices, oIdx, nFaces * sizeof(*m_WaterIndices));

	for( i = 0; i < nFaces; i++ )
	{
		D3DXVECTOR3 pos = oVert[m_WaterIndices[i].m_Idx[0]].m_Pos;

		pos += oVert[m_WaterIndices[i].m_Idx[1]].m_Pos;
		pos += oVert[m_WaterIndices[i].m_Idx[2]].m_Pos;
		pos.z = 0;

		pos /= 3.f;

		m_WaterFacePos[i] = pos;
	}


	m_WaterMesh->UnlockIndexBuffer();

	m_WaterMesh->UnlockVertexBuffer();

	return hr;
}

struct CompSortFace : public std::binary_function<FaceSortData, FaceSortData, bool>
{
	bool operator()( const FaceSortData& lhs, const FaceSortData& rhs) const
	{
		return lhs.m_Dist < rhs.m_Dist;
	}
};


void CMyD3DApplication::SortWaterMesh()
{
	const D3DXVECTOR3 eyePos(m_matPosition._41, m_matPosition._42, 0.f);
	const int nFaces = m_WaterMesh->GetNumFaces();
	int i;
	for( i = 0; i < nFaces; i++ )
	{
		D3DXVECTOR3 del(eyePos - m_WaterFacePos[i]);
		m_WaterSortData[i].m_Dist = D3DXVec3LengthSq(&del);
		m_WaterSortData[i].m_Idx = i;
	}

	FaceSortData* begin = m_WaterSortData;
	FaceSortData* end = begin + nFaces;

	std::sort(begin, end, CompSortFace());

	FaceIndices* oIdx;
	if( FAILED(m_WaterMesh->LockIndexBuffer(0, (void**)&oIdx)) )
	{
		m_WaterMesh->UnlockVertexBuffer();
		return;
	}

	for( i = 0; i < nFaces; i++ )
	{
		oIdx[i].m_Idx[0] = m_WaterIndices[m_WaterSortData[i].m_Idx].m_Idx[0];
		oIdx[i].m_Idx[1] = m_WaterIndices[m_WaterSortData[i].m_Idx].m_Idx[1];
		oIdx[i].m_Idx[2] = m_WaterIndices[m_WaterSortData[i].m_Idx].m_Idx[2];
	}

	m_WaterMesh->UnlockIndexBuffer();
}

HRESULT CMyD3DApplication::CreateClearBuffer()
{
	HRESULT hr;
	if( FAILED( hr = m_pd3dDevice->CreateVertexBuffer( 4 * kVSize,
												D3DUSAGE_WRITEONLY, 
												0,
												D3DPOOL_MANAGED, 
												&m_BumpVBuffer,
												NULL) ) )
	{
		return hr;
	}


	ClearVert* ptr;
	if( FAILED( hr = m_BumpVBuffer->Lock( 0, 0, (void **)&ptr, 0 ) ) )
		return hr;

	ptr[2].m_Pos.x = -1.f;
	ptr[2].m_Pos.y = -1.f;
	ptr[2].m_Pos.z = 0.5f;

	ptr[2].m_Uv.x = 0.5f / kBumpTexSize;
	ptr[1].m_Uv.y = 0.5f / kBumpTexSize;

	ptr[0] = ptr[2];
	ptr[0].m_Pos.y += 2.f;
	ptr[0].m_Uv.y += 1.f;

	ptr[1] = ptr[2];
	ptr[1].m_Pos.x += 2.f;
	ptr[1].m_Pos.y += 2.f;
	ptr[1].m_Uv.x += 1.f;
	ptr[1].m_Uv.y += 1.f;

	ptr[3] = ptr[2];
	ptr[3].m_Pos.x += 2.f;
	ptr[3].m_Uv.x += 1.f;

	m_BumpVBuffer->Unlock();

	return S_OK;
}


//-----------------------------------------------------------------------------
// Name: RestoreDeviceObjects()
// Desc: Paired with InvalidateDeviceObjects()
//       The device exists, but may have just been Reset().  Resources in
//       D3DPOOL_DEFAULT and any other device state that persists during
//       rendering should be set here.  Render states, matrices, textures,
//       etc., that don't change during rendering can be set once here to
//       avoid redundant state setting during Render() or FrameMove().
//-----------------------------------------------------------------------------
HRESULT CMyD3DApplication::RestoreDeviceObjects()
{
    // TODO: setup render states

    // Setup a material
    D3DMATERIAL9 mtrl;
    D3DUtil_InitMaterial( mtrl, 1.0f, 1.0f, 1.0f );
    m_pd3dDevice->SetMaterial( &mtrl );

    // Set up the textures
    m_pd3dDevice->SetTextureStageState( 0, D3DTSS_COLOROP,   D3DTOP_MODULATE );
    m_pd3dDevice->SetTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE );
    m_pd3dDevice->SetTextureStageState( 0, D3DTSS_COLORARG2, D3DTA_DIFFUSE );
    m_pd3dDevice->SetTextureStageState( 0, D3DTSS_ALPHAOP,   D3DTOP_MODULATE );
    m_pd3dDevice->SetTextureStageState( 0, D3DTSS_ALPHAARG1, D3DTA_TEXTURE );
    m_pd3dDevice->SetTextureStageState( 0, D3DTSS_ALPHAARG2, D3DTA_DIFFUSE );
    m_pd3dDevice->SetSamplerState( 0, D3DSAMP_MINFILTER, D3DTEXF_LINEAR );
    m_pd3dDevice->SetSamplerState( 0, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR );

    // Set miscellaneous render states
	m_pd3dDevice->SetRenderState(D3DRS_ALPHABLENDENABLE, TRUE);
    m_pd3dDevice->SetRenderState( D3DRS_DITHERENABLE,   FALSE );
    m_pd3dDevice->SetRenderState( D3DRS_SPECULARENABLE, FALSE );
    m_pd3dDevice->SetRenderState( D3DRS_ZENABLE,        TRUE );
    m_pd3dDevice->SetRenderState( D3DRS_AMBIENT,        0x000F0F0F );
	m_pd3dDevice->SetRenderState(D3DRS_CULLMODE, D3DCULL_CCW);

    // Set the world matrix
    D3DXMATRIX matIdentity;
    D3DXMatrixIdentity( &matIdentity );
    m_pd3dDevice->SetTransform( D3DTS_WORLD,  &matIdentity );


    // Set the projection matrix
    FLOAT fAspect = ((FLOAT)m_d3dsdBackBuffer.Width) / m_d3dsdBackBuffer.Height;
    D3DXMatrixPerspectiveFovLH( &m_matProjection, D3DX_PI/4, fAspect, 1.0f, 10000.0f );
    m_pd3dDevice->SetTransform( D3DTS_PROJECTION, &m_matProjection);

    // Set up lighting states
    D3DLIGHT9 light;
    D3DUtil_InitLight( light, D3DLIGHT_DIRECTIONAL, -1.0f, -1.0f, -2.0f );
    m_pd3dDevice->SetLight( 0, &light );
    m_pd3dDevice->LightEnable( 0, TRUE );
    m_pd3dDevice->SetRenderState( D3DRS_LIGHTING, TRUE );

    // Restore the font
    m_pFont->RestoreDeviceObjects();

	HRESULT hr;
	// Create our bump map. We'll composite the normals of our texture waves into this with renders.
    if(FAILED(hr = D3DXCreateTexture(m_pd3dDevice, kBumpTexSize, kBumpTexSize, 1, D3DUSAGE_RENDERTARGET, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, &m_BumpTex)) &&
       FAILED(hr = D3DXCreateTexture(m_pd3dDevice, kBumpTexSize, kBumpTexSize, 1, 0, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, &m_BumpTex)))
    {
        return hr;
    }

    D3DSURFACE_DESC desc;
    m_BumpTex->GetSurfaceLevel(0, &m_BumpSurf);
    m_BumpSurf->GetDesc(&desc);

    if(FAILED(hr = D3DXCreateRenderToSurface(m_pd3dDevice, desc.Width, desc.Height, 
									        desc.Format, FALSE, D3DFMT_UNKNOWN, &m_BumpRender)))
        return hr;

    m_CompCosinesEff->OnResetDevice();
	m_WaterEff->OnResetDevice();

    return S_OK;
}

static void Clamp(float& val, float lo, float hi)
{
	if( val < lo )
		val = lo;
	else if( val > hi )
		val = hi;
}

void CMyD3DApplication::MoveOnInput()
{
    //
    // Process keyboard input
    //

    D3DXVECTOR3 vecT(0.0f, 0.0f, 0.0f);
    D3DXVECTOR3 vecR(0.0f, 0.0f, 0.0f);
    D3DXVECTOR3 vecZ(0.0f, 0.0f, 0.0f);

    if(m_bKey[VK_NUMPAD1] || m_bKey[VK_LEFT])  vecT.x -= 1.0f; // Slide Left
    if(m_bKey[VK_NUMPAD3] || m_bKey[VK_RIGHT]) vecT.x += 1.0f; // Slide Right
    if(m_bKey[VK_DOWN])                        vecT.y -= 1.0f; // Slide Down
    if(m_bKey[VK_UP])                          vecT.y += 1.0f; // Slide Up
    if(m_bKey['W'])                            vecT.z += 2.0f; // Move Forward
    if(m_bKey['S'])                            vecT.z -= 2.0f; // Move Backward
    if(m_bKey['A'] || m_bKey[VK_NUMPAD8])      vecR.x -= 1.0f; // Pitch Down
    if(m_bKey['Z'] || m_bKey[VK_NUMPAD2])      vecR.x += 1.0f; // Pitch Up
    if(m_bKey['E'] || m_bKey[VK_NUMPAD6])      vecZ.z -= 1.0f; // Turn Right
    if(m_bKey['Q'] || m_bKey[VK_NUMPAD4])      vecZ.z += 1.0f; // Turn Left
    if(m_bKey[VK_NUMPAD9])                     vecR.z -= 2.0f; // Roll CW
    if(m_bKey[VK_NUMPAD7])                     vecR.z += 2.0f; // Roll CCW

	const float speed = 10.f;
	const float angSpeed = D3DX_PI / 5.f;
	vecT *= speed * m_fElapsedTime;
	vecR *= angSpeed * m_fElapsedTime;
	vecZ *= angSpeed * m_fElapsedTime;

	if(m_bKey[VK_SHIFT])
	{
		vecT *= 4.f;
		vecR *= 4.f;
		vecZ *= 4.f;
	}

    //
    // Update position and view matricies
    //

    D3DXMATRIXA16 matT, matR, matZ;
    D3DXQUATERNION qR;
    D3DXQUATERNION qZ;


    D3DXMatrixTranslation(&matT, vecT.x, vecT.y, vecT.z);
    D3DXMatrixMultiply(&m_matPosition, &matT, &m_matPosition);

    D3DXQuaternionRotationYawPitchRoll(&qR, vecR.y, vecR.x, vecR.z);
    D3DXMatrixRotationQuaternion(&matR, &qR);

    D3DXQuaternionRotationYawPitchRoll(&qZ, vecZ.y, vecZ.x, vecZ.z);
    D3DXMatrixRotationQuaternion(&matZ, &qZ);

    D3DXMatrixMultiply(&m_matPosition, &matR, &m_matPosition);
    D3DXMatrixMultiply(&m_matPosition, &m_matPosition, &matZ);

    D3DXMatrixInverse(&m_matView, NULL, &m_matPosition);

	float timeScale = m_bKey[VK_SHIFT] ? m_fElapsedTime : -m_fElapsedTime;
	// MoreOptions
	// Debounce the toggles
	const float kMinToggle = 0.5f;
	if( m_fTime - m_LastToggle > kMinToggle )
	{
		// Reset
		if(m_bKey['R'])
		{
			if( m_bKey[VK_SHIFT] )
				ResetWater();
			else
				InitWaves();
			m_LastToggle = m_fTime;
		}
		// Show bump
		if(m_bKey['B'])
		{
			m_bDrawBump = !m_bDrawBump;
			m_LastToggle = m_fTime;
		}

		if(m_bKey[VK_SPACE])
		{
			m_bShowHelp = !m_bShowHelp;
			m_LastToggle = m_fTime;
		}
	}
	// Water Height
	if(m_bKey['H'])
		m_GeoState.m_WaterLevel += timeScale * 3.f;
	// Geo Wave Height
	if(m_bKey['J'])
	{
		m_GeoState.m_AmpOverLen += timeScale * 0.05f;
		Clamp(m_GeoState.m_AmpOverLen, 0.f, 0.1f);
	}
	// Geo Chop
	if(m_bKey['K'])
	{
		m_GeoState.m_Chop += timeScale * 0.5f;
		Clamp(m_GeoState.m_Chop, 0.f, 4.f);
	}
	// Tex Wave Height
	if(m_bKey['U'])
	{
		m_TexState.m_AmpOverLen += timeScale * 0.05f;
		Clamp(m_TexState.m_AmpOverLen, 0.f, 0.5f);
	}
	// Tex scale
	if(m_bKey['Y'])
	{
		m_TexState.m_RippleScale += timeScale * 1.f;
		Clamp(m_TexState.m_RippleScale, 5.f, 50.f);
	}
	if(m_bKey['N'])
	{
		m_TexState.m_Noise += timeScale * 0.1f;
		Clamp(m_TexState.m_Noise, 0.f, 1.f);
	}
	if(m_bKey['O'])
	{
		m_GeoState.m_AngleDeviation += timeScale * 10.f;
		Clamp(m_GeoState.m_AngleDeviation, 0.f, 180.f);
	}
	if(m_bKey['P'])
	{
		m_TexState.m_AngleDeviation += timeScale * 10.f;
		Clamp(m_TexState.m_AngleDeviation, 0.f, 180.f);
	}
	if(m_bKey['G'])
	{
		m_GeoState.m_EnvRadius *= 1.f + timeScale * 0.5f;
		Clamp(m_GeoState.m_EnvRadius, 100.f, 10000.f);
	}
	if(m_bKey['F'])
	{
		m_GeoState.m_EnvHeight += timeScale * 10.f;
		Clamp(m_GeoState.m_EnvHeight, -100.f, 100.f);
	}
}


//-----------------------------------------------------------------------------
// Name: FrameMove()
// Desc: Called once per frame, the call is the entry point for animating
//       the scene.
//-----------------------------------------------------------------------------
HRESULT CMyD3DApplication::FrameMove()
{
    // TODO: update world

    // Update user input state
	MoveOnInput();

	UpdateTexWaves(m_fElapsedTime);
	UpdateGeoWaves(m_fElapsedTime);

    return S_OK;
}




//-----------------------------------------------------------------------------
// Name: UpdateInput()
// Desc: Update the user input.  Called once per frame 
//-----------------------------------------------------------------------------
void CMyD3DApplication::UpdateInput( UserInput* pUserInput )
{
    pUserInput->bRotateUp    = ( m_bActive && (GetAsyncKeyState( VK_UP )    & 0x8000) == 0x8000 );
    pUserInput->bRotateDown  = ( m_bActive && (GetAsyncKeyState( VK_DOWN )  & 0x8000) == 0x8000 );
    pUserInput->bRotateLeft  = ( m_bActive && (GetAsyncKeyState( VK_LEFT )  & 0x8000) == 0x8000 );
    pUserInput->bRotateRight = ( m_bActive && (GetAsyncKeyState( VK_RIGHT ) & 0x8000) == 0x8000 );

	pUserInput->bMoveUp = ( m_bActive && (GetAsyncKeyState( VK_UP )    & 0x8000) == 0x8000 );
}




//-----------------------------------------------------------------------------
// Name: Render()
// Desc: Called once per frame, the call is the entry point for 3d
//       rendering. This function sets up render states, clears the
//       viewport, and renders the scene.
//-----------------------------------------------------------------------------
HRESULT CMyD3DApplication::Render()
{
	RenderTexture();

    // Clear the viewport
    m_pd3dDevice->Clear( 0L, NULL, D3DCLEAR_TARGET|D3DCLEAR_ZBUFFER,
                         0x00707070, 1.0f, 0L );

    // Begin the scene
    if( SUCCEEDED( m_pd3dDevice->BeginScene() ) )
    {
        // TODO: render world
		m_pd3dDevice->SetTransform(D3DTS_PROJECTION, &m_matProjection);
		m_pd3dDevice->SetTransform(D3DTS_VIEW, &m_matView);
        
		m_pd3dDevice->SetTexture(0, m_LandTex);
		m_LandMesh->DrawSubset(0);
		m_pd3dDevice->SetTexture(0, NULL);

		m_PillarsMesh->DrawSubset(0);

		RenderWater();

		if( m_bDrawBump )
		{
			D3DXMATRIXA16 matIdent;
			D3DXMatrixIdentity(&matIdent);

			m_pd3dDevice->SetTransform(D3DTS_VIEW, &matIdent);
			matIdent._11 = 0.5f;
			matIdent._22 = 0.5f;
			m_pd3dDevice->SetTransform(D3DTS_PROJECTION, &matIdent);

			m_pd3dDevice->SetRenderState(D3DRS_SRCBLEND,  D3DBLEND_ONE);
			m_pd3dDevice->SetRenderState(D3DRS_DESTBLEND, D3DBLEND_ZERO);
			m_pd3dDevice->SetRenderState(D3DRS_ALPHAFUNC, D3DCMP_ALWAYS);

			m_pd3dDevice->SetTexture(0, m_BumpTex);
			m_pd3dDevice->SetFVF(kClearVertFVF);
			m_pd3dDevice->SetStreamSource(0, m_BumpVBuffer, 0, kVSize);

			m_pd3dDevice->SetTextureStageState( 0, D3DTSS_COLOROP,   D3DTOP_SELECTARG1 );
			m_pd3dDevice->SetTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE );
			m_pd3dDevice->SetTextureStageState( 0, D3DTSS_COLORARG2, D3DTA_DIFFUSE );

			m_pd3dDevice->DrawPrimitive(D3DPT_TRIANGLESTRIP, 0, 2);

			m_pd3dDevice->SetTextureStageState( 0, D3DTSS_COLOROP,   D3DTOP_MODULATE );
			m_pd3dDevice->SetTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE );
			m_pd3dDevice->SetTextureStageState( 0, D3DTSS_COLORARG2, D3DTA_DIFFUSE );
}

        // Render stats and help text  
        RenderText();

        // End the scene.
        m_pd3dDevice->EndScene();
    }

    return S_OK;
}




//-----------------------------------------------------------------------------
// Name: RenderText()
// Desc: Renders stats and help text to the scene.
//-----------------------------------------------------------------------------
HRESULT CMyD3DApplication::RenderText()
{
    D3DCOLOR fontColor        = D3DCOLOR_ARGB(255,255,255,0);
    TCHAR szMsg[MAX_PATH] = TEXT("");

    // Output display stats
    FLOAT fNextLine = 40.0f; 

    lstrcpy( szMsg, m_strDeviceStats );
    fNextLine -= 20.0f;
    m_pFont->DrawText( 2, fNextLine, fontColor, szMsg );

    lstrcpy( szMsg, m_strFrameStats );
    fNextLine -= 20.0f;
    m_pFont->DrawText( 2, fNextLine, fontColor, szMsg );

    // Output statistics & help
    fNextLine = (FLOAT) m_d3dsdBackBuffer.Height; 


    lstrcpy( szMsg, TEXT("Spacebar toggles help") );
    fNextLine -= 20.0f; m_pFont->DrawText( 2, fNextLine, fontColor, szMsg );

	if( m_bShowHelp )
	{
		lstrcpy( szMsg, TEXT("Press 'F2' to configure display") );
		fNextLine -= 40.0f; m_pFont->DrawText( 2, fNextLine, fontColor, szMsg );

		lstrcpy( szMsg, TEXT("'F' - Environment map height") );
		fNextLine -= 40.0f; m_pFont->DrawText( 2, fNextLine, fontColor, szMsg );

		lstrcpy( szMsg, TEXT("'G' - Environment map radius") );
		fNextLine -= 20.0f; m_pFont->DrawText( 2, fNextLine, fontColor, szMsg );

		lstrcpy( szMsg, TEXT("'P' - Texture wave angle deviation") );
		fNextLine -= 20.0f; m_pFont->DrawText( 2, fNextLine, fontColor, szMsg );

		lstrcpy( szMsg, TEXT("'O' - Geometric wave angle deviation") );
		fNextLine -= 20.0f; m_pFont->DrawText( 2, fNextLine, fontColor, szMsg );

		lstrcpy( szMsg, TEXT("'N' - Texture Noise") );
		fNextLine -= 20.0f; m_pFont->DrawText( 2, fNextLine, fontColor, szMsg );

		lstrcpy( szMsg, TEXT("'Y' - Texture scaling") );
		fNextLine -= 20.0f; m_pFont->DrawText( 2, fNextLine, fontColor, szMsg );

		lstrcpy( szMsg, TEXT("'U' - Texture wave height") );
		fNextLine -= 20.0f; m_pFont->DrawText( 2, fNextLine, fontColor, szMsg );

		lstrcpy( szMsg, TEXT("'K' - Geometric wave choppiness") );
		fNextLine -= 20.0f; m_pFont->DrawText( 2, fNextLine, fontColor, szMsg );

		lstrcpy( szMsg, TEXT("'J' - Geometric wave height") );
		fNextLine -= 20.0f; m_pFont->DrawText( 2, fNextLine, fontColor, szMsg );

		lstrcpy( szMsg, TEXT("'H' - Water level") );
		fNextLine -= 20.0f; m_pFont->DrawText( 2, fNextLine, fontColor, szMsg );

		lstrcpy( szMsg, TEXT("Parameters - Shift goes up, non-shift goes down") );
		fNextLine -= 20.0f; m_pFont->DrawText( 2, fNextLine, fontColor, szMsg );

		lstrcpy( szMsg, TEXT("'B' - Show bump map") );
		fNextLine -= 40.0f; m_pFont->DrawText( 2, fNextLine, fontColor, szMsg );

		lstrcpy( szMsg, TEXT("'r' - Reinitializes system with current settings") );
		fNextLine -= 20.0f; m_pFont->DrawText( 2, fNextLine, fontColor, szMsg );

		lstrcpy( szMsg, TEXT("'R' - Resets system settings to default and re-init") );
		fNextLine -= 20.0f; m_pFont->DrawText( 2, fNextLine, fontColor, szMsg );

		lstrcpy( szMsg, TEXT("Toggles:") );
		fNextLine -= 20.0f; m_pFont->DrawText( 2, fNextLine, fontColor, szMsg );

		lstrcpy( szMsg, TEXT("Left/right arrow - slide left/right") );
		fNextLine -= 40.0f; m_pFont->DrawText( 2, fNextLine, fontColor, szMsg );

		lstrcpy( szMsg, TEXT("Up/down arrow - move up/down") );
		fNextLine -= 20.0f; m_pFont->DrawText( 2, fNextLine, fontColor, szMsg );

		lstrcpy( szMsg, TEXT("W/S - move forward/backward") );
		fNextLine -= 20.0f; m_pFont->DrawText( 2, fNextLine, fontColor, szMsg );

		lstrcpy( szMsg, TEXT("A/Z - pitch up/down") );
		fNextLine -= 20.0f; m_pFont->DrawText( 2, fNextLine, fontColor, szMsg );

		lstrcpy( szMsg, TEXT("E/Q - rotate scene right/left") );
		fNextLine -= 20.0f; m_pFont->DrawText( 2, fNextLine, fontColor, szMsg );

		lstrcpy( szMsg, TEXT("Movement - Shift is faster:") );
		fNextLine -= 20.0f; m_pFont->DrawText( 2, fNextLine, fontColor, szMsg );


	}

    return S_OK;
}




//-----------------------------------------------------------------------------
// Name: MsgProc()
// Desc: Overrrides the main WndProc, so the sample can do custom message
//       handling (e.g. processing mouse, keyboard, or menu commands).
//-----------------------------------------------------------------------------
LRESULT CMyD3DApplication::MsgProc( HWND hWnd, UINT msg, WPARAM wParam,
                                    LPARAM lParam )
{
    switch( msg )
    {
        case WM_KEYDOWN:
            m_bKey[wParam] = TRUE;
            break;

        case WM_KEYUP:
            m_bKey[wParam] = FALSE;
            break;
        case WM_PAINT:
        {
            if( m_bLoadingApp )
            {
                // Draw on the window tell the user that the app is loading
                // TODO: change as needed
                HDC hDC = GetDC( hWnd );
                TCHAR strMsg[MAX_PATH];
                wsprintf( strMsg, TEXT("Loading... Please wait") );
                RECT rct;
                GetClientRect( hWnd, &rct );
                DrawText( hDC, strMsg, -1, &rct, DT_CENTER|DT_VCENTER|DT_SINGLELINE );
                ReleaseDC( hWnd, hDC );
            }
            break;
        }

    }

    return CD3DApplication::MsgProc( hWnd, msg, wParam, lParam );
}




//-----------------------------------------------------------------------------
// Name: InvalidateDeviceObjects()
// Desc: Invalidates device objects.  Paired with RestoreDeviceObjects()
//-----------------------------------------------------------------------------
HRESULT CMyD3DApplication::InvalidateDeviceObjects()
{
    // TODO: Cleanup any objects created in RestoreDeviceObjects()
    m_pFont->InvalidateDeviceObjects();
    m_CompCosinesEff->OnLostDevice();
	m_WaterEff->OnLostDevice();

	SAFE_RELEASE(m_BumpTex);
	SAFE_RELEASE(m_BumpSurf);
	SAFE_RELEASE(m_BumpRender);

    return S_OK;
}




//-----------------------------------------------------------------------------
// Name: DeleteDeviceObjects()
// Desc: Paired with InitDeviceObjects()
//       Called when the app is exiting, or the device is being changed,
//       this function deletes any device dependent objects.  
//-----------------------------------------------------------------------------
HRESULT CMyD3DApplication::DeleteDeviceObjects()
{
    // TODO: Cleanup any objects created in InitDeviceObjects()
    m_pFont->DeleteDeviceObjects();

	SAFE_RELEASE(m_CompCosinesEff);
	SAFE_RELEASE(m_WaterEff);
	SAFE_RELEASE(m_CosineLUT);
	SAFE_RELEASE(m_BiasNoiseMap);
	SAFE_RELEASE(m_EnvMap);
	SAFE_RELEASE(m_LandTex);

	SAFE_RELEASE(m_WaterMesh);
	SAFE_RELEASE(m_LandMesh);
	SAFE_RELEASE(m_PillarsMesh);

	SAFE_RELEASE(m_BumpVBuffer);

    return S_OK;
}




//-----------------------------------------------------------------------------
// Name: FinalCleanup()
// Desc: Paired with OneTimeSceneInit()
//       Called before the app exits, this function gives the app the chance
//       to cleanup after itself.
//-----------------------------------------------------------------------------
HRESULT CMyD3DApplication::FinalCleanup()
{
    // TODO: Perform any final cleanup needed
    // Cleanup D3D font
    SAFE_DELETE( m_pFont );

    return S_OK;
}

HRESULT CMyD3DApplication::CreateCosineLUT()
{
	HRESULT hr = D3DXCreateTexture(m_pd3dDevice,
		kBumpTexSize,
		1,
		1,
		0,
		D3DFMT_A8R8G8B8,
		D3DPOOL_MANAGED,
		&m_CosineLUT);

	if( FAILED(hr) )
		return hr;

	D3DLOCKED_RECT lockedRect;
	hr = m_CosineLUT->LockRect(0, &lockedRect, NULL, 0);
	if( FAILED(hr) )
		return hr;

	unsigned long* pDat = (unsigned long*)lockedRect.pBits;
	int i;
	for( i = 0; i < kBumpTexSize; i++ )
	{
		float dist = float(i) / float(kBumpTexSize-1) * 2.f * D3DX_PI;
		float c = float(cos(dist));
		float s = float(sin(dist));
		s *= 0.5f;
		s += 0.5f;
		s = float(pow(s, m_TexState.m_Chop));
		c *= s;
		unsigned char cosDist = (unsigned char)((c * 0.5 + 0.5) * 255.999f);
		pDat[i] = (0xff << 24)
					| (cosDist << 16)
					| (cosDist << 8)
					| 0xff;
	}

	m_CosineLUT->UnlockRect(0);

	return S_OK;
}

HRESULT CMyD3DApplication::CreateBiasNoiseMap()
{
	HRESULT hr = D3DXCreateTexture(m_pd3dDevice,
		kBumpTexSize,
		kBumpTexSize,
		1,
		0,
		D3DFMT_A8R8G8B8,
		D3DPOOL_MANAGED,
		&m_BiasNoiseMap);

	if( FAILED(hr) )
		return hr;

	D3DLOCKED_RECT lockedRect;
	hr = m_BiasNoiseMap->LockRect(0, &lockedRect, NULL, 0);
	if( FAILED(hr) )
		return hr;

	unsigned long* pDat = (unsigned long*)lockedRect.pBits;

	const int size = kBumpTexSize;
	int i;
	for( i = 0; i < size; i++ )
	{
		int j;
		for( j = 0; j < size; j++ )
		{
			float x = RandZeroToOne();
			float y = RandZeroToOne();

			unsigned char r = (unsigned char)(x * 255.999f);
			unsigned char g = (unsigned char)(y * 255.999f);
	
			pDat[j] = (0xff << 24)
				| (r << 16)
				| (g << 8)
				| 0xff;
		}

		pDat += lockedRect.Pitch / 4;
	}

	m_BiasNoiseMap->UnlockRect(0);

	return S_OK;
}

void CMyD3DApplication::InitTexWaves()
{
	int i;
	for( i = 0; i < kNumTexWaves; i++ )
		InitTexWave(i);
}

void CMyD3DApplication::UpdateTexWaves(FLOAT dt)
{
	int i;
	for( i = 0; i < kNumTexWaves; i++ )
		UpdateTexWave(i, dt);
}

void CMyD3DApplication::UpdateTexWave(int i, FLOAT dt)
{
	if( i == m_TexState.m_TransIdx )
	{
		m_TexWaves[i].m_Fade += m_TexState.m_TransDel * dt;
		if( m_TexWaves[i].m_Fade < 0 )
		{
			// This wave is faded out. Re-init and fade it back up.
			InitTexWave(i);
			m_TexWaves[i].m_Fade = 0;
			m_TexState.m_TransDel = -m_TexState.m_TransDel;
		}
		else if( m_TexWaves[i].m_Fade > 1.f )
		{
			// This wave is faded back up. Start fading another down.
			m_TexWaves[i].m_Fade = 1.f;
			m_TexState.m_TransDel = -m_TexState.m_TransDel;
			if( ++m_TexState.m_TransIdx >= kNumTexWaves )
				m_TexState.m_TransIdx = 0;
		}
	}
	m_TexWaves[i].m_Phase -= dt * m_TexWaves[i].m_Speed;
	m_TexWaves[i].m_Phase -= int(m_TexWaves[i].m_Phase);
}

void CMyD3DApplication::InitTexWave(int i)
{
	float rads = RandMinusOneToOne() * m_TexState.m_AngleDeviation * D3DX_PI / 180.f;
	float dx = float(sin(rads));
	float dy = float(cos(rads));


	float tx = dx;
	dx = m_TexState.m_WindDir.y * dx - m_TexState.m_WindDir.x * dy;
	dy = m_TexState.m_WindDir.x * tx + m_TexState.m_WindDir.y * dy;

	float maxLen = m_TexState.m_MaxLength * kBumpTexSize / m_TexState.m_RippleScale;
	float minLen = m_TexState.m_MinLength * kBumpTexSize / m_TexState.m_RippleScale;
	float len = float(i) / float(kNumTexWaves-1) * (maxLen - minLen) + minLen;

	float reps = float(kBumpTexSize) / len;

	dx *= reps;
	dy *= reps;
	dx = float(int(dx >= 0 ? dx + 0.5f : dx - 0.5f));
	dy = float(int(dy >= 0 ? dy + 0.5f : dy - 0.5f));

	m_TexWaves[i].m_RotScale.x = dx;
	m_TexWaves[i].m_RotScale.y = dy;

	float effK = float(1.0 / sqrt(dx*dx + dy*dy));
	m_TexWaves[i].m_Len = float(kBumpTexSize) * effK;
	m_TexWaves[i].m_Freq = D3DX_PI * 2.f / m_TexWaves[i].m_Len;
	m_TexWaves[i].m_Amp = m_TexWaves[i].m_Len * m_TexState.m_AmpOverLen;
	m_TexWaves[i].m_Phase = RandZeroToOne();
	
	m_TexWaves[i].m_Dir.x = dx * effK;
	m_TexWaves[i].m_Dir.y = dy * effK;

	m_TexWaves[i].m_Fade = 1.f;

	float speed = float( 1.0 / sqrt(m_TexWaves[i].m_Len / (2.f * D3DX_PI * kGravConst)) ) / 3.f;
	speed *= 1.f + RandMinusOneToOne() * m_TexState.m_SpeedDeviation;
	m_TexWaves[i].m_Speed = speed;
}

void CMyD3DApplication::InitTexState()
{
	m_TexState.m_Noise = 0.2f;
	m_TexState.m_Chop = 1.f;
	m_TexState.m_AngleDeviation = 15.f;
	m_TexState.m_WindDir.x = 0;
	m_TexState.m_WindDir.y = 1.f;
	m_TexState.m_MaxLength = 10.f;
	m_TexState.m_MinLength = 1.f;
	m_TexState.m_AmpOverLen = 0.1f;
	m_TexState.m_RippleScale = 25.f;
	m_TexState.m_SpeedDeviation = 0.1f;

	m_TexState.m_TransIdx = 0;
	m_TexState.m_TransDel = -1.f / 5.f;
}

void CMyD3DApplication::GetCompCosineEffParams()
{
	m_CompCosineParams.m_UTrans[0] = m_CompCosinesEff->GetParameterByName(NULL, "cUTrans0");
	m_CompCosineParams.m_UTrans[1] = m_CompCosinesEff->GetParameterByName(NULL, "cUTrans1");
	m_CompCosineParams.m_UTrans[2] = m_CompCosinesEff->GetParameterByName(NULL, "cUTrans2");
	m_CompCosineParams.m_UTrans[3] = m_CompCosinesEff->GetParameterByName(NULL, "cUTrans3");
	m_CompCosineParams.m_UTrans[4] = m_CompCosinesEff->GetParameterByName(NULL, "cUTrans4");
	m_CompCosineParams.m_UTrans[5] = m_CompCosinesEff->GetParameterByName(NULL, "cUTrans5");
	m_CompCosineParams.m_UTrans[6] = m_CompCosinesEff->GetParameterByName(NULL, "cUTrans6");
	m_CompCosineParams.m_UTrans[7] = m_CompCosinesEff->GetParameterByName(NULL, "cUTrans7");
	m_CompCosineParams.m_UTrans[8] = m_CompCosinesEff->GetParameterByName(NULL, "cUTrans8");
	m_CompCosineParams.m_UTrans[9] = m_CompCosinesEff->GetParameterByName(NULL, "cUTrans9");
	m_CompCosineParams.m_UTrans[10] = m_CompCosinesEff->GetParameterByName(NULL, "cUTrans10");
	m_CompCosineParams.m_UTrans[11] = m_CompCosinesEff->GetParameterByName(NULL, "cUTrans11");
	m_CompCosineParams.m_UTrans[12] = m_CompCosinesEff->GetParameterByName(NULL, "cUTrans12");
	m_CompCosineParams.m_UTrans[13] = m_CompCosinesEff->GetParameterByName(NULL, "cUTrans13");
	m_CompCosineParams.m_UTrans[14] = m_CompCosinesEff->GetParameterByName(NULL, "cUTrans14");
	m_CompCosineParams.m_UTrans[15] = m_CompCosinesEff->GetParameterByName(NULL, "cUTrans15");

	m_CompCosineParams.m_Coef[0] = m_CompCosinesEff->GetParameterByName(NULL, "cCoef0");
	m_CompCosineParams.m_Coef[1] = m_CompCosinesEff->GetParameterByName(NULL, "cCoef1");
	m_CompCosineParams.m_Coef[2] = m_CompCosinesEff->GetParameterByName(NULL, "cCoef2");
	m_CompCosineParams.m_Coef[3] = m_CompCosinesEff->GetParameterByName(NULL, "cCoef3");
	m_CompCosineParams.m_Coef[4] = m_CompCosinesEff->GetParameterByName(NULL, "cCoef4");
	m_CompCosineParams.m_Coef[5] = m_CompCosinesEff->GetParameterByName(NULL, "cCoef5");
	m_CompCosineParams.m_Coef[6] = m_CompCosinesEff->GetParameterByName(NULL, "cCoef6");
	m_CompCosineParams.m_Coef[7] = m_CompCosinesEff->GetParameterByName(NULL, "cCoef7");
	m_CompCosineParams.m_Coef[8] = m_CompCosinesEff->GetParameterByName(NULL, "cCoef8");
	m_CompCosineParams.m_Coef[9] = m_CompCosinesEff->GetParameterByName(NULL, "cCoef9");
	m_CompCosineParams.m_Coef[10] = m_CompCosinesEff->GetParameterByName(NULL, "cCoef10");
	m_CompCosineParams.m_Coef[11] = m_CompCosinesEff->GetParameterByName(NULL, "cCoef11");
	m_CompCosineParams.m_Coef[12] = m_CompCosinesEff->GetParameterByName(NULL, "cCoef12");
	m_CompCosineParams.m_Coef[13] = m_CompCosinesEff->GetParameterByName(NULL, "cCoef13");
	m_CompCosineParams.m_Coef[14] = m_CompCosinesEff->GetParameterByName(NULL, "cCoef14");
	m_CompCosineParams.m_Coef[15] = m_CompCosinesEff->GetParameterByName(NULL, "cCoef15");

	m_CompCosineParams.m_ReScale = m_CompCosinesEff->GetParameterByName(NULL, "cReScale");

	m_CompCosineParams.m_NoiseXform[0] = m_CompCosinesEff->GetParameterByName(NULL, "cNoiseXForm0_00");
	m_CompCosineParams.m_NoiseXform[1] = m_CompCosinesEff->GetParameterByName(NULL, "cNoiseXForm0_10");
	m_CompCosineParams.m_NoiseXform[2] = m_CompCosinesEff->GetParameterByName(NULL, "cNoiseXForm1_00");
	m_CompCosineParams.m_NoiseXform[3] = m_CompCosinesEff->GetParameterByName(NULL, "cNoiseXForm1_10");

	D3DXVECTOR4 init(20.f, 0.f, 0.f, 0.f);
	m_CompCosinesEff->SetVector(m_CompCosineParams.m_NoiseXform[0], &init);
	m_CompCosinesEff->SetVector(m_CompCosineParams.m_NoiseXform[2], &init);
	init.x = 0;
	init.y = 20.f;
	m_CompCosinesEff->SetVector(m_CompCosineParams.m_NoiseXform[1], &init);
	m_CompCosinesEff->SetVector(m_CompCosineParams.m_NoiseXform[3], &init);

	m_CompCosineParams.m_ScaleBias = m_CompCosinesEff->GetParameterByName(NULL, "cScaleBias");

	m_CompCosineParams.m_CosineLUT = m_CompCosinesEff->GetParameterByName(NULL, "tCosineLUT");
	m_CompCosineParams.m_BiasNoise = m_CompCosinesEff->GetParameterByName(NULL, "tBiasNoise");
}

void CMyD3DApplication::SetCompCosineEffParams()
{
	int i;
	for( i = 0; i < 16; i++ )
	{
		D3DXVECTOR4 UTrans(m_TexWaves[i].m_RotScale.x, m_TexWaves[i].m_RotScale.y, 0.f, m_TexWaves[i].m_Phase);
		m_CompCosinesEff->SetVector(m_CompCosineParams.m_UTrans[i], &UTrans);

		float normScale = m_TexWaves[i].m_Fade / float(kNumBumpPasses);
		D3DXVECTOR4 Coef(m_TexWaves[i].m_Dir.x * normScale, m_TexWaves[i].m_Dir.y * normScale, 1.f, 1.f);
		m_CompCosinesEff->SetVector(m_CompCosineParams.m_Coef[i], &Coef);

	}

	D3DXVECTOR4 xform;
	
	const FLOAT kRate = 0.1f;
	m_CompCosinesEff->GetVector(m_CompCosineParams.m_NoiseXform[0], &xform);
	xform.w += m_fElapsedTime * kRate;
	m_CompCosinesEff->SetVector(m_CompCosineParams.m_NoiseXform[0], &xform);

	m_CompCosinesEff->GetVector(m_CompCosineParams.m_NoiseXform[3], &xform);
	xform.w += m_fElapsedTime * kRate;
	m_CompCosinesEff->SetVector(m_CompCosineParams.m_NoiseXform[3], &xform);

	float s = 0.5f / (float(kNumBumpPerPass) + m_TexState.m_Noise);
	D3DXVECTOR4 reScale(s, s, 1.f, 1.f);
	m_CompCosinesEff->SetVector(m_CompCosineParams.m_ReScale, &reScale);

	float scaleBias = 0.5f * m_TexState.m_Noise / (float(kNumBumpPasses) + m_TexState.m_Noise);
	D3DXVECTOR4 scaleBiasVec(scaleBias, scaleBias, 0.f, 1.f);
	m_CompCosinesEff->SetVector(m_CompCosineParams.m_ScaleBias, &scaleBiasVec);

	m_CompCosinesEff->SetTexture(m_CompCosineParams.m_CosineLUT, m_CosineLUT);
	m_CompCosinesEff->SetTexture(m_CompCosineParams.m_BiasNoise, m_BiasNoiseMap);
}

void CMyD3DApplication::InitGeoWaves()
{
	int i;
	for( i = 0; i < kNumGeoWaves; i++ )
		InitGeoWave(i);
}

void CMyD3DApplication::InitGeoWave(int i)
{
	m_GeoWaves[i].m_Phase = RandZeroToOne() * D3DX_PI * 2.f;
	m_GeoWaves[i].m_Len = m_GeoState.m_MinLength + RandZeroToOne() * (m_GeoState.m_MaxLength - m_GeoState.m_MinLength);
	m_GeoWaves[i].m_Amp = m_GeoWaves[i].m_Len * m_GeoState.m_AmpOverLen / float(kNumGeoWaves);
	m_GeoWaves[i].m_Freq = 2.f * D3DX_PI / m_GeoWaves[i].m_Len;
	m_GeoWaves[i].m_Fade = 1.f;

	float rotBase = m_GeoState.m_AngleDeviation * D3DX_PI / 180.f;

	float rads = rotBase * RandMinusOneToOne();
	float rx = float(cosf(rads));
	float ry = float(sinf(rads));

	float x = m_GeoState.m_WindDir.x;
	float y = m_GeoState.m_WindDir.y;
	m_GeoWaves[i].m_Dir.x = x * rx + y * ry;
	m_GeoWaves[i].m_Dir.y = x * -ry + y * rx;
}

void CMyD3DApplication::UpdateGeoWave(int i, FLOAT dt)
{
	if( i == m_GeoState.m_TransIdx )
	{
		m_GeoWaves[i].m_Fade += m_GeoState.m_TransDel * dt;
		if( m_GeoWaves[i].m_Fade < 0 )
		{
			// This wave is faded out. Re-init and fade it back up.
			InitGeoWave(i);
			m_GeoWaves[i].m_Fade = 0;
			m_GeoState.m_TransDel = -m_GeoState.m_TransDel;
		}
		else if( m_GeoWaves[i].m_Fade > 1.f )
		{
			// This wave is faded back up. Start fading another down.
			m_GeoWaves[i].m_Fade = 1.f;
			m_GeoState.m_TransDel = -m_GeoState.m_TransDel;
			if( ++m_GeoState.m_TransIdx >= kNumGeoWaves )
				m_GeoState.m_TransIdx = 0;
		}
	}

	const float speed = float(1.0 / sqrt(m_GeoWaves[i].m_Len / (2.f * D3DX_PI * kGravConst)));

	m_GeoWaves[i].m_Phase += speed * dt;
	m_GeoWaves[i].m_Phase = float(fmod(m_GeoWaves[i].m_Phase, 2.f*D3DX_PI));

	m_GeoWaves[i].m_Amp = m_GeoWaves[i].m_Len * m_GeoState.m_AmpOverLen / float(kNumGeoWaves) * m_GeoWaves[i].m_Fade;
}

void CMyD3DApplication::UpdateGeoWaves(FLOAT dt)
{
	int i;
	for( i = 0; i < kNumGeoWaves; i++ )
		UpdateGeoWave(i, dt);
}

void CMyD3DApplication::InitGeoState()
{
	m_GeoState.m_Chop = 2.5f;
	m_GeoState.m_AngleDeviation = 15.f;
	m_GeoState.m_WindDir.x = 0;
	m_GeoState.m_WindDir.y = 1.f;

	m_GeoState.m_MinLength = 15.f;
	m_GeoState.m_MaxLength = 25.f;
	m_GeoState.m_AmpOverLen = 0.1f;

	m_GeoState.m_EnvHeight = -50.f;
	m_GeoState.m_EnvRadius = 100.f;
	m_GeoState.m_WaterLevel = -2.f;

	m_GeoState.m_TransIdx = 0;
	m_GeoState.m_TransDel = -1.f / 6.f;

	m_GeoState.m_SpecAtten = 1.f;
	m_GeoState.m_SpecEnd = 200.f;
	m_GeoState.m_SpecTrans = 100.f;
}

void CMyD3DApplication::GetWaterParams()
{
	m_WaterParams.m_cWorld2NDC = m_WaterEff->GetParameterByName(NULL, "cWorld2NDC");
	m_WaterParams.m_cWaterTint = m_WaterEff->GetParameterByName(NULL, "cWaterTint");
	m_WaterParams.m_cFrequency = m_WaterEff->GetParameterByName(NULL, "cFrequency");
	m_WaterParams.m_cPhase = m_WaterEff->GetParameterByName(NULL, "cPhase");
	m_WaterParams.m_cAmplitude = m_WaterEff->GetParameterByName(NULL, "cAmplitude");
	m_WaterParams.m_cDirX = m_WaterEff->GetParameterByName(NULL, "cDirX");
	m_WaterParams.m_cDirY = m_WaterEff->GetParameterByName(NULL, "cDirY");
	m_WaterParams.m_cSpecAtten = m_WaterEff->GetParameterByName(NULL, "cSpecAtten");
	m_WaterParams.m_cCameraPos = m_WaterEff->GetParameterByName(NULL, "cCameraPos");
	m_WaterParams.m_cEnvAdjust = m_WaterEff->GetParameterByName(NULL, "cEnvAdjust");
	m_WaterParams.m_cEnvTint = m_WaterEff->GetParameterByName(NULL, "cEnvTint");
	m_WaterParams.m_cLocal2World = m_WaterEff->GetParameterByName(NULL, "cLocal2World");
	m_WaterParams.m_cLengths = m_WaterEff->GetParameterByName(NULL, "cLengths");
	m_WaterParams.m_cDepthOffset = m_WaterEff->GetParameterByName(NULL, "cDepthOffset");
	m_WaterParams.m_cDepthScale = m_WaterEff->GetParameterByName(NULL, "cDepthScale");
	m_WaterParams.m_cFogParams = m_WaterEff->GetParameterByName(NULL, "cFogParams");
	m_WaterParams.m_cDirXK = m_WaterEff->GetParameterByName(NULL, "cDirXK");
	m_WaterParams.m_cDirYK = m_WaterEff->GetParameterByName(NULL, "cDirYK");
	m_WaterParams.m_cDirXW = m_WaterEff->GetParameterByName(NULL, "cDirXW");
	m_WaterParams.m_cDirYW = m_WaterEff->GetParameterByName(NULL, "cDirYW");
	m_WaterParams.m_cKW = m_WaterEff->GetParameterByName(NULL, "cKW");
	m_WaterParams.m_cDirXSqKW = m_WaterEff->GetParameterByName(NULL, "cDirXSqKW");
	m_WaterParams.m_cDirXDirYKW = m_WaterEff->GetParameterByName(NULL, "cDirXDirYKW");
	m_WaterParams.m_cDirYSqKW = m_WaterEff->GetParameterByName(NULL, "cDirYSqKW");

	m_WaterParams.m_tEnvMap = m_WaterEff->GetParameterByName(NULL, "tEnvMap");
	m_WaterParams.m_tBumpMap = m_WaterEff->GetParameterByName(NULL, "tBumpMap");
}

void CMyD3DApplication::SetWaterParams()
{
	D3DXMATRIXA16 world2NDC = m_matView * m_matProjection;
	m_WaterEff->SetMatrixTranspose(m_WaterParams.m_cWorld2NDC, &world2NDC);

	D3DXVECTOR4 waterTint(0.05f, 0.1f, 0.1f, 0.5f);
	m_WaterEff->SetVector(m_WaterParams.m_cWaterTint, &waterTint);

	D3DXVECTOR4 freq(m_GeoWaves[0].m_Freq, m_GeoWaves[1].m_Freq, m_GeoWaves[2].m_Freq, m_GeoWaves[3].m_Freq);
	m_WaterEff->SetVector(m_WaterParams.m_cFrequency, &freq);

	D3DXVECTOR4 phase(m_GeoWaves[0].m_Phase, m_GeoWaves[1].m_Phase, m_GeoWaves[2].m_Phase, m_GeoWaves[3].m_Phase);
	m_WaterEff->SetVector(m_WaterParams.m_cPhase, &phase);

	D3DXVECTOR4 amp(m_GeoWaves[0].m_Amp, m_GeoWaves[1].m_Amp, m_GeoWaves[2].m_Amp, m_GeoWaves[3].m_Amp);
	m_WaterEff->SetVector(m_WaterParams.m_cAmplitude, &amp);

	D3DXVECTOR4 dirX(m_GeoWaves[0].m_Dir.x, m_GeoWaves[1].m_Dir.x, m_GeoWaves[2].m_Dir.x, m_GeoWaves[3].m_Dir.x);
	m_WaterEff->SetVector(m_WaterParams.m_cDirX, &dirX);

	D3DXVECTOR4 dirY(m_GeoWaves[0].m_Dir.y, m_GeoWaves[1].m_Dir.y, m_GeoWaves[2].m_Dir.y, m_GeoWaves[3].m_Dir.y);
	m_WaterEff->SetVector(m_WaterParams.m_cDirY, &dirY);

	FLOAT normScale = m_GeoState.m_SpecAtten * m_TexState.m_AmpOverLen * 2.f * D3DX_PI;
	normScale *= (float(kNumBumpPasses) + m_TexState.m_Noise);
	normScale *= (m_TexState.m_Chop + 1.f);

	D3DXVECTOR4 specAtten(m_GeoState.m_SpecEnd, 1.f / m_GeoState.m_SpecTrans, normScale, 1.f / m_TexState.m_RippleScale);
	m_WaterEff->SetVector(m_WaterParams.m_cSpecAtten, &specAtten);

	D3DXVECTOR3 camPos(m_matPosition._41, m_matPosition._42, m_matPosition._43);
	m_WaterEff->SetVector(m_WaterParams.m_cCameraPos, &D3DXVECTOR4(camPos.x, camPos.y, camPos.z, 1.f));


	D3DXVECTOR3 envCenter(0.f, 0.f, m_GeoState.m_EnvHeight); // Just happens to be centered at origin.
	D3DXVECTOR3 camToCen = envCenter - camPos;
	float G = D3DXVec3LengthSq(&camToCen) - m_GeoState.m_EnvRadius * m_GeoState.m_EnvRadius;
	m_WaterEff->SetVector(m_WaterParams.m_cEnvAdjust, &D3DXVECTOR4(camToCen.x, camToCen.y, camToCen.z, G));

	D3DXVECTOR4 envTint(1.f, 1.f, 1.f, 1.f);
	m_WaterEff->SetVector(m_WaterParams.m_cEnvTint, &envTint);

	D3DXMATRIXA16 matIdent;
	D3DXMatrixIdentity(&matIdent);
	m_WaterEff->SetMatrixTranspose(m_WaterParams.m_cLocal2World, &matIdent);

	D3DXVECTOR4 lengths(m_GeoWaves[0].m_Len, m_GeoWaves[1].m_Len, m_GeoWaves[2].m_Len, m_GeoWaves[3].m_Len);
	m_WaterEff->SetVector(m_WaterParams.m_cLengths, &lengths);

	D3DXVECTOR4 depthOffset(m_GeoState.m_WaterLevel + 1.f, 
		m_GeoState.m_WaterLevel + 1.f, 
		m_GeoState.m_WaterLevel + 0.f, 
		m_GeoState.m_WaterLevel);
	m_WaterEff->SetVector(m_WaterParams.m_cDepthOffset, &depthOffset);

	D3DXVECTOR4 depthScale(1.f / 2.f, 1.f / 2.f, 1.f / 2.f, 1.f);
	m_WaterEff->SetVector(m_WaterParams.m_cDepthScale, &depthScale);

	D3DXVECTOR4 fogParams(-200.f, 1.f / (100.f - 200.f), 0.f, 1.f);
	m_WaterEff->SetVector(m_WaterParams.m_cFogParams, &fogParams);

	float K = 5.f;
	if( m_GeoState.m_AmpOverLen > m_GeoState.m_Chop / (2.f * D3DX_PI * kNumGeoWaves * K) )
		K = m_GeoState.m_Chop / (2.f*D3DX_PI* m_GeoState.m_AmpOverLen * kNumGeoWaves);
	D3DXVECTOR4 dirXK(m_GeoWaves[0].m_Dir.x * K, 
		m_GeoWaves[1].m_Dir.x * K, 
		m_GeoWaves[2].m_Dir.x * K, 
		m_GeoWaves[3].m_Dir.x * K);
	D3DXVECTOR4 dirYK(m_GeoWaves[0].m_Dir.y * K, 
		m_GeoWaves[1].m_Dir.y * K, 
		m_GeoWaves[2].m_Dir.y * K, 
		m_GeoWaves[3].m_Dir.y * K);
	m_WaterEff->SetVector(m_WaterParams.m_cDirXK, &dirXK);
	m_WaterEff->SetVector(m_WaterParams.m_cDirYK, &dirYK);

	D3DXVECTOR4 dirXW(m_GeoWaves[0].m_Dir.x * m_GeoWaves[0].m_Freq, 
		m_GeoWaves[1].m_Dir.x * m_GeoWaves[1].m_Freq, 
		m_GeoWaves[2].m_Dir.x * m_GeoWaves[2].m_Freq, 
		m_GeoWaves[3].m_Dir.x * m_GeoWaves[3].m_Freq);
	D3DXVECTOR4 dirYW(m_GeoWaves[0].m_Dir.y * m_GeoWaves[0].m_Freq, 
		m_GeoWaves[1].m_Dir.y * m_GeoWaves[1].m_Freq, 
		m_GeoWaves[2].m_Dir.y * m_GeoWaves[2].m_Freq, 
		m_GeoWaves[3].m_Dir.y * m_GeoWaves[3].m_Freq);
	m_WaterEff->SetVector(m_WaterParams.m_cDirXW, &dirXW);
	m_WaterEff->SetVector(m_WaterParams.m_cDirYW, &dirYW);

	D3DXVECTOR4 KW(K * m_GeoWaves[0].m_Freq,
		K * m_GeoWaves[1].m_Freq,
		K * m_GeoWaves[2].m_Freq,
		K * m_GeoWaves[3].m_Freq);
	m_WaterEff->SetVector(m_WaterParams.m_cKW, &KW);

	D3DXVECTOR4 dirXSqKW(m_GeoWaves[0].m_Dir.x * m_GeoWaves[0].m_Dir.x * K * m_GeoWaves[0].m_Freq,
		m_GeoWaves[1].m_Dir.x * m_GeoWaves[1].m_Dir.x * K * m_GeoWaves[1].m_Freq,
		m_GeoWaves[2].m_Dir.x * m_GeoWaves[2].m_Dir.x * K * m_GeoWaves[2].m_Freq,
		m_GeoWaves[3].m_Dir.x * m_GeoWaves[3].m_Dir.x * K * m_GeoWaves[3].m_Freq);
	m_WaterEff->SetVector(m_WaterParams.m_cDirXSqKW, &dirXSqKW);

	D3DXVECTOR4 dirYSqKW(m_GeoWaves[0].m_Dir.y * m_GeoWaves[0].m_Dir.y * K * m_GeoWaves[0].m_Freq,
		m_GeoWaves[1].m_Dir.y * m_GeoWaves[1].m_Dir.y * K * m_GeoWaves[1].m_Freq,
		m_GeoWaves[2].m_Dir.y * m_GeoWaves[2].m_Dir.y * K * m_GeoWaves[2].m_Freq,
		m_GeoWaves[3].m_Dir.y * m_GeoWaves[3].m_Dir.y * K * m_GeoWaves[3].m_Freq);
	m_WaterEff->SetVector(m_WaterParams.m_cDirYSqKW, &dirYSqKW);

	D3DXVECTOR4 dirXdirYKW(m_GeoWaves[0].m_Dir.y * m_GeoWaves[0].m_Dir.x * K * m_GeoWaves[0].m_Freq,
		m_GeoWaves[1].m_Dir.x * m_GeoWaves[1].m_Dir.y * K * m_GeoWaves[1].m_Freq,
		m_GeoWaves[2].m_Dir.x * m_GeoWaves[2].m_Dir.y * K * m_GeoWaves[2].m_Freq,
		m_GeoWaves[3].m_Dir.x * m_GeoWaves[3].m_Dir.y * K * m_GeoWaves[3].m_Freq);
	m_WaterEff->SetVector(m_WaterParams.m_cDirXDirYKW, &dirXdirYKW);

	m_WaterEff->SetTexture(m_WaterParams.m_tEnvMap, m_EnvMap);
	m_WaterEff->SetTexture(m_WaterParams.m_tBumpMap, m_BumpTex);
}

void CMyD3DApplication::ResetWater()
{
	InitTexState();
	InitGeoState();

	InitWaves();
}

void CMyD3DApplication::InitWaves()
{
	InitTexWaves();
	InitGeoWaves();
}

void CMyD3DApplication::RenderWater()
{
	SetWaterParams();

	if( m_bSortWater )
		SortWaterMesh();

	UINT nPass;
	m_WaterEff->Begin(&nPass, 0);

	UINT i;
	for( i = 0; i < nPass; i++ )
	{
		m_WaterEff->Pass(i);

		m_WaterMesh->DrawSubset(0);

	}
	m_WaterEff->End();
}

void CMyD3DApplication::RenderTexture()
{
	if( SUCCEEDED(m_BumpRender->BeginScene(m_BumpSurf, NULL)) )
	{

		D3DXMATRIXA16 matIdent;
		D3DXMatrixIdentity(&matIdent);
		m_pd3dDevice->SetTransform(D3DTS_PROJECTION, &matIdent);
		m_pd3dDevice->SetTransform(D3DTS_VIEW, &matIdent);
		m_pd3dDevice->SetTransform(D3DTS_WORLD, &matIdent);

		m_pd3dDevice->SetRenderState(D3DRS_ZENABLE, FALSE);

		SetCompCosineEffParams();

		UINT nPass;
		m_CompCosinesEff->Begin(&nPass, 0);

		UINT i;
		for( i = 0; i < nPass; i++ )
		{
			m_CompCosinesEff->Pass(i);

			m_pd3dDevice->SetFVF(kClearVertFVF);
			m_pd3dDevice->SetStreamSource(0, m_BumpVBuffer, 0, kVSize);
			m_pd3dDevice->DrawPrimitive(D3DPT_TRIANGLESTRIP, 0, 2);
		}
		m_CompCosinesEff->End();

		m_pd3dDevice->SetRenderState(D3DRS_ZENABLE, TRUE);

		m_BumpRender->EndScene( 0 );
	}
}