RiskYourLife/Client
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
067ec2bfa125c0f0236013f66c58959600289965
Client/GameTools/Zallad3D SceneClass/Glare.cpp
LGram16 dd97ddec92 Restructure repository to include all source folders 
Move git root from Client/ to src/ to track all source code:
- Client: Game client source (moved to Client/Client/)
- Server: Game server source
- GameTools: Development tools
- CryptoSource: Encryption utilities
- database: Database scripts
- Script: Game scripts
- rylCoder_16.02.2008_src: Legacy coder tools
- GMFont, Game: Additional resources

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>
2025-11-29 20:17:20 +09:00

723 lines
29 KiB
C++
Raw Blame History

// Glare.cpp: implementation of the CGlare class.
//
//////////////////////////////////////////////////////////////////////
#include "d3dx8.h"
#include "dxutil.h"
#include "BaseGraphicsLayer.h"
#include "Glare.h"
#include "SceneStateMgr.h"
#define __CENTER -0.5f
const DWORD GLAREDISPLAY_VERTEX::FVF = D3DFVF_XYZRHW | D3DFVF_TEX1 | D3DFVF_DIFFUSE;
CGlareScene::CGlareScene()
{
m_pd3dDevice = NULL;
m_pOldRenderTarget = NULL;
m_pOldZSurface = NULL;
ZeroMemory( m_RenderTarget256, sizeof(m_RenderTarget256) );
ZeroMemory( m_RenderTarget128, sizeof(m_RenderTarget128) );
ZeroMemory( m_RenderTarget64, sizeof(m_RenderTarget64) );
ZeroMemory( m_RenderTarget32, sizeof(m_RenderTarget32) );
ZeroMemory( m_RenderTarget16, sizeof(m_RenderTarget16) );
}
CGlareScene::~CGlareScene()
{
Destroy();
}
HRESULT CGlareScene::Create( LPDIRECT3DDEVICE8 Device )
{
m_pd3dDevice = Device;
HRESULT hr = S_OK;
for( int i = 0; i < NUM_256_TEXTURES; i++ )
{
if( FAILED(hr=CreateRenderTarget(&m_RenderTarget256[i], GLARETEXTURE_HEIGHT, GLARETEXTURE_WIDTH)) )
return hr;
}
for( i = 0; i < NUM_128_TEXTURES; i++ )
{
if( FAILED(hr= CreateRenderTarget(&m_RenderTarget128[i], GLARETEXTURE_HEIGHT>>1, GLARETEXTURE_HEIGHT>>1)) )
return hr;
}
for( i = 0; i < NUM_64_TEXTURES; i++ )
{
if( FAILED(hr=CreateRenderTarget(&m_RenderTarget64[i], GLARETEXTURE_HEIGHT>>2, GLARETEXTURE_HEIGHT>>2)) )
return hr;
}
for( i = 0; i < NUM_32_TEXTURES; i++ )
{
if( FAILED(hr=CreateRenderTarget(&m_RenderTarget32[i], GLARETEXTURE_HEIGHT>>3, GLARETEXTURE_HEIGHT>>3)) )
return hr;
}
for( i = 0; i < NUM_16_TEXTURES; i++ )
{
if( FAILED(hr=CreateRenderTarget(&m_RenderTarget16[i], GLARETEXTURE_HEIGHT>>4, GLARETEXTURE_HEIGHT>>4)) )
return hr;
}
m_pd3dDevice->GetRenderTarget( &m_pOldRenderTarget );
m_pd3dDevice->GetDepthStencilSurface( &m_pOldZSurface );
for (DWORD t=0; t<3; t++)
{
CSceneStateMgr::_SetD3DTextureStageState (t, D3DTSS_MAGFILTER, D3DTEXF_LINEAR);
CSceneStateMgr::_SetD3DTextureStageState (t, D3DTSS_MINFILTER, D3DTEXF_LINEAR);
}
return S_OK;
}
bool CGlareScene::BeginRenderToTexture()
{
m_pd3dDevice->GetViewport( &m_OldViewport );
m_pd3dDevice->GetRenderTarget( &m_pOldRenderTarget );
m_pd3dDevice->GetDepthStencilSurface( &m_pOldZSurface );
D3DVIEWPORT8 NewViewport;
NewViewport.X = 0;
NewViewport.Y = 0;
NewViewport.MaxZ = 1.0f;
NewViewport.MinZ = 0.0f;
NewViewport.Width = GLARETEXTURE_WIDTH;
NewViewport.Height = GLARETEXTURE_HEIGHT;
//RenderTarget PrimaryBlurImage
if( FAILED(m_pd3dDevice->SetRenderTarget(m_RenderTarget256[0].pSurface, m_RenderTarget256[0].pZSurface)) )
return false;
if( FAILED(m_pd3dDevice->SetViewport(&NewViewport)) )
return false;
m_pd3dDevice->Clear( 0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, 0x00000000, 1.0f, 0 );
//Render to Texture
m_pd3dDevice->EndScene();
m_pd3dDevice->BeginScene();
return true;
}
bool CGlareScene::EndRenderToTexture()
{
m_pd3dDevice->EndScene();
m_pd3dDevice->BeginScene();
//Return Old State
m_pd3dDevice->SetRenderTarget( m_pOldRenderTarget, m_pOldZSurface );
m_pd3dDevice->SetViewport( &m_OldViewport );
SAFE_RELEASE( m_pOldRenderTarget );
SAFE_RELEASE( m_pOldZSurface );
return true;
}
void CGlareScene::Destroy()
{
SAFE_RELEASE(m_pOldRenderTarget);
SAFE_RELEASE(m_pOldZSurface);
for( int i = 0; i < NUM_256_TEXTURES; i++ )
{
SAFE_RELEASE(m_RenderTarget256[i].pTexture);
SAFE_RELEASE(m_RenderTarget256[i].pSurface);
SAFE_RELEASE(m_RenderTarget256[i].pZSurface);
}
for( i = 0; i < NUM_128_TEXTURES; i++ )
{
SAFE_RELEASE(m_RenderTarget128[i].pTexture);
SAFE_RELEASE(m_RenderTarget128[i].pSurface);
SAFE_RELEASE(m_RenderTarget128[i].pZSurface);
}
for( i = 0; i < NUM_64_TEXTURES; i++ )
{
SAFE_RELEASE(m_RenderTarget64[i].pTexture);
SAFE_RELEASE(m_RenderTarget64[i].pSurface);
SAFE_RELEASE(m_RenderTarget64[i].pZSurface);
}
for( i = 0; i < NUM_32_TEXTURES; i++ )
{
SAFE_RELEASE(m_RenderTarget32[i].pTexture);
SAFE_RELEASE(m_RenderTarget32[i].pSurface);
SAFE_RELEASE(m_RenderTarget32[i].pZSurface);
}
for( i = 0; i < NUM_16_TEXTURES; i++ )
{
SAFE_RELEASE(m_RenderTarget16[i].pTexture);
SAFE_RELEASE(m_RenderTarget16[i].pSurface);
SAFE_RELEASE(m_RenderTarget16[i].pZSurface);
}
}
void CGlareScene::SetDiffuseColorShader()
{
CSceneStateMgr::_SetD3DTextureStageState (0, D3DTSS_COLORARG1, D3DTA_TEXTURE);
CSceneStateMgr::_SetD3DTextureStageState (0, D3DTSS_COLORARG2, D3DTA_DIFFUSE);
CSceneStateMgr::_SetD3DTextureStageState (0, D3DTSS_COLOROP, D3DTOP_SELECTARG2);
CSceneStateMgr::_SetD3DTextureStageState (0, D3DTSS_ALPHAOP, D3DTOP_DISABLE);
m_pd3dDevice->SetTexture (1, NULL);
CSceneStateMgr::_SetD3DTextureStageState (1, D3DTSS_COLOROP, D3DTOP_DISABLE);
CSceneStateMgr::_SetD3DTextureStageState (1, D3DTSS_ALPHAOP, D3DTOP_DISABLE);
}
void CGlareScene::SetTextureShader( LPDIRECT3DTEXTURE8 pTexture )
{
m_pd3dDevice->SetTexture (0, pTexture);
CSceneStateMgr::_SetD3DTextureStageState (0, D3DTSS_COLORARG1, D3DTA_TEXTURE);
CSceneStateMgr::_SetD3DTextureStageState (0, D3DTSS_COLORARG2, D3DTA_DIFFUSE);
CSceneStateMgr::_SetD3DTextureStageState (0, D3DTSS_COLOROP, D3DTOP_SELECTARG1);
CSceneStateMgr::_SetD3DTextureStageState (0, D3DTSS_ALPHAOP, D3DTOP_DISABLE);
m_pd3dDevice->SetTexture (1, NULL);
CSceneStateMgr::_SetD3DTextureStageState (1, D3DTSS_COLOROP, D3DTOP_DISABLE);
CSceneStateMgr::_SetD3DTextureStageState (1, D3DTSS_ALPHAOP, D3DTOP_DISABLE);
}
void CGlareScene::SetTextureAlphaFactorShader( LPDIRECT3DTEXTURE8 pTexture, D3DCOLOR color )
{
CSceneStateMgr::_SetD3DRenderState( D3DRS_TEXTUREFACTOR, color );
m_pd3dDevice->SetTexture ( 0, pTexture );
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE );
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG2, D3DTA_DIFFUSE );
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_SELECTARG1 );
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_ALPHAARG1, D3DTA_TEXTURE );
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_ALPHAARG2, D3DTA_TFACTOR );
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_ALPHAOP, D3DTOP_SELECTARG2 );
m_pd3dDevice->SetTexture( 1, NULL );
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLOROP, D3DTOP_DISABLE );
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_ALPHAOP, D3DTOP_DISABLE );
}
void CGlareScene::SetColorFactorShader( D3DCOLOR color )
{
CSceneStateMgr::_SetD3DRenderState( D3DRS_TEXTUREFACTOR, color );
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE );
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG2, D3DTA_TFACTOR );
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_SELECTARG2 );
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_ALPHAOP, D3DTOP_DISABLE );
m_pd3dDevice->SetTexture (1, NULL);
CSceneStateMgr::_SetD3DTextureStageState (1, D3DTSS_ALPHAOP, D3DTOP_DISABLE);
CSceneStateMgr::_SetD3DTextureStageState (1, D3DTSS_COLOROP, D3DTOP_DISABLE);
}
void CGlareScene::AddAttenuateThreeTextureShader( LPDIRECT3DTEXTURE8 pTex1,
LPDIRECT3DTEXTURE8 pTex2, LPDIRECT3DTEXTURE8 pTex3, D3DCOLOR color )
{
CSceneStateMgr::_SetD3DRenderState( D3DRS_TEXTUREFACTOR, color );
m_pd3dDevice->SetTexture( 0, pTex1 );
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE );
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG2, D3DTA_TFACTOR );
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_MODULATE );
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_ALPHAARG1, D3DTA_TEXTURE );
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_ALPHAARG2, D3DTA_DIFFUSE );
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_ALPHAOP, D3DTOP_SELECTARG2 );
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_TEXCOORDINDEX, 0);
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_DISABLE);
m_pd3dDevice->SetTexture( 1, pTex2 );
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLORARG1, D3DTA_CURRENT );
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLORARG2, D3DTA_TEXTURE );
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLOROP, D3DTOP_MODULATEALPHA_ADDCOLOR );
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_ALPHAARG1, D3DTA_TEXTURE );
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_ALPHAARG2, D3DTA_TFACTOR );
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_ALPHAOP, D3DTOP_SELECTARG2 );
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_TEXCOORDINDEX, 0);
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_DISABLE);
m_pd3dDevice->SetTexture( 2, pTex3 );
CSceneStateMgr::_SetD3DTextureStageState( 2, D3DTSS_COLORARG1, D3DTA_CURRENT );
CSceneStateMgr::_SetD3DTextureStageState( 2, D3DTSS_COLORARG2, D3DTA_TEXTURE );
CSceneStateMgr::_SetD3DTextureStageState( 2, D3DTSS_COLOROP, D3DTOP_MODULATEALPHA_ADDCOLOR );
CSceneStateMgr::_SetD3DTextureStageState( 2, D3DTSS_ALPHAOP, D3DTOP_DISABLE );
CSceneStateMgr::_SetD3DTextureStageState( 2, D3DTSS_TEXCOORDINDEX, 0);
CSceneStateMgr::_SetD3DTextureStageState( 2, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_DISABLE);
}
void CGlareScene::Set3StageAccumAdderShader( LPDIRECT3DTEXTURE8 pTex1,
LPDIRECT3DTEXTURE8 pTex2, LPDIRECT3DTEXTURE8 pTex3 )
{
CSceneStateMgr::_SetD3DRenderState( D3DRS_TEXTUREFACTOR, 0x55ffffff ); //a = 0.333
m_pd3dDevice->SetTexture( 0, pTex1 );
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE );
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG2, D3DTA_DIFFUSE );
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_SELECTARG1 );
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_ALPHAARG1, D3DTA_TEXTURE );
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_ALPHAARG2, D3DTA_DIFFUSE );
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_ALPHAOP, D3DTOP_SELECTARG2 );
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_TEXCOORDINDEX, 0);
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_DISABLE);
// Since diffuse alpha from stage 0 is 0.5, this stage computes
// 0.5*sample1 + 0.5*sample2.
m_pd3dDevice->SetTexture( 1, pTex2 );
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLORARG1, D3DTA_TEXTURE );
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLORARG2, D3DTA_CURRENT );
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLOROP, D3DTOP_BLENDCURRENTALPHA );
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_ALPHAARG1, D3DTA_TEXTURE );
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_ALPHAARG2, D3DTA_CURRENT );
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_ALPHAOP, D3DTOP_SELECTARG2 );
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_TEXCOORDINDEX, 0);
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_DISABLE);
// Computes 0.333*(sample3) + 0.666*(0.5*sample1+0.5*sample2) using
// texture alpha factor.
m_pd3dDevice->SetTexture( 2, pTex2 );
CSceneStateMgr::_SetD3DTextureStageState( 2, D3DTSS_COLORARG1, D3DTA_TEXTURE );
CSceneStateMgr::_SetD3DTextureStageState( 2, D3DTSS_COLORARG2, D3DTA_CURRENT );
CSceneStateMgr::_SetD3DTextureStageState( 2, D3DTSS_COLOROP, D3DTOP_BLENDFACTORALPHA );
CSceneStateMgr::_SetD3DTextureStageState( 2, D3DTSS_ALPHAARG1, D3DTA_TEXTURE );
CSceneStateMgr::_SetD3DTextureStageState( 2, D3DTSS_ALPHAARG2, D3DTA_TFACTOR );
CSceneStateMgr::_SetD3DTextureStageState( 2, D3DTSS_ALPHAOP, D3DTOP_SELECTARG2 );
CSceneStateMgr::_SetD3DTextureStageState( 2, D3DTSS_TEXCOORDINDEX, 0);
CSceneStateMgr::_SetD3DTextureStageState( 2, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_DISABLE);
m_pd3dDevice->SetTexture (3, NULL);
CSceneStateMgr::_SetD3DTextureStageState (3, D3DTSS_COLOROP, D3DTOP_DISABLE);
CSceneStateMgr::_SetD3DTextureStageState (3, D3DTSS_ALPHAOP, D3DTOP_DISABLE);
}
void CGlareScene::DownImage( RenderTarget* pSrc, RenderTarget* pDst, float offsetU, float offsetV )
{
HRESULT hr = S_OK;
D3DVIEWPORT8 NewViewport;
NewViewport.X = 0;
NewViewport.Y = 0;
NewViewport.Height = pDst->nHeight;
NewViewport.Width = pDst->nWidth;
NewViewport.MinZ = 0;
NewViewport.MaxZ = 1;
//============
//Set State
//============
m_pd3dDevice->GetViewport( &m_OldViewport );
m_pd3dDevice->GetRenderTarget( &m_pOldRenderTarget );
m_pd3dDevice->GetDepthStencilSurface( &m_pOldZSurface );
CSceneStateMgr::_SetD3DTextureStageState(0, D3DTSS_ADDRESSU, D3DTADDRESS_CLAMP);
CSceneStateMgr::_SetD3DTextureStageState(0, D3DTSS_ADDRESSV, D3DTADDRESS_CLAMP);
CSceneStateMgr::_SetD3DTextureStageState(1, D3DTSS_ADDRESSU, D3DTADDRESS_CLAMP);
CSceneStateMgr::_SetD3DTextureStageState(1, D3DTSS_ADDRESSV, D3DTADDRESS_CLAMP);
CSceneStateMgr::_SetD3DTextureStageState(2, D3DTSS_ADDRESSU, D3DTADDRESS_CLAMP);
CSceneStateMgr::_SetD3DTextureStageState(2, D3DTSS_ADDRESSV, D3DTADDRESS_CLAMP);
CSceneStateMgr::_SetD3DRenderState( D3DRS_ZENABLE, FALSE );
CSceneStateMgr::_SetD3DRenderState( D3DRS_DITHERENABLE, TRUE);
CSceneStateMgr::_SetD3DRenderState( D3DRS_FOGENABLE, FALSE );
float ooWidth = 1.0f/(float)NewViewport.Width;
float ooHeight = 1.0f/(float)NewViewport.Height;
float width = (float)NewViewport.Width;
float height = (float)NewViewport.Height;
GLAREDISPLAY_VERTEX pVertex[4];
//1
pVertex[0].x = __CENTER;
pVertex[0].y = __CENTER;
pVertex[0].z = 0.5f;
pVertex[0].rhw = 1.0f;
pVertex[0].u = offsetU * ooWidth;
pVertex[0].v = offsetV * ooHeight;
//2
pVertex[1].x = width + __CENTER;
pVertex[1].y = __CENTER;
pVertex[1].z = 0.5f;
pVertex[1].rhw = 1.0f;
pVertex[1].u = 1.0f + offsetU*ooWidth;
pVertex[1].v = offsetV * ooHeight;
//3
pVertex[2].x = __CENTER;
pVertex[2].y = height + __CENTER;
pVertex[2].z = 0.5f;
pVertex[2].rhw = 1.0f;
pVertex[2].u = offsetU * ooWidth;
pVertex[2].v = 1.0f + offsetV * ooHeight;
//4
pVertex[3].x = width + __CENTER;
pVertex[3].y = height + __CENTER;
pVertex[3].z = 0.5f;
pVertex[3].rhw = 1.0f;
pVertex[3].u = 1.0f + offsetU * ooWidth;
pVertex[3].v = 1.0f + offsetV * ooHeight;
//Change RenderTarget
m_pd3dDevice->SetRenderTarget( pDst->pSurface, pDst->pZSurface );
m_pd3dDevice->SetViewport( &NewViewport );
m_pd3dDevice->Clear( 0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, D3DCOLOR_XRGB(0, 0, 0), 1.0f, 0L );
//Begin Render to TextureQuad
m_pd3dDevice->EndScene();
m_pd3dDevice->BeginScene();
SetTextureShader( pSrc->pTexture );
m_pd3dDevice->SetVertexShader( GLAREDISPLAY_VERTEX::FVF );
m_pd3dDevice->DrawPrimitiveUP( D3DPT_TRIANGLESTRIP, 2, pVertex, sizeof(GLAREDISPLAY_VERTEX) );
//End Render
m_pd3dDevice->EndScene();
m_pd3dDevice->BeginScene();
//=============
//Back State
//=============
m_pd3dDevice->SetRenderTarget( m_pOldRenderTarget, m_pOldZSurface );
m_pd3dDevice->SetViewport( &m_OldViewport );
SAFE_RELEASE( m_pOldRenderTarget );
SAFE_RELEASE( m_pOldZSurface );
CSceneStateMgr::_SetD3DRenderState( D3DRS_ZENABLE, TRUE );
CSceneStateMgr::_SetD3DRenderState (D3DRS_DITHERENABLE, FALSE);
CSceneStateMgr::_SetD3DTextureStageState(0, D3DTSS_ADDRESSU, D3DTADDRESS_WRAP);
CSceneStateMgr::_SetD3DTextureStageState(0, D3DTSS_ADDRESSV, D3DTADDRESS_WRAP);
CSceneStateMgr::_SetD3DTextureStageState(1, D3DTSS_ADDRESSU, D3DTADDRESS_WRAP);
CSceneStateMgr::_SetD3DTextureStageState(1, D3DTSS_ADDRESSV, D3DTADDRESS_WRAP);
CSceneStateMgr::_SetD3DTextureStageState(2, D3DTSS_ADDRESSU, D3DTADDRESS_WRAP);
CSceneStateMgr::_SetD3DTextureStageState(2, D3DTSS_ADDRESSV, D3DTADDRESS_WRAP);
CSceneStateMgr::_SetD3DRenderState( D3DRS_FOGENABLE, TRUE );
}
HRESULT CGlareScene::CreateRenderTarget( RenderTarget* pTarget, UINT nHeight, UINT nWidth )
{
HRESULT hr = S_OK;
pTarget->nHeight = nHeight;
pTarget->nWidth = nWidth;
/*if(FAILED(hr=D3DXCreateTexture(m_pd3dDevice, nWidth, nHeight, 1, D3DUSAGE_RENDERTARGET, D3DFMT_A8R8G8B8,
D3DPOOL_DEFAULT, &pTarget->pTexture)))
return hr;
if(FAILED(hr=m_pd3dDevice->CreateDepthStencilSurface( nWidth, nHeight, D3DFMT_D24S8,
D3DMULTISAMPLE_NONE, &pTarget->pZSurface)))
return hr;*/
if(FAILED(hr=D3DXCreateTexture(m_pd3dDevice, nWidth, nHeight, 1, D3DUSAGE_RENDERTARGET,
BaseGraphicsLayer::m_d3dpp.BackBufferFormat, D3DPOOL_DEFAULT, &pTarget->pTexture)))
return hr;
if(FAILED(hr=m_pd3dDevice->CreateDepthStencilSurface( nWidth, nHeight,
BaseGraphicsLayer::m_d3dpp.AutoDepthStencilFormat, D3DMULTISAMPLE_NONE, &pTarget->pZSurface)))
return hr;
if(FAILED(hr=pTarget->pTexture->GetSurfaceLevel(0, &pTarget->pSurface)))
return hr;
return hr;
}
void CGlareScene::AccumulateImage( RenderTarget* pResult, RenderTarget* pSrc1,
RenderTarget* pSrc2, RenderTarget* pSrc3, RenderTarget* pSrc4 )
{
D3DVIEWPORT8 NewViewport;
NewViewport.X = 0;
NewViewport.Y = 0;
NewViewport.MinZ = 0.0f;
NewViewport.MaxZ = 1.0f;
NewViewport.Width = pResult->nWidth;
NewViewport.Height = pResult->nHeight;
//============
//Set State
//============
m_pd3dDevice->GetViewport( &m_OldViewport );
m_pd3dDevice->GetRenderTarget( &m_pOldRenderTarget );
m_pd3dDevice->GetDepthStencilSurface( &m_pOldZSurface );
CSceneStateMgr::_SetD3DTextureStageState(0, D3DTSS_ADDRESSU, D3DTADDRESS_CLAMP);
CSceneStateMgr::_SetD3DTextureStageState(0, D3DTSS_ADDRESSV, D3DTADDRESS_CLAMP);
CSceneStateMgr::_SetD3DTextureStageState(1, D3DTSS_ADDRESSU, D3DTADDRESS_CLAMP);
CSceneStateMgr::_SetD3DTextureStageState(1, D3DTSS_ADDRESSV, D3DTADDRESS_CLAMP);
CSceneStateMgr::_SetD3DTextureStageState(2, D3DTSS_ADDRESSU, D3DTADDRESS_CLAMP);
CSceneStateMgr::_SetD3DTextureStageState(2, D3DTSS_ADDRESSV, D3DTADDRESS_CLAMP);
CSceneStateMgr::_SetD3DRenderState( D3DRS_ZENABLE, FALSE );
CSceneStateMgr::_SetD3DRenderState( D3DRS_DITHERENABLE, TRUE);
CSceneStateMgr::_SetD3DRenderState( D3DRS_FOGENABLE, FALSE );
GLAREDISPLAY_VERTEX pVertex[4];
//1
pVertex[0].x = __CENTER;
pVertex[0].y = __CENTER;
pVertex[0].z = 0.5f;
pVertex[0].rhw = 1.0f;
pVertex[0].color = 0x80ffffff;
pVertex[0].u = 0.0f;
pVertex[0].v = 0.0f;
//2
pVertex[1].x = (float)pResult->nWidth + __CENTER;
pVertex[1].y = __CENTER;
pVertex[1].z = 0.5f;
pVertex[1].rhw = 1.0f;
pVertex[1].color = 0x80ffffff;
pVertex[1].u = 1.0f;
pVertex[1].v = 0.0f;
//3
pVertex[2].x = __CENTER;
pVertex[2].y = (float)pResult->nHeight + __CENTER;
pVertex[2].z = 0.5f;
pVertex[2].rhw = 1.0f;
pVertex[2].color = 0x80ffffff;
pVertex[2].u = 0.0f;
pVertex[2].v = 1.0f;
//4
pVertex[3].x = (float)pResult->nWidth + __CENTER;
pVertex[3].y = (float)pResult->nHeight + __CENTER;
pVertex[3].z = 0.5f;
pVertex[3].rhw = 1.0f;
pVertex[3].color = 0x80ffffff;
pVertex[3].u = 1.0f;
pVertex[3].v = 1.0f;
m_pd3dDevice->SetRenderTarget( pResult->pSurface, pResult->pZSurface );
m_pd3dDevice->SetViewport( &NewViewport );
m_pd3dDevice->Clear( 0, NULL, D3DCLEAR_TARGET|D3DCLEAR_ZBUFFER, 0x00000000, 1.0f, 0L );
//Begin Render To texture
m_pd3dDevice->EndScene();
m_pd3dDevice->BeginScene();
//1
m_pd3dDevice->SetVertexShader( GLAREDISPLAY_VERTEX::FVF );
Set3StageAccumAdderShader( pSrc1->pTexture, pSrc2->pTexture, pSrc3->pTexture );
m_pd3dDevice->DrawPrimitiveUP( D3DPT_TRIANGLESTRIP, 2, pVertex, sizeof(GLAREDISPLAY_VERTEX) );
//2
if( pSrc4 )
{
CSceneStateMgr::_SetD3DRenderState (D3DRS_ALPHABLENDENABLE, TRUE );
CSceneStateMgr::_SetD3DRenderState (D3DRS_SRCBLEND, D3DBLEND_SRCALPHA );
CSceneStateMgr::_SetD3DRenderState (D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA );
// Select texture as color arg and factor alpha as alpha arg.
// Alpha is set at 0.25 to blend (0.25*Src)+(0.75*Dest)
SetTextureAlphaFactorShader( pSrc4->pTexture, 0x40ffffff );
m_pd3dDevice->DrawPrimitiveUP( D3DPT_TRIANGLESTRIP, 2, pVertex, sizeof(GLAREDISPLAY_VERTEX) );
CSceneStateMgr::_SetD3DRenderState ( D3DRS_ALPHABLENDENABLE, FALSE );
}
m_pd3dDevice->EndScene();
m_pd3dDevice->BeginScene();
//=============
//Back State
//=============
m_pd3dDevice->SetRenderTarget( m_pOldRenderTarget, m_pOldZSurface );
m_pd3dDevice->SetViewport( &m_OldViewport );
SAFE_RELEASE( m_pOldRenderTarget );
SAFE_RELEASE( m_pOldZSurface );
CSceneStateMgr::_SetD3DRenderState( D3DRS_ZENABLE, TRUE );
CSceneStateMgr::_SetD3DRenderState (D3DRS_DITHERENABLE, FALSE);
CSceneStateMgr::_SetD3DTextureStageState(0, D3DTSS_ADDRESSU, D3DTADDRESS_CLAMP);
CSceneStateMgr::_SetD3DTextureStageState(0, D3DTSS_ADDRESSV, D3DTADDRESS_CLAMP);
CSceneStateMgr::_SetD3DTextureStageState(1, D3DTSS_ADDRESSU, D3DTADDRESS_CLAMP);
CSceneStateMgr::_SetD3DTextureStageState(1, D3DTSS_ADDRESSV, D3DTADDRESS_CLAMP);
CSceneStateMgr::_SetD3DTextureStageState(2, D3DTSS_ADDRESSU, D3DTADDRESS_CLAMP);
CSceneStateMgr::_SetD3DTextureStageState(2, D3DTSS_ADDRESSV, D3DTADDRESS_CLAMP);
CSceneStateMgr::_SetD3DRenderState( D3DRS_FOGENABLE, TRUE );
}
void CGlareScene::ShakeGlareImage( float weight16, float weight32, float weight64, float weight128 )
{
//DownImage Texture 256x256 -> 128x128
DownImage( &m_RenderTarget256[0], &m_RenderTarget128[0], 0.0f, 0.0f );
DownImage( &m_RenderTarget256[0], &m_RenderTarget128[1], OFFSET1U, OFFSET1V );
DownImage( &m_RenderTarget256[0], &m_RenderTarget128[2], OFFSET2U, OFFSET2V );
DownImage( &m_RenderTarget256[0], &m_RenderTarget128[3], OFFSET3U, OFFSET3V );
DownImage( &m_RenderTarget256[0], &m_RenderTarget128[4], OFFSET4U, OFFSET4V );
DownImage( &m_RenderTarget256[0], &m_RenderTarget128[5], OFFSET5U, OFFSET5V );
AccumulateImage( &m_RenderTarget128[6], &m_RenderTarget128[2], &m_RenderTarget128[5],
&m_RenderTarget128[3], &m_RenderTarget128[4] );
AccumulateImage( &m_RenderTarget128[7], &m_RenderTarget128[0], &m_RenderTarget128[1],
&m_RenderTarget128[6] );
//DownImage Texture 128x128 -> 64x64
DownImage( &m_RenderTarget128[0], &m_RenderTarget64[0], 0.0f, 0.0f );
DownImage( &m_RenderTarget128[0], &m_RenderTarget64[1], OFFSET1U, OFFSET1V );
DownImage( &m_RenderTarget128[0], &m_RenderTarget64[2], OFFSET2U, OFFSET2V );
DownImage( &m_RenderTarget128[0], &m_RenderTarget64[3], OFFSET3U, OFFSET3V );
DownImage( &m_RenderTarget128[0], &m_RenderTarget64[4], OFFSET4U, OFFSET4V );
DownImage( &m_RenderTarget128[0], &m_RenderTarget64[5], OFFSET5U, OFFSET5V );
AccumulateImage( &m_RenderTarget64[6], &m_RenderTarget64[2], &m_RenderTarget64[5],
&m_RenderTarget64[3], &m_RenderTarget64[4] );
AccumulateImage( &m_RenderTarget64[7], &m_RenderTarget64[0], &m_RenderTarget64[1],
&m_RenderTarget64[6] );
//DownImage Texture 64x64 -> 32x32
DownImage( &m_RenderTarget64[0], &m_RenderTarget32[0], 0.0f, 0.0f );
DownImage( &m_RenderTarget64[0], &m_RenderTarget32[1], OFFSET1U, OFFSET1V );
DownImage( &m_RenderTarget64[0], &m_RenderTarget32[2], OFFSET2U, OFFSET2V );
DownImage( &m_RenderTarget64[0], &m_RenderTarget32[3], OFFSET3U, OFFSET3V );
DownImage( &m_RenderTarget64[0], &m_RenderTarget32[4], OFFSET4U, OFFSET4V );
DownImage( &m_RenderTarget64[0], &m_RenderTarget32[5], OFFSET5U, OFFSET5V );
AccumulateImage( &m_RenderTarget32[6], &m_RenderTarget32[2], &m_RenderTarget32[5],
&m_RenderTarget32[3], &m_RenderTarget32[4] );
AccumulateImage( &m_RenderTarget32[7], &m_RenderTarget32[0], &m_RenderTarget32[1],
&m_RenderTarget32[6] );
DownImage( &m_RenderTarget32[0], &m_RenderTarget16[0], 0.0f, 0.0f );
DownImage( &m_RenderTarget32[0], &m_RenderTarget16[1], OFFSET1U, OFFSET1V );
DownImage( &m_RenderTarget32[0], &m_RenderTarget16[2], OFFSET2U, OFFSET2V );
DownImage( &m_RenderTarget32[0], &m_RenderTarget16[3], OFFSET3U, OFFSET3V );
DownImage( &m_RenderTarget32[0], &m_RenderTarget16[4], OFFSET4U, OFFSET4V );
DownImage( &m_RenderTarget32[0], &m_RenderTarget16[5], OFFSET5U, OFFSET5V );
AccumulateImage( &m_RenderTarget16[6], &m_RenderTarget16[2], &m_RenderTarget16[5],
&m_RenderTarget16[3], &m_RenderTarget16[4] );
AccumulateImage( &m_RenderTarget16[7], &m_RenderTarget16[0], &m_RenderTarget16[1],
&m_RenderTarget16[6] );
//Result Image
AddBlurImage( &m_RenderTarget256[1], &m_RenderTarget16[7], &m_RenderTarget32[7], &m_RenderTarget64[7],
&m_RenderTarget128[7], weight16, weight32, weight64, weight128 );
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_DISABLE );
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_ALPHAOP, D3DTOP_DISABLE );
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLOROP, D3DTOP_DISABLE );
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_ALPHAOP, D3DTOP_DISABLE );
CSceneStateMgr::_SetD3DTextureStageState( 2, D3DTSS_COLOROP, D3DTOP_DISABLE );
CSceneStateMgr::_SetD3DTextureStageState( 2, D3DTSS_ALPHAOP, D3DTOP_DISABLE );
}
void CGlareScene::AddBlurImage( RenderTarget* pResult, RenderTarget* pSrc1, RenderTarget* pSrc2,
RenderTarget* pSrc3, RenderTarget* pSrc4, float weight1,
float weight2, float weight3, float weight4 )
{
// Pack weights into tfactor.
D3DCOLOR d3dcWeightColor = D3DCOLOR_COLORVALUE(weight1, weight1, weight1, weight3);
D3DVIEWPORT8 NewViewport;
NewViewport.X = 0;
NewViewport.Y = 0;
NewViewport.Width = pResult->nWidth;
NewViewport.Height = pResult->nHeight;
NewViewport.MinZ = 0.0f;
NewViewport.MaxZ = 1.0f;
//============
//Set State
//============
m_pd3dDevice->GetViewport( &m_OldViewport );
m_pd3dDevice->GetRenderTarget( &m_pOldRenderTarget );
m_pd3dDevice->GetDepthStencilSurface( &m_pOldZSurface );
CSceneStateMgr::_SetD3DTextureStageState(0, D3DTSS_ADDRESSU, D3DTADDRESS_CLAMP);
CSceneStateMgr::_SetD3DTextureStageState(0, D3DTSS_ADDRESSV, D3DTADDRESS_CLAMP);
CSceneStateMgr::_SetD3DTextureStageState(1, D3DTSS_ADDRESSU, D3DTADDRESS_CLAMP);
CSceneStateMgr::_SetD3DTextureStageState(1, D3DTSS_ADDRESSV, D3DTADDRESS_CLAMP);
CSceneStateMgr::_SetD3DTextureStageState(2, D3DTSS_ADDRESSU, D3DTADDRESS_CLAMP);
CSceneStateMgr::_SetD3DTextureStageState(2, D3DTSS_ADDRESSV, D3DTADDRESS_CLAMP);
CSceneStateMgr::_SetD3DRenderState( D3DRS_ZENABLE, FALSE );
CSceneStateMgr::_SetD3DRenderState( D3DRS_DITHERENABLE, TRUE);
CSceneStateMgr::_SetD3DRenderState( D3DRS_FOGENABLE, FALSE );
GLAREDISPLAY_VERTEX pVertex[4];
pVertex[0].x = __CENTER;
pVertex[0].y = __CENTER;
pVertex[0].z = 0.5f;
pVertex[0].rhw = 1.0f;
pVertex[0].u = 0.0f;
pVertex[0].v = 0.0f;
pVertex[0].color = D3DCOLOR_COLORVALUE(0.0f, 0.0f, 0.0f, weight2);
pVertex[1].x = (float)GLARETEXTURE_WIDTH + __CENTER;
pVertex[1].y = __CENTER;
pVertex[1].z = 0.5f;
pVertex[1].rhw = 1.0f;
pVertex[1].u = 1.0f;
pVertex[1].v = 0.0f;
pVertex[1].color = D3DCOLOR_COLORVALUE(0.0f, 0.0f, 0.0f, weight2);
pVertex[2].x = __CENTER;
pVertex[2].y = (float)GLARETEXTURE_HEIGHT + __CENTER;
pVertex[2].z = 0.5f;
pVertex[2].rhw = 1.0f;
pVertex[2].u = 0.0f;
pVertex[2].v = 1.0f;
pVertex[2].color = D3DCOLOR_COLORVALUE(0.0f, 0.0f, 0.0f, weight2);
pVertex[3].x = (float)GLARETEXTURE_WIDTH + __CENTER;
pVertex[3].y = (float)GLARETEXTURE_HEIGHT + __CENTER;
pVertex[3].z = 0.5f;
pVertex[3].rhw = 1.0f;
pVertex[3].u = 1.0f;
pVertex[3].v = 1.0f;
pVertex[3].color = D3DCOLOR_COLORVALUE(0.0f, 0.0f, 0.0f, weight2);
m_pd3dDevice->SetRenderTarget( pResult->pSurface, pResult->pZSurface );
m_pd3dDevice->SetViewport( &NewViewport );
m_pd3dDevice->Clear( 0, NULL, D3DCLEAR_TARGET|D3DCLEAR_ZBUFFER, 0x00000000, 1.0f, 0L );
m_pd3dDevice->EndScene();
m_pd3dDevice->BeginScene ();
AddAttenuateThreeTextureShader( pSrc1->pTexture, pSrc2->pTexture,
pSrc3->pTexture, d3dcWeightColor );
m_pd3dDevice->SetVertexShader( GLAREDISPLAY_VERTEX::FVF );
m_pd3dDevice->DrawPrimitiveUP( D3DPT_TRIANGLESTRIP, 2, pVertex, sizeof(GLAREDISPLAY_VERTEX) );
if( pSrc4 )
{
CSceneStateMgr::_SetD3DRenderState (D3DRS_ALPHABLENDENABLE, TRUE);
CSceneStateMgr::_SetD3DRenderState (D3DRS_SRCBLEND, D3DBLEND_SRCALPHA);
CSceneStateMgr::_SetD3DRenderState (D3DRS_DESTBLEND, D3DBLEND_ONE);
D3DCOLOR weight4Factor = D3DCOLOR_COLORVALUE( 1.0f, 1.0f, 1.0f, weight4 );
SetTextureAlphaFactorShader(pSrc4->pTexture, weight4Factor);
m_pd3dDevice->DrawPrimitiveUP( D3DPT_TRIANGLESTRIP, 2, pVertex, sizeof(GLAREDISPLAY_VERTEX) );
CSceneStateMgr::_SetD3DRenderState (D3DRS_ALPHABLENDENABLE, FALSE);
}
m_pd3dDevice->EndScene();
m_pd3dDevice->BeginScene();
//=============
//Back State
//=============
m_pd3dDevice->SetRenderTarget( m_pOldRenderTarget, m_pOldZSurface );
m_pd3dDevice->SetViewport( &m_OldViewport );
SAFE_RELEASE( m_pOldRenderTarget );
SAFE_RELEASE( m_pOldZSurface );
CSceneStateMgr::_SetD3DRenderState( D3DRS_ZENABLE, TRUE );
CSceneStateMgr::_SetD3DRenderState (D3DRS_DITHERENABLE, FALSE);
CSceneStateMgr::_SetD3DTextureStageState(0, D3DTSS_ADDRESSU, D3DTADDRESS_WRAP);
CSceneStateMgr::_SetD3DTextureStageState(0, D3DTSS_ADDRESSV, D3DTADDRESS_WRAP);
CSceneStateMgr::_SetD3DTextureStageState(1, D3DTSS_ADDRESSU, D3DTADDRESS_WRAP);
CSceneStateMgr::_SetD3DTextureStageState(1, D3DTSS_ADDRESSV, D3DTADDRESS_WRAP);
CSceneStateMgr::_SetD3DTextureStageState(2, D3DTSS_ADDRESSU, D3DTADDRESS_WRAP);
CSceneStateMgr::_SetD3DTextureStageState(2, D3DTSS_ADDRESSV, D3DTADDRESS_WRAP);
CSceneStateMgr::_SetD3DRenderState( D3DRS_FOGENABLE, TRUE );
}
Reference in New Issue View Git Blame Copy Permalink