Microsoft Visual Studio .NET 2003
 Microsoft DirectX 9.0 SDK (December 2004)
 シェーダーモデル 2.0

■ブラーフィルターその2 Prev  Top  Next
関連ページ:ブラーフィルター

2008/12/31: デバイスロスト対応

ドメイン

今回もブラーフィルターです。
前回のブラーフィルターだとあんまりぼけなかったので強くぼけるようにします。基本的なアルゴリズムは前回と同じです。 違うのは2ステップでブラー処理を行うところです。処理の概要は次のとおりです。

ステップ1: X 方向にぼかす
ステップ2: ステップ1の結果を Y 方向にぼかします。

  
左側がステップ1の画像で、右側がステップ2の画像です。わかりやすくするために各ステップごとに4回づつぼかしをかけています。

ではソースです。

---BlurFilter2.fx---


float m_TU[5];   //X方向の隣のテクセル位置
float m_TV[5];   //Y方向の隣のテクセル位置

sampler s0 : register(s0);  //ブラーをかける元となるテクスチャー

struct VS_OUTPUT
{
   float4 Pos    : POSITION;
   float2 Tex    : TEXCOORD0;
};

VS_OUTPUT VS( float4 Pos    : POSITION,
              float2 Tex    : TEXCOORD0 )
{
   VS_OUTPUT Out;
   
   Out.Pos = Pos; //行列変換しないのでそのままピクセルシェーダーに渡す
   Out.Tex = Tex;
   
   return Out;
}

//X方向にぼかす
float4 PS1( VS_OUTPUT In ) : COLOR0
{
   //テクセルを取得   
   float2 Texel0 = In.Tex + float2( -m_TU[0], 0.0f );
   float2 Texel1 = In.Tex + float2( -m_TU[1], 0.0f );
   float2 Texel2 = In.Tex + float2( -m_TU[2], 0.0f );
   float2 Texel3 = In.Tex + float2( -m_TU[3], 0.0f );
   float2 Texel4 = In.Tex + float2( -m_TU[4], 0.0f );
      
   float2 Texel5 = In.Tex + float2( m_TU[0], 0.0f );
   float2 Texel6 = In.Tex + float2( m_TU[1], 0.0f );
   float2 Texel7 = In.Tex + float2( m_TU[2], 0.0f );
   float2 Texel8 = In.Tex + float2( m_TU[3], 0.0f );
   float2 Texel9 = In.Tex + float2( m_TU[4], 0.0f );

   //取得したテクセル位置のカラー情報を取得する。
   //それぞれのカラー値に重みをかけている。この重み値はすべての合計が 1.0f になるように調整する。
   float4 p0  = tex2D( s0, In.Tex ) * 0.20f;
      
   float4 p1  = tex2D( s0, Texel0 ) * 0.12f;
   float4 p2  = tex2D( s0, Texel1 ) * 0.10f;
   float4 p3  = tex2D( s0, Texel2 ) * 0.08f;
   float4 p4  = tex2D( s0, Texel3 ) * 0.06f;      
   float4 p5  = tex2D( s0, Texel4 ) * 0.04f;
   
   float4 p6  = tex2D( s0, Texel5 ) * 0.12f;
   float4 p7  = tex2D( s0, Texel6 ) * 0.10f;
   float4 p8  = tex2D( s0, Texel7 ) * 0.08f;
   float4 p9  = tex2D( s0, Texel8 ) * 0.06f;
   float4 p10 = tex2D( s0, Texel9 ) * 0.04f;

   //カラーを合成する
   return p0 + p1 + p2 + p3 + p4 + p5 + p6 + p7 + p8 + p9 + p10;
}

//Y方向にぼかす
float4 PS2( VS_OUTPUT In ) : COLOR0
{
   //テクセルを取得   
   float2 Texel0 = In.Tex + float2( 0.0f, -m_TV[0] );
   float2 Texel1 = In.Tex + float2( 0.0f, -m_TV[1] );
   float2 Texel2 = In.Tex + float2( 0.0f, -m_TV[2] );
   float2 Texel3 = In.Tex + float2( 0.0f, -m_TV[3] );
   float2 Texel4 = In.Tex + float2( 0.0f, -m_TV[4] );
      
   float2 Texel5 = In.Tex + float2( 0.0f, m_TV[0] );
   float2 Texel6 = In.Tex + float2( 0.0f, m_TV[1] );
   float2 Texel7 = In.Tex + float2( 0.0f, m_TV[2] );
   float2 Texel8 = In.Tex + float2( 0.0f, m_TV[3] );
   float2 Texel9 = In.Tex + float2( 0.0f, m_TV[4] );

   //取得したテクセル位置のカラー情報を取得する。
   //それぞれのカラー値に重みをかけている。この重み値はすべての合計が 1.0f になるように調整する。
   float4 p0  = tex2D( s0, In.Tex ) * 0.20f;
      
   float4 p1  = tex2D( s0, Texel0 ) * 0.12f;
   float4 p2  = tex2D( s0, Texel1 ) * 0.10f;
   float4 p3  = tex2D( s0, Texel2 ) * 0.08f;
   float4 p4  = tex2D( s0, Texel3 ) * 0.06f;      
   float4 p5  = tex2D( s0, Texel4 ) * 0.04f;
   
   float4 p6  = tex2D( s0, Texel5 ) * 0.12f;
   float4 p7  = tex2D( s0, Texel6 ) * 0.10f;
   float4 p8  = tex2D( s0, Texel7 ) * 0.08f;
   float4 p9  = tex2D( s0, Texel8 ) * 0.06f;
   float4 p10 = tex2D( s0, Texel9 ) * 0.04f;

   //カラーを合成する
   return p0 + p1 + p2 + p3 + p4 + p5 + p6 + p7 + p8 + p9 + p10;
}

technique TShader
{
   pass P0
   {
      VertexShader = compile vs_1_1 VS();
      PixelShader  = compile ps_2_0 PS1();
   }
   
   pass P1
   {
      VertexShader = compile vs_1_1 VS();
      PixelShader  = compile ps_2_0 PS2();
   }   
}

前回と異なり2パスで処理します。なお各カラー情報に積算している重み係数はだいたいです。本来は計算して算出するのですが、そこまでやってません。

---BlurFilter2.h---


class BLURFILTER2 : public D3D2DSQUARE
{
private:
   LPD3DXEFFECT m_pEffect;
   D3DXHANDLE m_pTechnique, m_pTU, m_pTV;
   LPDIRECT3DDEVICE9 m_pd3dDevice;

public:
   BLURFILTER2( LPDIRECT3DDEVICE9 pd3dDevice, D3DPRESENT_PARAMETERS* pd3dParameters );
   BLURFILTER2( LPDIRECT3DDEVICE9 pd3dDevice, UINT Width, UINT Height );
   ~BLURFILTER2();
   void Invalidate();
   void Restore();
   HRESULT Load();
   void SetTexel( float TU, float TV );
   void Render( UINT Pass );
   BOOL IsOK();
   LPD3DXEFFECT GetEffect(){ return m_pEffect; };
};

---BlurFilter2.cpp---


BLURFILTER2::BLURFILTER2( LPDIRECT3DDEVICE9 pd3dDevice, D3DPRESENT_PARAMETERS* pd3dParameters ) : D3D2DSQUARE( pd3dDevice, pd3dParameters )
{
   m_pd3dDevice = pd3dDevice;

   m_pEffect = NULL;
}

BLURFILTER2::BLURFILTER2( LPDIRECT3DDEVICE9 pd3dDevice, UINT Width, UINT Height ) : D3D2DSQUARE( pd3dDevice, Width, Height )
{
   m_pd3dDevice = pd3dDevice;

   m_pEffect = NULL;
}

BLURFILTER2::~BLURFILTER2()
{
   //SafeReleaseは関数ではなくマクロ
   //#define SafeRelease(x) { if(x) { (x)->Release(); (x)=NULL; } }
   SafeRelease( m_pEffect );
}

void BLURFILTER2::Invalidate()
{
   if( m_pEffect )
      m_pEffect->OnLostDevice();
}

void BLURFILTER2::Restore()
{
   if( m_pEffect )
      m_pEffect->OnResetDevice();
}

HRESULT BLURFILTER2::Load()
{
   D3DCAPS9 caps;
   HRESULT hr;

   m_pd3dDevice->GetDeviceCaps( &caps );
   if( caps.VertexShaderVersion >= D3DVS_VERSION( 1, 1 ) && caps.PixelShaderVersion >= D3DPS_VERSION( 2, 0 ) )
   {
      hr = D3D2DSQUARE::Load();
      if( FAILED( hr ) )
         return -1;

      //シェーダーの初期化
      LPD3DXBUFFER pErr = NULL;
      hr = D3DXCreateEffectFromFile( m_pd3dDevice, _T("BlurFilter2.fx"), NULL, NULL, 0, NULL, &m_pEffect, &pErr );
      if( FAILED( hr ) )
         return -2;

      m_pTechnique = m_pEffect->GetTechniqueByName( "TShader" );
      m_pTU        = m_pEffect->GetParameterByName( NULL, "m_TU" );
      m_pTV        = m_pEffect->GetParameterByName( NULL, "m_TV" );

      //1テクセルの大きさをセット
      float TU = 1.0f / D3D2DSQUARE::GetWidth();
      float TV = 1.0f / D3D2DSQUARE::GetHeight();
      
      const int Array = 5;

      float u[Array];
      float v[Array];
      for( int i=0; i<Array; i++ )
      {
         u[i] = TU * ( i + 1 );
         v[i] = TV * ( i + 1 );
      }

      m_pEffect->SetFloatArray( m_pTU, u, Array );      
      m_pEffect->SetFloatArray( m_pTV, v, Array );

      m_pEffect->SetTechnique( m_pTechnique );
   }

   else
   {
      return -3;
   }

   return S_OK;
}

void BLURFILTER2::SetTexel( float TU, float TV )
{
   if( m_pEffect )
   {
      m_pEffect->SetFloat( m_pTU, TU );
      m_pEffect->SetFloat( m_pTV, TV );
   }
}

void BLURFILTER2::Render( UINT Pass )
{
   if( m_pEffect )
   {
      m_pEffect->Begin( NULL, 0 );
      m_pEffect->BeginPass( Pass );

      D3D2DSQUARE::Render();   //2Dスプライトのレンダリング

      m_pEffect->EndPass();
      m_pEffect->End();
   }
}

BOOL BLURFILTER2::IsOK()
{
   if( m_pEffect == NULL )
      return FALSE;

   return TRUE;
}

ブラーフィルターシェーダーを制御するクラスです。前回と変わったのは1テクセルサイズを格納する変数が配列になったことだけです。
またD3D2DSQUAREクラスを継承しています。これは自作の2Dオブジェクトです。詳細は表面化散乱(Subsurface Scattering)を参照してください。

---Main.cpp---


LPDIRECT3DDEVICE9 m_pd3dDevice              = NULL;
D3DPRESENT_PARAMETERS m_d3dParameters;

//シーンのメッシュ
//DirectX SDK(December 2004) に添付されているDXUTMesh.cppファイルにあるヘルパークラス群
CDXUTMesh* m_pMeshBack = NULL;

//2Dオブジェクト(表面化散乱(Subsurface Scattering) ページ参照)
D3D2DSQUARE* m_pSqu1Back = NULL;

//ブラーフィルタークラスオブジェクトの宣言
BLURFILTER2* m_pBlurFilter2                 = NULL;

//シーンをレンダリングするときに使用するサーフェイスの宣言
//2パスでブラーをかけるので2つ必要になる
LPDIRECT3DTEXTURE9 m_pBackBufferTexture[2];
LPDIRECT3DSURFACE9 m_pBackBufferSurface[2];

//バックバッファの解像度
UINT nWidth  = 1024;
UINT nHeight = 768;

D3DXVECTOR4 LightPos = D3DXVECTOR4( 0.0f, 40.0f, -70.0f, 1.0f );
D3DXVECTOR4 LightDir;
D3DXVECTOR4 EyePos   = D3DXVECTOR4( 0.0f, 0.0f, 0.0f, 1.0f );

bool RenderOK = false;

int APIENTRY WinMain( HINSTANCE hInstance,
                      HINSTANCE /*hPrevInstance*/,
                      LPSTR     /*lpCmpLine*/,
                      INT       /*nCmdShow*/)
{  
   char* AppName = "Tutrial";

   MSG msg;
   ZeroMemory(&msg, sizeof(MSG));
   HWND hWnd = NULL;

   WNDCLASSEX wc;
   wc.cbSize      = sizeof(WNDCLASSEX);
   wc.style      = CS_VREDRAW | CS_HREDRAW;
   wc.lpfnWndProc   = (WNDPROC)WndProc;
   wc.cbClsExtra   = 0;
   wc.cbWndExtra   = sizeof(DWORD);
   wc.hCursor      = LoadCursor(NULL, IDC_ARROW);
   wc.hIcon      = NULL;
   wc.hIconSm      = NULL;
   wc.lpszMenuName    = NULL;
   wc.lpszClassName = AppName;
   wc.hbrBackground = (HBRUSH)GetStockObject( BLACK_BRUSH );
   wc.hInstance    = hInstance;
   RegisterClassEx(&wc);


   //****************************************************************
   //ここでウィンドウの作成処理
   //****************************************************************


   //****************************************************************
   //ここでDirect3Dの初期化を行う。
   //****************************************************************


   //メッシュの初期化
   m_pMeshBack = new CDXUTMesh();
   m_pMeshBack->Create( m_pd3dDevice, _T("res\\01.x") );
   m_pMeshBack->SetFVF( m_pd3dDevice, D3DFVF_XYZ | D3DFVF_NORMAL | D3DFVF_TEX1 );

   //2Dオブジェクトの初期化
   m_pSqu1Back = new D3D2DSQUARE( m_pd3dDevice, &m_d3dParameters );
   m_pSqu1Back->Load();

   //ブラーフィルターシェーダークラスのロード
   m_pBlurFilter2 = new BLURFILTER2( m_pd3dDevice, &m_d3dParameters );
   m_pBlurFilter2->Load();
   
   LightDir = D3DXVECTOR4( -LightPos.x, -LightPos.y, -LightPos.z, 0.0f );
   D3DXVec3Normalize( (D3DXVECTOR3*)&LightDir, (D3DXVECTOR3*)&LightDir );

   RenderOK = true;

   Restore();

   ::ShowWindow(hWnd, SW_SHOW);
   ::UpdateWindow(hWnd);

   do
   { 
      if( ::PeekMessage( &msg, 0, 0, 0, PM_REMOVE ) )
      {
         ::TranslateMessage(&msg); 
         ::DispatchMessage(&msg); 
      }
      else
      {
         if( MainLoop(hWnd) == FALSE )
            ::DestroyWindow( hWnd );
      }
   }while( msg.message != WM_QUIT );

   ::UnregisterClass( AppName, hInstance );

   return msg.wParam;
}

//デバイスのリセット前に開放すべきオブジェクト
void Invalidate()
{
   m_pBlurFilter2->Invalidate();

   for( int i=0; i<2; i++ )
   {
      SafeRelease( m_pBackBufferSurface[i] );
      SafeRelease( m_pBackBufferTexture[i] );
   }
}

//デバイスのリセット後に初期化すべきオブジェクト
void Restore()
{
   m_pBlurFilter2->Restore();

   for( int i=0; i<2; i++ )
   {
      m_pd3dDevice->CreateTexture( nWidth,
                             nHeight,
                            1,
                            D3DUSAGE_RENDERTARGET,
                            D3DFMT_A8R8G8B8,
                            D3DPOOL_DEFAULT,
                            &m_pBackBufferTexture[i],
                            NULL );
      m_pBackBufferTexture[i]->GetSurfaceLevel( 0, &m_pBackBufferSurface[i] );
   }



   //固定機能パイプラインライティングを設定する
   D3DLIGHT9 Light;
   ZeroMemory(&Light, sizeof(D3DLIGHT9));
   Light.Type = D3DLIGHT_DIRECTIONAL;
   Light.Direction = D3DXVECTOR3( LightDir.x, LightDir.y, LightDir.z );
   Light.Ambient   = D3DXCOLOR( 1.0f, 1.0f, 1.0f, 1.0f );
   Light.Diffuse   = D3DXCOLOR( 1.0f, 1.0f, 1.0f, 1.0f );
   Light.Specular  = D3DXCOLOR( 0.0f, 0.0f, 0.0f, 0.0f );
   m_pd3dDevice->SetLight(0, &Light);
   m_pd3dDevice->LightEnable(0, TRUE);

   D3DMATERIAL9 Material;
   ZeroMemory( &Material, sizeof( Material ) );
   Material.Diffuse.r = 1.0f;
   Material.Diffuse.g = 1.0f;
   Material.Diffuse.b = 1.0f;
   Material.Diffuse.a = 1.0f;
   m_pd3dDevice->SetMaterial( &Material );
}

BOOL MainLoop()
{
   HRESULT hr;
   
   //レンダリング不可能
   if( RenderOK == false )
   {
      hr = m_pd3dDevice->TestCooperativeLevel();
      switch( hr )
      {
      //デバイスは消失しているがReset可能
      case D3DERR_DEVICENOTRESET:

         //開放
         Invalidate();

         //デバイスをリセットする
         hr = m_pd3dDevice->Reset( &m_d3dParameters );
         
         switch( hr )
         {
         //デバイスロスト
         case D3DERR_DEVICELOST:
            break;

         //内部ドライバーエラー
         case D3DERR_DRIVERINTERNALERROR:
            return FALSE;
            break;

         //メソッドの呼び出しが無効です
         case D3DERR_INVALIDCALL:
            return FALSE;
            break;

         case S_OK:

            //初期化
            Restore();

            RenderOK = true;
         }
         break;
      }
   }

   //レンダリング可能
   else
   {
      //バックバッファを退避する
      LPDIRECT3DSURFACE9 OldSurface = NULL;
      m_pd3dDevice->GetRenderTarget( 0, &OldSurface );
      
      //メッシュをレンダリングするためのレンダーターゲットサーフェイスをセットする
      m_pd3dDevice->SetRenderTarget( 0, m_pBackBufferSurface[0] );
   
      m_pd3dDevice->Clear( 0L, NULL,
                           D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER,
                           0x0, 
                           1.0f,
                           0L);
   
      m_pd3dDevice->BeginScene();
   
      D3DXMATRIX matProj, matView, matWorld;
   
      //射影座標変換
      D3DXMatrixPerspectiveFovLH( &matProj,
                                  D3DX_PI/4.0f,
                                  4.0f / 3.0f,
                                  0.1f,
                                  210.0f );
      m_pd3dDevice->SetTransform( D3DTS_PROJECTION, &matProj );
   
      //ビュー座標変換
      D3DXMatrixIdentity( &matView );
      m_pd3dDevice->SetTransform( D3DTS_VIEW, &matView );
         
      //ワールド座標変換
      D3DXMatrixIdentity( &matWorld );
      m_pd3dDevice->SetTransform( D3DTS_WORLD, &matWorld );
   
      m_pd3dDevice->SetSamplerState( 0, D3DSAMP_MINFILTER, D3DTEXF_LINEAR );
      m_pd3dDevice->SetSamplerState( 0, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR );
      m_pd3dDevice->SetSamplerState( 0, D3DSAMP_MIPFILTER, D3DTEXF_NONE );
   
      //背景を固定機能パイプラインでレンダリング
      m_pd3dDevice->SetTexture( 0, m_pMeshBack->m_pTextures[0] );
      m_pMeshBack->m_pLocalMesh->DrawSubset(0);
      m_pd3dDevice->SetTexture( 0, m_pMeshBack->m_pTextures[1] );
      m_pMeshBack->m_pLocalMesh->DrawSubset(1);
      m_pd3dDevice->SetTexture( 0, m_pMeshBack->m_pTextures[2] );
      m_pMeshBack->m_pLocalMesh->DrawSubset(2);

      //テクセルの範囲 (0.0, 1.0) の外側のテクセル座標を、それぞれ、0.0 と 1.0 のテクスチャ色に設定する。
      m_pd3dDevice->SetSamplerState( 0, D3DSAMP_ADDRESSU, D3DTADDRESS_CLAMP );
      m_pd3dDevice->SetSamplerState( 0, D3DSAMP_ADDRESSV, D3DTADDRESS_CLAMP );

      //Zバッファへの書き込みを有効にしたままのとき、このあとレンダリングするオブジェクトがレンダリングされなくなる
      //多分2DオブジェクトをD3DFVF_XYZRHWでレンダリングするためZバッファに 0.0f で上書きされるのが原因だと思うのでZバッファを使用しないようにする
      m_pd3dDevice->SetRenderState( D3DRS_ZENABLE, D3DZB_FALSE );
   
      BYTE i;
      for( i=0; i<2; i++ )
      {
         //レンダーターゲットをセットする
         m_pd3dDevice->SetRenderTarget( 0, m_pBackBufferSurface[1 - i % 2] );

         //バックバッファをテクスチャーステージ0にセットする
         m_pd3dDevice->SetTexture( 0, m_pBackBufferTexture[i % 2] );

         //ブラーフィルターを適応する
         m_pBlurFilter2->Render( i % 2 );
      }

      //レンダーターゲットをバックバッファに戻す
      m_pd3dDevice->SetRenderTarget( 0, OldSurface );
      SafeRelease( OldSurface );

      m_pd3dDevice->SetTexture( 0, m_pBackBufferTexture[0] );
      m_pSqu1Back->Render();

      m_pd3dDevice->SetSamplerState( 0, D3DSAMP_ADDRESSU, D3DTADDRESS_WRAP );
      m_pd3dDevice->SetSamplerState( 0, D3DSAMP_ADDRESSV, D3DTADDRESS_WRAP );

      m_pd3dDevice->SetRenderState( D3DRS_ZENABLE, D3DZB_TRUE );
      
      m_pd3dDevice->EndScene();
   
      hr = m_pd3dDevice->Present( NULL, NULL, NULL, NULL );
      
      //デバイスロストのチェック
      switch( hr )
      {
      //デバイスロスト
      case D3DERR_DEVICELOST:
         RenderOK = false;
         break;

      //内部ドライバーエラー
      case D3DERR_DRIVERINTERNALERROR:
         return FALSE;
         break;

      //メソッドの呼び出しが無効です
      case D3DERR_INVALIDCALL:
         return FALSE;
         break;
      }
   }

   return TRUE;
}

以上です。
前回とほとんど同じなので、解説することもないです。

Prev  Top  Next
inserted by FC2 system