filterblit.cpp

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

/******************************************************************************

  Copyright (C) 1999, 2000 NVIDIA Corporation
  This file is provided without support, instruction, or implied warranty of any
  kind.  NVIDIA makes no guarantee of its fitness for a particular purpose and is
  not liable under any circumstances for any damages or loss whatsoever arising
  from the use or inability to use this file or items derived from it.
  
    Comments:
    
      
        
******************************************************************************/

#include <crtdbg.h>

#include "eb_effect.h"
#include "nvtex.h"
#include "nvmesh.h"
#include "nvdevice.h"
#include "FilterBlit.h"

#include "Constants.h"

using namespace nv_objects;
using namespace std;

DECLARE_EFFECT_MAIN()

extern "C"
{

__declspec(dllexport) unsigned int GetNumEffects() 
{ 
    return static_cast<unsigned int>(CFilterBlit::NUM_FILTER_OPTIONS); 
}

__declspec(dllexport) EBEffect* CreateEffect(unsigned int EffectNum)
{
	return new CFilterBlit(static_cast<CFilterBlit::eFilterOptions>(EffectNum));
}

}

CFilterBlit::CFilterBlit(eFilterOptions initDisplayOption)
	: meDisplayOption    (initDisplayOption)
    , meInitDisplayOption(initDisplayOption)
    , mbWireFrame        (false)
    , mpTextureToFilter  (NULL)
	, m_pNVDevice(NULL)
	, m_dwVertexShader(0)
    , m_dwLuminancePixelShader(0)
    , m_dwLuminanceDiagEdgePixelShader(0)
    , m_dwLuminanceSensitiveDiagEdgePixelShader(0)
    , m_dwBlurPixelShader   (0)
    , m_dwSharpenPixelShader(0)
	, m_pVertexBuffer(NULL)
	, mpBackbufferColor( 0 )
	, mpBackbufferDepth( 0 )
{
	for ( int i = 0; i < kMaxNumPasses; ++i )
	{
        mpTextureFiltered[i] = 0;
		mpFilterTarget   [i] = 0;
	}

	m_strEffectLocation     = "Pixel Shaders\\Image Processing";
	m_strEffectVertexShader = GetFilePath("FilterBlit.nvv");

    switch (meDisplayOption)
	{
		case CONE_FILTER:
            m_strEffectName        = "Filter Blitting (9-sample cone filter)";
			m_strEffectPixelShader = GetFilePath("BlurBlit.nvp");
			break;
		case BOX9_FILTER:
            m_strEffectName        = "Filter Blitting (9-sample box filter)";
			m_strEffectPixelShader = GetFilePath("BlurBlit.nvp");
			break;
		case BOX16_FILTER:
            m_strEffectName        = "Filter Blitting (16-sample box filter)";
			m_strEffectPixelShader = GetFilePath("BlurBlit.nvp");
			break;
		case SHARPEN_FILTER:
            m_strEffectName        = "Filter Blitting (sharpening filter)";
			m_strEffectPixelShader = GetFilePath("SharpenBlit.nvp");
            break;
		case LUMINANCE_EDGE:
            m_strEffectName        = "Filter Blitting (luminance edge detection)";
			m_strEffectPixelShader = GetFilePath("LuminanceDiagEdgeBlit.nvp");
			break;
		default:
            m_strEffectName        = "Filter Blitting (unknown)";
			m_strEffectPixelShader = GetFilePath("BlurBlit.nvp");
		    break;
    }
}

CFilterBlit::~CFilterBlit()
{
	Free();	
}

HRESULT CFilterBlit::ConfirmDevice(D3DCAPS8* pCaps, DWORD dwBehavior, D3DFORMAT Format)
{
    // check vertex shading support
    if(D3DSHADER_VERSION_MAJOR(pCaps->VertexShaderVersion) < 1)
	{
		m_strLastError = "Device does not support vertex shaders!";
		return E_FAIL;
	}
    if(D3DSHADER_VERSION_MINOR(pCaps->VertexShaderVersion) < 1)
	{
		m_strLastError = "Device does not support 1.1 vertex shaders!";
		return E_FAIL;
	}

    // check simultaneous texture support
    if(pCaps->MaxSimultaneousTextures < 4)
	{
		m_strLastError = "Device does not support 4 simultaneous textures!";
		return E_FAIL;
	}

    // check pixel shader support
    if(D3DSHADER_VERSION_MAJOR(pCaps->PixelShaderVersion) < 1)
	{
		m_strLastError = "Device does not support pixel shaders!";
		return E_FAIL;
	}
	if(D3DSHADER_VERSION_MINOR(pCaps->PixelShaderVersion) < 1)
	{
		m_strLastError = "Device does not support 1.1 pixel shaders!";
		return E_FAIL;
	}
	if(pCaps->MaxTextureBlendStages < 8)
	{
		m_strLastError = "Device does not support 8 register combiners!";
		return E_FAIL;
	}


	return S_OK;
}

void CFilterBlit::UpdateProperties()
{
	EBEffect::UpdateProperties();

    AddProperty(new EBProperty("Wireframe", OBJECT_MEMBER(mbWireFrame), EBTYPE_BOOL_PROP));

	EBEnumProperty* pEnumProp = new EBEnumProperty("Display Options", OBJECT_MEMBER(meDisplayOption), EBTYPE_DWORD_PROP, PROPFLAG_CALLBACK | PROPFLAG_PUBLIC);
	
	pEnumProp->AddEnumerant(new EBEnumValue(pEnumProp, "Show  9-sample Cone Filtering", (DWORD)CONE_FILTER, EBTYPE_DWORD_PROP));
	pEnumProp->AddEnumerant(new EBEnumValue(pEnumProp, "Show  9-sample Box  Filtering", (DWORD)BOX9_FILTER, EBTYPE_DWORD_PROP));
	pEnumProp->AddEnumerant(new EBEnumValue(pEnumProp, "Show 16-sample Box  Filtering", (DWORD)BOX16_FILTER, EBTYPE_DWORD_PROP));
	pEnumProp->AddEnumerant(new EBEnumValue(pEnumProp, "Show Sharpening Filter",        (DWORD)SHARPEN_FILTER, EBTYPE_DWORD_PROP));
	pEnumProp->AddEnumerant(new EBEnumValue(pEnumProp, "Show Luminance Edge Detection", (DWORD)LUMINANCE_EDGE, EBTYPE_DWORD_PROP));
	AddProperty(pEnumProp);

	// Vertex shaders
	m_pVertexShaderEnum->AddEnumerant(new EBEnumValue(m_pVertexShaderEnum, "Filter Blit", GetFilePath("FilterBlit.nvv"), EBTYPE_STRING_PROP));

	// Pixel shaders
	m_pPixelShaderEnum->AddEnumerant(new EBEnumValue(m_pPixelShaderEnum, "Blur Blit", GetFilePath("BlurBlit.nvp"), EBTYPE_STRING_PROP));
	m_pPixelShaderEnum->AddEnumerant(new EBEnumValue(m_pPixelShaderEnum, "Luminance Blit", GetFilePath("LuminanceBlit.nvp"), EBTYPE_STRING_PROP));
	m_pPixelShaderEnum->AddEnumerant(new EBEnumValue(m_pPixelShaderEnum, "Luminance Edge Blit", GetFilePath("LuminanceDiagEdgeBlit.nvp"), EBTYPE_STRING_PROP));
	m_pPixelShaderEnum->AddEnumerant(new EBEnumValue(m_pPixelShaderEnum, "SharpenBlit Blit", GetFilePath("SharpenBlit.nvp"), EBTYPE_STRING_PROP));

}

HRESULT CFilterBlit::Initialize(IDirect3DDevice8* pDev)
{
    int     i;
	HRESULT hr;

	// get the device
	m_pD3DDev = pDev;
	pDev->AddRef();

	m_pNVDevice = new NVDevice(pDev);

	// create the vertex and pixel shaders
	vector<DWORD> Declaration;
	Declaration.push_back(D3DVSD_STREAM(0));
	Declaration.push_back(D3DVSD_REG(0, D3DVSDT_FLOAT3));
	Declaration.push_back(D3DVSD_REG(1, D3DVSDT_FLOAT2));
	Declaration.push_back(D3DVSD_END());

	m_dwVertexShader = 0;
	hr = LoadAndCreateShader(GetFilePath("FilterBlit.vso"), &Declaration[0], 0, SHADERTYPE_VERTEX, &m_dwVertexShader);
	if (FAILED(hr))
		return hr;
	
	hr = LoadAndCreateShader(GetFilePath("LuminanceBlit.pso"), NULL, 0, SHADERTYPE_PIXEL, &m_dwLuminancePixelShader);
	if (FAILED(hr))
		return hr;
	hr = LoadAndCreateShader(GetFilePath("LuminanceDiagEdgeBlit.pso"), NULL, 0, SHADERTYPE_PIXEL, &m_dwLuminanceDiagEdgePixelShader);
	if (FAILED(hr))
		return hr;
	hr = LoadAndCreateShader(GetFilePath("LuminanceSensitiveDiagEdgeBlit.pso"), NULL, 0, SHADERTYPE_PIXEL, &m_dwLuminanceSensitiveDiagEdgePixelShader);
	if (FAILED(hr))
		return hr;

    hr = LoadAndCreateShader(GetFilePath("BlurBlit.pso"), NULL, 0, SHADERTYPE_PIXEL, &(m_dwBlurPixelShader));
	if (FAILED(hr))
		return hr;
	hr = LoadAndCreateShader(GetFilePath("SharpenBlit.pso"), NULL, 0, SHADERTYPE_PIXEL, &(m_dwSharpenPixelShader));
	if (FAILED(hr))
		return hr;

	// load the texture to filter
	mpTextureToFilter = new NVTexture();
    hr = mpTextureToFilter->CreateFromFile(m_pD3DDev, GetFilePath("MSLobby.dds"));
	if (FAILED(hr))
	{
		m_strLastError = "Could not load texture MSLobby.dds";
		return hr;
	}

	D3DSURFACE_DESC ddsd;
    mpTextureToFilter->GetTexture()->GetLevelDesc(0, &ddsd);

	// create vertex buffer 
	hr = m_pD3DDev->CreateVertexBuffer( 4 * sizeof(QuadVertex), D3DUSAGE_WRITEONLY | D3DUSAGE_DYNAMIC, 0, D3DPOOL_DEFAULT, &m_pVertexBuffer);
	if (FAILED(hr))
		return hr;

	QuadVertex      *pBuff;

	if (m_pVertexBuffer)
	{
		hr = m_pVertexBuffer->Lock(0, 4 * sizeof(QuadVertex),(BYTE**)&pBuff, 0);
		if (FAILED(hr))
		{
			m_strLastError = "Couldn't lock buffer!";
			return hr;
		}

        for (i = 0; i < 4; ++i)
        {
            pBuff->Position = D3DXVECTOR3((i==0 || i==3) ? -1.0f : 1.0f,
                                          (i<2)          ? -1.0f : 1.0f,
                                          0.0f);
		    pBuff->Tex      = D3DXVECTOR2((i==0 || i==3) ? 0.0f : 1.0f, 
                                          (i<2)          ? 1.0f : 0.0f);
		    pBuff++;
        }
        m_pVertexBuffer->Unlock();
    }
    CreateAndWriteUVOffsets(ddsd.Width, ddsd.Height);

    // set up render state: disable all except texture stage 0 (see below)
    for (i = 0; i < 4; ++i)
    {
	    m_pD3DDev->SetTextureStageState(i, D3DTSS_COLOROP,   D3DTOP_DISABLE);
	    m_pD3DDev->SetTextureStageState(i, D3DTSS_COLORARG1, D3DTA_TEXTURE);
	    m_pD3DDev->SetTextureStageState(i, D3DTSS_ALPHAOP,   D3DTOP_DISABLE);

        m_pD3DDev->SetTextureStageState(i, D3DTSS_MAGFILTER, D3DTEXF_LINEAR);
	    m_pD3DDev->SetTextureStageState(i, D3DTSS_MINFILTER, D3DTEXF_LINEAR);
	    m_pD3DDev->SetTextureStageState(i, D3DTSS_MIPFILTER, D3DTEXF_NONE);
	    m_pD3DDev->SetTextureStageState(i, D3DTSS_ADDRESSU,  D3DTADDRESS_CLAMP);
	    m_pD3DDev->SetTextureStageState(i, D3DTSS_ADDRESSV,  D3DTADDRESS_CLAMP);
    }
    m_pD3DDev->SetTextureStageState(0, D3DTSS_COLOROP,   D3DTOP_SELECTARG1);

    m_pD3DDev->SetRenderState(D3DRS_ALPHABLENDENABLE, FALSE);
    m_pD3DDev->SetRenderState(D3DRS_ZENABLE, FALSE);

    return CreateTextureRenderTarget();
}

HRESULT CFilterBlit::Free()
{
	SAFE_RELEASE(m_pVertexBuffer);
	SAFE_DELETE(m_pNVDevice);
	SAFE_DELETE(mpTextureToFilter);
	
	if (m_pD3DDev)
	{
		m_pD3DDev->DeleteVertexShader(m_dwVertexShader);
		m_pD3DDev->DeletePixelShader(m_dwLuminancePixelShader);
		m_pD3DDev->DeletePixelShader(m_dwLuminanceDiagEdgePixelShader);
		m_pD3DDev->DeletePixelShader(m_dwLuminanceSensitiveDiagEdgePixelShader);

		m_pD3DDev->DeletePixelShader(m_dwBlurPixelShader);
		m_pD3DDev->DeletePixelShader(m_dwSharpenPixelShader);

        for (int i = 0; i < kMaxNumPasses; ++i)
        {
            
            SAFE_RELEASE(mpTextureFiltered[i]);
            SAFE_RELEASE(mpFilterTarget[i]);
        }

        SAFE_RELEASE(mpBackbufferColor);
		SAFE_RELEASE(mpBackbufferDepth);

        SAFE_RELEASE(m_pD3DDev);
	}
	
	return S_OK;
}

HRESULT CFilterBlit::Start()
{
	return S_OK;
}

// Our properties were updated, set the correct shader to match
void CFilterBlit::PropertyUpdateCallback(const EBProperty* pProperty, bool bWritten)
{
	// If somebody changed the filter we are doing, set the dirty flag and change the 
    // pixel shader enum to reflect this.
	if (pProperty->IsKindOf(EBTYPE_ENUM_PROP))
	{
		if (bWritten)
		{
			if (pProperty->GetOffset() == OBJECT_MEMBER(m_strEffectPixelShader))
			{
				if (m_strEffectPixelShader.compare(GetFilePath("BlurBlit.nvp")) == 0)
				{
					meDisplayOption = CONE_FILTER;
				}
				else if (m_strEffectPixelShader.compare(GetFilePath("SharpenBlit.nvp")) == 0)
				{
					meDisplayOption = SHARPEN_FILTER;
				}
				else if (   (m_strEffectPixelShader.compare(GetFilePath("LuminanceDiagEdgeBlit.nvp")) == 0)
						 || (m_strEffectPixelShader.compare(GetFilePath("LuminanceBlit.nvp")) == 0))
				{
					meDisplayOption = LUMINANCE_EDGE;
				}

				m_dwEffectDirtyFlags |= EBEFFECT_DIRTY_PUBLICSTATE;
			}
			else
			{
				switch (meDisplayOption)
				{
					case CONE_FILTER:
					case BOX9_FILTER:
					case BOX16_FILTER:
						m_strEffectPixelShader = GetFilePath("BlurBlit.nvp");
						break;
					case SHARPEN_FILTER:
						m_strEffectPixelShader = GetFilePath("SharpenBlit.nvp");
							break;
					case LUMINANCE_EDGE:
						m_strEffectPixelShader = GetFilePath("LuminanceDiagEdgeBlit.nvp");
						break;
					default:
					;
				}

				m_dwEffectDirtyFlags |= EBEFFECT_DIRTY_PIXELSHADERS;
			}
		}		
	}
}

HRESULT CFilterBlit::Tick(EBTimer* pTimer)
{
	HRESULT hr;

    // set a bunch of render-state for rendering the world
    m_pD3DDev->SetRenderState(D3DRS_FILLMODE, (mbWireFrame) ? D3DFILL_WIREFRAME : D3DFILL_SOLID);

	D3DXMATRIX matWorld;
	D3DXMATRIX matView;