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

■フォンシェーディング Prev  Top  Next
関連ページ:ランバート拡散照明

ドメイン

今回はプラスチックなどで発生するスペキュラーハイライトをやります。Direct3Dには固定機能パイプラインとして存在しますが、頂点シェーダー でスペキュラーの計算を行っているため、レンダリング結果がきれいになりません。


左のボールが固定機能パイプラインによる頂点シェーダーでのレンダリング結果で、 右のボールがシェーダーによるピクセルシェーダーでのレンダリング結果です。 右のほうがきれいにレンダリングされているのがわかると思います。

ではソースを見ていきましょう。

---PhongShading.fx---


float4x4 m_WVP;
float4 m_LightDir;
float4 m_EyePos;                //カメラの位置ベクトル
float4 m_Ambient  = 1.0f;
//float4 m_Emissive = 0.0f; 
float  m_Specular = 0.0f;       //スペキュラーの範囲
float  m_SpecularPower = 0.0f;  //スペキュラーの強度

sampler s0 : register(s0);      //オブジェクトのテクスチャー

struct VS_OUTPUT
{
   float4 Pos    : POSITION;
   float4 Col    : COLOR0;   
   float2 Tex    : TEXCOORD0;
   float3 N      : TEXCOORD1;   //オブジェクトの法線ベクトル
   float3 L      : TEXCOORD2;   //頂点 -> ライト位置 ベクトル
   float3 E      : TEXCOORD3;   //頂点 -> 視点 ベクトル
};

VS_OUTPUT VS( float4 Pos    : POSITION,
              float4 Normal : NORMAL,
              float2 Tex    : TEXCOORD0 )
{
   VS_OUTPUT Out;
   
   Out.Pos = mul( Pos, m_WVP );
   Out.Tex = Tex; 
      
   //ライト方向で入力されるので、頂点 -> ライト位置とするために逆向きに変換する。なおアプリケーションで必ず正規化すること
   Out.L = -m_LightDir.xyz;
   
   Out.N = Normal.xyz;
   
   //ライトベクトルと法線ベクトルの内積を計算し、計算結果の色の最低値を環境光( m_Ambient )に制限する
//   Out.Col = min( max( m_Ambient, dot( Out.N, Out.L ) ) + m_Emissive, 1.0f );
   Out.Col = min( max( m_Ambient, dot( Out.N, Out.L ) ), 1.0f );
   
   //頂点 -> 視点 へのベクトルを計算
   Out.E = m_EyePos.xyz - Pos.xyz;
    
   return Out;
}

float4 PS( VS_OUTPUT In ) : COLOR0
{ 
   float4 Out;
   
   //法線ベクトルを正規化する
   float3 N = normalize( In.N );
   //頂点 -> ライト位置ベクトル + 頂点 -> 視点ベクトル(注意1)
   float3 H = normalize( In.L + normalize( In.E ) );
   //スペキュラーカラーを計算する(注意2)
   float S = pow( max( 0.0f, dot( N, H ) ), m_Specular ) * m_SpecularPower;
   
   //スペキュラーカラーを加算する
   Out = In.Col * tex2D( s0, In.Tex ) + S;

   return Out;
}

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

ベースのシェーディングをランバート拡散照明で行い、この結果にスペキュラーカラーを加算してます。

(注意1) 頂点 -> ライト位置ベクトル + 頂点 -> 視点ベクトルの計算を行います

(注意2) H と N の内積を計算します。H と N の角度が小さいほどスペキュラーが強くなります。

---PhongShading.h---


class PHONG_SHADE
{
private:
   LPD3DXEFFECT m_pEffect;
//   D3DXHANDLE m_pTechnique, m_pWVP, m_pLightDir, m_pEyePos, m_pAmbient, m_pEmissive, m_pSpecular, m_pSpecularPower;
   D3DXHANDLE m_pTechnique, m_pWVP, m_pLightDir, m_pEyePos, m_pAmbient, m_pSpecular, m_pSpecularPower;
   D3DXMATRIX m_matView, m_matProj;
   LPDIRECT3DDEVICE9 m_pd3dDevice;

public:
   PHONG_SHADE( LPDIRECT3DDEVICE9 pd3dDevice );
   ~PHONG_SHADE();
   HRESULT Load();
   void Invalidate();
   void Restore();
   void Begin();
   void BeginPass();
   void SetAmbient( float Ambient );
   void SetAmbient( D3DXVECTOR4* pAmbient );
//   void SetEmissive( float Emissive );
//   void SetEmissive( D3DXVECTOR4* pEmissive );
   void SetSpecular( float Specular );
   void SetSpecularPower( float SpecularPower );
   void SetMatrix( D3DXMATRIX* pMatWorld, D3DXVECTOR4* pCameraPos, D3DXVECTOR4* pLightDir );
   void CommitChanges();
   void EndPass();
   void End();
   BOOL IsOK();
};

---PhongShading.cpp---


PHONG_SHADE::PHONG_SHADE( LPDIRECT3DDEVICE9 pd3dDevice )
{
   m_pd3dDevice = pd3dDevice;
   m_pEffect = NULL;
}

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

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

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

HRESULT PHONG_SHADE::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("PhongShading.fx"), NULL, NULL, 0, NULL, &m_pEffect, &pErr );
      if( SUCCEEDED( hr ) )
      {
         m_pTechnique = m_pEffect->GetTechniqueByName( "TShader" );
         m_pWVP = m_pEffect->GetParameterByName( NULL, "m_WVP" );
         m_pLightDir = m_pEffect->GetParameterByName( NULL, "m_LightDir" );
         m_pEyePos = m_pEffect->GetParameterByName( NULL, "m_EyePos" );
         m_pAmbient = m_pEffect->GetParameterByName( NULL, "m_Ambient" );
//         m_pEmissive = m_pEffect->GetParameterByName( NULL, "m_Emissive" );
         m_pSpecularPower = m_pEffect->GetParameterByName( NULL, "m_SpecularPower" );
         m_pSpecular = m_pEffect->GetParameterByName( NULL, "m_Specular" );

         m_pEffect->SetTechnique( m_pTechnique );   
      }

      else
      {
         return -1;
      }
   }

   else
   {
      return -2;
   }

   return S_OK;
}

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

void PHONG_SHADE::BeginPass()
{
   if( m_pEffect )
      m_pEffect->BeginPass(0);
}

void PHONG_SHADE::SetAmbient( float Ambient )
{
   if( m_pEffect )
   {
      D3DXVECTOR4 A;
      A = D3DXVECTOR4( Ambient, Ambient, Ambient, 1.0f );
      m_pEffect->SetVector( m_pAmbient, &A );
   }

   else
   {
      D3DMATERIAL9 old_material;
      m_pd3dDevice->GetMaterial( &old_material );
      old_material.Ambient.r = Ambient;
      old_material.Ambient.g = Ambient;
      old_material.Ambient.b = Ambient;
      old_material.Ambient.a = 1.0f;
      m_pd3dDevice->SetMaterial( &old_material );
   }
}

void PHONG_SHADE::SetAmbient( D3DXVECTOR4* pAmbient )
{
   if( m_pEffect )
      m_pEffect->SetVector( m_pAmbient, pAmbient );

   else
   {
      D3DMATERIAL9 old_material;
      m_pd3dDevice->GetMaterial( &old_material );
      old_material.Ambient.r = pAmbient->x;
      old_material.Ambient.g = pAmbient->y;
      old_material.Ambient.b = pAmbient->z;
      old_material.Ambient.a = pAmbient->w;
      m_pd3dDevice->SetMaterial( &old_material );
   }
}

/*
void PHONG_SHADE::SetEmissive( float Emissive )
{
   if( m_pEffect )
   {
      D3DXVECTOR4 A;
      A = D3DXVECTOR4( Emissive, Emissive, Emissive, 1.0f );
      m_pEffect->SetVector( m_pEmissive, &A );
   }

   else
   {
      D3DMATERIAL9 old_material;
      m_pd3dDevice->GetMaterial( &old_material );
      old_material.Emissive.r = Emissive;
      old_material.Emissive.g = Emissive;
      old_material.Emissive.b = Emissive;
      old_material.Emissive.a = 1.0f;
      m_pd3dDevice->SetMaterial( &old_material );
   }
}

void PHONG_SHADE::SetEmissive( D3DXVECTOR4* pEmissive )
{
   if( m_pEffect )
      m_pEffect->SetVector( m_pEmissive, pEmissive );

   else
   {
      D3DMATERIAL9 old_material;
      m_pd3dDevice->GetMaterial( &old_material );
      old_material.Emissive.r = pEmissive->x;
      old_material.Emissive.g = pEmissive->y;
      old_material.Emissive.b = pEmissive->z;
      old_material.Emissive.a = pEmissive->w;
      m_pd3dDevice->SetMaterial( &old_material );
   }
}
*/

//スペキュラーの範囲を設定する
void PHONG_SHADE::SetSpecular( float Specular )
{
   if( m_pEffect )
      m_pEffect->SetFloat( m_pSpecular, Specular );
}

//スペキュラーの強度を設定する
void PHONG_SHADE::SetSpecularPower( float SpecularPower )
{
   if( m_pEffect )
      m_pEffect->SetFloat( m_pSpecularPower, SpecularPower );
}

void PHONG_SHADE::SetMatrix( D3DXMATRIX* pMatWorld, D3DXVECTOR4* pCameraPos, D3DXVECTOR4* pLightDir )
{
   if( m_pEffect )
   {
      D3DXMATRIX m, m1;
      D3DXVECTOR4 LightDir;
      D3DXVECTOR4 v;

      m = (*pMatWorld) * m_matView * m_matProj;
      m_pEffect->SetMatrix( m_pWVP, &m );

      //カメラ位置
      m1 = (*pMatWorld) * m_matView;
      D3DXMatrixInverse( &m1, NULL, &m1 );
      D3DXVec4Transform( &v, pCameraPos, &m1 );
      m_pEffect->SetVector( m_pEyePos, &v );

      //ライトの方向ベクトル
      LightDir = *pLightDir;
      D3DXMatrixInverse( &m1, NULL, pMatWorld );
      D3DXVec4Transform( &v, &LightDir, &m1 );
      D3DXVec4Normalize( &v, &v );
      m_pEffect->SetVector( m_pLightDir, &v );
   }

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

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

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

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

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

   return FALSE;
}

フォンシェーディングを制御するクラスです。ランバート拡散照明をベースにしてちょこっと修正した程度です。

---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;
CDXUTMesh* m_pMeshBall = NULL;

//フォンシェーダークラスの宣言
PHONG_SHADE* m_pPhongShade = NULL;

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

//太陽の位置ベクトル
//光源の位置はカメラの視線方向にある
D3DXVECTOR4 LightPos = D3DXVECTOR4( 100.0f, 100.0f, -100.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_pPhongShade = new PHONG_SHADE( m_pd3dDevice );
   m_pPhongShade->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_pMeshBall = new CDXUTMesh();
   m_pMeshBall->Create( m_pd3dDevice, _T("res\\Ball.x") );
   m_pMeshBall->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_pPhongShade->Invalidate();
}

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

   //固定機能パイプラインライティングを設定する
   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
   {
      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_LINEAR );

      //固定機能パイプラインで背景をレンダリング
      m_pd3dDevice->SetTexture( 0, m_pMeshBack->m_pTextures[0] );
      m_pMeshBack->m_pLocalMesh->DrawSubset( 0 );
      m_pd3dDevice->SetRenderState( D3DRS_LIGHTING, FALSE );
      m_pMeshBack->m_pLocalMesh->DrawSubset( 1 );
      
      //フォンシェーディングによりボールをレンダリング
      m_pPhongShade->Begin();
      m_pPhongShade->SetAmbient( 0.0f );
      m_pPhongShade->SetSpecular( 20.0f );
      m_pPhongShade->SetSpecularPower( 0.75f );
      m_pPhongShade->SetMatrix( &matWorld, &EyePos, &LightDir );
      m_pd3dDevice->SetTexture( 0, m_pMeshBall->m_pTextures[0] );
      m_pPhongShade->BeginPass();
      m_pMeshBall->m_pLocalMesh->DrawSubset( 0 );
      m_pPhongShade->EndPass();
      m_pPhongShade->End();

      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