Microsoft Visual Express 2013 for Desktop C++
 Direct3D 11.0( SM 5.0 )
 DirectXTex texture processing library
 XMLLite

■Direct3D11 Opacity Shadow Maps Prev Top Next
関連ページ:Direct3D11 自作ライブラリ


今回はOpacity Shadow Mapsというものをやります。不透明シャドウマップです。前回同様、日本語解説しているサイトがなかったので、英語論文を適当に解釈して実装しました。
論文はここです。

Opacity Shadow Maps は草とか髪の毛のように隙間が空いてスカスカなメッシュの影をシミュレートします。

概要について簡単に説明すると、隙間が空いているメッシュの場合、光の散乱が発生しやすいため影の濃淡が複雑になります。
しかし、シャドウマッピングは一般に最も手前の深度値を基準に計算するため、影が一様になってしまいます。ちょうど

こんな感じになります。
これを解決するために深度マップをボクセル化します。

具体的には、ライトビューの深度方向にフィールドをスライスし、それぞれに対し深度マップを作成します。
そして描画するピクセルの深度値より手前にある深度マップをサンプリングし影を生成していきます。
この時、描画するピクセルの深度値と深度マップの距離が遠くになるほど遮蔽の影響度は小さくなると考え、遮蔽率を調整していきます。
また計算した遮蔽率をそのまま使用すると迷彩色っぽくなりださいのでPCFでぼかしをかけます。

こんな感じになります。


@Direct3D 自作の共通ライブラリ一式をここを参照して作成してください。

Aシェーダー系で使用するソースです。
OpacityShadowMaps_Pass0.hlsl 遮蔽率マップを生成するシェーダーソース
OpacityShadowMaps_Pass1.hlsl シーンをレンダリングするシェーダーソース
OpacityShadowMaps.h OpacityShadowMapsクラスのヘッダーファイル
OpacityShadowMaps.cpp OpacityShadowMapsクラスのソースファイル

B個別に使用するソースです。
GrassMesh.h Grassメッシュクラスのヘッダーファイル
GrassMesh.cpp Grassメッシュクラスのソースファイル
PlaneMesh.h 地面メッシュクラスのヘッダーファイル
PlaneMesh.cpp 地面メッシュクラスのソースファイル
main.cpp main関数のソースファイル


---OpacityShadowMaps_Pass0.hlsl---  ↑

// ************************************************************
// Opacity Shadow Maps     深度スライスを作成
// ************************************************************

// 定数バッファ
cbuffer CBuffer : register( b0 )
{
   column_major float4x4 g_matLightWorldViewProj  : packoffset( c0 );    // ライトビューのワールドビュー射影行列
   float g_DepthMapCount            : packoffset( c4.x );
};

Texture2D g_DecalMap : register( t0 );

// サンプラーステート
SamplerState g_Sampler : register( s0 );

// 頂点シェーダーの入力パラメータ
struct VS_IN
{
   float3 pos    : POSITION;    // 頂点座標
   float3 normal : NORMAL;      // 法線ベクトル
   float2 texel  : TEXCOORD;    // テクセル
};

// 頂点シェーダーの出力パラメータ
struct VS_OUT_GS_IN
{
   float3 pos    : POSITION;    // 頂点座標
   float2 texel  : TEXCOORD;    // テクセル
};

// ジオメトリシェーダーの出力パラメータ
struct GS_OUT_PS_IN
{
   float4 pos     : SV_POSITION;
   float2 texel   : TEXCOORD0;
   float4 posLWVP : TEXCOORD1;
   uint   layer   : SV_RenderTargetArrayIndex;
};

// 頂点シェーダー
VS_OUT_GS_IN OpacityShadowMaps_Pass0_VS_Main( VS_IN In )
{
   VS_OUT_GS_IN Out = { In.pos, In.texel };
   return Out;
}

// ジオメトリシェーダー
[maxvertexcount(3)]                                                              // ジオメトリシェーダーで出力する最大頂点数
void OpacityShadowMaps_Pass0_GS_Main( triangle VS_OUT_GS_IN In[3],               // トライアングル プリミティブの入力情報
                                      inout TriangleStream<GS_OUT_PS_IN> TStream // ポリゴン プリミティブの出力ストリーム
                                    )
{
   GS_OUT_PS_IN Out;
   
   for( uint i=0; i<3; i++ )
   {
      Out.pos = mul( float4( In[i].pos, 1 ), g_matLightWorldViewProj );
      Out.texel = In[i].texel;
      Out.posLWVP = Out.pos;
      Out.layer = floor( Out.pos.z * g_DepthMapCount );

      TStream.Append( Out );
   }
   
   TStream.RestartStrip();
}

// ピクセルシェーダ
float OpacityShadowMaps_Pass0_PS_Main( GS_OUT_PS_IN In ) : SV_TARGET
{
   float4 col = g_DecalMap.Sample( g_Sampler, In.texel );
   if( col.a == 0.0f )
      discard;
   return In.posLWVP.z;
}

メッシュの深度値によってレンダーターゲットサーフェスの出力先のインデックスが決まります。
頂点シェーダーではSV_RenderTargetArrayIndexは使えないようなので、ほとんど意味がないのですがジオメトリシェーダーを使用しています。

---OpacityShadowMaps_Pass1.hlsl---  ↑


// ************************************************************
// Opacity Shadow Maps     セルフシャドウを描画
// ************************************************************

// 定数バッファ
cbuffer CBuffer : register( b0 )
{
   column_major float4x4 g_matLightWorldViewProj  : packoffset( c0 );    // ライトビューのワールドビュー射影行列
   column_major float4x4 g_matCameraWorldViewProj  : packoffset( c4 );    // カメラビューのワールドビュー射影行列
   float g_DepthMapCount            : packoffset( c8.x );
};

Texture2D g_DecalMap          : register( t0 );
Texture2DArray g_DepthMap : register( t1 );

SamplerState g_Sampler : register( s0 );

// 頂点シェーダーの入力パラメータ
struct VS_IN
{
   float3 pos    : POSITION;    // 頂点座標
   float3 normal : NORMAL;      // 法線ベクトル
   float2 texel  : TEXCOORD;    // テクセル
};

// 頂点シェーダーの出力パラメータ
struct VS_OUT_PS_IN
{
   float4 pos      : SV_POSITION;
   float2 texel    : TEXCOORD0;
   float4 posLWVP  : TEXCOORD1;
};

// 頂点シェーダー
VS_OUT_PS_IN OpacityShadowMaps_Pass1_VS_Main( VS_IN In )
{
   VS_OUT_PS_IN Out;

   Out.pos = mul( float4( In.pos, 1.0f ), g_matCameraWorldViewProj );
   Out.texel = In.texel;
   Out.posLWVP = mul( float4( In.pos, 1.0f ), g_matLightWorldViewProj );
   
   return Out;
}

// ピクセルシェーダ
float4 OpacityShadowMaps_Pass1_PS_Main( VS_OUT_PS_IN In ) : SV_TARGET
{
   float4 col = g_DecalMap.Sample( g_Sampler, In.texel );
   
   if( col.a == 0.0f )
      discard;

   float shadow = 0;

   float2 texel = float2( In.posLWVP.x * 0.5f + 0.5f, In.posLWVP.y * -0.5f + 0.5f );
   if( texel.x < 0 || texel.x > 1 || texel.y < 0 || texel.y > 1 )
      shadow = 1.0f;
   
   else
   {
      // サンプリングするレンダーターゲットサーフェイス配列のインデックス値
      uint index = floor( In.posLWVP.z * g_DepthMapCount );
   
      float depth;

      // 遮蔽率
      float sc = 0.4f;
   
      [unroll(20)]
      for( int i=index; i>=0; i-- )
      {
         // 遮蔽率は遮蔽物と描画位置との距離が離れるほど減衰させる
         sc *= 0.99f;
      
         float cnt = 0;
         float s = 0;
         
         // PCFのループ
         for( int j=-2; j<3; j+=2 )
         {
            for( int k=-2; k<3; k+=2 )
            {
               depth = g_DepthMap.Sample( g_Sampler, float3( texel, i ), int2( j, k ) ).r;
          
               // 遮蔽されていれば遮蔽率を加算
               if( depth + 0.0005f < In.posLWVP.z )
                  s += sc;
            
               cnt++;
            }
         }
         if( s > 0 )
            shadow += s / cnt;
      }
   
      // 遮蔽率による影の強さを計算
      shadow = exp( -shadow );
   }
   
   return float4( col.bgr * shadow, col.a );
}

最初ボリュームテクスチャーを使うことも考えたのですが、ボリュームテクスチャーを使った場合深度ステンシルビューを使えないようなので、テクスチャー配列にしました。

それとコンパイルに妙に時間がかかります。ループ使いすぎのせいかなあ。

---OpacityShadowMaps.h---  ↑


#ifndef OPACITY_SHADOW_MAPS_H
#define OPACITY_SHADOW_MAPS_H

#include "../Common/UCommon.h"
#include "../Common/UException.h"
#include "../Common/UGraphicsPipeline.h"
#include "../Common/UDirect3D11.h"

// XNAMath
#include "../Common/XNAMath/xnamath.h"

class OpacityShadowMaps
{
private:
   // 深度マップスライスを作成
   typedef struct _CBUFFER_PASS0
   {
      XMMATRIX matLightWorldViewProj;
      float DepthMapCount;
      float Dummy2;
      float Dummy3;
      float Dummy4;
   }CBUFFER_PASS0;

   // 最終レンダリング
   typedef struct _CBUFFER_PASS1
   {
      XMMATRIX matLightWorldViewProj;
      XMMATRIX matCameraWorldViewProj;
      float DepthMapCount;
      float Dummy2;
      float Dummy3;
      float Dummy4;
   }CBUFFER_PASS1;

   // 深度マップスライスの配列
   ID3D11RenderTargetView* m_pRTViewOfDepthMapArray;
   ID3D11ShaderResourceView* m_pSRViewOfDepthMapArray;
   UINT m_DepthMapCount;

   ID3D11DepthStencilView* m_pDSView;

   // レンダーターゲットと深度ステンシルとビューポートのバックアップ
   ID3D11RenderTargetView* m_pOldRTView[D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT];
   ID3D11DepthStencilView* m_pOldDSView;
   D3D11_VIEWPORT m_pOldViewport[D3D11_VIEWPORT_AND_SCISSORRECT_OBJECT_COUNT_PER_PIPELINE];
   UINT m_ViewportCount;

   // シェーダー用定数バッファ
   ID3D11Buffer* m_pConstantBuffers[2];

   UGraphicsPipeline* m_pGraphicsPipeline[2];

   UINT m_Width, m_Height;

   int m_Pass;

   XMMATRIX m_MatLightView;
   XMMATRIX m_MatLightProj;
   XMMATRIX m_MatCameraView;
   XMMATRIX m_MatCameraProj;
   XMFLOAT4 m_VecLightPos;

public:
   OpacityShadowMaps();
   virtual ~OpacityShadowMaps();
   void Invalidate();
   void Create( ID3D11Device* pD3DDevice, UINT Width, UINT Height, UINT DepthMapCount );
   void BeginPass( ID3D11DeviceContext* pD3DDeviceContext, UINT Pass,
                   XMFLOAT4* pVecLightPos, XMMATRIX* pMatLightProj, XMMATRIX* pMatCameraView, XMMATRIX* pMatCameraProj );
   void SetConstantBuffers( ID3D11DeviceContext* pD3DDeviceContext, XMMATRIX* pMatWorld );
   void EndPass( ID3D11DeviceContext* pD3DDeviceContext );
   inline UINT GetMaxPass(){ return _countof( m_pGraphicsPipeline ); };
   inline const ID3D11ShaderResourceView* GetDepthMap(){ return m_pSRViewOfDepthMapArray; };
};

#endif

---OpacityShadowMaps.cpp---  ↑



#include "../../Header/Shader/OpacityShadowMaps.h"
#include "../../HLSL/OpacityShadowMaps_Pass0_VS_Main.h"
#include "../../HLSL/OpacityShadowMaps_Pass0_GS_Main.h"
#include "../../HLSL/OpacityShadowMaps_Pass0_PS_Main.h"
#include "../../HLSL/OpacityShadowMaps_Pass1_VS_Main.h"
#include "../../HLSL/OpacityShadowMaps_Pass1_PS_Main.h"

OpacityShadowMaps::OpacityShadowMaps()
{
   m_pRTViewOfDepthMapArray = nullptr;
   m_pSRViewOfDepthMapArray = nullptr;
   m_pDSView = nullptr;
   for( UINT i=0; i<_countof( m_pGraphicsPipeline ); i++ )
   {
      m_pGraphicsPipeline[i] = nullptr;
      m_pConstantBuffers[i] = nullptr;
   }

   m_Pass = -1;
}

OpacityShadowMaps::~OpacityShadowMaps()
{
   for( UINT i=0; i<_countof( m_pGraphicsPipeline ); i++ )
   {
      SAFE_DELETE( m_pGraphicsPipeline[i] );
      SAFE_RELEASE( m_pConstantBuffers[i] );
   }
   SAFE_RELEASE( m_pDSView );
   SAFE_RELEASE( m_pSRViewOfDepthMapArray );
   SAFE_RELEASE( m_pRTViewOfDepthMapArray );
}

void OpacityShadowMaps::Create( ID3D11Device* pD3DDevice, UINT Width, UINT Height, UINT DepthMapCount )
{
   m_Width = Width;
   m_Height = Height;
   m_DepthMapCount = DepthMapCount;

   m_Pass = -1;

   if( DepthMapCount == 0 )
      throw( UException( -1, _T("OpacityShadowMaps::Create()でエラーが発生しました。DepthMapCountは1以上で設定してください。") ) );
      
   // *******************************************************************************************************
   // 深度マップスライスを作成する
   // *******************************************************************************************************

   m_pGraphicsPipeline[0] = NEW UGraphicsPipeline();

   // ラスタライザーステートを作成する( 両面ポリゴン描画 )
   m_pGraphicsPipeline[0]->CreateRasterizerState( pD3DDevice, D3D11_CULL_MODE::D3D11_CULL_NONE );

   // 深度ステンシルステートを作成する
   m_pGraphicsPipeline[0]->CreateDepthStencilState( pD3DDevice, TRUE, D3D11_DEPTH_WRITE_MASK::D3D11_DEPTH_WRITE_MASK_ALL );

   // ブレンドステートを作成する
   UGraphicsPipeline::UEBLEND_STATE BlendStateType[1] = { UGraphicsPipeline::UEBLEND_STATE::NONE };
   m_pGraphicsPipeline[0]->CreateBlendState( pD3DDevice, BlendStateType, 1, TRUE );

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

   // シェーダーを作成する
#if defined(DEBUG) || defined(_DEBUG)
   m_pGraphicsPipeline[0]->CreateVertexShaderFromFile( pD3DDevice, _T("../HLSL/OpacityShadowMaps_Pass0.hlsl"), "OpacityShadowMaps_Pass0_VS_Main", layout, _countof( layout ) );
   m_pGraphicsPipeline[0]->CreateGeometryShaderFromFile( pD3DDevice, _T("../HLSL/OpacityShadowMaps_Pass0.hlsl"), "OpacityShadowMaps_Pass0_GS_Main" );
   m_pGraphicsPipeline[0]->CreatePixelShaderFromFile( pD3DDevice, _T("../HLSL/OpacityShadowMaps_Pass0.hlsl"), "OpacityShadowMaps_Pass0_PS_Main" );
#else
   m_pGraphicsPipeline[0]->CreateVertexShaderFromMemory( pD3DDevice, (LPBYTE)g_OpacityShadowMaps_Pass0_VS_Main, sizeof( g_OpacityShadowMaps_Pass0_VS_Main ), layout, _countof( layout ) );
   m_pGraphicsPipeline[0]->CreateGeometryShaderFromMemory( pD3DDevice, (LPBYTE)g_OpacityShadowMaps_Pass0_GS_Main, sizeof( g_OpacityShadowMaps_Pass0_GS_Main ) );
   m_pGraphicsPipeline[0]->CreatePixelShaderFromMemory( pD3DDevice, (LPBYTE)g_OpacityShadowMaps_Pass0_PS_Main, sizeof( g_OpacityShadowMaps_Pass0_PS_Main ) );
#endif

   // レンダーターゲットビューを作成する( 深度ステンシルビューを使用する場合は、ボリュームテクスチャーは使えないっぽいので、配列で )
   UMaps::CreateRenderTargetView( pD3DDevice, DXGI_FORMAT_R16_FLOAT, m_Width, m_Height, &m_pRTViewOfDepthMapArray, &m_pSRViewOfDepthMapArray, m_DepthMapCount );

   UMaps::CreateDepthStencilView( pD3DDevice, m_Width, m_Height, &m_pDSView, nullptr, m_DepthMapCount );

   // 定数バッファを作成する
   m_pConstantBuffers[0] = m_pGraphicsPipeline[0]->CreateConstantBuffer( pD3DDevice, nullptr, sizeof( OpacityShadowMaps::CBUFFER_PASS0 ), D3D11_CPU_ACCESS_WRITE );

   // *******************************************************************************************************
   // メッシュのレンダリング
   // *******************************************************************************************************

   m_pGraphicsPipeline[1] = NEW UGraphicsPipeline();

   // ラスタライザーステートを作成する
   m_pGraphicsPipeline[1]->CreateRasterizerState( pD3DDevice, D3D11_CULL_MODE::D3D11_CULL_NONE );

   // 深度ステンシルステートを作成する
   m_pGraphicsPipeline[1]->CreateDepthStencilState( pD3DDevice, TRUE, D3D11_DEPTH_WRITE_MASK::D3D11_DEPTH_WRITE_MASK_ALL );

   // ブレンドステートを作成する
   BlendStateType[0] = UGraphicsPipeline::UEBLEND_STATE::NONE;
   m_pGraphicsPipeline[1]->CreateBlendState( pD3DDevice, BlendStateType, 1, TRUE );

   // シェーダーを作成する
#if defined(DEBUG) || defined(_DEBUG)
   m_pGraphicsPipeline[1]->CreateVertexShaderFromFile( pD3DDevice, _T("../HLSL/OpacityShadowMaps_Pass1.hlsl"), "OpacityShadowMaps_Pass1_VS_Main", layout, _countof( layout ) );
   m_pGraphicsPipeline[1]->CreatePixelShaderFromFile( pD3DDevice, _T("../HLSL/OpacityShadowMaps_Pass1.hlsl"), "OpacityShadowMaps_Pass1_PS_Main" );
#else
   m_pGraphicsPipeline[1]->CreateVertexShaderFromMemory( pD3DDevice, (LPBYTE)g_OpacityShadowMaps_Pass1_VS_Main, sizeof( g_OpacityShadowMaps_Pass1_VS_Main ), layout, _countof( layout ) );
   m_pGraphicsPipeline[1]->CreatePixelShaderFromMemory( pD3DDevice, (LPBYTE)g_OpacityShadowMaps_Pass1_PS_Main, sizeof( g_OpacityShadowMaps_Pass1_PS_Main ) );
#endif
   
   // 定数バッファを作成する
   m_pConstantBuffers[1] = m_pGraphicsPipeline[1]->CreateConstantBuffer( pD3DDevice, nullptr, sizeof( OpacityShadowMaps::CBUFFER_PASS1 ), D3D11_CPU_ACCESS_WRITE );
}

void OpacityShadowMaps::BeginPass( ID3D11DeviceContext* pD3DDeviceContext, UINT Pass,
                                   XMFLOAT4* pVecLightPos, XMMATRIX* pMatLightProj, XMMATRIX* pMatCameraView, XMMATRIX* pMatCameraProj )
{
   if (m_Pass != -1)
   {
      throw(UException(-1, _T("OpacityShadowMaps::BeginPass()はCreate()またはEndPass()実行後に使用してください")));
   }

   m_Pass = (int)Pass;

   switch( m_Pass )
   {
   case 0:
      {
         // レンダーターゲットビューと深度ステンシルビューを切り替える

         pD3DDeviceContext->OMGetRenderTargets( _countof( m_pOldRTView ), m_pOldRTView, &m_pOldDSView );
         pD3DDeviceContext->OMSetRenderTargets( 1, &m_pRTViewOfDepthMapArray, m_pDSView );

         pD3DDeviceContext->RSGetViewports( &m_ViewportCount, nullptr );
         pD3DDeviceContext->RSGetViewports( &m_ViewportCount, &m_pOldViewport[0] );

         // ビューポートを切り替える。
         D3D11_VIEWPORT Viewport[1];
         Viewport[0].TopLeftX = 0;
         Viewport[0].TopLeftY = 0;
         Viewport[0].Width    = (FLOAT)m_Width;
         Viewport[0].Height   = (FLOAT)m_Height;
         Viewport[0].MinDepth = 0.0f;
         Viewport[0].MaxDepth = 1.0f;
         pD3DDeviceContext->RSSetViewports( 1, Viewport );

         float ClearColor[4] = { 1.0f, 1.0f, 1.0f, 1.0f };

         pD3DDeviceContext->ClearRenderTargetView( m_pRTViewOfDepthMapArray, ClearColor ); 
         pD3DDeviceContext->ClearDepthStencilView( m_pDSView, D3D11_CLEAR_DEPTH | D3D11_CLEAR_STENCIL, 1.0f, 0  );

         m_VecLightPos = *pVecLightPos;

         m_MatLightView = XMMatrixLookAtLH(XMLoadFloat3((XMFLOAT3*)&m_VecLightPos), XMLoadFloat3(&XMFLOAT3(0, 0, 0)), XMLoadFloat3(&XMFLOAT3(0, 1, 0)));
         m_MatLightProj = (*pMatLightProj);

         m_MatCameraView = XMMatrixIdentity();
         m_MatCameraProj = XMMatrixIdentity();
      }
      break;

   case 1:
      {
         pD3DDeviceContext->PSSetShaderResources( 1, 1, &m_pSRViewOfDepthMapArray );

         m_MatCameraView = (*pMatCameraView);
         m_MatCameraProj = (*pMatCameraProj);
      }
      break;

   default:
      throw(UException(-1, _T("OpacityShadowMaps::BeginPass()で無効なPassが指定されました")));
   }

   // 各種ステートを設定する
   m_pGraphicsPipeline[m_Pass]->SetRasterizerState( pD3DDeviceContext );
   m_pGraphicsPipeline[m_Pass]->SetDepthStencilState( pD3DDeviceContext );
   m_pGraphicsPipeline[m_Pass]->SetBlendState( pD3DDeviceContext );

   // 各種グラフィックパイプラインを設定
   m_pGraphicsPipeline[m_Pass]->SetVertexShader( pD3DDeviceContext );
   m_pGraphicsPipeline[m_Pass]->SetHullShader( pD3DDeviceContext );
   m_pGraphicsPipeline[m_Pass]->SetDomainShader( pD3DDeviceContext );
   m_pGraphicsPipeline[m_Pass]->SetGeometryShader( pD3DDeviceContext );
   m_pGraphicsPipeline[m_Pass]->SetPixelShader( pD3DDeviceContext );
}

void OpacityShadowMaps::SetConstantBuffers( ID3D11DeviceContext* pD3DDeviceContext, XMMATRIX* pMatWorld )
{
   HRESULT hr = E_FAIL;

   // ライトビューのビュー行列を作成
   XMMATRIX matLightView = XMMatrixLookAtLH( XMLoadFloat3( (XMFLOAT3*)&m_VecLightPos ), XMLoadFloat3( &XMFLOAT3( 0, 0, 0 ) ), XMLoadFloat3( &XMFLOAT3( 0, 1, 0 ) ) );

   // ライトビューのワールド行列とビュー行列と射影行列
   XMMATRIX matLightWorldViewProj = XMMatrixTranspose( *pMatWorld * matLightView * m_MatLightProj );

   switch( m_Pass )
   {
   case 0:
      {
         // 定数バッファをロックする
         D3D11_MAPPED_SUBRESOURCE mappedResource;
         if( FAILED( hr = pD3DDeviceContext->Map( m_pConstantBuffers[m_Pass], 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource ) ) )
            throw( UException( -1, _T("OpacityShadowMaps::SetConstantBuffers()でエラーが発生しました。Map()が失敗しました。") ) );
         OpacityShadowMaps::CBUFFER_PASS0* cbuffer = (OpacityShadowMaps::CBUFFER_PASS0*)mappedResource.pData;
         ::CopyMemory( &cbuffer->matLightWorldViewProj, &matLightWorldViewProj, sizeof( XMMATRIX ) );
         cbuffer->DepthMapCount = (float)( m_DepthMapCount - 1 );
         pD3DDeviceContext->Unmap( m_pConstantBuffers[m_Pass], 0 );

         // 定数バッファを設定
         pD3DDeviceContext->GSSetConstantBuffers( 0, 1, &m_pConstantBuffers[m_Pass] );
      }
      break;

   case 1:
      {
         XMMATRIX matCameraWorldViewProj = XMMatrixTranspose( *pMatWorld * m_MatCameraView * m_MatCameraProj );

         // 定数バッファをロックする
         D3D11_MAPPED_SUBRESOURCE mappedResource;
         if( FAILED( hr = pD3DDeviceContext->Map( m_pConstantBuffers[m_Pass], 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource ) ) )
            throw( UException( -1, _T("OpacityShadowMaps::SetConstantBuffers()でエラーが発生しました。Map()が失敗しました。") ) );
         OpacityShadowMaps::CBUFFER_PASS1* cbuffer = (OpacityShadowMaps::CBUFFER_PASS1*)mappedResource.pData;
         ::CopyMemory( &cbuffer->matLightWorldViewProj, &matLightWorldViewProj, sizeof( XMMATRIX ) );
         ::CopyMemory( &cbuffer->matCameraWorldViewProj, &matCameraWorldViewProj, sizeof( XMMATRIX ) );
         cbuffer->DepthMapCount = (float)( m_DepthMapCount - 1 );
         pD3DDeviceContext->Unmap( m_pConstantBuffers[m_Pass], 0 );

         // 定数バッファを設定
         pD3DDeviceContext->VSSetConstantBuffers( 0, 1, &m_pConstantBuffers[m_Pass] );
         pD3DDeviceContext->PSSetConstantBuffers( 0, 1, &m_pConstantBuffers[m_Pass] );
      }
      break;
   }
}

void OpacityShadowMaps::EndPass( ID3D11DeviceContext* pD3DDeviceContext )
{
   switch( m_Pass )
   {
   case 0:
      {
         // レンダーターゲットビューと深度ステンシルビューとビューポートを戻す

         pD3DDeviceContext->OMSetRenderTargets( _countof( m_pOldRTView ), m_pOldRTView, m_pOldDSView );
         for( UINT i=0; i<_countof( m_pOldRTView ); i++ )
            SAFE_RELEASE( m_pOldRTView[i] );
         SAFE_RELEASE( m_pOldDSView );

         pD3DDeviceContext->RSSetViewports( m_ViewportCount, m_pOldViewport );
      }
      break;

   case 1:
      {
         ID3D11ShaderResourceView* pSRViewNull[] = { nullptr, nullptr };
         pD3DDeviceContext->PSSetShaderResources( 0, _countof( pSRViewNull ), pSRViewNull );
      }
      break;
   }

   m_Pass = -1;
}

一応アルファトゥカバレッジを有効にしてます。

---GrassMesh.h---  ↑


#ifndef GRASSMESH_H
#define GRASSMESH_H

#include "../Common/UCommon.h"
#include "../Common/UDirect3D11.h"
#include "../Common/UException.h"
#include "../Common/UD3DMeshDataCreater.h"

#include "../Common/XNAMath/xnamath.h"

class GrassMesh
{
private:
   // 頂点バッファ
   ID3D11Buffer* m_pVertexBuffer;

   // シェーダーリソースビュー
   ID3D11ShaderResourceView* m_pSRView;

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

   XMMATRIX m_MatWorld;
   
   ULONG m_VertexCount;

   // ランダム値取得
   inline float GetRandomize(){ return (float)(rand()%100 - 50) / 50.0f; };

public:
   GrassMesh();
   virtual ~GrassMesh();
   void Invalidate();
   void CreateMesh( ID3D11Device* pD3DDevice, UINT MeshCount );
   void NextFrame();
   inline XMMATRIX* GetMatWorld(){ return &m_MatWorld; };
   void Render( ID3D11DeviceContext* pD3DDeviceContext );
};

#endif

---GrassMesh.cpp---  ↑


#include "../../Header/Mesh/GrassMesh.h"

GrassMesh::GrassMesh()
{
   m_pVertexBuffer = nullptr;
   m_pSRView = nullptr;
   m_pSamplerState = nullptr;
   m_VertexCount = 0;
}

GrassMesh::~GrassMesh()
{
   Invalidate();
}

void GrassMesh::Invalidate()
{
   m_VertexCount = 0;
   SAFE_RELEASE( m_pSamplerState );
   SAFE_RELEASE( m_pSRView );
   SAFE_RELEASE( m_pVertexBuffer );
}

void GrassMesh::CreateMesh( ID3D11Device* pD3DDevice, UINT MeshCount )
{
   const UINT VertexCountOfOneMesh = 12;

   m_VertexCount = VertexCountOfOneMesh * MeshCount;

   UD3DMeshDataCreater::VERTEX* vertex = NEW UD3DMeshDataCreater::VERTEX[m_VertexCount];

   for( ULONG i=0; i<m_VertexCount; i+=VertexCountOfOneMesh )
   {
      float x = GetRandomize() * 40.0f;
      float y = -2.0f;
      float z = GetRandomize() * 80.0f;
      float yOffset = GetRandomize() * 10.0f;

      float r = GetRandomize() * XM_2PI;
      XMMATRIX matRotationY = XMMatrixRotationY( r );

      vertex[i+0].Position = XMFLOAT3(  3.0f, y + 15.0f, 2.0f );  vertex[i+0].Texcoord = XMFLOAT2( 1.0f, 0.5f );
      vertex[i+1].Position = XMFLOAT3( -3.0f, y + 15.0f, 2.0f );  vertex[i+1].Texcoord = XMFLOAT2( 0.0f, 0.5f );
      vertex[i+2].Position = XMFLOAT3(  3.0f, y,         0.0f );  vertex[i+2].Texcoord = XMFLOAT2( 1.0f, 1.0f );
      vertex[i+3].Position = XMFLOAT3( -3.0f, y + 15.0f, 2.0f );  vertex[i+3].Texcoord = XMFLOAT2( 0.0f, 0.5f );
      vertex[i+4].Position = XMFLOAT3( -3.0f, y,         0.0f );  vertex[i+4].Texcoord = XMFLOAT2( 0.0f, 1.0f );
      vertex[i+5].Position = XMFLOAT3(  3.0f, y,         0.0f );  vertex[i+5].Texcoord = XMFLOAT2( 1.0f, 1.0f );

      vertex[i+6].Position = XMFLOAT3(   3.0f, y + 30.0f + yOffset, 6.0f );  vertex[i+6].Texcoord = XMFLOAT2( 1.0f, 0.0f );
      vertex[i+7].Position = XMFLOAT3(  -3.0f, y + 30.0f + yOffset, 6.0f );  vertex[i+7].Texcoord = XMFLOAT2( 0.0f, 0.0f );
      vertex[i+8].Position = XMFLOAT3(   3.0f, y + 15.0f,           2.0f );  vertex[i+8].Texcoord = XMFLOAT2( 1.0f, 0.5f );
      vertex[i+9].Position = XMFLOAT3(  -3.0f, y + 30.0f + yOffset, 6.0f );  vertex[i+9].Texcoord = XMFLOAT2( 0.0f, 0.0f );
      vertex[i+10].Position = XMFLOAT3( -3.0f, y + 15.0f,           2.0f );  vertex[i+10].Texcoord = XMFLOAT2( 0.0f, 0.5f );
      vertex[i+11].Position = XMFLOAT3(  3.0f, y + 15.0f,           2.0f );  vertex[i+11].Texcoord = XMFLOAT2( 1.0f, 0.5f );

      for( ULONG j=i; j<i + VertexCountOfOneMesh; j++ )
      {
         XMVECTOR v = XMLoadFloat4( &XMFLOAT4( vertex[j].Position.x, vertex[j].Position.y, vertex[j].Position.z, 1 ) );
         v = XMVector4Transform( v, matRotationY );
         XMStoreFloat3( &vertex[j].Position, v );

         vertex[j].Position.x += x;
         vertex[j].Position.z += z;
      }
   }

   // 頂点バッファを作成する
   m_pVertexBuffer = UBuffers::CreateVertexBuffer( pD3DDevice, vertex, sizeof( UD3DMeshDataCreater::VERTEX ) * m_VertexCount, 0 );
  
   // サンプラーステートを作成する
   m_pSamplerState = USamplers::CreateSamplerState( pD3DDevice, D3D11_TEXTURE_ADDRESS_CLAMP, D3D11_FILTER_MIN_MAG_MIP_POINT );

   // テクスチャーを作成する
   UMaps::CreateSRViewFromDDSFile( pD3DDevice, _T("../Resource//Grass.dds"), &m_pSRView );

   SAFE_DELETE_ARRAY( vertex );
}

void GrassMesh::NextFrame()
{
   XMMATRIX matTranslate;

   matTranslate = XMMatrixTranslation( 0.0f, -20.0f, 0.0f );
   m_MatWorld = matTranslate;
}

void GrassMesh::Render( ID3D11DeviceContext* pD3DDeviceContext )
{
   // 頂点バッファ設定
   UINT stride = sizeof( UD3DMeshDataCreater::VERTEX );
   UINT offset = 0;
   pD3DDeviceContext->IASetVertexBuffers( 0, 1, &m_pVertexBuffer, &stride, &offset );

   // プリミティブ タイプおよびデータの順序に関する情報を設定
   pD3DDeviceContext->IASetPrimitiveTopology( D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST );

   // ピクセルシェーダーのサンプラーステートを設定する
   pD3DDeviceContext->PSSetSamplers( 0, 1, &m_pSamplerState );

   // デカールマップを設定する
   pD3DDeviceContext->PSSetShaderResources( 0, 1, &m_pSRView );

   // インデックスバッファを使用しない描画
   pD3DDeviceContext->Draw( m_VertexCount, 0 );
}

---main.cpp---  ↑


#include "../Header/Common/UCommon.h"
#include "../Header/Common/UException.h"
#include "../Header/Common/UDirect3D11.h"
#include "../Header/Common/UDebugFont.h"
#if defined(DEBUG) || defined(_DEBUG)
#include "../Header/Common/USRViewRenderer.h"
#endif
#include "../Header/Shader/OpacityShadowMaps.h"
#include "../Header/Mesh/GrassMesh.h"
#include "../Header/Mesh/PlaneMesh.h"

// アプリケーション名
TCHAR* AppName = _T("Direct3D11 Opacity Shadow Maps");

// Direct3D関連の自作クラス
UDirect3D11* g_pDirect3D11 = nullptr;

OpacityShadowMaps* g_pOpacityShadowMaps = nullptr;

GrassMesh* g_pGrassMesh = nullptr;
PlaneMesh* g_pPlaneMesh = nullptr;

UDebugFont* g_pDebugFont = nullptr;
UFPS* g_pFPS = nullptr;

#if defined(DEBUG) || defined(_DEBUG)
USRViewRenderer* g_pSRViewRenderer = nullptr;
#endif

DWORD g_Width = 640, g_Height = 480;
float g_LZFar = 550.0f, g_LZNear = 50.0f;

// カメラビュー行列
XMMATRIX g_MatCameraView = XMMatrixIdentity();

// カメラービュー射影行列
XMMATRIX g_MatCameraProj = XMMatrixPerspectiveFovLH( XM_PI / 5.0f, (float)g_Width / (float)g_Height, 10.0f, 500.0f );

// ライトビューは距離計算が正しくできるように射影行列にする
XMMATRIX g_MatLightProj = XMMatrixOrthographicLH( 130.0f, 130.0f, g_LZNear, g_LZFar );

// 平行光源の位置ベクトル
XMFLOAT4 g_VecLightPos = XMFLOAT4( 0.0f, 50.0f, -200.0f, 0 );

UINT g_DepthCount = 10;
float g_DepthLevel = 0.0f;

// メモリ解放
void Invalidate()
{
#if defined(DEBUG) || defined(_DEBUG)
   SAFE_DELETE( g_pSRViewRenderer );
#endif
   SAFE_DELETE( g_pOpacityShadowMaps );
   SAFE_DELETE( g_pFPS );
   SAFE_DELETE( g_pDebugFont );
   SAFE_DELETE( g_pPlaneMesh );
   SAFE_DELETE( g_pGrassMesh );
   SAFE_DELETE( g_pDirect3D11 );
}

// ウィンドウプロシージャ
LRESULT CALLBACK WndProc( HWND hWnd, UINT msg, UINT wParam, LONG lParam )
{
   switch( msg )
   {
   case WM_KEYUP:
      // アプリ終了
      if( wParam == VK_ESCAPE )
         ::DestroyWindow( hWnd );
      break;

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

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

   return 0L;
}

// Direct3Dの作成
void CreateDirect3D( HINSTANCE hInstance )
{
   DXGI_MODE_DESC* pModeDescArray = nullptr;

   __try
   {
      DXGI_MODE_DESC  ModeDesc;
      UINT num;

      // ディスプレイモード一覧の数を取得する
      g_pDirect3D11->GetDisplayMode( nullptr, &num );

      pModeDescArray = NEW DXGI_MODE_DESC[num];
      // ディスプレイモード一覧を取得する
      g_pDirect3D11->GetDisplayMode( pModeDescArray, &num );

      bool find = false;
      for( UINT i=0; i<num; i++ )
      {
         // 適切な解像度のディスプレイモードを検索する
         if( pModeDescArray[i].Width == g_Width && pModeDescArray[i].Height == g_Height )
         {
            find = true;
            ::CopyMemory( &ModeDesc, &pModeDescArray[i], sizeof( DXGI_MODE_DESC ) );
            break;
         }
      }

      if( find == false )
         throw( UException( -1, _T("InitDirect3D()でエラーが発生しました。適切なディスプレイモードの解像度を取得できません。") ) );

      // ウィンドウの作成およびDirect3D の作成
      g_pDirect3D11->CreateDirect3D11( AppName, hInstance, WndProc, &ModeDesc, TRUE, TRUE );

      g_pDebugFont->CreateMesh( g_pDirect3D11->m_pD3DDevice, 0.03f, 0.08f );

      // FPS描画クラス
      g_pFPS->CreateMesh( g_pDirect3D11->m_pD3DDevice );

#if defined(DEBUG) || defined(_DEBUG)
      g_pSRViewRenderer->Create( g_pDirect3D11->m_pD3DDevice, 1.0f - 400.0f / (float)g_Width, 1.0f, 1.0f, 1.0f - 400.0f / (float)g_Height );
#endif
   }
   __finally
   {
      SAFE_DELETE_ARRAY( pModeDescArray );
   }
}

void CreateGraphicePipeline()
{
   DWORD Width = 256, Height = 256;
   g_pOpacityShadowMaps->Create( g_pDirect3D11->m_pD3DDevice, Width, Height, g_DepthCount );
}

// メッシュを作成する
void CreateMesh()
{
   g_pGrassMesh = NEW GrassMesh();
   g_pGrassMesh->CreateMesh( g_pDirect3D11->m_pD3DDevice, 250 );

   g_pPlaneMesh = NEW PlaneMesh();
   g_pPlaneMesh->CreateMesh( g_pDirect3D11->m_pD3DDevice );
}

void CreateResource( HINSTANCE hInstance )
{
   // Direct3D 関連自作クラスのインスタンスを作成
   // CreateDirect3D()関数内でインスタンスの作成を行うと、C2712 エラーが発生するのでここで行う。
   g_pDirect3D11 = NEW UDirect3D11();

   g_pOpacityShadowMaps = NEW OpacityShadowMaps();

   g_pDebugFont = NEW UDebugFont();
   g_pFPS = NEW UFPS();

#if defined(DEBUG) || defined(_DEBUG)
   g_pSRViewRenderer = NEW USRViewRenderer();
#endif

   // Direct3Dの作成
   CreateDirect3D( hInstance );

   // グラフィックパイプラインリソースの作成
   CreateGraphicePipeline();

   // リソースの作成
   CreateMesh();
}

void NextFrame()
{
   // ビュー行列
   if( GetKeyState( VK_UP ) & 0x8000 )
      g_MatCameraView *= XMMatrixTranslation( 0, 0, -0.2f );
   if( GetKeyState( VK_DOWN ) & 0x8000 )
      g_MatCameraView *= XMMatrixTranslation( 0, 0, 0.2f );
   if( GetKeyState( VK_RIGHT ) & 0x8000 )
      g_MatCameraView *= XMMatrixRotationY( -0.002f );
   if( GetKeyState( VK_LEFT ) & 0x8000 )
      g_MatCameraView *= XMMatrixRotationY( 0.002f );
   if( GetKeyState( 'Q' ) & 0x8000 )
      g_MatCameraView *= XMMatrixRotationX( 0.002f );
   if( GetKeyState( 'A' ) & 0x8000 )
      g_MatCameraView *= XMMatrixRotationX( -0.002f );

   if( GetKeyState( 'V' ) & 0x8000 )
   {
      g_DepthLevel += 0.01f;
      if( g_DepthLevel > (float)g_DepthCount - 1.0f )
         g_DepthLevel = (float)g_DepthCount - 1.0f;
   }
   if( GetKeyState( 'B' ) & 0x8000 )
   {
      g_DepthLevel -= 0.01f;
      if( g_DepthLevel < 0.0f )
         g_DepthLevel = 0.0f;
   }

   g_pFPS->NextFrame();

   g_pGrassMesh->NextFrame();
   g_pPlaneMesh->NextFrame();

   TCHAR str[100];
   _stprintf_s(str, _T("%f\nV:VolumeLevel Up\nB:VolumeLevel Down"), g_DepthLevel);
   g_pDebugFont->NextFrame( str, &XMFLOAT2( -0.97f, 0.86f ), &XMFLOAT4( 1, 1, 1, 1 ) );
}

// 描画処理
HRESULT Render()
{
   HRESULT hr = E_FAIL;
   
   static float ClearColor[4] = { 0.3f, 0.3f, 1.0f, 1.0f };

   // バックバッファをクリアする。
   g_pDirect3D11->ClearBackBuffer( ClearColor ); 

   // 深度バッファをクリアする。
   g_pDirect3D11->ClearDepthStencilView( D3D11_CLEAR_DEPTH | D3D11_CLEAR_STENCIL, 1.0f, 0 );

   for( UINT i=0; i<g_pOpacityShadowMaps->GetMaxPass(); i++ )
   {
      g_pOpacityShadowMaps->BeginPass( g_pDirect3D11->m_pD3DDeviceContext, i, &g_VecLightPos, &g_MatLightProj, &g_MatCameraView, &g_MatCameraProj );

      g_pOpacityShadowMaps->SetConstantBuffers( g_pDirect3D11->m_pD3DDeviceContext, g_pGrassMesh->GetMatWorld() );
      g_pGrassMesh->Render( g_pDirect3D11->m_pD3DDeviceContext );

      if( i == 1 )
         g_pPlaneMesh->Render( g_pDirect3D11->m_pD3DDeviceContext );

      g_pOpacityShadowMaps->EndPass( g_pDirect3D11->m_pD3DDeviceContext );
   }

#if defined(DEBUG) || defined(_DEBUG)
   int SrvRGB[] = { 0, 1, 2, 3 };
   g_pSRViewRenderer->SetSRView( g_pOpacityShadowMaps->GetDepthMap(), SrvRGB, g_DepthLevel );
   g_pSRViewRenderer->Render( g_pDirect3D11->m_pD3DDeviceContext );
#endif

   g_pFPS->Render( g_pDirect3D11->m_pD3DDeviceContext );
   g_pDebugFont->Render( g_pDirect3D11->m_pD3DDeviceContext );

   // レンダリングされたイメージをユーザーに表示。
   if( FAILED( hr = g_pDirect3D11->Present( 0, 0 ) ) )
      throw( UException( hr, _T("IDXGISwapChain::Present()が失敗しました") ) );

   return hr;
}
 
// メイン関数
int APIENTRY _tWinMain( HINSTANCE hInstance,
                        HINSTANCE,
                        LPTSTR,
                        INT )
{
   // メモリリーク検出
//   _CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF | CRTDBG_CHECK_ALWAYS_DF );
   _CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF | _CRTDBG_CHECK_EVERY_1024_DF );

   MSG msg = {0};

   try
   {
      CreateResource( hInstance );

      ::ShowWindow( g_pDirect3D11->m_hWnd, SW_SHOW );
      ::UpdateWindow( g_pDirect3D11->m_hWnd );

      // メッセージループ
      do
      { 
         if( ::PeekMessage( &msg, 0, 0, 0, PM_REMOVE ) )
         {
            ::TranslateMessage(&msg); 
            ::DispatchMessage(&msg); 
         }
         else
         {
            NextFrame();
            Render();
         }
      }while( msg.message != WM_QUIT );
   }
   catch( UException ex )
   {
      ::MessageBox( nullptr, ex.m_pErrorStr, _T("エラー"), MB_OK );
   }

   Invalidate();

   ::UnregisterClass( AppName, hInstance );

   return msg.wParam;
}


web拍手 by FC2

Prev Top Next

inserted by FC2 system