ca_fire.cpp

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

		    pBuff++;
        }
        m_pVertexBuffer->Unlock();
    }


    // 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_ADDRESSU,  D3DTADDRESS_CLAMP);
	    m_pD3DDev->SetTextureStageState(i, D3DTSS_ADDRESSV,  D3DTADDRESS_CLAMP);
	    m_pD3DDev->SetTextureStageState(i, D3DTSS_ADDRESSW,  D3DTADDRESS_CLAMP);

        m_pD3DDev->SetTextureStageState(i, D3DTSS_MAGFILTER, D3DTEXF_POINT );
	    m_pD3DDev->SetTextureStageState(i, D3DTSS_MINFILTER, D3DTEXF_POINT );
	    m_pD3DDev->SetTextureStageState(i, D3DTSS_MIPFILTER, D3DTEXF_NONE  );

		m_pD3DDev->SetTextureStageState(i,D3DTSS_TEXTURETRANSFORMFLAGS,	 D3DTTFF_DISABLE );
		m_pD3DDev->SetTextureStageState(i,D3DTSS_TEXCOORDINDEX, D3DTSS_TCI_PASSTHRU | i );

		m_pD3DDev->SetTextureStageState(i, D3DTSS_RESULTARG, D3DTA_CURRENT );
    }

	// Set wrap to zero - It will wrap anyway and avoid the problems of
	//   setting cylindrical wrapping (D3DRS_WRAP0, D3DWRAP_U == cylindrical)
	//   for texture coords > 1.0f

	// For wrapped textures, you should use only the D3DTSS_ADDRESSU/V/W
	//   states, unless you are doing cube environment mapping.

    m_pD3DDev->SetRenderState(D3DRS_WRAP0, 0);
    m_pD3DDev->SetRenderState(D3DRS_WRAP1, 0);
    m_pD3DDev->SetRenderState(D3DRS_WRAP2, 0);
    m_pD3DDev->SetRenderState(D3DRS_WRAP3, 0);
    m_pD3DDev->SetRenderState(D3DRS_WRAP4, 0);
    m_pD3DDev->SetRenderState(D3DRS_WRAP5, 0);
    m_pD3DDev->SetRenderState(D3DRS_WRAP6, 0);
    m_pD3DDev->SetRenderState(D3DRS_WRAP7, 0);


    m_pD3DDev->SetTextureStageState(0, D3DTSS_COLOROP,   D3DTOP_SELECTARG1);

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

	m_pD3DDev->SetRenderState(D3DRS_FOGENABLE,			FALSE );
	m_pD3DDev->SetRenderState(D3DRS_DITHERENABLE,		FALSE );
	m_pD3DDev->SetRenderState(D3DRS_ALPHATESTENABLE,	FALSE );
	m_pD3DDev->SetRenderState(D3DRS_SRCBLEND,			D3DBLEND_ONE  );
	m_pD3DDev->SetRenderState(D3DRS_DESTBLEND,			D3DBLEND_ZERO );

	m_pD3DDev->SetRenderState(D3DRS_ZWRITEENABLE,		FALSE );

	m_pD3DDev->SetRenderState(D3DRS_SPECULARENABLE,		FALSE );
	m_pD3DDev->SetRenderState(D3DRS_STENCILENABLE,		FALSE );
	m_pD3DDev->SetRenderState(D3DRS_LIGHTING,			FALSE );

	m_pD3DDev->SetRenderState(D3DRS_COLORVERTEX,		FALSE );

	m_pD3DDev->SetRenderState(D3DRS_FILLMODE,			D3DFILL_SOLID );
	m_pD3DDev->SetRenderState(D3DRS_CULLMODE,			D3DCULL_NONE );


    return hr;
}


HRESULT CA_Fire::Free()
{
	SAFE_RELEASE( m_pVertexBuffer);			// sets pointers to null after delete
	SAFE_RELEASE( m_pInitialStateTexture);
	SAFE_RELEASE( m_pOutputMapTexture );

	SAFE_DELETE(m_pUI);

	SAFE_DELETE( m_pObj );

	if (m_pD3DDev)
	{
		m_dwVertexShader = 0;
		m_SHI_SimpleObjVShader = 0;
		m_dwTwoWeight_PostMultShader = 0;
		m_dwDependentAR = 0;


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

        SAFE_RELEASE(mpBackbufferColor);
		SAFE_RELEASE(mpBackbufferDepth);

        SAFE_RELEASE(m_pD3DDev);		// we AddRef()'d in Initialize
	}
	

	m_pShaderManager = NULL;

	return S_OK;
}


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



std::string CA_Fire::GetFilePath( const std::string& strFileName )
{
	return(	effect_api::GetFilePath( strFileName ) );
}



HRESULT CA_Fire::CreateTextureRenderTargets()
{
    HRESULT         hr;

	_ASSERT( mpBackbufferColor != NULL );
	_ASSERT( mpBackbufferDepth != NULL );

    // get the description for the texture we want to filter
	D3DSURFACE_DESC ddsd;
    m_pInitialStateTexture->GetLevelDesc(0, &ddsd);

	int i;

	for( i=0; i < kMaxNumTargets; i++ )
	{
		if( mpFilterTarget[i] != NULL )
		{
            SAFE_RELEASE(mpFilterTarget[i]);
			mpFilterTarget[i] = NULL;
		}

		if( mpTextureFiltered[i] != NULL )
		{            
            SAFE_RELEASE(mpTextureFiltered[i]);
			mpTextureFiltered[i] = NULL;
		}
	}


    // create new textures just like the current texture
    for( i = 0; i < kMaxNumTargets; i++ )
    {
        hr = m_pD3DDev->CreateTexture(ddsd.Width, ddsd.Height, 1, 
                                      D3DUSAGE_RENDERTARGET, D3DFMT_X8R8G8B8, 
                                      D3DPOOL_DEFAULT, &mpTextureFiltered[i]);
        if (FAILED(hr))
        {
		    m_strLastError = "Can't CreateTexture!\n";
            assert(false);
            return E_FAIL;
        }

        hr = mpTextureFiltered[i]->GetSurfaceLevel(0, &mpFilterTarget[i]);
        if (FAILED(hr))
        {
		    m_strLastError = "Can't Get to top-level texture!\n";
            assert(false);
            return E_FAIL;
        }

        // set our render target to the new and shiny textures without depth
        hr = m_pD3DDev->SetRenderTarget(mpFilterTarget[i], NULL);
        if (FAILED(hr))
        {
		    m_strLastError = "Can't SetRenderTarget to new surface!\n";
            assert(false);
            return E_FAIL;
        }
    }

    // switch back to conventional back-buffer
    hr = m_pD3DDev->SetRenderTarget(mpBackbufferColor, mpBackbufferDepth);
    if (FAILED(hr))
    {
		m_strLastError = "Can't SetRenderTarget to original back-buffer surfaces!\n";
        assert(false);
        return E_FAIL;
    }

    return S_OK;
}


HRESULT		CA_Fire::SetPixelShader( DWORD dwIndex )
{
	HRESULT hr = S_OK;

	hr = m_pD3DDev->SetPixelShader( m_pShaderManager->GetShaderHandle( dwIndex ) );
	ASSERT_IF_FAILED(hr);

	return hr;
}


HRESULT		CA_Fire::SetVertexShader( DWORD dwIndex )
{
	HRESULT hr = S_OK;

	hr = m_pD3DDev->SetVertexShader( m_pShaderManager->GetShaderHandle( dwIndex ) );
	ASSERT_IF_FAILED(hr);

	return hr;
}



bool CA_Fire::Keyboard(DWORD dwKey, UINT nFlags, bool bDown)
{
	// Returns true if keyboard command was processed


	char charcode;

	if( bDown )
	{
		// Use only capital letters here - these are VK_ codes!

		switch( dwKey )
		{
		case VK_LEFT:
			if( m_nSlowDelay > 0 )
				m_nSlowDelay--;
			m_bSlow = true;
			FDebug("frame rate slow delay: %d\n", m_nSlowDelay );
			return( true );			// keyboard command was processed
			break;
		case VK_RIGHT:
			if( m_nSlowDelay < 500 )
				m_nSlowDelay++;
			m_bSlow = true;
			FDebug("frame rate slow delay: %d\n", m_nSlowDelay );
			return( true );
			break;

		case 'C':
			m_bMulticolor = !m_bMulticolor;
			return( true );
			break;

		case 'B':
			m_bWrap = !m_bWrap;
			FDebug("Wrap mode:  %d\n", m_bWrap );
			return( true );
			break;

		case 'M':
			m_nSkipInterval++;
			FDebug("Skip Interval:  %d\n", m_nSkipInterval );
			return( true );
			break;
		case 'N':
			m_nSkipInterval--;
			if( m_nSkipInterval < 0 )
				m_nSkipInterval = 0;
			FDebug("Skip Interval:  %d\n", m_nSkipInterval );
			return( true );
			break;

		case '1' :
			m_eRenderMode = FULLSCREEN_FINALOUT;
			return( true );
			break;

		case '2':
			m_eRenderMode = FULLSCREEN_EMBER_TEXTURE;
			return( true );
			break;

		case '3' :
			m_eRenderMode = ALL_TOGETHER;
			return( true );
			break;

		case 'F':
			m_bFarther = !m_bFarther;
			return( true );
			break;

		case 'R':
		case '`':
		case '~':
			m_bReset = true;

			return( true );
			break;
		case 'G':
			// start or stop the animation
			m_bAnimate = !m_bAnimate;
			return( true );
			break;
		case VK_SPACE:
			m_bSingleStep = !m_bSingleStep;
			return( true );
			break;
		case 'S':
			m_bSlow = !m_bSlow;
			return( true );
			break;

		default:

			charcode = MapVirtualKey( dwKey, 2 ); // VK to char code

			switch( charcode )
			{
			case '[':
			case '{':
				m_fColorAtten *= 0.999f;
				FDebug("blend:  %f\n", m_fColorAtten );
				return( true );
				break;

			case ']':
			case '}':
				m_fColorAtten *= 1.001f;
				FDebug("blend:  %f\n", m_fColorAtten );
				return( true );
				break;

			case '-':
				m_fTranslateAmount *= 0.99f;
				FDebug("m_fTranslateAmount:  %f\n", m_fTranslateAmount );
				return( true );
				break;

			case '=':
				m_fTranslateAmount *= 1.01f;
				FDebug("m_fTranslateAmount:  %f\n", m_fTranslateAmount );
				return( true );
				break;

			};
		};
	}

	return( false );		// keyboard wasn't processed

}








void CA_Fire::MouseButton(HWND hWnd, eButtonID button, bool bDown, int x, int y)
{
	if(button == MOUSE_LEFTBUTTON)
	{
		if(bDown)
		{
			m_pUI->OnLButtonDown(x, y);
		}
		else
		{
			m_pUI->OnLButtonUp(x, y);
		}
	}
}


void CA_Fire::MouseMove(HWND hWnd, int x, int y)
{
	if( m_pUI != NULL )
		m_pUI->OnMouseMove(x, y);

	return;
}


IDirect3DTexture8 *	CA_Fire::GetOutputTexture()
{
	assert( m_pOutputSrc != NULL );
	return( m_pOutputSrc );
}

void	CA_Fire::SetInputTexture( IDirect3DTexture8 * pTex )
{
	m_pInputTexture = pTex;
}


HRESULT CA_Fire::Tick()
{	
	// Render a new frame

	HRESULT hr;



	D3DXMATRIX matWorld;
	D3DXMATRIX matView;
	D3DXMATRIX matProj;
	D3DXMATRIX matViewProj;
	D3DXMATRIX matWorldViewProj;

    // write to constant memory which uv-offsets to use to accumulate neighbor information
    D3DXVECTOR4     offset(0.0f, 0.0f, 0.0f, 0.0f);
	m_pD3DDev->SetVertexShaderConstant(CV_UV_OFFSET_TO_USE, &offset, 1);


	// Disable culling
	m_pD3DDev->SetRenderState(D3DRS_CULLMODE, D3DCULL_NONE);

    // set render state 
	SetVertexShader(m_dwVertexShader);
	m_pD3DDev->SetStreamSource(0, m_pVertexBuffer, sizeof(QuadVertex));


	D3DXVECTOR3 const vEyePt    = D3DXVECTOR3( 0.0f, 0.0f, -5.0f );
	D3DXVECTOR3 const vLookatPt = D3DXVECTOR3( 0.0f, 0.0f, 0.0f );
	D3DXVECTOR3 const vUp       = D3DXVECTOR3( 0.0f, 1.0f, 0.0f );

	// Set World, View, Projection, and combination matrices.
	D3DXMatrixLookAtLH(&matView, &vEyePt, &vLookatPt, &vUp);
	D3DXMatrixOrthoLH(&matProj, 4.0f, 4.0f, 0.2f, 20.0f);

    D3DXMatrixMultiply(&matViewProj, &matView, &matProj);

    // draw a single quad to texture:
    // the quad covers the whole "screen" exactly