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

■線画シェーダー Prev  Top  Next
関連ページ:ハーフランバートシェーダー

2009/01/07: デバイスロスト対応

ドメイン

今回は、線画シェーダーです。陰部分の表現が線画になっているだけなのでこの名称は正確ではないかもしれませんが まあいいでしょう。ちなみに元ネタは「戦場のヴァルキュリア」というゲームです。

 
右が線画シェーダーを適応した画像です。陰となる部分を暗くするのではなく、線によって表現されています。

実装方法は大まかに次のようになります。

1.レンダーターゲットサーフェイスを2枚用意し、これに「カラー情報」と「拡散反射率情報」をそれぞれ書き込む。
2.1で取得した拡散反射率サーフェイスを参照し、暗くなるほど線を強く減算するようにしてポストエフェクトを適応する。

となります。線の描画には専用のテクスチャーを使用します。
線画テクスチャー
解像度は落としてありますが、こんな感じのテクスチャーです。なお線の描画はシーンのカラー情報から減算するため黒の背景に白の線を引くようにして作成します。 なお線画テクスチャーの作成は「PhotoShop CS2」では次のようにして行います。

1.「フィルタ」メニューを開く。
2.「スケッチ」をポイントし、「グラフィックペン」をクリックする。
3.「イメージ」メニューを開く。
4.「色調補正」をポイントし、「階調反転」をクリックする。

最初このテクスチャーどうやって作成しようかと思いましたが、らくちんでした。PhotoShopさまさまです。

ではソースを見ていきます。

---Lambert9.fx---


float4x4 m_WVP;                   //ワールド × ビュー × 遠近射影
float4 m_LightDir;                //平行光源の方向ベクトル
float4 m_Ambient  = 0.0f;         //環境光

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

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

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.Normal = Normal.xyz;
   
   return Out;
}

struct PS_OUTPUT
{
   float4 Col1 : COLOR0;
   float4 Col2 : COLOR1;
};
PS_OUTPUT PS( VS_OUTPUT In )
{ 
   PS_OUTPUT Out;
   
   //ハーフランバートによるライティング
   float p = dot( normalize( In.Normal ), -m_LightDir.xyz );
   p = p * 0.5f + 0.5;
   p = p * p;

   //色情報をCol1に格納する
   Out.Col1 = tex2D( tex0, In.Tex );
   
   //拡散反射率をCol2に格納する
   Out.Col2 = max( m_Ambient, p );
   
   return Out;
}

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

まずは、シーンのモデルの拡散反射率を適応しない状態のカラー情報と拡散反射率を別のサーフェイスに出力します。

---Canvas.fx---


sampler tex0 : register(s0);      //オブジェクトのテクスチャー
sampler tex1 : register(s1);      //拡散反射率のテクスチャー
sampler tex2 : register(s2);      //線画書き込み用のテクスチャー

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 = 0.0f;
   
   //シーンの拡散反射率を取得
   float Material = tex2D( tex1, In.Tex ).r;

   //取得した拡散反射率を調整する
   //線のかかり具合を小さくするために 0.5f 加算する
   Material = clamp( ( Material + 0.5f ), 0.0f, 1.0f );

   //線の色を計算する。
   float LineColor = ( 1.0f - Material ) * tex2D( tex2, In.Tex );
   
   //最終的なカラー情報を計算する
   //線だけでは弱いのでMaterialを積算して若干陰をつけている
   Col = tex2D( tex0, In.Tex ) * Material - LineColor;
      
   return Col;
}

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

ポストエフェクトにより線画調に変換します。

---Lambert.h---


class LAMBERT9
{
private:
   LPD3DXEFFECT m_pEffect;
   D3DXHANDLE m_pTechnique, m_pWVP, m_pLightDir, m_pAmbient;
   D3DXMATRIX m_matView, m_matProj;
   LPDIRECT3DDEVICE9 m_pd3dDevice;

public:
   LAMBERT9( LPDIRECT3DDEVICE9 pd3dDevice );
   ~LAMBERT9();
   void Invalidate();
   void Restore();
   HRESULT Load();
   void Begin();
   void BeginPass();
   void SetAmbient( float Ambient );
   void SetAmbient( D3DXVECTOR4* pAmbient );
   void SetMatrix( D3DXMATRIX* pMatWorld, D3DXVECTOR4* pLightDir );
   void CommitChanges();
   void EndPass();
   void End();
   BOOL IsOK();
   LPD3DXEFFECT GetEffect(){ return m_pEffect; };
};

---Lambert.cpp---


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

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

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

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

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

   //ハードウェアがサポートするバーテックスシェーダーとピクセルシェーダーのバージョンをチェックする
   m_pd3dDevice->GetDeviceCaps( &caps );
   if( caps.VertexShaderVersion >= D3DVS_VERSION( 1, 1 ) && caps.PixelShaderVersion >= D3DPS_VERSION( 2, 0 ) )
   {
      LPD3DXBUFFER pErr = NULL;

      //fxファイルをロードし、シェーダーの準備を行う。他にobjファイルをロードしたり、ヘッダファイルをインクルードする方法もある。
      //隠蔽性を考慮するとobjファイルやヘッダファイルを使用する方法がよりベター。
      hr = D3DXCreateEffectFromFile( m_pd3dDevice, _T("Lambert9.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_pAmbient   = m_pEffect->GetParameterByName( NULL, "m_Ambient" );
         m_pEffect->SetTechnique( m_pTechnique );   
      }

      else
      {
         return -1;
      }
   }

   else
   {
      return -2;
   }

   return S_OK;
}

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

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

void LAMBERT9::SetAmbient( float Ambient )
{
   if( m_pEffect != NULL )
   {
      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 LAMBERT9::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 LAMBERT9::SetMatrix( D3DXMATRIX* pMatWorld, D3DXVECTOR4* pLightDir )
{
   if( m_pEffect )
   {
      D3DXMATRIX m, m1;
      D3DXVECTOR4 LightDir;
      D3DXVECTOR4 v;

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

      //Light
      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 LAMBERT9::CommitChanges()
{
   if( m_pEffect )
      m_pEffect->CommitChanges();
}

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

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

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

   return FALSE;
}

シーンの色情報とハーフランバートによる拡散反射率を出力するシェーダーの制御クラスです。

---Canvas.h---


//D3D2DSQUAREはスクリーン全体をおおう2Dオブジェクト(表面化散乱(Subsurface Scattering) ページ参照)
class CANVAS : public D3D2DSQUARE
{
private:
   LPD3DXEFFECT m_pEffect;
   D3DXHANDLE m_pTechnique;
   LPDIRECT3DDEVICE9 m_pd3dDevice;

public:
   CANVAS( LPDIRECT3DDEVICE9 pd3dDevice, D3DPRESENT_PARAMETERS* pd3dParameters );
   ~CANVAS();
   void Invalidate();
   void Restore();
   HRESULT Load();
   void Render( LPDIRECT3DTEXTURE9 pBackBuffer, LPDIRECT3DTEXTURE9 pMaterial, LPDIRECT3DTEXTURE9 pCanvas );
   BOOL IsOK();
   LPD3DXEFFECT GetEffect(){ return m_pEffect; };
};

---Canvas.cpp---


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

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

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

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

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

      m_pTechnique = m_pEffect->GetTechniqueByName( "TShader" );
      m_pEffect->SetTechnique( m_pTechnique );   
   }

   else
   {
      return -3;
   }

   return S_OK;
}

void CANVAS::Render( LPDIRECT3DTEXTURE9 pBackBuffer, LPDIRECT3DTEXTURE9 pMaterial, LPDIRECT3DTEXTURE9 pCanvas )
{
   if(  m_pEffect )
   {
      m_pd3dDevice->SetTexture( 0, pBackBuffer );
      m_pd3dDevice->SetTexture( 1, pMaterial );
      m_pd3dDevice->SetTexture( 2, pCanvas );

      m_pEffect->Begin( NULL, 0 );
      m_pEffect->BeginPass( 0 );
      D3D2DSQUARE::Render();
      m_pEffect->EndPass();
      m_pEffect->End();

      m_pd3dDevice->SetTexture( 1, NULL );
      m_pd3dDevice->SetTexture( 2, NULL );
   }
}

BOOL CANVAS::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_pMeshObj = NULL;

//カラー情報とハーフランバートにより拡散反射率を別々に出力するシェーダーの宣言
LAMBERT9* m_pLambert9 = NULL;

//キャンバスシェーダーの宣言
CANVAS* m_pCanvas = NULL;

//シーンのカラー情報を格納するサーフェイスの宣言
LPDIRECT3DTEXTURE9    m_pFullScreenTexture = NULL;
LPDIRECT3DSURFACE9    m_pFullScreenSurface = NULL;

//シーンの拡散反射率情報を格納するサーフェイスの宣言
LPDIRECT3DTEXTURE9    m_pDiffuseTexture = NULL;
LPDIRECT3DSURFACE9    m_pDiffuseSurface = NULL;

//線画テクスチャー
LPDIRECT3DTEXTURE9    m_pCanvasTexture = NULL;

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 );

   m_pMeshObj = new CDXUTMesh();
   m_pMeshObj->Create( m_pd3dDevice, _T("res\\tiger.x") );
   m_pMeshObj->SetFVF( m_pd3dDevice, D3DFVF_XYZ | D3DFVF_NORMAL | D3DFVF_TEX1 );

   //色と拡散反射率を出力するシェーダーの初期化
   m_pLambert9 = new LAMBERT9( m_pd3dDevice );
   m_pLambert9->Load();

   //キャンバスシェーダーの初期化
   m_pCanvas = new CANVAS( m_pd3dDevice );
   m_pCanvas->Load();

   //線画テクスチャーの初期化
   D3DXCreateTextureFromFileEx( m_pd3dDevice,
                                "Canvas.bmp",         //ファイル名
                                D3DX_DEFAULT,         //幅
                                D3DX_DEFAULT,         //高さ
                                1,                    //ミップマップレベル
                                0,                    //テクスチャーの使用目的
                                D3DFMT_UNKNOWN,       //フォーマット
                                D3DPOOL_MANAGED,      //メモリ管理方法
                                D3DX_DEFAULT,         //フィルタリング方法
                                D3DX_DEFAULT,         //フィルタリング方法
                                0x0,                  //カラーキー
                                NULL,                 //ファイルの情報を格納する構造体
                                NULL,                 //256色パレットを示す構造体
                                &m_pCanvasTexture );  //IDirect3DTexture9 インターフェイス

   //平行光源の位置ベクトルから方向ベクトルを計算する
   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_pLambert9->Invalidate();
   m_pCanvas->Invalidate();

   SafeRelease( m_pDiffuseSurface );
   SafeRelease( m_pDiffuseTexture );
   SafeRelease( m_pFullScreenTexture );
   SafeRelease( m_pFullScreenSurface );
}

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

    //カラー情報を格納するマルチレンダーターゲットで使用するテクスチャーを作成する
    D3DXCreateTexture( m_pd3dDevice,
                       nWidth, nHeight, 
                       1,
                       D3DUSAGE_RENDERTARGET,
                       D3DFMT_A8R8G8B8,
                       D3DPOOL_DEFAULT,
                       &m_pFullScreenTexture );
   m_pFullScreenTexture->GetSurfaceLevel( 0, &m_pFullScreenSurface );

   D3DXCreateTexture( m_pd3dDevice,
                      nWidth, nHeight, 
                      1,
                      D3DUSAGE_RENDERTARGET,
                      D3DFMT_R32F,
                      D3DPOOL_DEFAULT,
                      &m_pDiffuseTexture );
   m_pDiffuseTexture->GetSurfaceLevel( 0, &m_pDiffuseSurface );


   //固定機能パイプラインライティングを設定する
   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 pBackBuffer = NULL;
      m_pd3dDevice->GetRenderTarget( 0, &pBackBuffer );
      m_pd3dDevice->SetRenderTarget( 0, m_pFullScreenSurface );
      m_pd3dDevice->SetRenderTarget( 1, m_pDiffuseSurface );

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

      m_pd3dDevice->BeginScene();

      D3DXMATRIX matWorld, matView, matProj;

      //遠近射影座標変換
      D3DXMatrixPerspectiveFovLH( &matProj,
                                  D3DX_PI/4.0f,
                                  4.0f / 3.0f,
                                  11.0f,
                                  220.0f );
      m_pd3dDevice->SetTransform( D3DTS_PROJECTION, &matProj );

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

      //ワールド座標変換
      D3DXMatrixIdentity( &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 );


      //****************************************************************
      //STEP1 : シーンの色と拡散反射率を別々のサーフェイスに出力する
      //****************************************************************

      //カラー情報と拡散反射率を取得する
      m_pLambert9->Begin();
      
      //背景
      m_pLambert9->SetAmbient( 0.0f );
      m_pLambert9->SetMatrix( &matWorld, &LightDir );
      m_pLambert9->BeginPass();
      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);
      m_pd3dDevice->SetTexture( 0, m_pMeshBack->m_pTextures[3] );
      m_pMeshBack->m_pLocalMesh->DrawSubset(3);
      m_pd3dDevice->SetTexture( 0, m_pMeshBack->m_pTextures[4] );
      m_pMeshBack->m_pLocalMesh->DrawSubset(4);

      //トラ
      D3DXMATRIX matScaling, matTranslation;
      D3DXMatrixScaling( &matScaling, 5.0f, 5.0f, 5.0f );
      D3DXMatrixTranslation( &matTranslation, 0.0f, -1.0f, 50.0 );
      matWorld = matScaling * matTranslation;
      m_pd3dDevice->SetTexture( 0, m_pMeshObj->m_pTextures[0] );
      m_pLambert9->SetMatrix( &matWorld, &LightDir );
      m_pLambert9->CommitChanges();
      m_pMeshObj->m_pLocalMesh->DrawSubset(0);
      m_pLambert9->EndPass();
      m_pLambert9->End();

      //バックバッファに戻す
      m_pd3dDevice->SetRenderTarget( 0, pBackBuffer );
      m_pd3dDevice->SetRenderTarget( 1, NULL );
      SafeRelease( pBackBuffer );


      //****************************************************************
      //STEP2 : 線画を適応する
      //****************************************************************

      //シーンの色情報
      m_pd3dDevice->SetSamplerState( 0, D3DSAMP_MINFILTER, D3DTEXF_POINT );
      m_pd3dDevice->SetSamplerState( 0, D3DSAMP_MAGFILTER, D3DTEXF_POINT );
      m_pd3dDevice->SetSamplerState( 0, D3DSAMP_MIPFILTER, D3DTEXF_NONE );

      //拡散反射率マップ
      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->SetSamplerState( 2, D3DSAMP_MINFILTER, D3DTEXF_LINEAR );
      m_pd3dDevice->SetSamplerState( 2, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR );
      m_pd3dDevice->SetSamplerState( 2, D3DSAMP_MIPFILTER, D3DTEXF_NONE );

      //線画を適応する
      m_pCanvas->Render( m_pFullScreenTexture, m_pDiffuseTexture, m_pCanvasTexture );
      
      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;
}

以上です。

さて今回の線画シェーダーですが、線の描画はポストエフェクトにより処理しています。 なのでカメラやオブジェクトがアニメーションしたりすると、違和感があります。 「戦場のヴァルキュリア」の紹介画面をみるとポストエフェクトのように見えるのでそうしたのですが、やっぱり動いているところ見ないとなんともいえません。 プロモーションムービーでは、解像度が低くて、線がつぶれているし。 はやくやってみたいです。って「PlayStation 3」のみかよ!!「XBOX 360」でも発売してください「SEGA」さん。

Prev  Top  Next
inserted by FC2 system