3D Client Programmer

  class BloomResource {

  LPDIRECT3DSURFACE9       lpD3DSurface[ 2];                             //다이렉트 표면 장치
  LPDIRECT3DTEXTURE9       lpD3DTexture[ 2];                             //다이렉트 텍스처 장치
  LPDIRECT3DVERTEXBUFFER9     lpD3DTexVB;                           //텍스처 정점 버텍스

  LPD3DXEFFECT                         lpD3DEffect;                             //다이렉트 이펙트 핸들
  D3DXHANDLE                             hTechBloom;                          //셰이더 테크닉 핸들

  BOOL InitBloomResource( LPDIRECT3DDEVICE9  );
  VOID RenderBloom( LPDIRECT3DDEVICE9 );

 };

 BOOL BloomResource ::InitBloomResource( LPDIRECT3DDEVICE9 lpD3DDevice ) {

 //스크린 사이즈 구하기 
 POINT ptScreen;
 ptScreen.x = d3ddm.Width;
 ptScreen.y = d3ddm.Height;

 //텍스처 정점 설정
 FTexture vertices[ 4 ];

 vertices[ 0 ].vPosition = D3DXVECTOR4(  ptScreen.x - 0.5f, ptScreen.y - 0.5f, 0, 1 );
 vertices[ 0 ].vTexCoord = D3DXVECTOR2( 1, 1 );
 vertices[ 1 ].vPosition = D3DXVECTOR4( -0.5f, ptScreen.y - 0.5f, 0, 1 );
 vertices[ 1 ].vTexCoord = D3DXVECTOR2( 0, 1 );
 vertices[ 2 ].vPosition = D3DXVECTOR4( -0.5f, -0.5f, 0, 1 );
 vertices[ 2 ].vTexCoord = D3DXVECTOR2( 0, 0 );
 vertices[ 3 ].vPosition = D3DXVECTOR4( ptScreen.x - 0.5f, -0.5f, 0, 1 );
 vertices[ 3 ].vTexCoord = D3DXVECTOR2( 1, 0 );

 HRESULT  hResult = E_FAIL;

 UINT vertexSize = sizeof( vertices );

 hResult = lpD3DDevice->CreateVertexBuffer(  vertexSize,  0,  vertices[ 0 ].FVF,  D3DPOOL_DEFAULT,   &lpD3DTexVB,  NULL );

 if( FAILED( hResult ) ) {   return FALSE; }

VOID* pVertices = NULL;

 hResult = lpD3DTexVB->Lock( 0, vertexSize, static_cast< VOID** >( &pVertices ), 0 );

 if( FAILED( hResult ) ) {  return FALSE; }

 memcpy( pVertices, vertices, vertexSize );

 lpD3DTexVB->Unlock();

 //셰이더 설정
 hResult = D3DXCreateEffectFromFile( lpD3DDevice,   szFileName,  NULL,  NULL,  D3DXSHADER_DEBUG,  NULL,  &lpD3DEffect,  NULL );

 hTechBloom = lpD3DEffect->GetTechniqueByName( "GOneBloom" );

 FLOAT fTexSizeX = static_cast< FLOAT >( ptScreen.x );
 FLOAT fTexSizeY = static_cast< FLOAT >( ptScreen.y );

 D3DXHANDLE hMapCX = lpD3DEffect->GetParameterByName( NULL, "map_cx" );
 lpD3DEffect->SetValue( hMapCX, &fTexSizeX, sizeof( FLOAT ) );

 D3DXHANDLE hMapCY = lpD3DEffect->GetParameterByName( NULL, "map_cy" );
 lpD3DEffect->SetValue( hMapCY, &fTexSizeY, sizeof( FLOAT ) );

//서피스 및 텍스처 생성 

D3DXCreateTexture(lpD3DDevice,  TEXTURE_SIZE, TEXTURE_SIZE, 0, D3DUSAGE_RENDERTARGET, d3ddm.Format, D3DPOOL_DEFAULT, &lpD3DTexture[ 0 ] );

lpD3DTexture[ 0 ]->GetSurfaceLevel( 0, &lpD3DSurface[ 0 ] );

 D3DXCreateTexture(lpD3DDevice,  ptScreen.x,  ptScreen.y, 0, D3DUSAGE_RENDERTARGET, d3ddm.Format,

D3DPOOL_DEFAULT, &lpD3DTexture[ 1 ] );

 lpD3DTexture[ 1 ]->GetSurfaceLevel( 0, &lpD3DSurface[ 1 ] );

return TRUE;

}//BOOL InitBloomResource( LPDIRECT3DDEVICE9 lpD3DDevice )

 VOID BloomResource ::RenderBloom( LPDIRECT3DDEVICE9  lpD3DDevice ) {
 

 LPDIRECT3DSURFACE9       lpCurrentSurface = NULL;     //현재 화면 장치 
 lpD3DDevice->GetRenderTarget( 0, &lpCurrentSurface );
 lpD3DDevice->StretchRect(  lpCurrentSurface, NULL, lpD3DSurface[ 0 ], NULL, D3DTEXF_LINEAR );
 lpD3DDevice->StretchRect(  lpCurrentSurface, NULL, lpD3DSurface[ 1 ], NULL, D3DTEXF_LINEAR );

 lpD3DDevice->SetRenderTarget( 0, lpCurrentSurface );
 SAFE_RELEASE( lpCurrentSurface ); 

 lpD3DDevice->SetFVF( FTexture ::FVF );
 lpD3DDevice->SetTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE );
 lpD3DDevice->SetTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_SELECTARG1 );
 lpD3DDevice->SetTexture( 0, lpD3DTexture[ 0 ]);
 lpD3DDevice->SetTexture( 1, lpD3DTexture[ 1 ]);

 lpD3DEffect->SetTechnique( hTechBloom );

 UINT iPass = 0;

 lpD3DEffect->Begin( &iPass,  NULL  );
 lpD3DEffect->BeginPass( 0 );
 {
  lpD3DDevice->Clear( 0, NULL, D3DCLEAR_TARGET, D3DCOLOR_XRGB( 255, 255, 255 ), 1.0f, 0 );
  lpD3DDevice->SetStreamSource( 0, lpD3DTexVB, 0, sizeof( FTexture ) );
  lpD3DDevice->DrawPrimitive( D3DPT_TRIANGLEFAN, 0, 2 );
 
  lpD3DEffect->EndPass();

 }//IF

 lpD3DEffect->End();
 
 lpD3DDevice->SetTexture( 0, NULL );
 lpD3DDevice->SetTexture( 1, NULL );

}

VOID Render() {

  LPDIRECT3DDEVICE9 lpD3DDevice = m_lpD3DDevice;

  //카메라 변환에 의한 뷰행렬 설정

  //기본 화면 렌더링 
  if( SUCCEEDED( lpD3DDevice->BeginScene() ) ) {

     lpD3DDevice->Clear( 0, NULL, D3DCLEAR_TARGET | D3DCLEAR_STENCIL | D3DCLEAR_ZBUFFER, D3DCOLOR_XRGB( 

                                 255, 255, 255 ), 1.0f, 0 );

      //여기서 화면에 뿌리고 싶은 모델들 렌더링

      lpD3DDevice->EndScene();
  }//if

   //블룸 효과를 마지막 렌더링 m_pBloomResource는 BloomResource 객체.
   m_pBloomResource->RenderBloom( lpD3DDevice );

   lpD3DDevice->Present( NULL, NULL, m_hWnd, NULL );

}

float map_cx;                        //텍스처 크기  가로 
float map_cy;                        //텍스처 크기  세로

sampler Sampler0;
sampler Sampler1;

float2 rcpres = { 0.0025, 0.0033333333333333333333333333333333 };

//텍스처 의 임의의 위치의 픽셀에 접근하귀 위한 좌표 ( 가로 방향)
float2 PixelKernelH[13] =
{
    { -6, 0 },    { -5, 0 },    { -4, 0 },    { -3, 0 },    { -2, 0 },    { -1, 0 },    {  0, 0 },    {  1, 0 },    {  2, 0 },    {  3, 0 },    {  4, 0 },
    {  5, 0 },    {  6, 0 },
};

//텍스처의 임의의 위치의 픽셀에 접근하기 위한 좌표 ( 세로 방향)

float2 PixelKernelV[13] =
{
    { 0, -6 },    { 0, -5 },    { 0, -4 },    { 0, -3 },    { 0, -2 },    { 0, -1 },    { 0,  0 },    { 0,  1 },    { 0,  2 },    { 0,  3 },    { 0,  4 },
    { 0,  5 },    { 0,  6 },
};

//미리 계산해 둔 가우스 필터의 마스크 값
float BlurWeights[13] = 
{
    0.002216,    0.008764,    0.026995,    0.064759,    0.120985,    0.176033,    0.199471,    0.176033,    0.120985,    0.064759,
    0.026995,    0.008764,    0.002216,

};

float4 PSBlur( float2 Tex : TEXCOORD ) : COLOR {

    float4 Color = tex2D( Sampler0, Tex );
    Color = pow( Color, 32 );
    
    float4 Color2 = -0.84;
 
    for( int index = 0; index < 13; ++index ) {
        Color2 += tex2D( Sampler0, Tex + ( PixelKernelH[ index ] * rcpres ) ) * BlurWeights[ index ];
        Color2 += tex2D( Sampler0, Tex + ( PixelKernelV[ index ] * rcpres ) ) * BlurWeights[ index ];
    }
    
    Color2 *= 0.48;
    
    float4 Color3 = tex2D( Sampler1, Tex );

    return  Color + Color2 + Color3;
    
}

technique GOneBloom {

    pass P0 {
        CullMode = CCW;      
        PixelShader = compile ps_3_0 PSBlur();
    
    }
}