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

■コースティックシェーダー Prev  Top  Next
関連ページ:ブラーフィルターその2 波シェーダー
2009/08/17: 波マップに追加する波の高さを変更できるようにする

無料レンタルサーバー

コースティック

今回はコースティックシェーダーです。ずっとやろうと思っていて放置していたネタです。 自作のゲーム「GrowWing」でもやってますが、あっちではあらかじめ作成してあるテクスチャーをテクセルのTU方向とTV方向に少しづつずらした2つのイメージを合成したものを適応しているだけで、 たいしたことやってないんですよね。実は。今回のネタは結果だけ見ると「GrowWing」とあまり変わらないですが、 テクスチャーを自前で作成する必要がないため、こっちの方がいいと思います。
で上のサンプルイメージですが、コースティックが適応され、部分的に明るくなっています。静止画ではわかりにくいかもしれませんが、実際にアニメーションさせると面白い動きするのでやってみてください。 あとわからんと思うので言っておきますが、このシーンは水中です(笑)。フォグを適応しないと水中には見えないよな、やっぱ。

コースティックについて簡単に説明します。 水面下の物体に光の網目模様みたいなのが投射される光学現象のこと。太陽光が水面上に発生する波の凸凹がレンズ効果を発生させることにより、集光して輝いてみえるようになる現象です。 GAME Watch参照。

では実装方法です。

1.波マップ(最終的には水面の法線マップ)を作成します。波マップの作成方法は、波シェーダーを参照してください。

2.1で作成した法線マップを参照してコースティックマップを作成します。コースティックマップはこんな感じで作成します。
水面を真横から見た波の断面
青い矢印が水面の法線ベクトルです。で黄色いところがコースティックにより明るくなります。 輝度を計算する方法は単純で、法線ベクトルと[0.0f, 0.0f, 1.0f]のベクトルとの内積を計算するだけです。その後白黒反転するので、結果的に図の部分が明るくなります。 物理学的にはまったく正しくない、擬似的な方法ですが、結構それっぽく見えると思います。

3.2で作成したコースティックマップにブラーフィルターを適応します。これも既出なので今回は省略します。ブラーフィルターその2を参照してください。

4.3で作成したぼかしたコースティックマップを参照して、モデルにコースティックを適応します。

ではソースです。

---CausticShader.fx---


float4x4 m_W;                     //ワールド行列のみ
float4x4 m_WVP;                   //ワールド × ビュー × 遠近射影行列
float4   m_LightDir;              //平行光源の方向ベクトル
float    m_CausticScale;          //コースティックの大きさ

sampler tex0 : register(s0);      //Pass0:法線マップ Pass1:コースティックマップ
sampler tex1 : register(s1);      //                  Pass1:デカールマップ

//コースティックマップ作成

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

VS_OUTPUT VS( float4 Pos    : POSITION,
              float4 Col    : COLOR0,
              float2 Tex    : TEXCOORD0 )
{
   VS_OUTPUT Out;

   Out.Pos = Pos;
   Out.Tex = Tex;

   return Out;
}

float4 PS( VS_OUTPUT In ) : COLOR0
{
   float4 Col;

   float4 Normal = tex2D( tex0, In.Tex );
   
   //法線マップには法線情報が[0.0f 〜 1.0f]で格納されているので[-1.0f 〜 1.0f]に変換する
   Normal.x = Normal.x * 2.0f - 1.0f;
   Normal.y = -( Normal.y * 2.0f - 1.0f );
   
   //輝度を計算する
   float c = dot( normalize( Normal.xyz ), float3( 0.0f, 0.0f, 1.0f ) );

   //0.0f 〜 1.0fの範囲内に変換する
   c = c * 0.5f + 0.5f;
   
   //陰を適当に強調する
//   c = pow( c, 5.0f );
   c = pow( c, 100.0f );

   //白黒反転
//   Col = ( 1.0f - c );
   Col = ( 1.0f - c ) * 1.2f;

   return Col;

}

//コースティックマップを適応してハーフランバートライティング

struct VS1_OUTPUT
{
   float4 Pos    : POSITION;
   float2 Tex    : TEXCOORD0;
   float3 Normal : TEXCOORD1;
   float3 WPos   : TEXCOORD2;
};

VS1_OUTPUT VS1( float4 Pos    : POSITION,
                float4 Normal : NORMAL,
                float2 Tex    : TEXCOORD0 )
{
   VS1_OUTPUT Out;
   
   Out.Pos    = mul( Pos, m_WVP );
   Out.Tex    = Tex;
   
   Out.Normal = normalize( Normal.xyz );
   
   Out.WPos   = mul( Pos, m_W );
   
   return Out;
}

float4 PS1( VS1_OUTPUT In ) : COLOR0
{ 
   float4 Out;

   //この辺がハーフランバートライティング
   float p = dot(In.Normal, -m_LightDir.xyz);
   p = p * 0.5f + 0.5;
   p = p * p;

   //コースティックマップを参照し、明るくする。
   Out = p * tex2D( tex1, In.Tex ) + tex2D( tex0, float2( In.WPos.x, In.WPos.z ) * m_CausticScale );

   return Out;
}

technique TShader
{
   //コースティックマップ作成
   pass P0
   {
      VertexShader = compile vs_1_1 VS();
      PixelShader  = compile ps_2_0 PS();
   }

   //コースティックマップを適応してハーフランバートライティング
   pass P1
   {
      VertexShader = compile vs_1_1 VS1();
      PixelShader  = compile ps_2_0 PS1();
   }
}

コースティックシェーダーです。

パス0のピクセルシェーダー内で内積の計算を行っています。

次にパス1のピクセルシェーダー内でコースティックマップをサンプリングするときに使用するテクセル座標ですが、頂点をワールド行列で行列変換したものを使用しています。 これは頂点に設定されているテクセル座標に依存しないようにするためです。
あとライティングにハーフランバートを使用していますが、既出なので省略します。というかライティングは今回のネタとは直接関係しません。

---CausticShader.h---


//D3D2DSQUAREは表面化散乱(Subsurface Scattering)を参照すること
class CAUSTIC_SHADER : private D3D2DSQUARE
{
private:
   LPD3DXEFFECT m_pEffect;
   D3DXHANDLE m_pTechnique, m_pWVP, m_pW, m_pLightDir, m_pCausticScale;
   D3DXMATRIX m_matView, m_matProj;
   LPDIRECT3DDEVICE9 m_pd3dDevice;

public:
   CAUSTIC_SHADER( LPDIRECT3DDEVICE9 pd3dDevice, D3DPRESENT_PARAMETERS* pd3dParameters );
   CAUSTIC_SHADER( LPDIRECT3DDEVICE9 pd3dDevice, UINT Width, UINT Height );
   ~CAUSTIC_SHADER();
   void Invalidate();
   void Restore();
   HRESULT Load();

   //コースティックマップを作成する
   void Step01_Render( UINT Pass );

   //コースティックマップを適応してモデルをレンダリングする
   void Step02_Begin();
   void Step02_BeginPass();
   void Step02_SetMatrix( D3DXMATRIX* pMatWorld, D3DXVECTOR4* pLightDir );
   void Step02_SetCausticScale( float CausticScale );
   void Step02_EndPass();
   void Step02_End();
   void CommitChanges();

   BOOL IsOK();
   LPD3DXEFFECT GetEffect(){ return m_pEffect; };
};

---CausticShader.cpp---


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

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

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

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

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

HRESULT CAUSTIC_SHADER::Load()
{
   D3DCAPS9 caps;

   m_pd3dDevice->GetDeviceCaps( &caps );
   if( caps.VertexShaderVersion >= D3DVS_VERSION( 1, 1 ) && caps.PixelShaderVersion >= D3DPS_VERSION( 2, 0 ) )
   {
      LPD3DXBUFFER pErr = NULL;
      HRESULT hr = D3DXCreateEffectFromFile( m_pd3dDevice, _T("CausticShader.fx"), NULL, NULL, 0, NULL, &m_pEffect, &pErr );
      if( SUCCEEDED( hr ) )
      {
         HRESULT hr = D3D2DSQUARE::Load();
         if( FAILED( hr ) )
            return -1;

         m_pTechnique    = m_pEffect->GetTechniqueByName( "TShader" );
         m_pWVP          = m_pEffect->GetParameterByName( NULL, "m_WVP" );
         m_pW            = m_pEffect->GetParameterByName( NULL, "m_W" );
         m_pLightDir     = m_pEffect->GetParameterByName( NULL, "m_LightDir" );
         m_pCausticScale = m_pEffect->GetParameterByName( NULL, "m_CausticScale" );
         m_pEffect->SetTechnique( m_pTechnique );   
      }

      else
      {
         return -2;
      }
   }

   else
   {
      return -3;
   }

   return S_OK;
}

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

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

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

void CAUSTIC_SHADER::Step02_Begin()
{
   if(  m_pEffect )
   {
      m_pd3dDevice->GetTransform( D3DTS_VIEW, &m_matView );
      m_pd3dDevice->GetTransform( D3DTS_PROJECTION, &m_matProj );
      m_pEffect->Begin( NULL, 0 );
   }
}

void CAUSTIC_SHADER::Step02_BeginPass()
{
   if( m_pEffect )
   {
      m_pEffect->BeginPass( 1 );
   }
}

//ローカル座標系で行列変換
void CAUSTIC_SHADER::Step02_SetMatrix( D3DXMATRIX* pMatWorld, D3DXVECTOR4* pLightDir )
{
   if( m_pEffect )
   {
      D3DXMATRIX m;
      D3DXVECTOR4 v;

      //ワールド行列のみ
      m_pEffect->SetMatrix( m_pW, pMatWorld );

      //ワールド × ビュー × 遠近射影行列
      m = (*pMatWorld) * m_matView * m_matProj;
      m_pEffect->SetMatrix( m_pWVP, &m );

      //平行光源の方向ベクトル
      D3DXMatrixInverse( &m, NULL, pMatWorld );
      D3DXVec4Transform( &v, pLightDir, &m );
      //XYZ成分について正規化する
      D3DXVec3Normalize( (D3DXVECTOR3*)&v, (D3DXVECTOR3*)&v );
      m_pEffect->SetVector( m_pLightDir, &v );
   }

   else
      m_pd3dDevice->SetTransform( D3DTS_WORLD, pMatWorld );
}

void CAUSTIC_SHADER::Step02_SetCausticScale( float CausticScale )
{
   if( m_pEffect )
   {
      m_pEffect->SetFloat( m_pCausticScale, CausticScale );
   }
}

void CAUSTIC_SHADER::Step02_EndPass()
{
   if( m_pEffect )
   {
      m_pEffect->EndPass();
   }
}

void CAUSTIC_SHADER::Step02_End()
{
   if( m_pEffect )
   {
      m_pEffect->End();
   }
}

void CAUSTIC_SHADER::CommitChanges()
{
   if( m_pEffect )
      m_pEffect->CommitChanges();
}

波シェーダークラスと別クラスにしましたが、一緒にしてもいいかも。設計方法はよくわからん。

---Main.cpp---


LPDIRECT3D9 m_pdirect3d9 = NULL;
LPDIRECT3DDEVICE9 m_pd3dDevice = NULL;
D3DPRESENT_PARAMETERS m_d3dParameters;

D3DCAPS9 Caps;

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

//波シェーダークラスの宣言
WAVE*           m_pWave          = NULL;

//コースティックシェーダークラスの宣言
CAUSTIC_SHADER* m_pCausticShader = NULL;

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

//コースティックマップの宣言
LPDIRECT3DTEXTURE9 m_pCausticTexture = NULL;
LPDIRECT3DSURFACE9 m_pCausticSurface = NULL;

//ブラーを適応したコースティックマップの宣言
LPDIRECT3DTEXTURE9 m_pBlurTexture[2];
LPDIRECT3DSURFACE9 m_pBlurSurface[2];

//スクリーンの解像度
UINT nWidth = 1024;
UINT nHeight = 768;

//波マップとコースティックマップのサイズ
D3DXVECTOR2 WaveMapSize = D3DXVECTOR2( 512.0f, 512.0f );

D3DXVECTOR4 LightPos = D3DXVECTOR4( 50.0f, 100.0f, 750.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_pd3dDevice->GetDeviceCaps(&Caps);


   //波シェーダークラスの初期化
   m_pWave = new WAVE( m_pd3dDevice, (UINT)WaveMapSize.x, (UINT)WaveMapSize.y );
   m_pWave->Load();

   //コースティックシェーダークラスの初期化
   m_pCausticShader = new CAUSTIC_SHADER( m_pd3dDevice, &m_d3dParameters );
   m_pCausticShader->Load();

   //ブラーフィルターシェーダークラスの初期化
   m_pBlurFilter2 = new BLURFILTER2( m_pd3dDevice, (UINT)WaveMapSize.x, (UINT)WaveMapSize.y );
   m_pBlurFilter2->Load();


   //モデルのロード
   //背景
   m_pMeshBack = new CDXUTMesh();
   m_pMeshBack->Create( m_pd3dDevice, _T("back.x") );
   m_pMeshBack->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_pWave->Invalidate();
   m_pCausticShader->Invalidate();
   m_pBlurFilter2->Invalidate();

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

   SafeRelease( m_pCausticTexture );
   SafeRelease( m_pCausticSurface );
}

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

   for( int i=0; i<2; i++ )
   {
      m_pd3dDevice->CreateTexture( (UINT)WaveMapSize.x,
                                   (UINT)WaveMapSize.y,
                                   1,
                                   D3DUSAGE_RENDERTARGET,
                                   D3DFMT_A8R8G8B8,
                                   D3DPOOL_DEFAULT,
                                   &m_pBlurTexture[i],
                                   NULL );
      m_pBlurTexture[i]->GetSurfaceLevel( 0, &m_pBlurSurface[i] );
   }

   //コースティックマップの作成
   m_pd3dDevice->CreateTexture( (UINT)WaveMapSize.x,
                                (UINT)WaveMapSize.y,
                                1,
                                D3DUSAGE_RENDERTARGET,
                                D3DFMT_A8R8G8B8,
                                D3DPOOL_DEFAULT,
                                &m_pCausticTexture,
                                NULL );
   m_pCausticTexture->GetSurfaceLevel( 0, &m_pCausticSurface );


   //固定機能パイプラインライティングを設定する
   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 matWVP, matPProj, matView, matWorld;

      //遠近射影座標変換
      //クリップ面はアプリケーションごとに調整すること
      D3DXMatrixPerspectiveFovLH( &matPProj,
                                  D3DX_PI/4.0f,
                                  4.0f / 3.0f,
                                  30.0f,
                                  700.0f );
      m_pd3dDevice->SetTransform( D3DTS_PROJECTION, &matPProj );


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

      m_pd3dDevice->BeginScene();


      //****************************************************************
      // (STEP1) 波マップの更新
      //****************************************************************

      //浮動小数点フォーマットはビデオカードによっては「LINEAR」がきかないのでここでは「POINT」に設定しておく
      m_pd3dDevice->SetSamplerState( 0, D3DSAMP_MINFILTER, D3DTEXF_POINT );
      m_pd3dDevice->SetSamplerState( 0, D3DSAMP_MAGFILTER, D3DTEXF_POINT );
      m_pd3dDevice->SetSamplerState( 0, D3DSAMP_MIPFILTER, D3DTEXF_NONE );

      //2Dスプライトオブジェクトを使用してレンダリングするのでZバッファへの書き込みを無効にする
      m_pd3dDevice->SetRenderState( D3DRS_ZENABLE, D3DZB_FALSE );

      m_pWave->SetSpringPower( 0.15f );

      //適当に波を新規作成する
      //追加する波の高さを設定できるように修正. 詳細は波シェーダーページを参照
//      m_pWave->AddWavePos( (float)(rand()%100) * 0.01f, (float)(rand()%100) * 0.01f );
      m_pWave->AddWave( (float)(rand()%100) * 0.01f, (float)(rand()%100) * 0.01f, (float)(rand()%100-50) * 0.002f );

      //波マップの更新
      LPDIRECT3DTEXTURE9 BumpMap = m_pWave->Render();


      //****************************************************************
      // (STEP2) コースティックマップを作成
      //****************************************************************

      D3DVIEWPORT9 OldViewport, NewViewport;

      //ビューポートをコースティックマップのサイズに合わせる
      m_pd3dDevice->GetViewport( &OldViewport );
      CopyMemory( &NewViewport, &OldViewport, sizeof( D3DVIEWPORT9 ) );
      NewViewport.Width  = (DWORD)WaveMapSize.x;
      NewViewport.Height = (DWORD)WaveMapSize.y;
      m_pd3dDevice->SetViewport( &NewViewport );

      //レンダーターゲットサーフェイスを切り替える
      //レンダーターゲットの解像度 > Zバッファの解像度 の場合
      //IDirect3DDevice::Clearメソッドの実行時にエラーになるので本当はZバッファも切り替えるべき
      LPDIRECT3DSURFACE9 OldSurface = NULL;
      m_pd3dDevice->GetRenderTarget( 0, &OldSurface );
      m_pd3dDevice->SetRenderTarget( 0, m_pCausticSurface );
      m_pd3dDevice->SetTexture( 0, BumpMap );
      
      //コースティックマップを作成する
      m_pCausticShader->Step01_Render(0);


      //****************************************************************
      // (STEP3) ブラーをかます
      //****************************************************************

      m_pd3dDevice->SetTexture( 0, m_pCausticTexture );

      for( int i=0; i<2; i++ )
      {
         m_pd3dDevice->SetRenderTarget( 0, m_pBlurSurface[i % 2] );

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

         m_pd3dDevice->SetTexture( 0, m_pBlurTexture[i % 2] );
      }

      //レンダーターゲットサーフェイスを戻す
      m_pd3dDevice->SetRenderTarget( 0, OldSurface );
      SafeRelease( OldSurface );

      //ビューポートも戻す
      m_pd3dDevice->SetViewport( &OldViewport );

      m_pd3dDevice->SetRenderState( D3DRS_ZENABLE, D3DZB_TRUE );


      //****************************************************************
      // (STEP4) コースティックを適応してモデルをレンダリングする
      //****************************************************************

      m_pd3dDevice->Clear( 0L,
                           NULL,
                           D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER,
                           0xff4a676d, 
                           1.0f,
                           0L
                        );

      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->SetSamplerState( 1, D3DSAMP_MINFILTER, D3DTEXF_LINEAR );
      m_pd3dDevice->SetSamplerState( 1, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR );
      m_pd3dDevice->SetSamplerState( 1, D3DSAMP_MIPFILTER, D3DTEXF_NONE );

      //海底をレンダリング
      m_pCausticShader->Step02_Begin();
      D3DXMatrixIdentity( &matWorld );
      m_pCausticShader->Step02_SetMatrix( &matWorld, &LightDir );
      m_pd3dDevice->SetTexture( 0, m_pBlurTexture[1] );
      m_pd3dDevice->SetTexture( 1, m_pMeshBack->m_pTextures[0] );
      m_pCausticShader->Step02_SetCausticScale( 0.001f );
      m_pCausticShader->Step02_BeginPass();
      m_pMeshBack->m_pLocalMesh->DrawSubset( 0 );
      m_pCausticShader->Step02_EndPass();
      m_pCausticShader->Step02_End();

      m_pd3dDevice->SetTexture( 1, NULL );

      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