Microsoft Visual C++ 2010 Express
 Microsoft DirectX SDK (June 2010)
 Direct3D 11.0
 Shader Model 4.0
 FBX SDK 2011.3

■Direct3D 11.0 ファー Prev Top Next
関連ページ:Direct3D 11.0 初期化 Direct3D 11.0 デバック用フォント描画 FBX SDKを使う


ファー

今回は DirectX9 で既出のファーシェーダーをやります。
DirectX9 ではシェル法を使用して描画を行いました。この方法については当サイトの過去記事のファーシェーダー を参照してください。 でこの方法ではシェル間に隙間が空いているため、メッシュの輪郭付近でのファーが不連続になりがちでした。 これに対応するために Direct3D 10 ではシェル法とフィン法のハイブリットで描画する方法が考えられています。 この方法については3Dグラフィックス・マニアックスを参照してください。

さて今回のサンプルは、シェル法もフィン法を使用せず、ジオメトリシェーダーでファーを一本一本生成する方法で描画します。 詳細については、4Gamer.netを参照してください。

あと、ファーをはやすメッシュの描画時に使用するテクスチャーですが、アルファチャンネルにファーの長さを書き込んでいます。 したがって RGBA 成分を持つのddsファイルで作成してください。

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


Fur.hlsl ファーのhlslファイル。
Fur.h ファークラスのヘッダファイル。
Fur.cpp ファークラスのソースファイル。
main.cpp メイン関数があるソースファイル。

---Fur.hlsl---  ↑


// ************************************************************
// ファー
// ************************************************************

// ************************************************************
// 構造体の宣言
// ************************************************************

// ファーをはやすメッシュの描画フェーズで使用する構造体の宣言

// 頂点シェーダー入力用の構造体
struct _VS01
{
   float3 pos    : POSITION;   // 頂点座標
   float3 normal : NORMAL;     // 法線
   float2 texel  : TEXCOORD;   // テクセル
};

// 頂点シェーダー - ピクセルシェーダーの構造体
struct VS_PS01
{
   float4 pos       : SV_POSITION;
   float3 normal    : NORMAL;
   float2 texel     : TEXCOORD0;
   float4 posWVP    : TEXCOORD1;
};

// ピクセルシェーダー出力用の構造体
struct PS_01
{
   float4 BackBuffer   : SV_Target0;   // シーンのレンダリングイメージ
   float4 ColorBuffer  : SV_Target1;   // カラーマップ + ファーの長さ
   float4 NormalBuffer : SV_Target2;   // 法線マップ + 深度マップ
};

// ファーの描画フェーズで使用する構造体の宣言

// 頂点シェーダー入力用の構造体
struct _VS02
{
   float3 pos   : POSITION;   // 頂点座標
   float2 texel : TEXCOORD;   // テクセル
};

// 頂点シェーダー - ジオメトリシェーダー用の構造体
struct VS_GS02
{
   float3 pos    : POSITION;
   float2 texel  : TEXCOORD;
};

// ジオメトリシェーダー - ピクセルシェーダー用の構造体
struct GS_PS02
{
   float4 pos    : SV_POSITION;
   float4 color  : COLOR0;
};

// ************************************************************
// 定数バッファ
// ************************************************************

// 定数バッファ1
cbuffer CB_STEP01 : register( b0 )
{
   column_major float4x4 g_matWVP : packoffset( c0 );   // ワールド × ビュー × 射影 行列
   column_major float4x4 g_matWV  : packoffset( c4 );   // ワールド × ビュー 行列
   float4 g_vecLight              : packoffset( c8 );   // ローカル座標系での平行光源の方向ベクトル
};

// 定数バッファ2
cbuffer CB_STEP02 : register( b0 )
{
   column_major float4x4 g_matInvProj : packoffset( c0 );   // 射影逆行列
   column_major float4x4 g_matProj    : packoffset( c4 );   // 射影行列
   float4 g_vecLight2                 : packoffset( c8 );   // ビュー空間上での平行光源の方向ベクトル
   float2 g_ScreenSize                : packoffset( c9 );   // スクリーンサイズ
   float  g_FurSize                   : packoffset( c9.z ); // メッシュ全体にかかるファーの長さ
};

// ************************************************************
// テクスチャー
// ************************************************************

Texture2D g_DecalMap  : register( t0 );  // デカールマップ。a成分はファーの長さが格納される
Texture2D g_ColorMap  : register( t0 );  // カラーマップ + ファーの長さ
Texture2D g_NormalMap : register( t1 );  // 法線マップ + 深度マップ

// ************************************************************
// サンプラーステート
// ************************************************************

SamplerState  g_Sampler : register( s0 );

// ************************************************************
// ファーをはやすメッシュの描画フェーズ
// ************************************************************

// 頂点シェーダー
VS_PS01 Step01_VS_Main( _VS01 In )
{
   VS_PS01 Out;
   Out.pos    = mul( float4( In.pos, 1.0f ), g_matWVP );
   Out.normal = In.normal;
   Out.texel  = In.texel;
   Out.posWVP = Out.pos;

   return Out;
}

// ピクセルシェーダー
PS_01 Step01_PS_Main( VS_PS01 In )
{
   PS_01 Out;

   // デカールマップ
   float4 decalmap = g_DecalMap.Sample( g_Sampler, In.texel );
   
   // ライティング
   float lambert = dot( -g_vecLight.xyz, In.normal );
   
   // ハーフランバート
   float halflambert = lambert * 0.5f + 0.5f;
   halflambert *= halflambert;
  
   // シーンのレンダリングイメージを出力
   Out.BackBuffer = float4( decalmap.rgb * halflambert, 1 );

   // ファーのカラーマップ + ファーの長さ
   Out.ColorBuffer = decalmap;
   
   // ファーの法線ベクトル + 深度マップを出力

   // 法線ベクトルをワールド空間上で行列変換する
   // 平行移動成分を無効にするためにw成分を 0 にする
   // 法線ベクトルのz成分は計算により算出するためここではいれない
   Out.NormalBuffer.xy = normalize( mul( float4( In.normal, 0 ), g_matWV ).xyz ).xy;
   // 深度値
   Out.NormalBuffer.zw = In.posWVP.zw;

   return Out;
}

// ************************************************************
// ファーの描画フェーズ
// ************************************************************

// 頂点シェーダー
VS_GS02 Step02_VS_Main( _VS02 In )
{
   VS_GS02 Out;
   Out.pos    = In.pos;
   Out.texel  = In.texel;
   return Out;
}

// ジオメトリシェーダーで出力する最大頂点数( 最大値 128 ? )
[maxvertexcount(128)]
// ジオメトリシェーダー
void Step02_GS_Main( point VS_GS02 In[1]               // ポイント リストを構成する頂点配列の入力情報
                   , inout LineStream<GS_PS02> lStream // 頂点情報を追加するためのストリームオブジェクト
                   )
{
   GS_PS02 Out;

   float4 spos;
   float4 epos;
   float2 texel;

   for( int i=0; i<40; i+=5 )
   {
      for( int j=0; j<40; j+=5 )
      {
         // テクセル
         texel = float2( In[0].texel.x + (float)i / g_ScreenSize.x, In[0].texel.y + (float)j / g_ScreenSize.y );

         // 法線マップ + 深度マップ取得
         float4 normalmap = g_NormalMap.Load( float3( texel * g_ScreenSize, 0 ) );

         // wは0にならないはずなので0のときは描画しない
         if( normalmap.w == 0.0f )
            continue;

         // 法線マップから法線ベクトルを計算する
         float3 normal;
         normal.xy = normalmap.xy;
         normal.z = -sqrt( 1 - normal.x * normal.x - normal.y * normal.y );
         normal = normalize( normal );

         // カラーマップ + ファーの長さを取得
         float4 colormap = g_ColorMap.Load( float3( texel * g_ScreenSize, 0 ) );

         // ファーのライティング
         // 法線ベクトルと平行光源の方向ベクトルの角度が大きいほど明るいと考えた
         float diffuse = max( 1.0f - abs( dot( -g_vecLight2.xyz, normal ) ), 0.7f );

         // クリップ空間上のファーの開始座標を計算
         spos.xy = ( texel * 2.0f - 1.0f ) * normalmap.w;
         spos.y *= -1.0f;
         spos.zw = normalmap.zw;

         // ファーの開始位置のカメラ空間上での座標を計算
         epos = mul( spos, g_matInvProj );
         // 法線ベクトル方向に移動
         epos.xyz = epos.xyz + normal * colormap.a * g_FurSize;
         // クリップ空間上に行列変換
         epos = mul( float4( epos.xyz, 1 ), g_matProj );

         // ファーの開始位置の頂点を追加
         Out.pos = spos;
         Out.color = float4( colormap.rgb * diffuse, 1 );
         lStream.Append( Out );

         // ファーの終了位置の頂点を追加
         Out.pos = epos;
         Out.color = float4( colormap.rgb * diffuse, 0 );
         lStream.Append( Out );

         // 現在のストリップを終了し、新しいストリップを開始する。
         lStream.RestartStrip();
      }
   }
}

// ピクセルシェーダ
float4 Step02_PS_Main( GS_PS02 In ) : SV_Target0
{
   return In.color;
}

ジオメトリシェーダー内ではカラーマップと法線マップをサンプリングし、ピクセル単位でファーを描画する処理を行います。 ジオメトリシェーダーは頂点単位で実行されるため、ピクセル単位で実行できるようにあらかじめ頂点を作成しておきます。 でまともに全ピクセル分の頂点を作成すると実行時エラーになります。頂点数が多すぎるからだと思うので、ジオメトリシェーダー内でループさせることで 適当に分散させます。さらに5ピクセルずつ間隔をあけて処理しています。
正直なところこの方法が最適解であるかはわかりません。ロストプラネットではどうやっているんだろう。

---Fur.h---  ↑


#ifndef FUR_H
#define FUR_H

class FUR
{
private:
   // ファーをはやすメッシュの描画フェーズで使用する構造体定義
   typedef struct _CB_STEP01
   {
      // ワールド × ビュー × 射影 行列
      D3DXMATRIX  matWVP;
      // ワールド × ビュー 行列
      D3DXMATRIX  matWV;
      // 平行光源の方向ベクトル
      D3DXVECTOR4 vecLight;
   }CB_STEP01;
   
   // ファーの描画フェーズで使用する構造体定義
   typedef struct _CB_STEP02
   {
      // 射影逆行列
      D3DXMATRIX  matInvProj;
      // 射影行列
      D3DXMATRIX  matProj;
      // 平行光源の方向ベクトル
      D3DXVECTOR4 vecLight;
      // スクリーンサイズ
      D3DXVECTOR2  vec2ScreenSize;
      // ファーの長さ
      float FurSize;
      float Dummy3;
   }CB_STEP02;

   // ファーをはやすメッシュの描画フェーズで使用するリソースの構造体定義
   typedef struct _STEP01
   {
      // 入力レイアウト
      ID3D11InputLayout* pLayout;

      // 頂点シェーダー
      ID3D11VertexShader* pVertexShader;

      // ピクセルシェーダー
      ID3D11PixelShader* pPixelShader;

      // 定数バッファ
      ID3D11Buffer* pConstantBuffers;

      // サンプラーステート
      ID3D11SamplerState* pSamplerState;

      // 深度ステンシルステート
      ID3D11DepthStencilState*  pDepthStencilState;

      // ブレンドステート
      ID3D11BlendState* pBlendState;
   }STEP01;

   // ファーの描画フェーズで使用するリソースの構造体定義
   typedef struct _STEP02
   {
      // 頂点定義
      typedef struct _VERTEX
      {
         D3DXVECTOR3 pos;
         D3DXVECTOR2 texel;
      }VERTEX;

      // 頂点バッファ
      ID3D11Buffer* pVertexBuffer;
      UINT VertexesCount;

      // 入力レイアウト
      ID3D11InputLayout* pLayout;

      // 頂点シェーダー
      ID3D11VertexShader* pVertexShader;

      // ジオメトリシェーダー
      ID3D11GeometryShader* pGeometryShader;

      // ピクセルシェーダー
      ID3D11PixelShader* pPixelShader;

      // 定数バッファ
      ID3D11Buffer* pConstantBuffers;

      // 深度ステンシルステート
      ID3D11DepthStencilState*  pDepthStencilState;

      // ブレンドステート
      ID3D11BlendState* pBlendState;

      D3DXVECTOR2 ScreenSize;
   }STEP02;

   // 宣言
   STEP01 m_Step01;
   STEP02 m_Step02;

private:
   // 共通項目の初期化
   HRESULT InitCommon( ID3D11Device* pD3DDevice );

   // ファーをはやすメッシュの描画フェーズの初期化
   HRESULT InitStep01( ID3D11Device* pD3DDevice
                     , const BYTE* pVSStep01Shader, size_t VSStep01Size
                     , const BYTE* pPSStep01Shader, size_t PSStep01Size
                     );

   // ファーの描画フェーズの初期化
   HRESULT InitStep02( ID3D11Device* pD3DDevice
                     , const BYTE* pVSStep02Shader, size_t VSStep02Size
                     , const BYTE* pGSStep02Shader, size_t GSStep02Size
                     , const BYTE* pPSStep02Shader, size_t PSStep02Size
                     , D3DXVECTOR2* pScreenSize
                     );
public:
   FUR();
   ~FUR();

   // 初期化
   HRESULT Init( ID3D11Device* pD3DDevice
               // hlslファイルのファイル名
               , TCHAR pSrcFile[]
               // ファーをはやすメッシュの描画フェーズ
               , CHAR pVSStep01FunctionName[], CHAR pPSStep01FunctionName[]
               // ファーの描画フェーズ
               , CHAR pVSStep02FunctionName[], CHAR pGSStep02FunctionName[], CHAR pPSStep02FunctionName[]
               , D3DXVECTOR2* pScreenSize
               );
   HRESULT Init( ID3D11Device* pD3DDevice
               // ファーをはやすメッシュの描画フェーズ
               , const BYTE* pVSStep01Shader, size_t VSStep01Size
               , const BYTE* pPSStep01Shader, size_t PSStep01Size
               // ファーの描画フェーズ
               , const BYTE* pVSStep02Shader, size_t VSStep02Size
               , const BYTE* pGSStep02Shader, size_t GSStep02Size
               , const BYTE* pPSStep02Shader, size_t PSStep02Size
               , D3DXVECTOR2* pScreenSize
               );

   // ファーをはやすメッシュの描画フェーズの開始処理
   HRESULT BeginStep01( ID3D11DeviceContext* pD3DDeviceContext );
   // ファーをはやすメッシュの描画フェーズで使用する定数バッファを設定
   HRESULT SetCBStep01( ID3D11DeviceContext* pD3DDeviceContext
                      , D3DXMATRIX* p_matWVP
                      , D3DXMATRIX* p_matWV
                      , D3DXVECTOR4* p_vecLight
                      , ID3D11ShaderResourceView* pDecalMap
                      );
   // ファーをはやすメッシュの描画フェーズの終了処理
   HRESULT EndStep01( ID3D11DeviceContext* pD3DDeviceContext );

   // ファーの描画フェーズの描画関数
   HRESULT RenderStep02( ID3D11DeviceContext* pD3DDeviceContext
                       , D3DXMATRIX* p_matInvProj, D3DXMATRIX* p_matProj
                       , D3DXVECTOR4* p_vecLight
                       , float FurSize
                       , ID3D11ShaderResourceView* pSRView[2]
                       );
};

#endif

---Fur.cpp---  ↑

#include "DX11User.h"
#include "Fur.h"

FUR::FUR()
{
   m_Step01.pLayout = NULL;
   m_Step01.pVertexShader = NULL;
   m_Step01.pPixelShader = NULL;
   m_Step01.pConstantBuffers = NULL;
   m_Step01.pSamplerState = NULL;
   m_Step01.pDepthStencilState = NULL;
   m_Step01.pBlendState = NULL;

   m_Step02.pVertexBuffer = NULL;
   m_Step02.VertexesCount = 0;
   m_Step02.pLayout = NULL;
   m_Step02.pVertexShader = NULL;
   m_Step02.pGeometryShader = NULL;
   m_Step02.pPixelShader = NULL;
   m_Step02.pConstantBuffers = NULL;
   m_Step02.pDepthStencilState = NULL;
   m_Step02.pBlendState = NULL;
}

FUR::~FUR()
{
   SAFE_RELEASE( m_Step01.pLayout );
   SAFE_RELEASE( m_Step01.pVertexShader );
   SAFE_RELEASE( m_Step01.pPixelShader );
   SAFE_RELEASE( m_Step01.pConstantBuffers );
   SAFE_RELEASE( m_Step01.pSamplerState );
   SAFE_RELEASE( m_Step01.pDepthStencilState );
   SAFE_RELEASE( m_Step01.pBlendState );

   SAFE_RELEASE( m_Step02.pVertexBuffer );
   m_Step02.VertexesCount = 0;
   SAFE_RELEASE( m_Step02.pLayout );
   SAFE_RELEASE( m_Step02.pVertexShader );
   SAFE_RELEASE( m_Step02.pGeometryShader );
   SAFE_RELEASE( m_Step02.pPixelShader );
   SAFE_RELEASE( m_Step02.pConstantBuffers );
   SAFE_RELEASE( m_Step02.pDepthStencilState );
   SAFE_RELEASE( m_Step02.pBlendState );
}

// 共通項目の初期化
HRESULT FUR::InitCommon( ID3D11Device* /*pD3DDevice*/ )
{
   HRESULT hr = E_FAIL;

   hr = S_OK;
//EXIT:
   return hr;
}

// ファーをはやすメッシュの描画フェーズの初期化
HRESULT FUR::InitStep01( ID3D11Device* pD3DDevice
                       , const BYTE* pVSStep01Shader, size_t VSStep01Size
                       , const BYTE* pPSStep01Shader, size_t PSStep01Size
                       )
{
   HRESULT hr = E_FAIL;
   D3D11_BUFFER_DESC BufferDesc;

   if( pD3DDevice == NULL ) goto EXIT;

   // *****************************************************************************************************************
   // 頂点シェーダーの作成
   // *****************************************************************************************************************

   hr = pD3DDevice->CreateVertexShader( pVSStep01Shader, VSStep01Size, NULL, &m_Step01.pVertexShader );
   if( FAILED( hr ) ) goto EXIT;

   // 入力レイアウトは固定設定にしておく
   D3D11_INPUT_ELEMENT_DESC layout[] = {
         { "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0,  0, D3D11_INPUT_PER_VERTEX_DATA, 0 },
         { "NORMAL",   0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 12, D3D11_INPUT_PER_VERTEX_DATA, 0 },
         { "TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT,    0, 24, D3D11_INPUT_PER_VERTEX_DATA, 0 },
   };
   hr = pD3DDevice->CreateInputLayout( layout, _countof( layout ), pVSStep01Shader, VSStep01Size, &m_Step01.pLayout );
   if( FAILED( hr ) ) goto EXIT;

   // *****************************************************************************************************************
   // ピクセルェーダーの作成
   // *****************************************************************************************************************

   hr = pD3DDevice->CreatePixelShader( pPSStep01Shader, PSStep01Size, NULL, &m_Step01.pPixelShader );
   if( FAILED( hr ) ) goto EXIT;

   // *****************************************************************************************************************
   // 定数バッファを作成
   // *****************************************************************************************************************

   ::ZeroMemory( &BufferDesc, sizeof( BufferDesc ) );
   BufferDesc.ByteWidth             = sizeof( CB_STEP01 );       // バッファサイズ
   BufferDesc.Usage                 = D3D11_USAGE_DYNAMIC;       // リソース使用法を特定する
   BufferDesc.BindFlags             = D3D11_BIND_CONSTANT_BUFFER;// バッファの種類
   BufferDesc.CPUAccessFlags        = D3D11_CPU_ACCESS_WRITE;    // CPU アクセス
   BufferDesc.MiscFlags             = 0;                         // その他のフラグも設定しない
   hr = pD3DDevice->CreateBuffer( &BufferDesc, NULL, &m_Step01.pConstantBuffers );
   if( FAILED( hr ) ) goto EXIT;

   // *****************************************************************************************************************
   // サンプラーステートの作成
   // *****************************************************************************************************************

   D3D11_SAMPLER_DESC samplerDesc;
   samplerDesc.Filter = D3D11_FILTER_MIN_MAG_MIP_LINEAR;  // サンプリング時に使用するフィルタ。
   samplerDesc.AddressU = D3D11_TEXTURE_ADDRESS_WRAP;     // 0 〜 1 の範囲外にある u テクスチャー座標の描画方法
   samplerDesc.AddressV = D3D11_TEXTURE_ADDRESS_WRAP;     // 0 〜 1 の範囲外にある v テクスチャー座標
   samplerDesc.AddressW = D3D11_TEXTURE_ADDRESS_WRAP;     // 0 〜 1 の範囲外にある w テクスチャー座標
   samplerDesc.MipLODBias = 0;                            // 計算されたミップマップ レベルからのバイアス
   samplerDesc.MaxAnisotropy = 1;                         // サンプリングに異方性補間を使用している場合の限界値。有効な値は 1 〜 16 。
   samplerDesc.ComparisonFunc = D3D11_COMPARISON_ALWAYS;  // 比較オプション。
   ::CopyMemory( samplerDesc.BorderColor, &D3DXVECTOR4( 0.0f, 0.0f, 0.0f, 0.0f ), sizeof( D3DXVECTOR4 ) ); // 境界色
   samplerDesc.MinLOD = 0;                                // アクセス可能なミップマップの下限値
   samplerDesc.MaxLOD = D3D11_FLOAT32_MAX;                // アクセス可能なミップマップの上限値
   hr = pD3DDevice->CreateSamplerState( &samplerDesc, &m_Step01.pSamplerState );
   if( FAILED( hr ) )
      goto EXIT;

   // *****************************************************************************************************************
   // 深度ステンシルステートの作成
   // *****************************************************************************************************************

   // 深度ステンシルステートを作成する
   D3D11_DEPTH_STENCIL_DESC ddsDesc;
   ::ZeroMemory( &ddsDesc, sizeof( ddsDesc ) );
   ddsDesc.DepthEnable = TRUE;                            // 深度テストを有効
   ddsDesc.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ALL;   // 深度バッファへの書き込みを行う
   ddsDesc.DepthFunc = D3D11_COMPARISON_LESS;
   ddsDesc.StencilEnable = FALSE;
   hr = pD3DDevice->CreateDepthStencilState( &ddsDesc, &m_Step01.pDepthStencilState );
   if( FAILED( hr ) )
      goto EXIT;

   // *****************************************************************************************************************
   // ブレンドステートの作成
   // *****************************************************************************************************************

   D3D11_BLEND_DESC BlendDesc;
   ::ZeroMemory( &BlendDesc, sizeof( BlendDesc ) );
   BlendDesc.AlphaToCoverageEnable = FALSE;
   BlendDesc.IndependentBlendEnable = FALSE;
   // アルファブレンドを無効
   BlendDesc.RenderTarget[0].BlendEnable = FALSE;
   BlendDesc.RenderTarget[0].SrcBlend = D3D11_BLEND_ONE;
   BlendDesc.RenderTarget[0].DestBlend = D3D11_BLEND_ZERO;
   BlendDesc.RenderTarget[0].BlendOp = D3D11_BLEND_OP_ADD;
   BlendDesc.RenderTarget[0].SrcBlendAlpha = D3D11_BLEND_ONE;
   BlendDesc.RenderTarget[0].DestBlendAlpha = D3D11_BLEND_ZERO;
   BlendDesc.RenderTarget[0].BlendOpAlpha = D3D11_BLEND_OP_ADD;
   BlendDesc.RenderTarget[0].RenderTargetWriteMask = D3D11_COLOR_WRITE_ENABLE_ALL;
   hr = pD3DDevice->CreateBlendState( &BlendDesc, &m_Step01.pBlendState );
   if( FAILED( hr ) )
      goto EXIT;

   hr = S_OK;

EXIT:
   return hr;
}

// ファーの描画フェーズの初期化
HRESULT FUR::InitStep02( ID3D11Device* pD3DDevice
                       , const BYTE* pVSStep02Shader, size_t VSStep02Size
                       , const BYTE* pGSStep02Shader, size_t GSStep02Size
                       , const BYTE* pPSStep02Shader, size_t PSStep02Size
                       , D3DXVECTOR2* pScreenSize
                       )
{
   HRESULT hr = E_FAIL;
   D3D11_BUFFER_DESC BufferDesc;
   STEP02::VERTEX* pVertex = NULL;

   if( pD3DDevice == NULL ) goto EXIT;

   ::CopyMemory( &m_Step02.ScreenSize, pScreenSize, sizeof( D3DXVECTOR2 ) );

   // カラーマップや法線マップのサンプリング位置のオフセット値
   // fur.hlslのジオメトリシェーダー内のループ処理と同期させること
   const UINT offset = 40;

   // 頂点数
   m_Step02.VertexesCount = ( (UINT)m_Step02.ScreenSize.x / offset + 1 ) * ( (UINT)m_Step02.ScreenSize.y / offset + 1 );
   pVertex = NEW STEP02::VERTEX[m_Step02.VertexesCount];
   UINT index = 0;
   for( UINT i=0; i<=(UINT)pScreenSize->x / offset; i++ )
   {
      for( UINT j=0; j<=(UINT)pScreenSize->y / offset; j++ )
      {
         pVertex[index].pos.x =  (float)( i * offset ) / pScreenSize->x * 2.0f - 1.0f;
         pVertex[index].pos.y = -(float)( j * offset ) / pScreenSize->y * 2.0f + 1.0f;
         pVertex[index].pos.z = 0.0f;

         pVertex[index].texel.x = (float)( i * offset ) / pScreenSize->x;
         pVertex[index].texel.y = (float)( j * offset ) / pScreenSize->y;

         index++;

         if( m_Step02.VertexesCount <= index )
            break;
      }
      if( m_Step02.VertexesCount <= index )
         break;
   }

   // 頂点バッファー リソース
   ::ZeroMemory( &BufferDesc, sizeof( BufferDesc ) );
   BufferDesc.ByteWidth             = sizeof( STEP02::VERTEX ) * m_Step02.VertexesCount;     // バッファサイズ
   BufferDesc.Usage                 = D3D11_USAGE_DEFAULT;       // リソース使用法を特定する
   BufferDesc.BindFlags             = D3D11_BIND_VERTEX_BUFFER;  // バッファの種類
   BufferDesc.CPUAccessFlags        = 0;                         // CPU アクセス
   BufferDesc.MiscFlags             = 0;                         // その他のフラグも設定しない
   // サブリソース( 初期値 )
   D3D11_SUBRESOURCE_DATA resource;
   resource.pSysMem = reinterpret_cast<void*>(pVertex);
   resource.SysMemPitch = 0;
   resource.SysMemSlicePitch = 0;
   // バッファを作成する
   hr = pD3DDevice->CreateBuffer( &BufferDesc, &resource, &m_Step02.pVertexBuffer );
   if( FAILED( hr ) )
      goto EXIT;
   SAFE_DELETE_ARRAY( pVertex );

   // *****************************************************************************************************************
   // 頂点シェーダーの作成
   // *****************************************************************************************************************

   hr = pD3DDevice->CreateVertexShader( pVSStep02Shader, VSStep02Size, NULL, &m_Step02.pVertexShader );
   if( FAILED( hr ) )
      goto EXIT;

   // *****************************************************************************************************************
   // 入力レイアウトの作成
   // *****************************************************************************************************************

   D3D11_INPUT_ELEMENT_DESC layout[] = {
         { "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT,    0,  0, D3D11_INPUT_PER_VERTEX_DATA, 0 },
         { "TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT,       0, 12, D3D11_INPUT_PER_VERTEX_DATA, 0 },
   };
   hr = pD3DDevice->CreateInputLayout( layout, _countof( layout ), pVSStep02Shader, VSStep02Size, &m_Step02.pLayout );
   if( FAILED( hr ) )
      goto EXIT;

   // *****************************************************************************************************************
   // ジオメトリシェーダーの作成
   // *****************************************************************************************************************

   hr = pD3DDevice->CreateGeometryShader( pGSStep02Shader, GSStep02Size, NULL, &m_Step02.pGeometryShader );
   if( FAILED( hr ) )
      goto EXIT;

   // *****************************************************************************************************************
   // ピクセルシェーダーの作成
   // *****************************************************************************************************************

   hr = pD3DDevice->CreatePixelShader( pPSStep02Shader, PSStep02Size, NULL, &m_Step02.pPixelShader );
   if( FAILED( hr ) )
      goto EXIT;

   // *****************************************************************************************************************
   // 定数バッファを作成
   // *****************************************************************************************************************

   ::ZeroMemory( &BufferDesc, sizeof( BufferDesc ) );
   BufferDesc.ByteWidth             = sizeof( CB_STEP02 );       // バッファサイズ
   BufferDesc.Usage                 = D3D11_USAGE_DYNAMIC;       // リソース使用法を特定する
   BufferDesc.BindFlags             = D3D11_BIND_CONSTANT_BUFFER;// バッファの種類
   BufferDesc.CPUAccessFlags        = D3D11_CPU_ACCESS_WRITE;    // CPU アクセス
   BufferDesc.MiscFlags             = 0;                         // その他のフラグも設定しない
   hr = pD3DDevice->CreateBuffer( &BufferDesc, NULL, &m_Step02.pConstantBuffers );
   if( FAILED( hr ) ) goto EXIT;

   // *****************************************************************************************************************
   // 深度ステンシルステートの作成
   // *****************************************************************************************************************

   // 深度ステンシルステートを作成する
   D3D11_DEPTH_STENCIL_DESC ddsDesc;
   ::ZeroMemory( &ddsDesc, sizeof( ddsDesc ) );
   ddsDesc.DepthEnable = TRUE;                             // 深度テストを有効
   ddsDesc.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ZERO;   // 深度バッファへの書き込みを行わない
   ddsDesc.DepthFunc = D3D11_COMPARISON_LESS;
   ddsDesc.StencilEnable = FALSE;
   hr = pD3DDevice->CreateDepthStencilState( &ddsDesc, &m_Step02.pDepthStencilState );
   if( FAILED( hr ) )
      goto EXIT;

   // *****************************************************************************************************************
   // ブレンドステートの作成
   // *****************************************************************************************************************

   D3D11_BLEND_DESC BlendDesc;
   ::ZeroMemory( &BlendDesc, sizeof( BlendDesc ) );
   BlendDesc.AlphaToCoverageEnable = FALSE;
   BlendDesc.IndependentBlendEnable = FALSE;
   // アルファブレンド( 線形合成 )を有効
   BlendDesc.RenderTarget[0].BlendEnable = TRUE;
   BlendDesc.RenderTarget[0].SrcBlend = D3D11_BLEND_SRC_ALPHA;
   BlendDesc.RenderTarget[0].DestBlend = D3D11_BLEND_INV_SRC_ALPHA;
   BlendDesc.RenderTarget[0].BlendOp = D3D11_BLEND_OP_ADD;
   BlendDesc.RenderTarget[0].SrcBlendAlpha = D3D11_BLEND_ONE;
   BlendDesc.RenderTarget[0].DestBlendAlpha = D3D11_BLEND_ZERO;
   BlendDesc.RenderTarget[0].BlendOpAlpha = D3D11_BLEND_OP_ADD;
   BlendDesc.RenderTarget[0].RenderTargetWriteMask = D3D11_COLOR_WRITE_ENABLE_ALL;
   hr = pD3DDevice->CreateBlendState( &BlendDesc, &m_Step02.pBlendState );
   if( FAILED( hr ) )
      goto EXIT;

   hr = S_OK;

EXIT:
   return hr;
}

// 初期化
HRESULT FUR::Init( ID3D11Device* pD3DDevice
                  // hlsl ファイル名
                 , TCHAR pSrcFile[]
                  // ファーをはやすメッシュの描画フェーズ
                 , CHAR pVSStep01FunctionName[], CHAR pPSStep01FunctionName[]
                  // ファーの描画フェーズ
                 , CHAR pVSStep02FunctionName[], CHAR pGSStep02FunctionName[], CHAR pPSStep02FunctionName[]
                 , D3DXVECTOR2* pScreenSize
                 )
{
   HRESULT hr = E_FAIL;

   ID3D10Blob* pBlob[3] = { NULL, NULL, NULL };

   UINT Flag1 = D3D10_SHADER_PACK_MATRIX_COLUMN_MAJOR | D3D10_SHADER_ENABLE_STRICTNESS;
#if defined(DEBUG) || defined(_DEBUG)
   Flag1 |= D3D10_SHADER_OPTIMIZATION_LEVEL0;
#else
   Flag1 |= D3D10_SHADER_OPTIMIZATION_LEVEL3;
#endif

   // *****************************************************************************************************************
   // ファーをはやすメッシュの描画フェーズ用のシェーダーソースのコンパイル
   // *****************************************************************************************************************

   // 頂点シェーダーのコンパイル
   hr = D3DX11CompileFromFile( pSrcFile, NULL, NULL, pVSStep01FunctionName, "vs_4_0", Flag1, 0, NULL, &pBlob[0], NULL, NULL );
   if( FAILED( hr ) )
      goto EXIT;

   // ピクセルシェーダーのコンパイル
   hr = D3DX11CompileFromFile( pSrcFile, NULL, NULL, pPSStep01FunctionName, "ps_4_0", Flag1, 0, NULL, &pBlob[1], NULL, NULL );
   if( FAILED( hr ) )
      goto EXIT;

   // 初期化
   hr = InitStep01( pD3DDevice
                  , reinterpret_cast<LPBYTE>( pBlob[0]->GetBufferPointer() ), pBlob[0]->GetBufferSize()
                  , reinterpret_cast<LPBYTE>( pBlob[1]->GetBufferPointer() ), pBlob[1]->GetBufferSize()
                  );
   if( FAILED( hr ) )
      goto EXIT;

   // *****************************************************************************************************************
   // ファーの描画フェーズ用のシェーダーソースのコンパイル
   // *****************************************************************************************************************

   // 頂点シェーダーのコンパイル
   hr = D3DX11CompileFromFile( pSrcFile, NULL, NULL, pVSStep02FunctionName, "vs_4_0", Flag1, 0, NULL, &pBlob[0], NULL, NULL );
   if( FAILED( hr ) )
      goto EXIT;

   // ジオメトリシェーダーのコンパイル
   hr = D3DX11CompileFromFile( pSrcFile, NULL, NULL, pGSStep02FunctionName, "gs_4_0", Flag1, 0, NULL, &pBlob[1], NULL, NULL );
   if( FAILED( hr ) )
      goto EXIT;

   // ピクセルシェーダーのコンパイル
   hr = D3DX11CompileFromFile( pSrcFile, NULL, NULL, pPSStep02FunctionName, "ps_4_0", Flag1, 0, NULL, &pBlob[2], NULL, NULL );
   if( FAILED( hr ) )
      goto EXIT;

   // 初期化
   hr = InitStep02( pD3DDevice
                  , reinterpret_cast<LPBYTE>( pBlob[0]->GetBufferPointer() ), pBlob[0]->GetBufferSize()
                  , reinterpret_cast<LPBYTE>( pBlob[1]->GetBufferPointer() ), pBlob[1]->GetBufferSize()
                  , reinterpret_cast<LPBYTE>( pBlob[2]->GetBufferPointer() ), pBlob[2]->GetBufferSize()
                  , pScreenSize
                  );
   if( FAILED( hr ) )
      goto EXIT;

   // *****************************************************************************************************************
   // 共通項目の初期化
   // *****************************************************************************************************************

   hr = InitCommon( pD3DDevice );
   if( FAILED( hr ) )
      goto EXIT;

   hr = S_OK;

EXIT:
   return hr;
}

// 初期化
HRESULT FUR::Init( ID3D11Device* pD3DDevice
                  // ファーをはやすメッシュの描画フェーズ
                  , const BYTE* pVSStep01Shader, size_t VSStep01Size
                  , const BYTE* pPSStep01Shader, size_t PSStep01Size
                  // ファーの描画フェーズ
                  , const BYTE* pVSStep02Shader, size_t VSStep02Size
                  , const BYTE* pGSStep02Shader, size_t GSStep02Size
                  , const BYTE* pPSStep02Shader, size_t PSStep02Size
                  , D3DXVECTOR2* pScreenSize
                  )
{
   HRESULT hr = E_FAIL;

   // ファーをはやすメッシュの描画フェーズ用の初期化
   hr = InitStep01( pD3DDevice, pVSStep01Shader, VSStep01Size, pPSStep01Shader, PSStep01Size );
   if( FAILED( hr ) )
      goto EXIT;

   // ファーの描画フェーズ用の初期化
   hr = InitStep02( pD3DDevice, pVSStep02Shader, VSStep02Size, pGSStep02Shader, GSStep02Size, pPSStep02Shader, PSStep02Size, pScreenSize );
   if( FAILED( hr ) )
      goto EXIT;

   // 共通項目の初期化
   hr = InitCommon( pD3DDevice );
   if( FAILED( hr ) )
      goto EXIT;

   hr = S_OK;

EXIT:
   return hr;
}

// ファーをはやすメッシュの描画フェーズの開始処理
HRESULT FUR::BeginStep01( ID3D11DeviceContext* pD3DDeviceContext )
{
   HRESULT hr = E_FAIL;

   // *****************************************************************************************************************
   // 入力アセンブラー ステージを設定
   // *****************************************************************************************************************

   pD3DDeviceContext->IASetInputLayout( m_Step01.pLayout );

   // *****************************************************************************************************************
   // シェーダーをデバイスに設定
   // *****************************************************************************************************************

   // 頂点シェーダーをデバイスに設定する。
   pD3DDeviceContext->VSSetShader( m_Step01.pVertexShader, NULL, 0 );

   // ハルシェーダーを無効にする。
   pD3DDeviceContext->HSSetShader( NULL, NULL, 0 );

   // ドメインシェーダーを無効にする。
   pD3DDeviceContext->DSSetShader( NULL, NULL, 0 );

   // ジオメトリシェーダーを無効にする。
   pD3DDeviceContext->GSSetShader( NULL, NULL, 0 );
   
   // ピクセルシェーダーをデバイスに設定する
   pD3DDeviceContext->PSSetShader( m_Step01.pPixelShader, NULL, 0 );
   // ピクセルシェーダーにサンプラーステートを設定する。
   pD3DDeviceContext->PSSetSamplers( 0, 1, &m_Step01.pSamplerState );

   // コンピュートシェーダーを無効にする。
   pD3DDeviceContext->CSSetShader( NULL, NULL, 0 );

   // *****************************************************************************************************************
   // 出力結合ステージを設定
   // *****************************************************************************************************************

   // ブレンドステートを設定
   pD3DDeviceContext->OMSetBlendState( m_Step01.pBlendState, 0, 0xffffffff );

   // 深度ステンシルステートを設定
   pD3DDeviceContext->OMSetDepthStencilState( m_Step01.pDepthStencilState, 0 );

   hr = S_OK;
//EXIT:
   return hr;
}

// ファーをはやすメッシュの描画フェーズの定数バッファの設定
HRESULT FUR::SetCBStep01( ID3D11DeviceContext* pD3DDeviceContext
                        , D3DXMATRIX* p_matWVP, D3DXMATRIX* p_matWV
                        , D3DXVECTOR4* p_vecLight
                        , ID3D11ShaderResourceView* pDecalMap )
{
   HRESULT hr = E_FAIL;

   // *****************************************************************************************************************
   // 定数バッファを設定
   // *****************************************************************************************************************

   D3D11_MAPPED_SUBRESOURCE mappedResource;
   CB_STEP01* cbuffer;

   hr = pD3DDeviceContext->Map( m_Step01.pConstantBuffers, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource );
   if( FAILED( hr ) ) goto EXIT;
   cbuffer = reinterpret_cast<CB_STEP01*>(mappedResource.pData);

   ::CopyMemory( &cbuffer->matWVP, p_matWVP, sizeof( D3DXMATRIX ));
   ::CopyMemory( &cbuffer->matWV, p_matWV, sizeof( D3DXMATRIX ));
   ::CopyMemory( &cbuffer->vecLight, p_vecLight, sizeof( D3DXVECTOR4 ));

   pD3DDeviceContext->Unmap( m_Step01.pConstantBuffers, 0 );

   // *****************************************************************************************************************
   // 定数バッファをデバイスに設定
   // *****************************************************************************************************************

   // 頂点シェーダーに定数バッファを設定する
   pD3DDeviceContext->VSSetConstantBuffers( 0, 1, &m_Step01.pConstantBuffers );

   // ピクセルシェーダーに定数バッファを設定する
   pD3DDeviceContext->PSSetConstantBuffers( 0, 1, &m_Step01.pConstantBuffers );
   // デカールマップを設定する
   pD3DDeviceContext->PSSetShaderResources( 0, 1, &pDecalMap );

   hr = S_OK;
EXIT:
   return hr;
}

// ファーをはやすメッシュの描画フェーズの終了処理( 何もしない )
HRESULT FUR::EndStep01( ID3D11DeviceContext* /*pD3DDeviceContext*/ )
{
   HRESULT hr = E_FAIL;

   hr = S_OK;

//EXIT:
   return hr;
}

// ファーの描画フェーズの描画処理
HRESULT FUR::RenderStep02( ID3D11DeviceContext* pD3DDeviceContext
                         , D3DXMATRIX* p_matInvProj, D3DXMATRIX* p_matProj
                         , D3DXVECTOR4* p_vecLight
                         , float FurSize
                         , ID3D11ShaderResourceView* pSRView[2]
                         )
{
   HRESULT hr = E_FAIL;

   D3DXMATRIX matInvProj;

   // *****************************************************************************************************************
   // 入力アセンブラー ステージを設定
   // *****************************************************************************************************************

   // 入力レイアウト設定
   pD3DDeviceContext->IASetInputLayout( m_Step02.pLayout );

   // *****************************************************************************************************************
   // プリミティブ タイプおよびデータの順序に関する情報を設定
   // *****************************************************************************************************************

   // ポイントリストを使用する
   pD3DDeviceContext->IASetPrimitiveTopology( D3D11_PRIMITIVE_TOPOLOGY_POINTLIST );

   // *****************************************************************************************************************
   // 頂点バッファ設定
   // *****************************************************************************************************************

   UINT stride = sizeof( STEP02::VERTEX );
   UINT offset = 0;
   pD3DDeviceContext->IASetVertexBuffers( 0, 1, &m_Step02.pVertexBuffer, &stride, &offset );

   // *****************************************************************************************************************
   // シェーダーをデバイスに設定
   // *****************************************************************************************************************

   // 頂点シェーダーをデバイスに設定する。
   pD3DDeviceContext->VSSetShader( m_Step02.pVertexShader, NULL, 0 );

   // ハルシェーダーを無効にする。
   pD3DDeviceContext->HSSetShader( NULL, NULL, 0 );

   // ドメインシェーダーを無効にする
   pD3DDeviceContext->DSSetShader( NULL, NULL, 0 );

   // ジオメトリシェーダーをデバイスに設定にする。
   pD3DDeviceContext->GSSetShader( m_Step02.pGeometryShader, NULL, 0 );

   // ピクセルシェーダーをデバイスに設定する。
   pD3DDeviceContext->PSSetShader( m_Step02.pPixelShader, NULL, 0 );

   // コンピュートシェーダーを無効にする。
   pD3DDeviceContext->CSSetShader( NULL, NULL, 0 );

   // *****************************************************************************************************************
   // 出力結合ステージを設定
   // *****************************************************************************************************************

   // ブレンドステートを設定
   pD3DDeviceContext->OMSetBlendState( m_Step02.pBlendState, 0, 0xffffffff );

   // 深度ステンシルステートを設定
   pD3DDeviceContext->OMSetDepthStencilState( m_Step02.pDepthStencilState, 0 );

   // *****************************************************************************************************************
   // 定数バッファを設定
   // *****************************************************************************************************************

   D3D11_MAPPED_SUBRESOURCE mappedResource;
   CB_STEP02* cbuffer;

   hr = pD3DDeviceContext->Map( m_Step02.pConstantBuffers, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource );
   if( FAILED( hr ) ) goto EXIT;
   cbuffer = reinterpret_cast<CB_STEP02*>(mappedResource.pData);

   ::CopyMemory( cbuffer->matInvProj, p_matInvProj, sizeof( D3DXMATRIX ) );
   ::CopyMemory( cbuffer->matProj, p_matProj, sizeof( D3DXMATRIX ) );
   ::CopyMemory( cbuffer->vecLight, p_vecLight, sizeof( D3DXVECTOR4 ) );
   ::CopyMemory( cbuffer->vec2ScreenSize, &m_Step02.ScreenSize, sizeof( D3DXVECTOR2 ) );
   cbuffer->FurSize = FurSize;

   pD3DDeviceContext->Unmap( m_Step02.pConstantBuffers, 0 );

   // *****************************************************************************************************************
   // 定数バッファをデバイスに設定
   // *****************************************************************************************************************

   // ジオメトリシェーダーに定数バッファを設定する
   pD3DDeviceContext->GSSetConstantBuffers( 0, 1, &m_Step02.pConstantBuffers );

   // テクスチャーを設定する
   // Index0:カラーマップ + ファーの長さ
   // Index1:法線マップ + 深度マップ
   pD3DDeviceContext->GSSetShaderResources( 0, 2, pSRView );

   // *****************************************************************************************************************
   // 描画
   // *****************************************************************************************************************

   pD3DDeviceContext->Draw( m_Step02.VertexesCount, 0 );

   // *****************************************************************************************************************
   // 後始末
   // *****************************************************************************************************************

   ID3D11ShaderResourceView* pSRVNull[2] = { NULL, NULL };
   pD3DDeviceContext->GSSetShaderResources( 0, 2, pSRVNull );

   hr = S_OK;
EXIT:
   return hr;
}

---main.cpp---  ↑

#include "../../USER/DX11User.h"
#include "../../USER/D3D11User.h"
#include "../../USER/DebugFontUser.h"
#include "../../USER/BaseShading.h"
#include "../../USER/Fur.h"

// FBX SDK 用
#include "../../USER/MeshUser.h"
#include "../../USER/FBXSDKMeshLoaderUser.h"

// シェーダーオブジェクトを作成するとき、ファイルから読むか、メモリから読むかを切り替える
#if defined(DEBUG) || defined(_DEBUG)
#define UNCOMPILED_SHADER     // ファイルを読み込んでコンパイルする

#else
// ランバート拡散照明用
#include "../../USER/HLSL/BaseShading_BaseShading_VS_Main.h"
#include "../../USER/HLSL/BaseShading_BaseShading_PS_Main.h"

// ファー用
#include "../../USER/HLSL/Fur_Step01_VS_Main.h"
#include "../../USER/HLSL/Fur_Step01_PS_Main.h"
#include "../../USER/HLSL/Fur_Step02_VS_Main.h"
#include "../../USER/HLSL/Fur_Step02_GS_Main.h"
#include "../../USER/HLSL/Fur_Step02_PS_Main.h"
#endif

// アプリケーション名
TCHAR* AppName = _T("DX11_Tutrial 173 ファー");

// Direct3D関連の自作クラス
D3D11USER* g_pD3D11User = NULL;

// デバッグ専用のテキスト描画する自作クラス
CDebugFont* g_pDebugFontUser = NULL;

// FBX メッシュローダー
FBXSDK_MESHLOADER_USER* g_pMeshBallLoader = NULL;

// メッシュオブジェクト
BASE_MESH_USER*         g_pMeshPlane = NULL;
BASE_MESH_USER*         g_pMeshBall = NULL;

// シェーディング系シェーダークラス
BASE_SHADING* g_pBaseShading = NULL;
// ファークラス
FUR* g_pFur = NULL;

// レンダーターゲットサーフェス
ID3D11RenderTargetView* g_pRTView[2] = { NULL, NULL };

// 平行光源の方向ベクトル
D3DXVECTOR4 g_vecLight = D3DXVECTOR4( -0.3f, -1.0f, 0.3f, 0.0f );

// 連続入力されたかを判定する際に使用するキーボード入力バッファ
BYTE g_KeyBuffer[256];

// ビュー行列
D3DXMATRIX g_matView;

// 節電モードの制御に使用する変数。
bool Activate = true;    // ウィンドウがアクティブか
bool StandBy = false;    // スタンバイ状態か

bool ScreenShot = false; // スクリーンショットを作成するかフラグ

// リソースの初期化
HRESULT Init()
{
   HRESULT hr = E_FAIL;

   // デバッグ専用フォント出力クラスの作成処理
   // デバックコンパイル時のみ使用する
#if defined(DEBUG) || defined(_DEBUG)
   g_pDebugFontUser = NEW CDebugFont();
   hr = g_pDebugFontUser->Create( g_pD3D11User->m_D3DDevice, 0.015f, 0.04f );
   if( FAILED( hr ) )
   {
      ::MessageBox( NULL, _T("デバックフォントクラス初期化エラー"), _T("初期化エラー"), MB_OK );
      goto EXIT;
   }
#endif

   // 自作のメッシュローダーの初期化
   g_pMeshBallLoader = NEW FBXSDK_MESHLOADER_USER();
   hr = g_pMeshBallLoader->Initialize( g_pD3D11User->m_D3DDevice );
   if( FAILED( hr ) )
      goto EXIT;

   // 頂点情報を取得する
   hr = g_pMeshBallLoader->LoadMeshData( _T("Res/Plane.fbx"), &g_pMeshPlane );
   if( FAILED( hr ) )
      goto EXIT;

   hr = g_pMeshBallLoader->LoadMeshData( _T("Res/Ball.fbx"), &g_pMeshBall );
   if( FAILED( hr ) )
      goto EXIT;

   // シェーダー系クラスの初期化
   g_pBaseShading = NEW BASE_SHADING();
   g_pFur = NEW FUR();

   // スクリーンサイズを取得
   DXGI_SWAP_CHAIN_DESC Desc;
   g_pD3D11User->m_SwapChain->GetDesc( &Desc );
#ifndef UNCOMPILED_SHADER
   hr = g_pBaseShading->Init( g_pD3D11User->m_D3DDevice
                              ,g_BaseShading_VS_Main, sizeof( g_BaseShading_VS_Main )
                              ,g_BaseShading_PS_Main, sizeof( g_BaseShading_PS_Main )
                              );
   if( FAILED( hr ) )
      goto EXIT;

   hr = g_pFur->Init( g_pD3D11User->m_D3DDevice
                    , g_Step01_VS_Main, sizeof( g_Step01_VS_Main )
                    , g_Step01_PS_Main, sizeof( g_Step01_PS_Main )
                    , g_Step02_VS_Main, sizeof( g_Step02_VS_Main )
                    , g_Step02_GS_Main, sizeof( g_Step02_GS_Main )
                    , g_Step02_PS_Main, sizeof( g_Step02_PS_Main )
                    , &D3DXVECTOR2( (float)Desc.BufferDesc.Width, (float)Desc.BufferDesc.Height )
                    );
   if( FAILED( hr ) )
      goto EXIT;
#else
   hr = g_pBaseShading->Init( g_pD3D11User->m_D3DDevice
                             , _T("../../USER/HLSL/BaseShading.hlsl")
                             , "BaseShading_VS_Main"
                             , "BaseShading_PS_Main"
                            );
   if( FAILED( hr ) )
      goto EXIT;

   hr = g_pFur->Init( g_pD3D11User->m_D3DDevice
                    , _T("../../USER/HLSL/Fur.hlsl")
                    , "Step01_VS_Main", "Step01_PS_Main"
                    , "Step02_VS_Main", "Step02_GS_Main", "Step02_PS_Main"
                    , &D3DXVECTOR2( (float)Desc.BufferDesc.Width, (float)Desc.BufferDesc.Height )
                    );
   if( FAILED( hr ) )
      goto EXIT;
#endif

   // ファーのカラーマップ + ファーの長さ
   hr = g_pD3D11User->CreateRenderTargetView( &g_pRTView[0], NULL, DXGI_FORMAT_R16G16B16A16_FLOAT );
   if( FAILED( hr ) )
      goto EXIT;

   // ファーの法線ベクトル + 深度マップ
   hr = g_pD3D11User->CreateRenderTargetView( &g_pRTView[1], NULL, DXGI_FORMAT_R16G16B16A16_FLOAT );
   if( FAILED( hr ) )
      goto EXIT;

   // キーボード入力バッファの初期化
   ::ZeroMemory( g_KeyBuffer, sizeof( BYTE ) * _countof( g_KeyBuffer ) );

   // ビュー行列
   D3DXMatrixLookAtLH( &g_matView, &D3DXVECTOR3( 0.0f, 0.0f, -20.0f ), &D3DXVECTOR3( 0.0f, 0.0f, 0.0f ), &D3DXVECTOR3( 0.0f, 1.0f, 0.0f ) );

   hr = S_OK;

EXIT:
   return hr;
}

// メモリ開放
void Invalidate()
{
   SAFE_DELETE( g_pFur );
   SAFE_DELETE( g_pBaseShading );
   SAFE_DELETE( g_pMeshBall );
   SAFE_DELETE( g_pMeshPlane );
   SAFE_DELETE( g_pMeshBallLoader );
   for( int i=0; i<_countof( g_pRTView ); i++ )
      SAFE_RELEASE( g_pRTView[i] );
   SAFE_DELETE( g_pDebugFontUser );
   SAFE_DELETE( g_pD3D11User );
}

// 地面描画
HRESULT RenderPlane( D3DXMATRIX* pMatView, D3DXMATRIX* pMatProj )
{
   HRESULT hr = E_FAIL;

   D3DXMATRIX matScaling, matTranslation, matWorld, matWVP, matInv;
   D3DXVECTOR4 vec4LightDir;

   // サンプラーステート
   ID3D11SamplerState* pSamplerState = NULL;

   // ブレンドステート設定用の変数
   D3D11_RENDER_TARGET_BLEND_DESC RTBlendDesc;

   // ステージ0のアルファブレンドを無効にする
   RTBlendDesc = g_pD3D11User->GetDefaultBlendDesc();
   hr = g_pD3D11User->SetBlendState( &RTBlendDesc, 1, FALSE );
   if( FAILED( hr ) )
      goto EXIT;

   // 深度バッファに書き込む
   hr = g_pD3D11User->SetDepthStencilState( TRUE, D3D11_DEPTH_WRITE_MASK_ALL );
   if( FAILED( hr ) )
      goto EXIT;

   // サンプラーステートを作成する
   hr = g_pD3D11User->CreateSamplerState( &pSamplerState, D3D11_FILTER_MIN_MAG_MIP_LINEAR, 1 );
   if( FAILED( hr ) )
      goto EXIT;

   // ピクセルシェーダーにサンプラーステートを設定する。
   g_pD3D11User->m_D3DDeviceContext->PSSetSamplers( 0, 1, &pSamplerState );

   // シェーダーの開始
   hr = g_pBaseShading->Begin( g_pD3D11User->m_D3DDeviceContext, "g_HalfLambert" );
   if( FAILED( hr ) )
      goto EXIT;

   // 頂点バッファ設定
   UINT stride = sizeof( MESH_USER::VERTEX_USER );
   UINT offset = 0;
   g_pD3D11User->m_D3DDeviceContext->IASetVertexBuffers( 0, 1, &g_pMeshPlane->MeshUser[0].VertexBuffer, &stride, &offset );

   // インデックスバッファ設定
   g_pD3D11User->m_D3DDeviceContext->IASetIndexBuffer( g_pMeshPlane->MeshUser[0].IndexBuffer, DXGI_FORMAT_R32_UINT, 0 );

   // 頂点シェーダー用の定数バッファをデバイスに設定
   {
      // ワールド行列

      // スケーリング行列
      D3DXMatrixScaling( &matScaling, 3.0f, 3.0f, 3.0f );
      // 平行移動行列
      D3DXMatrixTranslation( &matTranslation, 5.0f, 0.0f, 0.0f );
      // ワールド座標系の行列の合成
      matWorld = matScaling * matTranslation;

      // 行列を合成
      matWVP = matWorld * (*pMatView) * (*pMatProj);
      // シェーダー内では列優先にしているので転置行列を作成する。
      D3DXMatrixTranspose( &matWVP, &matWVP );

      // 頂点シェーダー用の定数バッファを設定する
      g_pBaseShading->SetCBVertexShader( g_pD3D11User->m_D3DDeviceContext, &matWVP );
   }

   // 平行光源の方向ベクトル

   // ワールド行列の逆行列を作成
   D3DXMatrixInverse( &matInv, NULL, &matWorld );
   D3DXVec4Transform( &vec4LightDir, &g_vecLight, &matInv );
   D3DXVec3Normalize( (D3DXVECTOR3*)&vec4LightDir, (D3DXVECTOR3*)&vec4LightDir );

   ID3D11ShaderResourceView* pDecalMap = NULL;
   g_pMeshPlane->MeshUser[0].GetTexture( _T("DiffuseColor"), &pDecalMap );

   // ハーフランバートシェーダー用の定数シェーダーをデバイスに設定
   hr = g_pBaseShading->SetCBHalfLambert( g_pD3D11User->m_D3DDeviceContext, &vec4LightDir, pDecalMap );
   if( FAILED( hr ) )
      goto EXIT;

   // インデックスバッファを使用した描画
   g_pD3D11User->m_D3DDeviceContext->DrawIndexed( g_pMeshPlane->MeshUser[0].IndexesCount, 0, 0 );

   g_pBaseShading->End();

   hr = S_OK;
EXIT:
   SAFE_RELEASE( pSamplerState );
   return hr;
}

// ファー描画
HRESULT RenderFurMesh( FUR* pFur, D3DXMATRIX* pMatView, D3DXMATRIX* pMatProj )
{
   HRESULT hr = E_FAIL;

   D3DXMATRIX matScaling, matTranslation, matWorld, matWVP, matWV, matInv;
   D3DXVECTOR4 vec4LightDir;

   // 頂点バッファ設定
   UINT stride = sizeof( MESH_USER::VERTEX_USER );
   UINT offset = 0;
   g_pD3D11User->m_D3DDeviceContext->IASetVertexBuffers( 0, 1, &g_pMeshBall->MeshUser[0].VertexBuffer, &stride, &offset );

   // インデックスバッファ設定
   g_pD3D11User->m_D3DDeviceContext->IASetIndexBuffer( g_pMeshBall->MeshUser[0].IndexBuffer, DXGI_FORMAT_R32_UINT, 0 );

   // デカールマップを取得
   ID3D11ShaderResourceView* pDecalMap = NULL;
   g_pMeshBall->MeshUser[0].GetTexture( _T("DiffuseColor"), &pDecalMap );
   
   // 定数バッファとシェーダーリソースビューを設定する
   {
      // ワールド行列

      // スケーリング行列
      D3DXMatrixScaling( &matScaling, 1.0f, 1.0f, 1.0f );
      // 平行移動行列
      D3DXMatrixTranslation( &matTranslation, 0.0f, 5.0f, 5.0f );
      // ワールド座標系の行列の合成
      matWorld = matScaling * matTranslation;

      // 行列を合成
      matWVP = matWorld * (*pMatView) * (*pMatProj);
      // シェーダー内では列優先にしているので転置行列を作成する。
      D3DXMatrixTranspose( &matWVP, &matWVP );

      matWV = matWorld * (*pMatView);
      // シェーダー内では列優先にしているので転置行列を作成する。
      D3DXMatrixTranspose( &matWV, &matWV );

      // 平行光源の方向ベクトル

      // ワールド行列の逆行列を作成
      D3DXMatrixInverse( &matInv, NULL, &matWorld );
      D3DXVec4Transform( &vec4LightDir, &g_vecLight, &matInv );
      D3DXVec3Normalize( (D3DXVECTOR3*)&vec4LightDir, (D3DXVECTOR3*)&vec4LightDir );

      // 定数バッファとシェーダーリソースビューを設定する
      pFur->SetCBStep01( g_pD3D11User->m_D3DDeviceContext, &matWVP, &matWV, &vec4LightDir, pDecalMap );
   }

   // インデックスバッファを使用した描画
   g_pD3D11User->m_D3DDeviceContext->DrawIndexed( g_pMeshBall->MeshUser[0].IndexesCount, 0, 0 );

   hr = S_OK;
//EXIT:
   return hr;
}

// ファー描画
HRESULT RenderFur( FUR* pFur, D3DXMATRIX* pMatView, D3DXMATRIX* pMatProj, ID3D11ShaderResourceView* pSRView[2] )
{
   HRESULT hr = E_FAIL;

   D3DXMATRIX matInvProj, matProj;
   D3DXVECTOR4 vec4LightDir;

   // 射影行列の逆行列を取得する
   D3DXMatrixInverse( &matInvProj, NULL, pMatProj );
   D3DXMatrixTranspose( &matInvProj, &matInvProj );

   D3DXMatrixTranspose( &matProj, pMatProj );

   // 平行光源の方向ベクトルをビュー空間上で設定する
   D3DXVec4Transform( &vec4LightDir, &g_vecLight, pMatView );
   D3DXVec3Normalize( (D3DXVECTOR3*)&vec4LightDir, (D3DXVECTOR3*)&vec4LightDir );

   // ファーレンダリング
   hr = pFur->RenderStep02( g_pD3D11User->m_D3DDeviceContext, &matInvProj, &matProj, &vec4LightDir, 1.5f, pSRView );
   if( FAILED( hr ) )
      goto EXIT;

   hr = S_OK;
EXIT:
   return hr;
}

// 描画処理
HRESULT Render()
{
   HRESULT hr = E_FAIL;
   D3DXMATRIX matProj, m;
   float Zfar = 100.0f;
   float BackBufferClearColor[4] = { 0.3f, 0.3f, 0.9f, 1.0f };
   float ColorMapClearColor[4] = { 0.0f, 0.0f, 0.0f, 0.0f };
   float NormalMapClearColor[4] = { 0.0f, 0.0f, 0.0f, 0.0f };

   // バックバッファをクリア
   g_pD3D11User->m_D3DDeviceContext->ClearRenderTargetView( g_pD3D11User->m_RenderTargetView, BackBufferClearColor ); 

   // 深度バッファをクリア
   if( g_pD3D11User->m_DepthStencilView )
      g_pD3D11User->m_D3DDeviceContext->ClearDepthStencilView( g_pD3D11User->m_DepthStencilView, D3D11_CLEAR_DEPTH | D3D11_CLEAR_STENCIL, 1.0f, 0 );

   // 射影行列
   D3DXMatrixPerspectiveFovLH( &matProj, D3DX_PI / 5.0f, 4.0f / 3.0f, 1.0f, Zfar );

   // ビュー行列
   D3DXMatrixIdentity( &m );
   if( g_KeyBuffer[VK_RIGHT] )
   {
      D3DXMatrixRotationY( &m, -0.001f );
      g_matView = g_matView * m;
   }
   if( g_KeyBuffer[VK_LEFT] )
   {
      D3DXMatrixRotationY( &m, 0.001f );
      g_matView = g_matView * m;
   }
   if( g_KeyBuffer[VK_UP] )
   {
      D3DXMatrixTranslation( &m, 0, 0, -0.01f );
      g_matView = g_matView * m;
   }
   if( g_KeyBuffer[VK_DOWN] )
   {
      D3DXMatrixTranslation( &m, 0, 0, 0.01f );
      g_matView = g_matView * m;
   }
   if( g_KeyBuffer['W'] )
   {
      D3DXMatrixRotationX( &m, 0.001f );
      g_matView = g_matView * m;
   }
   if( g_KeyBuffer['S'] )
   {
      D3DXMatrixRotationX( &m, -0.001f );
      g_matView = g_matView * m;
   }

   // 三角ポリゴン描画
   g_pD3D11User->m_D3DDeviceContext->IASetPrimitiveTopology( D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST );

   hr = RenderPlane( &g_matView, &matProj );
   if( FAILED( hr ) )
      goto EXIT;

   ID3D11RenderTargetView* pRTV[3] = { NULL, NULL, NULL };

   // レンダーターゲットサーフェスをクリア
   g_pD3D11User->m_D3DDeviceContext->ClearRenderTargetView( g_pRTView[0], ColorMapClearColor ); 
   g_pD3D11User->m_D3DDeviceContext->ClearRenderTargetView( g_pRTView[1], NormalMapClearColor ); 

   // レンダーターゲットサーフェスのステージ0はそのまま
   pRTV[0] = g_pD3D11User->m_RenderTargetView;
   pRTV[1] = g_pRTView[0];
   pRTV[2] = g_pRTView[1];

   // レンダーターゲットサーフェスを切り替える
   g_pD3D11User->m_D3DDeviceContext->OMSetRenderTargets( 3, pRTV, g_pD3D11User->m_DepthStencilView );

   // シェーディング処理を開始
   g_pFur->BeginStep01( g_pD3D11User->m_D3DDeviceContext );
   {
      // ファー用のメッシュを描画
      hr = RenderFurMesh( g_pFur, &g_matView, &matProj );
      if( FAILED( hr ) )
         goto EXIT;
   }
   // シェーディング処理を終了
   g_pFur->EndStep01( g_pD3D11User->m_D3DDeviceContext );

   // レンダーターゲットサーフェスのステージ0はそのまま
   pRTV[0] = g_pD3D11User->m_RenderTargetView;
   pRTV[1] = NULL;
   pRTV[2] = NULL;

   // レンダーターゲットサーフェスを切り替える
   g_pD3D11User->m_D3DDeviceContext->OMSetRenderTargets( 2, pRTV, g_pD3D11User->m_DepthStencilView );

   ID3D11ShaderResourceView* pSRV[2] = { NULL, NULL };
   // シェーダーリソースビューを作成
   pSRV[0] = g_pD3D11User->GetSRViewFromRTView( g_pRTView[0] );
   pSRV[1] = g_pD3D11User->GetSRViewFromRTView( g_pRTView[1] );

   // ファーレンダリング
   hr = RenderFur( g_pFur, &g_matView, &matProj, pSRV );
   if( FAILED( hr ) )
      goto EXIT;

   for( int i=0; i<_countof( pSRV ); i++ )
      SAFE_RELEASE( pSRV[i] );

   if( g_pDebugFontUser )
   {
      // デバッグ専用フォント描画
      hr = g_pDebugFontUser->RenderFPS( g_pD3D11User->m_D3DDeviceContext, 0, 0 );
      if( FAILED( hr ) )
         goto EXIT;
   }

   // レンダリングされたイメージをユーザーに表示。
   hr = g_pD3D11User->m_SwapChain->Present( 0, 0 );
   if( FAILED( hr ) )
      goto EXIT;

   if( ScreenShot )
   {
      // スクリーンショット作成
      hr = g_pD3D11User->CreateScreenShot();
      if( FAILED( hr ) )
         goto EXIT;
      ScreenShot = false;
   }

   hr = S_OK;

EXIT:
   return hr;
}

// 節電処理および描画処理
HRESULT PowerSavingAndRender()
{
   HRESULT hr = E_FAIL;

   switch( StandBy )
   {
   // スタンバイモード
   case  true:
      // テストのみ行い、描画処理は行わない。
      hr = g_pD3D11User->m_SwapChain->Present( 0, DXGI_PRESENT_TEST );
      switch( hr )
      {
      // いまだスタンバイ中。。。
      case DXGI_STATUS_OCCLUDED:
         // 電源管理によるスリープ状態の場合ここにくる。
         // フルスクリーンモード時にスクリーンセーバーが起動時した場合は、表示モードが強制的にウィンドウモードに変更されるためここにこない。
         goto EXIT;
         break;
      case S_OK:
         // フルスクリーンモード時にスクリーンセーバーが起動時した場合は表示モードが強制的にウィンドウモードに変更される。
         // ウィンドウモードの場合スタンバイから復帰してしまうため、ウィンドウがアクティブになったときに復帰するようにする。
         if( Activate == true )
         {
            // たまにウィンドウが表示されないときがあるので表示するようにする
            ::ShowWindow( g_pD3D11User->m_hWnd, SW_SHOW );
            StandBy = false;
         }
         break;
      default:
         goto EXIT;
         break;
      }
      break;
   // スタンバイモードでない
   case false:
      // 描画処理
      hr = Render();
      if( FAILED( hr ) ) goto EXIT;

      switch( hr )
      {
      case DXGI_STATUS_OCCLUDED:
         // スタンバイモードへ移行
         // フルスクリーンモード時のスクリーンセーバー起動時、
         // スリープ状態に移行した時に発生する。
         StandBy = true;
         goto EXIT;
         break;
      case S_OK:
         break;
      default:
         goto EXIT;
         break;
      }
      break;
   }

   hr = S_OK;

EXIT:

   return hr;
}

// ウィンドウプロシージャ
LRESULT CALLBACK WndProc( HWND hWnd, UINT msg, UINT wParam, LONG lParam )
{
   switch( msg )
   {
   case WM_KEYDOWN:
      g_KeyBuffer[wParam] = 1;
      break;

   case WM_KEYUP:
      g_KeyBuffer[wParam] = 0;

      // アプリ終了
      switch( wParam )
      {
      case VK_ESCAPE:
         ::DestroyWindow( hWnd );
         break;

      // F2キーを押すと、ウィンドウモードを切り替える。
      // 自動的にウィンドウモードを切り替える機能もあるが、ウィンドウスタイルを自由に変更するために自分で実装することにした。
      case VK_F2:
         g_pD3D11User->ChangeWindowMode();
         break;

      // スクリーンショットを作成する
      case VK_SNAPSHOT:
         ScreenShot = true;
         break;
      }
      break;


   case WM_ACTIVATE:
      Activate = true;
      break;

   case WM_DESTROY:
      Invalidate();
      ::PostQuitMessage(0);
      break;

   default:
      return ::DefWindowProc( hWnd, msg, wParam, lParam );
   }

   return 0L;
}

// メイン関数
int APIENTRY _tWinMain( HINSTANCE hInstance,
                        HINSTANCE,
                        LPTSTR,
                        INT )
{
   HRESULT hr = E_FAIL;
   MSG msg;
   ::ZeroMemory(&msg, sizeof(MSG));

   // メモリリーク検出
   _CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF | _CRTDBG_CHECK_EVERY_1024_DF);

   // 表示モードを記述するための構造体。
   DXGI_MODE_DESC sd;

   // Direct3D 関連自作クラスのインスタンスを作成
   g_pD3D11User = NEW D3D11USER();

   // ディスプレイモード一覧を取得する。
   // 取得した値はクラス内部に保持される。
   hr = g_pD3D11User->GetDisplayMode();
   if( FAILED( hr ) )
   {
      ::MessageBox( NULL, _T("ディスプレイモード取得エラー"), _T("初期化エラー"), MB_OK );
      goto EXIT;
   }
   // とりあえず最初に見つかったディスプレイモードを選択する
   CopyMemory( &sd, &g_pD3D11User->m_DisplayModeDesc[0], sizeof( DXGI_MODE_DESC ) );

   // ウィンドウの作成およびDirect3D の初期化
   // マルチサンプルを無効にする
   hr = g_pD3D11User->InitD3D11( AppName, hInstance, WndProc, &sd, TRUE, TRUE, FALSE, TRUE );
   if( FAILED( hr ) )
   {
      ::MessageBox( NULL, _T("Direct3D 11.0 初期化エラー"), _T("初期化エラー"), MB_OK );
      goto EXIT;
   }

   // リソースの初期化
   hr = Init();
   if( FAILED( hr ) )
   {
      ::MessageBox( NULL, _T("リソース初期化エラー"), _T("初期化エラー"), MB_OK );
      goto EXIT;
   }
   
   ::ShowWindow(g_pD3D11User->m_hWnd, SW_SHOW);
   ::UpdateWindow(g_pD3D11User->m_hWnd);

   // メッセージループ
   do
   { 
      if( ::PeekMessage( &msg, 0, 0, 0, PM_REMOVE ) )
      {
         ::TranslateMessage(&msg); 
         ::DispatchMessage(&msg); 
      }
      else
      {
         hr = PowerSavingAndRender();
         if( FAILED( hr ) )
            ::DestroyWindow( g_pD3D11User->m_hWnd );
      }
   }while( msg.message != WM_QUIT );

EXIT:
   if( g_pD3D11User && g_pD3D11User->m_hWnd )
      ::DestroyWindow( g_pD3D11User->m_hWnd );

   ::UnregisterClass( AppName, hInstance );

   return msg.wParam;
}

最後に。
今回のサンプルはいくつか改善の余地があります。

1.一部ファーが描画されないところがあります。 これはおそらくファーをはやす間隔をあけて描画しているためかと思われます。ですのでカラーマップと法線マップをサンプリングするテクセル位置をずらすようにすれば対応できるかもしれません。

2.ファーをはやすメッシュが遠くにあるときはファーがスカスカになる。 これはどうにかできるのかな。

3.ファーをはやすメッシュが他のメッシュの裏に隠れている時、本来ファーだけが見えるはずの状態でファーが描画されません。 これはレンダーターゲットサーフェスへの描画方法を変更することで対応できると思います。

4.ファーをはやすメッシュがウィンドウの端で切り取られて描画される時、ウィンドウの端付近でファーの描画数が少なくなります。 これはシェル法の場合は問題なく処理されると思いますが、今回の方法ではどうにもできないような気がします。

またジオメトリシェーダーでカラーマップと法線マップのサンプリング方法がこれでいいのか自信ないので、この辺は調べる余地があると思います。


web拍手 by FC2

Prev Top Next

inserted by FC2 system