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

■点描画シェーダー	Prev　　Top　　Next
	関連ページ：線画シェーダー　アルファチャンネルつきDDSファイル作成

無料レンタルサーバー

さて今回は点描画シェーダーをやります。フランスの画家、ジョルジュ・スーラの技法を参考にしています。作ったのでとりあえず公開しましたが、正直微妙なネタです。

こんなふうになりました。なんかノイズをいれただけって感じだな。

処理フローです。
１．レンダーターゲットサーフェイスを２枚用意し、これに「テクスチャーを貼り付けたカラー情報」と「拡散反射率情報」をそれぞれ書き込む。
２．１の「カラー情報」と「点描画マップ」を線形合成し、１の「拡散反射率情報」を積算する。

使用する点描画マップのサンプルです。
RGB成分
アルファチャンネル
点描画マップはddsファイルです。ddsファイルの作成はアルファチャンネルつきDDSファイル作成で紹介してます。

さてソースを見ていきます。

まずステップ１の処理ですが、これは線画シェーダーで使用しているLAMBERT9クラスを使用します。既出なので省略します。

---PointImageShader.fx---

sampler s0 : register(s0);   //点描画マップ
sampler s1 : register(s1);   //テクスチャーを適応したカラー情報
sampler s2 : register(s2);   //拡散反射率情報

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

float4 PS( VS_OUTPUT In ) : COLOR0
{
   float4 Out;
   
   float4 PointImage = tex2D( s0, In.Tex );
   float4 DecalMap   = tex2D( s1, In.Tex );
   float4 DiffuseMap = tex2D( s2, In.Tex );

   //点描画テクスチャーのアルファ成分をキーにしてカラー情報と点描画マップを線形合成し、拡散反射率を積算する
   Out = lerp( PointImage, DecalMap, PointImage.a ) * DiffuseMap.r;
   
   return Out;
}

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

点描画フィルターを適応する。

---PointImageShader.h---

//D3D2DSQUAREは2Dオブジェクト(表面化散乱(Subsurface Scattering) ページ参照)
class POINT_IMAGE_SHADER : public D3D2DSQUARE 
{
private:
   LPD3DXEFFECT m_pEffect;
   D3DXHANDLE m_pTechnique;
   LPDIRECT3DDEVICE9 m_pd3dDevice;

   //点描画テクスチャー
   LPDIRECT3DTEXTURE9    m_pPointImageTexture;

public:
   POINT_IMAGE_SHADER( LPDIRECT3DDEVICE9 pd3dDevice, D3DPRESENT_PARAMETERS* pd3dParameters );
   POINT_IMAGE_SHADER( LPDIRECT3DDEVICE9 pd3dDevice, UINT Width, UINT Height );
   ~POINT_IMAGE_SHADER();
   void Invalidate();
   void Restore();
   HRESULT Load( LPCTSTR pPointImageFileName );
   void Render();
   BOOL IsOK();
   LPD3DXEFFECT GetEffect(){ return m_pEffect; };
};

---PointImageShader.cpp---

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

   m_pEffect = NULL;
   m_pPointImageTexture = NULL;
}

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

   m_pEffect = NULL;
   m_pPointImageTexture = NULL;
}

POINT_IMAGE_SHADER::~POINT_IMAGE_SHADER()
{
   SafeRelease( m_pEffect );
   SafeRelease( m_pPointImageTexture );
}

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

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

HRESULT POINT_IMAGE_SHADER::Load( LPCTSTR pPointImageFileName )
{
   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;

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

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

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

      m_pEffect->SetTechnique( m_pTechnique );
   }

   else
   {
      return -4;
   }

   return S_OK;
}

void POINT_IMAGE_SHADER::Render()
{
   if( m_pEffect )
   {
      m_pd3dDevice->SetTexture( 0, m_pPointImageTexture );

      m_pEffect->Begin( NULL, 0 );
      m_pEffect->BeginPass( 0 );

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

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

BOOL POINT_IMAGE_SHADER::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_pMeshSun = NULL;
CDXUTMesh* m_pMeshTiger = NULL;

//拡散反射率情報を別サーフェイスに出力するクラスの宣言
LAMBERT9* m_pLambert9 = NULL;

//点描画シェーダークラスの宣言
POINT_IMAGE_SHADER* m_pPointImageShader = NULL;

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

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


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

D3DXVECTOR4 LightPos = D3DXVECTOR4( 100.0f, 100.0f, 0.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_pLambert9 = new LAMBERT9( m_pd3dDevice );
   m_pLambert9->Load();

   //点描画シェーダークラスの初期化
   m_pPointImageShader = new POINT_IMAGE_SHADER( m_pd3dDevice, &m_d3dParameters );
   m_pPointImageShader->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_pMeshSun = new CDXUTMesh();
   //m_pMeshSun->Create( m_pd3dDevice, _T("res\\sun.x") );
   //m_pMeshSun->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 );


   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_pPointImageShader->Invalidate();

   SafeRelease( m_pFullScreenSurface );
   SafeRelease( m_pFullScreenTexture );

   SafeRelease( m_pDiffuseSurface );
   SafeRelease( m_pDiffuseTexture );
}

//デバイスのリセット後に初期化すべきオブジェクト
void Restore()
{
   m_pLambert9->Restore();
   m_pPointImageShader->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( 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, matTiger, matScaling, matTranslation, matRotation;

      //遠近射影座標変換
      //クリップ面はアプリケーションごとに調整すること
      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 );

      //トラ
      D3DXMatrixRotationY( &matRotation, D3DXToRadian( 45.0f ) );
      D3DXMatrixScaling( &matScaling, 50.0f, 50.0f, 50.0f );
      D3DXMatrixTranslation( &matTranslation, 0.0f, 70.0f, 400.0f );
      matTiger = matScaling * matRotation * matTranslation;

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

      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_POINT );
      m_pd3dDevice->SetSamplerState( 2, D3DSAMP_MAGFILTER, D3DTEXF_POINT );
      m_pd3dDevice->SetSamplerState( 2, D3DSAMP_MIPFILTER, D3DTEXF_NONE );


      //****************************************************************
      //ステップ１ : カラー情報と拡散情報を出力
      //****************************************************************

      //マルチレンダーターゲットに切り替える
      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,
                           0x00000000,
                           1.0f,
                           0L
                         );

      //背景レンダリング
      m_pLambert9->Begin();
      D3DXMatrixIdentity( &matWorld );
      m_pLambert9->SetMatrix( &matWorld, &LightDir );
      m_pd3dDevice->SetTexture( 0, m_pMeshBack->m_pTextures[0] );
      m_pLambert9->SetAmbient( 0.2f );
      m_pLambert9->BeginPass();
      m_pMeshBack->m_pLocalMesh->DrawSubset( 0 );
      m_pLambert9->EndPass();

      //トラ
      m_pLambert9->SetMatrix( &matTiger, &LightDir );
      m_pd3dDevice->SetTexture( 0, m_pMeshTiger->m_pTextures[0] );
      m_pLambert9->SetAmbient( 0.2f );
      m_pLambert9->BeginPass();
      m_pMeshTiger->m_pLocalMesh->DrawSubset( 0 );
      m_pLambert9->EndPass();

      //空レンダリング
      //Zバッファ書込み禁止
      m_pd3dDevice->SetRenderState( D3DRS_ZWRITEENABLE, FALSE );
      m_pd3dDevice->SetTexture( 0, m_pMeshBack->m_pTextures[1] );
      D3DXMatrixIdentity( &matWorld );
      m_pLambert9->SetMatrix( &matWorld, &LightDir );
      m_pLambert9->SetAmbient( 1.0f );
      m_pLambert9->BeginPass();
      m_pMeshBack->m_pLocalMesh->DrawSubset( 1 );
      m_pLambert9->EndPass();

      //太陽はレンダリングしない(注意１)
      ////太陽レンダリング
      ////αブレンドを有効にする
      //m_pd3dDevice->SetRenderState( D3DRS_ALPHABLENDENABLE, TRUE );
      ////加算合成
      //m_pd3dDevice->SetRenderState( D3DRS_BLENDOP,   D3DBLENDOP_ADD );
      //m_pd3dDevice->SetRenderState( D3DRS_SRCBLEND,  D3DBLEND_SRCALPHA );
      //m_pd3dDevice->SetRenderState( D3DRS_DESTBLEND, D3DBLEND_ONE );

      //m_pd3dDevice->SetTexture( 0, m_pMeshBack->m_pTextures[0] );      

      //D3DXMatrixTranslation( &matTranslation, LightPos.x, LightPos.y, LightPos.z );
      ////ビルボードマトリックスを取得(ビルボード ページ参照)
      //matWorld = GetBillBoardMatrix( m_pd3dDevice, &matTranslation );
      //m_pLambert9->SetMatrix( &matWorld, &LightDir );
      //m_pLambert9->SetAmbient( 1.0f );
      //m_pLambert9->BeginPass();
      //m_pMeshBack->m_pLocalMesh->DrawSubset( 0 );
      //m_pLambert9->EndPass();
      m_pLambert9->End();

      //m_pd3dDevice->SetRenderState( D3DRS_ALPHABLENDENABLE, FALSE );
      m_pd3dDevice->SetRenderState( D3DRS_ZWRITEENABLE, TRUE );

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


      //****************************************************************
      //ステップ２ : 点描画シェーダーを適応
      //****************************************************************

      m_pd3dDevice->SetRenderState( D3DRS_ZENABLE, D3DZB_FALSE );
      m_pd3dDevice->SetTexture( 1, m_pFullScreenTexture );
      m_pd3dDevice->SetTexture( 2, m_pDiffuseTexture );
      m_pPointImageShader->Render();
      m_pd3dDevice->SetTexture( 1, NULL );
      m_pd3dDevice->SetTexture( 2, NULL );
      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;
}

以上です。

この手のフィルターはゲームで使用するのは無理なんかな。スクリーントーンシェーダーのときも思ったけど。 それとも調整すればマシになるのかな。まあ確かに改善の余地はあります。エッジが鋭すぎるため違和感があります。 そのあたりなんとかすればあるいは。

(注意１)　太陽はレンダリングしません。どうもマルチレンダーターゲットを使用時にアルファブレンドを使用すると 正しくレンダリングできないようです。環境による問題なのかはよくわかりませんが、やらないようにした方が無難かな。