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

■陽炎シェーダー Prev  Top  Next
関連ページ:ブラーフィルターその2 アルファチャンネルつきDDSファイル作成

ドメイン

今回は、陽炎シェーダーをやります。熱源の周囲に発生する気流の乱れにより密度の異なる空気が混じることにより不規則に光の屈折が発生することにより 発生する現象です。ゲームではロボットのブースターの周辺に発生したりします。

 
左の画像が通常のレンダリングで、右の画像が陽炎シェーダーによるレンダリングです。 トラが陽炎によりゆがんでしまいました。静止画ではよくわかりませんが、アニメーションさせると面白い動きをするはずです。

フローイメージは次のとおりです。

1.レンダーターゲットサーフェイスに切り替え、シーンをレンダリングします。
2.別のレンダーターゲットサーフェイスに切り替え、陽炎の種となる揺らぎパーティクルをレンダリングします。Zバッファは1で使用したものをそのまま使用します。
3.2にブラー処理を適応します。揺らぎパーティクルの一部がメッシュの後ろ隠れて陰面処理により揺らぎパーティクルが切り取られるとき、揺らぎパーティクルに生じるエッジ付近が 正しくレンダリングされないのでブラーを適応してなめらかにします。ブラー処理でなくソフトパーティクルでもいいかもしれません。 ようは鋭いエッジが発生しないようにすればいいです。
4.3の結果を元に1のテクスチャーのテクセルを移動させて、ゆがませます。

揺らぎパーティクルのレンダリングで使用するテクスチャーはこんな感じです。
RGB成分
アルファチャンネル
揺らぎパーティクルは線形合成するためアルファチャンネルを含むDDSファイルで作成します。DDSファイルについてはアルファチャンネルつきDDSファイル作成を参照してください。 使用方法は R 成分を U 方向のテクセルの移動量、 G 成分を V 方向のテクセルの移動量となります。

ではソースです。

---Shimmer.fx---


float m_Param;     // 揺らぎ具合係数

sampler s0 : register(s0);   // 陽炎テクスチャー
sampler s1 : register(s1);   // バックバッファテクスチャー

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

VS_OUTPUT VS( float4 Pos      : POSITION,
              float4 Color    : COLOR0,
              float2 Tex      : TEXCOORD0 )
{
   VS_OUTPUT Out;
   
   Out.Pos = Pos;
   Out.Col = Color;
   Out.Tex = Tex;
   
   return Out;
}

float4 PS( VS_OUTPUT In ) : COLOR
{
   //陽炎テクスチャーから色情報を取得し、テクセルの移動量を計算する
   float4 ShimmerColor = tex2D( s0, In.Tex );
   
   //テクスチャーには 0.0f 〜 1.0f の範囲で格納されているので -1.0f 〜 1.0f に変換する
   ShimmerColor.xy = ( ShimmerColor.xy - 0.5f ) * 2.0f;
   
   return tex2D( s1, In.Tex - ( ShimmerColor.xy ) * ShimmerColor.z * m_Param );
}

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

陽炎シェーダーです。揺らぎパーティクルをレンダリングした陽炎テクスチャーを元に バックバッファイメージをゆがませます。

なお前回のディスプレースメントマッピングの作成で SM3.0 ではサンプラーステートの設定方法を変更する必要があることが判明したため 今まで作成したものすべて修正しようかとも思ったのですが、大変なのでやめます。 統一性がなくなるので本当は修正した方がいいんですけどね。

---Shimmer.h---


//D3D2DSQUAREは2Dオブジェクト。詳細は表面化散乱(Subsurface Scattering) を参照
class SHIMMER : public D3D2DSQUARE
{
private:
   LPD3DXEFFECT m_pEffect;
   D3DXHANDLE m_pTechnique, m_Param;
   LPDIRECT3DDEVICE9 m_pd3dDevice;

public:
   SHIMMER( LPDIRECT3DDEVICE9 pd3dDevice, D3DPRESENT_PARAMETERS* pd3dParameters );
   SHIMMER( LPDIRECT3DDEVICE9 pd3dDevice, UINT Width, UINT Height );
   ~SHIMMER();
   void Invalidate();
   void Restore();
   HRESULT Load();
   //揺らぎ具合係数
   void SetParam( float Param );
   void Render();
   BOOL IsOK();
   LPD3DXEFFECT GetEffect(){ return m_pEffect; };
};

---Shimmer.cpp---


SHIMMER::SHIMMER( LPDIRECT3DDEVICE9 pd3dDevice, D3DPRESENT_PARAMETERS* pd3dParameters ) : D3D2DSQUARE( pd3dDevice, pd3dParameters )
{
   m_pd3dDevice = pd3dDevice;
   m_pEffect = NULL;
}

SHIMMER::SHIMMER( LPDIRECT3DDEVICE9 pd3dDevice, UINT Width, UINT Height ) : D3D2DSQUARE( pd3dDevice, Width, Height )
{
   m_pd3dDevice = pd3dDevice;
   m_pEffect = NULL;
}

SHIMMER::~SHIMMER()
{
   SafeRelease( m_pEffect );
}

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

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

HRESULT SHIMMER::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("Shimmer.fx"), NULL, NULL, 0, NULL, &m_pEffect, &pErr );
      if( FAILED( hr ) )
         return -2;

      m_pTechnique        = m_pEffect->GetTechniqueByName( "TShader" );
      m_Param             = m_pEffect->GetParameterByName( NULL, "m_Param" );
      m_pEffect->SetTechnique( m_pTechnique );   
   }

   else
   {
      return -3;
   }

   return S_OK;
}

void SHIMMER::SetParam( float Param )
{
   if( m_pEffect )
      m_pEffect->SetFloat( m_Param, Param );
}

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

      D3D2DSQUARE::Render();

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

BOOL SHIMMER::IsOK()
{
   if( m_pEffect )
      return TRUE;

   return FALSE;
}

陽炎シェーダーの制御クラスです。

---Main.cpp---


LPDIRECT3DDEVICE9 m_pd3dDevice = NULL;
D3DPRESENT_PARAMETERS m_d3dParameters;

D3DCAPS9 Caps;

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

//バックバッファテクスチャー
LPDIRECT3DTEXTURE9      m_pBackBufferTexture = NULL;
LPDIRECT3DSURFACE9      m_pBackBufferSurface = NULL;

//揺らぎパーティクルをレンダリングして作成した陽炎テクスチャー
LPDIRECT3DTEXTURE9      m_pShimmerTexture = NULL;
LPDIRECT3DSURFACE9      m_pShimmerSurface = NULL;

//陽炎テクスチャーをぼかしたサーフェイス
LPDIRECT3DTEXTURE9      m_pHalfTexture[2];
LPDIRECT3DSURFACE9      m_pHalfSurface[2];

//ランバート拡散照明クラス
LAMBERT1* m_pLambert = NULL;

//ブラーフィルタークラス
BLURFILTER2* m_pBlurFilter2 = NULL;

//陽炎シェーダークラス
SHIMMER* m_pShimmer = NULL;

UINT nWidth = 1024;
UINT nHeight = 768;

//太陽の位置ベクトル
D3DXVECTOR4 LightPos = D3DXVECTOR4( 72.0f, 100.0f, 620.0f, 0.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_pd3dDevice->GetDeviceCaps(&Caps);
         
   //ランバート拡散照明シェーダーの初期化
   m_pLambert = new LAMBERT1( m_pd3dDevice );
   m_pLambert->Load();

   //ブラーフィルターの初期化
   m_pBlurFilter2 = new BLURFILTER2( m_pd3dDevice, &m_d3dParameters );
   m_pBlurFilter2->Load();

   //陽炎シェーダーの初期化
   m_pShimmer = new SHIMMER( m_pd3dDevice, &m_d3dParameters );
   m_pShimmer->Load();

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

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

   //揺らぎパーティクルの初期化
   m_pMeshShimmer = new CDXUTMesh();
   m_pMeshShimmer->Create( m_pd3dDevice, _T("res\\Shimmer.x") );
   m_pMeshShimmer->SetFVF( m_pd3dDevice, D3DFVF_XYZ | D3DFVF_NORMAL | D3DFVF_TEX1 );
      
   //平行光源の位置ベクトルから方向ベクトルを計算する
   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_pLambert->Invalidate();
   m_pBlurFilter2->Invalidate();
   m_pShimmer->Invalidate();

   SafeRelease( m_pHalfSurface[1] );
   SafeRelease( m_pHalfTexture[1] );
   SafeRelease( m_pHalfSurface[0] );
   SafeRelease( m_pHalfTexture[0] );
   SafeRelease( m_pShimmerSurface );
   SafeRelease( m_pShimmerTexture );
   SafeRelease( m_pBackBufferSurface );
   SafeRelease( m_pBackBufferTexture );
}

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

   for( int i=0; i<2; i++ )
   {
      D3DXCreateTexture( m_pd3dDevice,
                         nWidth,
                         nHeight,
                         1,
                         D3DUSAGE_RENDERTARGET,
                         D3DFMT_A8R8G8B8,
                         D3DPOOL_DEFAULT,
                         &m_pHalfTexture[i] );
      m_pHalfTexture[i]->GetSurfaceLevel( 0, &m_pHalfSurface[i] );
   }

   D3DXCreateTexture( m_pd3dDevice,
                      nWidth,
                      nHeight,
                      1,
                      D3DUSAGE_RENDERTARGET,
                      D3DFMT_A8R8G8B8,
                      D3DPOOL_DEFAULT,
                      &m_pBackBufferTexture );
   m_pBackBufferTexture->GetSurfaceLevel( 0, &m_pBackBufferSurface );

   D3DXCreateTexture( m_pd3dDevice,
                      nWidth,
                      nHeight,
                      1,
                      D3DUSAGE_RENDERTARGET,
                      D3DFMT_A8R8G8B8,
                      D3DPOOL_DEFAULT,
                      &m_pShimmerTexture );
   m_pShimmerTexture->GetSurfaceLevel( 0, &m_pShimmerSurface );


   //固定機能パイプラインライティングを設定する
   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( HWND HWnd )
{
   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
   {
      D3DXMATRIX matProj, matView, matWorld;

      //現在のバックバッファとZバッファを保存する
      LPDIRECT3DSURFACE9 OldBackBuffer;
      m_pd3dDevice->GetRenderTarget( 0, &OldBackBuffer );

      //レンダーターゲットサーフェイスをバックバッファ用のサーフェイスに切り替える
      //Zバッファは切り替えない
      m_pd3dDevice->SetRenderTarget( 0, m_pBackBufferSurface );

      //クリアする
      m_pd3dDevice->Clear( 0L,
                           NULL,
                           D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER,
                           0x0, 
                           1.0f,
                           0L
                         );

      m_pd3dDevice->BeginScene();

      //背景のレンダリング用のサンプラーステートの設定
      m_pd3dDevice->SetSamplerState( 0, D3DSAMP_MINFILTER, D3DTEXF_LINEAR );
      m_pd3dDevice->SetSamplerState( 0, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR );
      m_pd3dDevice->SetSamplerState( 0, D3DSAMP_MIPFILTER, D3DTEXF_NONE );
      
      //射影座標変換
      D3DXMatrixPerspectiveFovLH( &matProj,
                                  D3DX_PI/4.0f,
                                  4.0f / 3.0f,
                                  0.1f,
                                  1000.0f
                                 );
      m_pd3dDevice->SetTransform( D3DTS_PROJECTION, &matProj );

      //ビュー座標変換
      D3DXMatrixIdentity( &matView );
      m_pd3dDevice->SetTransform( D3DTS_VIEW, &matView );

      //ワールド座標変換
      D3DXMatrixIdentity( &matWorld );
      m_pd3dDevice->SetTransform( D3DTS_WORLD, &matWorld );


      //****************************************************************
      // (STEP1) 背景その他すべてのメッシュをレンダリング
      //****************************************************************

      m_pLambert->Begin();
      m_pLambert->SetAmbient( 0.0f );
      m_pLambert->SetMatrix( &matWorld, &LightDir );

      // 背景をレンダリング
      m_pd3dDevice->SetTexture( 0, m_pMeshBack->m_pTextures[0] );
      m_pLambert->BeginPass(0);
      m_pMeshBack->m_pLocalMesh->DrawSubset( 0 );
      m_pLambert->EndPass();

      //トラをレンダリング
      m_pd3dDevice->SetTexture( 0, m_pMeshTiger->m_pTextures[0] );
      m_pLambert->BeginPass(0);
      m_pMeshTiger->m_pLocalMesh->DrawSubset( 0 );
      m_pLambert->EndPass();
      m_pLambert->End();


      //****************************************************************
      // (STEP2) 揺らぎパーティクルをレンダリング
      //****************************************************************
      
      //レンダーターゲットサーフェイスを陽炎用サーフェイスに切り替える
      //ZバッファはSTEP1で使用したものを使用するので切り替えない
      m_pd3dDevice->SetRenderTarget( 0, m_pShimmerSurface );

      //Zバッファはクリアしない
      //またレンダーターゲットサーフェイスの初期化カラーは [128] にする。このサーフェイスにはテクセルの移動量を格納するが、移動しない時の値つまり中心の値が [128] となるためこの値で初期化する。
      m_pd3dDevice->Clear( 0L,
                           NULL,
                           D3DCLEAR_TARGET,
                           0x80808080, 
                           1.0f,
                           0L
                         );

      //線形合成に設定する
      m_pd3dDevice->SetRenderState( D3DRS_BLENDOP,   D3DBLENDOP_ADD );
      m_pd3dDevice->SetRenderState( D3DRS_SRCBLEND,  D3DBLEND_SRCALPHA );
      m_pd3dDevice->SetRenderState( D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA );

      //アルファブレンドを有効にする
      m_pd3dDevice->SetRenderState( D3DRS_ALPHABLENDENABLE, TRUE );

      //固定機能パイプラインにより2Dスプライトをレンダリングするので、ライティングしないようにする
      m_pd3dDevice->SetRenderState( D3DRS_LIGHTING, FALSE );

      //半透明メッシュをレンダリングするので、Zバッファへの書き込みを禁止する
      m_pd3dDevice->SetRenderState( D3DRS_ZWRITEENABLE, FALSE );

      m_pd3dDevice->SetTexture( 0, m_pMeshShimmer->m_pTextures[0] );
      
      //揺らぎパーティクルを適当にレンダリングする
      D3DXMatrixTranslation( &matTranslation, 0.0f, 3.0f, 80.0 );
      //ビルボードマトリックスを取得(ビルボード ページ参照)
      matWorld = GetBillBoardMatrix( m_pd3dDevice, &matTranslation );
      m_pd3dDevice->SetTransform( D3DTS_WORLD, &matWorld );
      m_pMeshShimmer->m_pLocalMesh->DrawSubset(0);

      D3DXMatrixTranslation( &matTranslation, -2.0f, 2.0f, 75.0 );
      matWorld = GetBillBoardMatrix( m_pd3dDevice, &matTranslation );
      m_pd3dDevice->SetTransform( D3DTS_WORLD, &matWorld );
      m_pMeshShimmer->m_pLocalMesh->DrawSubset(0);

      D3DXMatrixTranslation( &matTranslation, 3.0f, 3.0f, 72.0 );
      matWorld = GetBillBoardMatrix( m_pd3dDevice, &matTranslation );
      m_pd3dDevice->SetTransform( D3DTS_WORLD, &matWorld );
      m_pMeshShimmer->m_pLocalMesh->DrawSubset(0);

      D3DXMatrixTranslation( &matTranslation, -2.0f, 5.0f, 81.0 );
      matWorld = GetBillBoardMatrix( m_pd3dDevice, &matTranslation );
      m_pd3dDevice->SetTransform( D3DTS_WORLD, &matWorld );
      m_pMeshShimmer->m_pLocalMesh->DrawSubset(0);

      D3DXMatrixTranslation( &matTranslation, 2.0f, 6.0f, 83.0 );
      matWorld = GetBillBoardMatrix( m_pd3dDevice, &matTranslation );
      m_pd3dDevice->SetTransform( D3DTS_WORLD, &matWorld );
      m_pMeshShimmer->m_pLocalMesh->DrawSubset(0);

      //アルファブレンドを無効にする
      m_pd3dDevice->SetRenderState( D3DRS_ALPHABLENDENABLE, FALSE );

      //Zバッファへの書き込みを有効にする
      m_pd3dDevice->SetRenderState( D3DRS_ZWRITEENABLE, TRUE );
      
      //ランバート拡散照明が使えない環境では固定機能パイプラインでレンダリングするためライトを有効にしてあげる
      //固定機能パイプラインをサポートしないのであれば常に無効にしてよい
      m_pd3dDevice->SetRenderState( D3DRS_LIGHTING, TRUE );


      //****************************************************************
      // (STEP3) 揺らぎパーティクルのレンダリング結果をぼかす
      //****************************************************************

      // テクセル位置が [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_ZWRITEENABLE, FALSE );

      m_pd3dDevice->SetTexture( 0, m_pShimmerTexture );
      m_pd3dDevice->SetRenderTarget( 0, m_pHalfSurface[0] );
      
      // X 方向にブラーフィルターを適応する
      m_pBlurFilter2->Render( 0 );

      m_pd3dDevice->SetTexture( 0, m_pHalfTexture[0] );
      m_pd3dDevice->SetRenderTarget( 0, m_pHalfSurface[1] );

      // Y 方向にブラーフィルターを適応する
      m_pBlurFilter2->Render( 1 );

      m_pd3dDevice->SetRenderState( D3DRS_ZWRITEENABLE, TRUE );

      //レンダーターゲットをバックバッファに戻す
      m_pd3dDevice->SetRenderTarget( 0, OldBackBuffer );
      
      //開放
      SafeRelease( OldBackBuffer );
            
            
      //****************************************************************
      // (STEP4) バックバッファのテクセルを移動させて、ゆがませる
      //****************************************************************

      m_pd3dDevice->SetSamplerState( 1, D3DSAMP_MINFILTER, D3DTEXF_POINT );
      m_pd3dDevice->SetSamplerState( 1, D3DSAMP_MAGFILTER, D3DTEXF_POINT );
      m_pd3dDevice->SetSamplerState( 1, D3DSAMP_MIPFILTER, D3DTEXF_NONE );

      m_pd3dDevice->SetTexture( 0, m_pHalfTexture[1] );
      m_pd3dDevice->SetTexture( 1, m_pBackBufferTexture );

      //ゆがみ係数を設定
      m_pShimmer->SetParam( 0.2f );
      
      m_pShimmer->Render();
      
      m_pd3dDevice->SetTexture( 1, NULL );

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


      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