renderd3dwnd.cpp

游戏编程精华02－含有几十个游戏编程例子

/* Copyright (C) Greg James, 2001. 
 * All rights reserved worldwide.
 *
 * This software is provided "as is" without express or implied
 * warranties. You may freely copy and compile this source into
 * applications you distribute provided that the copyright text
 * below is included in the resulting source code, for example:
 * "Portions Copyright (C) Greg James, 2001"
 */
// RenderD3DWnd.cpp : implementation file
//

#include "StdAfx.h"
#include "NVEffectsBrowser.h"
#include "RenderD3DWnd.h"

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

//#define DISPLAY_D3D_TEXT

using namespace std;
using namespace nv_objects;

// Old-style D3D vertices
class Vertex
{
public:
	Vertex(const D3DXVECTOR3& Pos, const D3DXVECTOR3& Norm, const D3DXVECTOR2& Tex)
		: Position(Pos), Normal(Norm), Texture(Tex)
	{}

	Vertex()
	{}

	D3DXVECTOR3 Position;
	D3DXVECTOR3 Normal;
	D3DXVECTOR2 Texture;
};

class TLVertex
{
public:
	D3DXVECTOR4 Position;
	DWORD Diffuse;
	DWORD Specular;
	D3DXVECTOR2 Texture;
};

#define D3DFVF_VERTEX (D3DFVF_XYZ | D3DFVF_NORMAL | D3DFVF_TEX1)
#define D3DFVF_TLVERTEX (D3DFVF_XYZRHW | D3DFVF_DIFFUSE | D3DFVF_SPECULAR | D3DFVF_TEX1)



/////////////////////////////////////////////////////////////////////////////
// CRenderD3DWnd

IMPLEMENT_DYNCREATE(CRenderD3DWnd, CRenderWnd)

CRenderD3DWnd::CRenderD3DWnd()
  : m_devType(D3DDEVTYPE_REF),
	m_devBhv(0),
	m_bActive(true),
	m_colorBufferFormat(D3DFMT_UNKNOWN),
   	m_MultiSampleType(D3DMULTISAMPLE_NONE),
   	m_pD3DDev(NULL),
 	m_bUseSWVP(false),
 	m_pLogoVB(NULL),
 	m_pLogoTexture(NULL),
	m_bValid(false),
	m_pFontTexture(NULL),
	m_pFontVB(NULL)
{
	// Font setup
    _tcscpy( m_strFontName, _T("Arial"));
    m_dwFontHeight   = 10;
    m_dwFontFlags    = D3DFONT_BOLD;
}

CRenderD3DWnd::~CRenderD3DWnd()
{
}


BEGIN_MESSAGE_MAP(CRenderD3DWnd, CRenderWnd)
	//{{AFX_MSG_MAP(CRenderD3DWnd)
	ON_WM_SIZE()
	ON_WM_MOUSEMOVE()
	ON_WM_LBUTTONDOWN()
	ON_WM_LBUTTONUP()
	ON_WM_RBUTTONDOWN()
	ON_WM_RBUTTONUP()
	ON_WM_KEYDOWN()
	ON_WM_KEYUP()
	ON_WM_SYSKEYDOWN()
	ON_WM_SYSKEYUP()
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()


/////////////////////////////////////////////////////////////////////////////
// CRenderD3DWnd parent class overrides

HRESULT CRenderD3DWnd::Init()
{
	return InitD3D();
}

HRESULT CRenderD3DWnd::Release()
{
	return ReleaseD3D();
}

void CRenderD3DWnd::GetDevice(LPDIRECT3DDEVICE8* pDev) 
{
	if (!m_pD3DDev)
		*pDev = NULL;

	if (m_pD3DDev) {
		*pDev = m_pD3DDev; 
		m_pD3DDev->AddRef();
	}
}

HRESULT CRenderD3DWnd::UpdateDevice()
{
	HRESULT hr;
	m_devType = theApp.GetDeviceType();

	CNVEffectsDoc* pDoc = GetDocument();

	pDoc->DeleteDeviceObjects();

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

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

	hr = pDoc->InitDeviceObjects();
	if (FAILED(hr))
		return hr;

	return hr;
}

HRESULT CRenderD3DWnd::ConfirmDevice(EBEffect *pEffect)
{
	D3DCAPS8 Caps;
	m_pD3DDev->GetDeviceCaps(&Caps);
	
	HRESULT hr = pEffect->ConfirmDevice(&Caps, 0, D3DFMT_UNKNOWN);
    if (FAILED(hr))
        SetDefaultError(_T("This effect cannot run in this window or on this hardware."));

    return hr;
}

HRESULT CRenderD3DWnd::SetupEffect(EBEffect *pEffect)
{
	ASSERT(m_pD3DDev);
	if (!m_pD3DDev)
		return NVEFF_ERR_NOTINITIALIZED;
	
	ASSERT(pEffect);
	if (!pEffect)
		return NVEFF_ERR_NOTINITIALIZED;

	HRESULT hr;

	hr = m_pD3DDev->TestCooperativeLevel();
	if (FAILED(hr))
        return hr;

	hr = ConfirmDevice(pEffect);
	if (FAILED(hr))
        return hr;

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

	hr = pEffect->Initialize(m_pD3DDev);
    if (FAILED(hr)) {
        SetDefaultError(_T("This effect was unable to initialize."));
        return hr;
    }

	CRect r;
	GetClientRect(r);
	pEffect->Resize(GetSafeHwnd(), r.Width(), r.Height(), true);

	return S_OK;
}

HRESULT CRenderD3DWnd::SetDefaultRenderstates()
{
	ASSERT(m_pD3DDev);
	if (!m_pD3DDev)
		return NVEFF_ERR_NOTINITIALIZED;

	return SetDefaultRenderstatesD3D();
}

HRESULT CRenderD3DWnd::Render(bool bDrawLogo)
{
	ASSERT(m_pD3DDev);
	if (!m_pD3DDev)
		return NVEFF_ERR_NOTINITIALIZED;

	CRect r;
	GetClientRect(&r);
	CNVEffectsDoc* pDoc = GetDocument();
	if (!m_bValid || !IsWindowVisible() ||
		(r.Width() <= 0 || r.Height() <= 0) ||
		!pDoc->IsEffectValid())
		return NVEFF_ERR_NOTINITIALIZED;

	HRESULT hr;

	hr = m_pD3DDev->BeginScene();
	if (FAILED(hr))
        return hr;

    hr = pDoc->Tick();
    if (FAILED(hr))
        return hr;

	if (bDrawLogo)
		DrawLogo();

	DrawText();

	hr = m_pD3DDev->EndScene();
	if (FAILED(hr))
        return hr;

	hr = m_pD3DDev->Present(NULL, NULL, NULL, NULL);
	if (FAILED(hr))
        return hr;

	// Update the FPS, TPS, VPS labels...
	GetRenderView()->UpdateLabels();
	
	return hr;
}

HRESULT CRenderD3DWnd::Refresh(CDC* pDC)
{
	ASSERT(m_pD3DDev);
	if (!m_pD3DDev)
		return NVEFF_ERR_NOTINITIALIZED;

	HRESULT hr;

	hr = m_pD3DDev->Present(NULL, NULL, GetSafeHwnd(), NULL);
	if (FAILED(hr))
        return hr;

	return hr;
}

HRESULT CRenderD3DWnd::Clear()
{
	ASSERT(m_pD3DDev);
	if (!m_pD3DDev)
		return NVEFF_ERR_NOTINITIALIZED;

	HRESULT hr;

	// Clear to grey
	hr = m_pD3DDev->Clear(0, NULL, D3DCLEAR_TARGET|D3DCLEAR_ZBUFFER, D3DCOLOR_XRGB( 0xAA, 0xAA, 0xAA ), 1.0, 0);
	if (FAILED(hr))
        return hr;
	
	hr = m_pD3DDev->Present(NULL, NULL, GetSafeHwnd(), NULL);
	if (FAILED(hr))
        return hr;

	return hr;
}

/////////////////////////////////////////////////////////////////////////////
// CRenderD3DWnd message handlers

void CRenderD3DWnd::OnSize(UINT nType, int cx, int cy) 
{
	CRenderWnd::OnSize(nType, cx, cy);

	// Short circuit if this window is hidden
	if (!IsWindowVisible())
		return;

	CNVEffectsDoc* pDoc = GetDocument();

	m_bValid = false;

	// Update the D3D device...
	{
		pDoc->DeleteDeviceObjects();
		FreeTextBuffer();
		
		if (m_pD3DDev) {
			
			HRESULT hr;
			
			hr = m_pD3DDev->Reset(&m_d3dpp);
			if (FAILED(hr)) {
				DISPDBG(0, "ERROR: Failed resize");
				return;
			}
			
			m_bValid = true;
			
			hr = m_pD3DDev->Clear(0, NULL, D3DCLEAR_TARGET|D3DCLEAR_ZBUFFER, D3DCOLOR_XRGB( 0xAA, 0xAA, 0xAA ), 1.0, 0);
			if (FAILED(hr))	{
				DISPDBG(0, "ERROR: Failed clear");
				return;
			}
			
			hr = ResizeLogo();
			if (FAILED(hr))	{
				DISPDBG(0, "ERROR: Failed logo resize");
				return;
			}
			
			hr = SetupTextBuffer();
			if (FAILED(hr))	{
				DISPDBG(0, "ERROR: Failed setup of text VB");
				return;
			}
			
			pDoc->InitDeviceObjects();
		}
	}
}

void CRenderD3DWnd::OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags) 
{
	CRenderWnd::OnKeyDown(nChar, nRepCnt, nFlags);
}

void CRenderD3DWnd::OnKeyUp(UINT nChar, UINT nRepCnt, UINT nFlags) 
{
	CRenderWnd::OnKeyUp(nChar, nRepCnt, nFlags);
}

void CRenderD3DWnd::OnLButtonDown(UINT nFlags, CPoint point) 
{
	CRenderWnd::OnLButtonDown(nFlags, point);
}

void CRenderD3DWnd::OnLButtonUp(UINT nFlags, CPoint point) 
{
	CRenderWnd::OnLButtonUp(nFlags, point);
}

void CRenderD3DWnd::OnMouseMove(UINT nFlags, CPoint point) 
{
	CRenderWnd::OnMouseMove(nFlags, point);
}

void CRenderD3DWnd::OnRButtonDown(UINT nFlags, CPoint point) 
{
	CRenderWnd::OnRButtonDown(nFlags, point);
}

void CRenderD3DWnd::OnRButtonUp(UINT nFlags, CPoint point) 
{
	CRenderWnd::OnRButtonUp(nFlags, point);
}

void CRenderD3DWnd::OnSysKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags) 
{
	CRenderWnd::OnSysKeyDown(nChar, nRepCnt, nFlags);
}

void CRenderD3DWnd::OnSysKeyUp(UINT nChar, UINT nRepCnt, UINT nFlags) 
{
	CRenderWnd::OnSysKeyUp(nChar, nRepCnt, nFlags);
}

/////////////////////////////////////////////////////////////////////////////
// CRenderD3DWnd private implementation 

HRESULT CRenderD3DWnd::InitD3D()
{
	D3DDISPLAYMODE DisplayMode;
	UINT i;
	IDirect3D8 *pEnum = Direct3DCreate8(D3D_SDK_VERSION);

	m_bValid = false;
    if (pEnum == NULL)
	{
		assert(0);
        return E_FAIL;
	}

    HRESULT hr;
 
	m_devType = theApp.GetDeviceType();
	
	// Use current display mode
	if(FAILED(pEnum->GetAdapterDisplayMode(D3DADAPTER_DEFAULT , &DisplayMode)))
	{
		MessageBox("Could not get adapter display mode!", "ERROR", MB_OK);
		return E_FAIL;
	}

	m_colorBufferFormat = DisplayMode.Format;
    
	m_devType = theApp.GetDeviceType();
    memset(&m_d3dpp, 0, sizeof(m_d3dpp));
    m_d3dpp.Windowed = TRUE;
    m_d3dpp.BackBufferFormat = m_colorBufferFormat;
    m_d3dpp.MultiSampleType = m_MultiSampleType;
    m_d3dpp.EnableAutoDepthStencil = TRUE;

    D3DFORMAT s_ZS16[] = 
    { 
        D3DFMT_D16_LOCKABLE,
        D3DFMT_D16,
        D3DFMT_D15S1,
        D3DFMT_D32,
        D3DFMT_D24S8,
        D3DFMT_D24X4S4,
        D3DFMT_D24X8
    };

    D3DFORMAT s_ZS32[] = 
    { 
        D3DFMT_D32,
        D3DFMT_D24S8,
        D3DFMT_D24X4S4,
        D3DFMT_D24X8,
        D3DFMT_D16_LOCKABLE,
        D3DFMT_D16,
        D3DFMT_D15S1
    };

    D3DFORMAT *pZS;

    switch(m_colorBufferFormat)
    {
		case D3DFMT_R5G6B5:
		case D3DFMT_X1R5G5B5:
		case D3DFMT_A1R5G5B5:
		case D3DFMT_A4R4G4B4:
		case D3DFMT_A8R3G3B2:
		case D3DFMT_X4R4G4B4:
			pZS = s_ZS16;
			break;

		case D3DFMT_R8G8B8:
		case D3DFMT_A8R8G8B8:
		case D3DFMT_X8R8G8B8:
		default:
			pZS = s_ZS32;
			break;
    }

    for(i = 0; i < 7; i++)
    {

        if(FAILED(pEnum->CheckDeviceFormat(D3DADAPTER_DEFAULT, m_devType, 
            m_colorBufferFormat, D3DUSAGE_DEPTHSTENCIL, D3DRTYPE_SURFACE, pZS[i])))
        {
            continue;
        }

        if(FAILED(pEnum->CheckDepthStencilMatch(D3DADAPTER_DEFAULT, m_devType, 
            m_colorBufferFormat, m_colorBufferFormat, pZS[i])))