water.cpp

水波演示

// Water.cpp : Defines the class behaviors for the application.
//

#include "stdafx.h"
#include "Water.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

/////////////////////////////////////////////////////////////////////////////
// CWaterApp

BEGIN_MESSAGE_MAP(CWaterApp, CDirectXApp)
	//{{AFX_MSG_MAP(CWaterApp)
	ON_COMMAND(ID_APP_ABOUT, OnAppAbout)
		// NOTE - the ClassWizard will add and remove mapping macros here.
		//    DO NOT EDIT what you see in these blocks of generated code!
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CWaterApp construction

#ifdef _DEBUG
#pragma comment(lib, "DXGuideD.lib")
#else
#pragma comment(lib, "DXGuide.lib")
#endif	// _DEBUG

CWaterApp::CWaterApp(void)
{
	for (int  i = 1; i < __argc; ++ i)
	{
		LPCTSTR	pszParam = __targv[i];
		if ((pszParam[0] == _T('-') || pszParam[0] == _T('/'))
			&& ::lstrlen(pszParam) == 2)
		{
			switch (pszParam[1])
			{
			case _T('f'):
			case _T('F'):
				SetFullScreen(true);
				break;

			default:
				break;
			}
		}
	}

	SetPackFileName(_T("Media"), _T("gui.ff"));

	m_pDDDevice = NULL;
	m_pRenderSurface = NULL;

	m_pBuf1 = m_pBuf2 = NULL;
	m_pTexture = NULL;
	m_pRender = NULL;
}

bool	CWaterApp::GetDXInitSettings(void)
{
	if (m_pDirectSound != NULL)
	{
		if (m_pDirectSound->SelectDSDriver(0) == false)
			return  false;
	}
	
	if (m_pDirectMusic != NULL)
	{
		if (m_pDirectMusic->SelectDefaultDMusPort() == false)
			return  false;
	}

	if (m_pDirectDraw->SelectDDDevice(0) == false)
		return  false;

	if (m_pDirectDraw->GetFirstEnableDevice()->SelectDisplayMode(
		IsFullScreen(), 640, 480, 16) == false)
		return  false;

	return  true;

	//return  CDirectXApp::GetDXInitSettings();
}

bool	CWaterApp::InitDXObjects(void)
{
	m_pDDDevice = GetFirstDDDevice();
	m_pRenderSurface = m_pDDDevice->GetRenderSurface();
	// add your init code here !
	m_pBuf1 = new short[64000];
	m_pBuf2 = new short[64000];
	::ZeroMemory(m_pBuf1, 64000 * sizeof(short));
	::ZeroMemory(m_pBuf2, 64000 * sizeof(short));

	m_pTexture = new  CDDDIBSurface;
	m_pTexture->Create(m_pDDDevice, _T("texture.bmp"), m_pPackFileManager, CDIB::FT_BITMAP, CDDSurface::SURFACEMEM_SYSTEM);

	m_pRender = new  CDDSurface;
	m_pRender->Create(m_pDDDevice, 320, 200, CDDSurface::SURFACEMEM_AUTO);

	return  true;
}

bool	CWaterApp::DestroyDXObjects(void)
{
	// add your destroy code here !
	if (m_pRender != NULL)
	{
		delete  m_pRender;
		m_pRender = NULL;
	}

	if (m_pTexture != NULL)
	{
		delete  m_pTexture;
		m_pTexture = NULL;
	}

	if (m_pBuf1 != NULL)
	{
		delete  []m_pBuf1;
		m_pBuf1 = NULL;
	}

	if (m_pBuf2 != NULL)
	{
		delete  []m_pBuf2;
		m_pBuf2 = NULL;
	}

	m_pRenderSurface = NULL;
	m_pDDDevice = NULL;
	return  CDirectXApp::DestroyDXObjects();
}

CRect	rc1(0, 0, 640, 480);
CRect	rc2(0, 1, 320, 199);
CRect	rc3(160, 141, 480, 339);
bool	CWaterApp::UpdateFrame(void)
{
	// add your code here !
	// add source
	int	r = abs(rand()) << 1;
	r = r > 0xF9FF ? 0xF9FF : r;
	r = r < 320 ? 320 : r;
	m_pBuf1[r] = 32;

	RippleSpread();
	RenderRipple();
	m_pRenderSurface->Blt(&rc1, m_pTexture, &rc1, DDBLT_WAIT, NULL);
	m_pRenderSurface->Blt(&rc3, m_pRender, &rc2, DDBLT_WAIT, NULL);

	return  CDirectXApp::UpdateFrame();
}

/////////////////////////////////////////////////////////////////////////////
// The one and only CWaterApp object

CWaterApp theApp;

// App command to run the dialog
#include "AboutDlg.h"
void CWaterApp::OnAppAbout()
{
	CAboutDlg aboutDlg;
	aboutDlg.DoModal();
}

/////////////////////////////////////////////////////////////////////////////
// CWaterApp commands

void	CWaterApp::RippleSpread(void)
{
	for (int  i = 320; i < 64000 - 320; ++ i)
	{
		// Spread out
		m_pBuf2[i] = short(
			((m_pBuf1[i - 1]
			+ m_pBuf1[i + 1]
			+ m_pBuf1[i - 320]
			+ m_pBuf1[i + 320]) >> 1) - m_pBuf2[i]);

		// Energy damping
		m_pBuf2[i] -= (short)(m_pBuf2[i] >> 5);
	}

	// Swap m_pBuf1 and m_pBuf2
	short*	ptmp = m_pBuf1;
	m_pBuf1 = m_pBuf2;
	m_pBuf2 = ptmp;
}

void CWaterApp::RenderRipple(void)
{
	DDSURFACEDESC2	ddsd;
	ddsd.dwSize = sizeof (DDSURFACEDESC2);
	m_pTexture->Lock(&ddsd);

	DDSURFACEDESC2	ddsd1;
	ddsd1.dwSize = sizeof(DDSURFACEDESC2);
	m_pRender->Lock(&ddsd1);

	int	k = 320;
	for (int  i = 1; i < 199; ++ i)
	{
		for (int  j = 0; j < 320; ++ j)
		{
			// do refraction
			int	xoff = m_pBuf1[k - 1] - m_pBuf1[k + 1];
			int	yoff = m_pBuf1[k - 320] - m_pBuf1[k + 320];
			DWORD	dwPixel = m_pTexture->GetPixel(&ddsd, 160 + j + xoff, 140 + i + yoff);

			// do shading
			int	p = dwPixel & 0x1F;
			p += xoff;
			if (p > 31)
				p = 31;
			if (p < 0)
				p = 0;
			dwPixel = (dwPixel & 0xFFFFFFE0) | p;

			m_pRender->PutPixel(&ddsd1, j, i, dwPixel);
			k ++;
		}
	}

	m_pTexture->Unlock();
	m_pRender->Unlock();
}