Microsoft DirectX 9.0 SDK (December 2004)
シェーダーモデル 2.0
|
|
Microsoft Visual Studio .NET 2003 Microsoft DirectX 9.0 SDK (December 2004) シェーダーモデル 2.0 |
| ■ゴッドレイ | Prev Top Next |
| 関連ページ：ライトブルーム その２ 爆発ブラー |
今回はゴッドレイをやります。木漏れ日ってやつですかね。
太陽を中心に放射状にライトブルームが発生しています。これがゴッドレイです。以前やったライトブルーム その２では丸いライトブルームが発生するだけでしたが、この方がいいですな。
カメラワークによってライトブルームのかかり具合が変化するのも面白いです。
処理フローイメージです。
１．普通にシーンをレンダリングします。
２．マスクマップを作成します。白くクリアしたレンダーターゲットサーフェイスを使用し、ピクセルシェーダーから黒く色を出力します。
つまりオブジェクトのシルエットを作成するような感じです。
３．浮動小数点フォーマットのレンダーターゲットサーフェイスを使用し、太陽をレンダリングします。このときマスクマップによりマスクします。
４．３のサーフェイスにブラー処理をかけます。
５．２のマスクマップを太陽の位置を中心に放射状にブラー処理をかけます。
６．５の放射ブラーイメージとブルームイメージを積算し、ゴットレイイメージを作成します。
７．１と４と６を合成します。４と６は加算合成です。
ではソースの解説です。
---Lambert15.fx---
float4x4 m_WVP;
//オブジェクトのテクスチャー
sampler tex0 : register(s0);
struct VS_OUTPUT
{
float4 Pos : POSITION;
float2 Tex : TEXCOORD0;
};
VS_OUTPUT VS( float4 Pos : POSITION,
float4 Normal : NORMAL,
float2 Tex : TEXCOORD0 )
{
VS_OUTPUT Out;
Out.Pos = mul( Pos, m_WVP );
Out.Tex = Tex;
return Out;
}
//不透明オブジェクトで使用するピクセルシェーダー
float4 PS( VS_OUTPUT In ) : COLOR0
{
return 0.0f;
}
//半透明オブジェクトで使用するピクセルシェーダー
float4 PS_AlphaBlend( VS_OUTPUT In ) : COLOR0
{
float4 Col = tex2D( tex0, In.Tex );
//不透明部分
if( Col.a )
Col = 0.0f;
//透明部分
else
Col = 1.0f;
return Col;
}
technique TShader
{
//不透明オブジェクトで使用するピクセルシェーダー
pass P0
{
VertexShader = compile vs_1_1 VS();
PixelShader = compile ps_1_1 PS();
}
//半透明オブジェクトで使用するピクセルシェーダー
pass P1
{
VertexShader = compile vs_1_1 VS();
PixelShader = compile ps_1_1 PS_AlphaBlend();
}
}
マスクマップを作成するシェーダーです。
---Lambert.h---
class LAMBERT15
{
private:
LPD3DXEFFECT m_pEffect;
D3DXHANDLE m_pTechnique, m_pWVP;
D3DXMATRIX m_matView, m_matProj;
LPDIRECT3DDEVICE9 m_pd3dDevice;
public:
LAMBERT15( LPDIRECT3DDEVICE9 pd3dDevice );
~LAMBERT15();
void Invalidate();
void Restore();
HRESULT Load();
void Begin();
void BeginPass( UINT Pass );
void SetMatrix( D3DXMATRIX* pMatWorld );
void CommitChanges();
void EndPass();
void End();
BOOL IsOK();
LPD3DXEFFECT GetEffect(){ return m_pEffect; };
};
---Lambert.cpp---
LAMBERT15::LAMBERT15( LPDIRECT3DDEVICE9 pd3dDevice )
{
m_pd3dDevice = pd3dDevice;
m_pEffect = NULL;
}
LAMBERT15::~LAMBERT15()
{
//SafeReleaseは関数ではなくマクロ
//#define SafeRelease(x) { if(x) { (x)->Release(); (x)=NULL; } }
SafeRelease( m_pEffect );
}
//デバイスがロストしたときにコールする関数
void LAMBERT15::Invalidate()
{
if( m_pEffect )
m_pEffect->OnLostDevice();
}
//デバイスがリストアしたときにコールする関数
void LAMBERT15::Restore()
{
if( m_pEffect )
m_pEffect->OnResetDevice();
}
HRESULT LAMBERT15::Load()
{
D3DCAPS9 caps;
m_pd3dDevice->GetDeviceCaps( &caps );
if( caps.VertexShaderVersion >= D3DVS_VERSION( 1, 1 ) && caps.PixelShaderVersion >= D3DPS_VERSION( 1, 1 ) )
{
LPD3DXBUFFER pErr = NULL;
HRESULT hr = D3DXCreateEffectFromFile( m_pd3dDevice, _T("Lambert15.fx"), NULL, NULL, 0, NULL, &m_pEffect, &pErr );
if( SUCCEEDED( hr ) )
{
m_pTechnique = m_pEffect->GetTechniqueByName( "TShader" );
m_pWVP = m_pEffect->GetParameterByName( NULL, "m_WVP" );
m_pEffect->SetTechnique( m_pTechnique );
}
else
{
return -1;
}
}
else
{
return -2;
}
return S_OK;
}
void LAMBERT15::Begin()
{
if( m_pEffect )
{
m_pd3dDevice->GetTransform( D3DTS_VIEW, &m_matView );
m_pd3dDevice->GetTransform( D3DTS_PROJECTION, &m_matProj );
m_pEffect->Begin( NULL, 0 );
}
}
void LAMBERT15::BeginPass( UINT Pass )
{
if( m_pEffect )
m_pEffect->BeginPass( Pass );
}
void LAMBERT15::SetMatrix( D3DXMATRIX* pMatWorld )
{
if( m_pEffect )
{
D3DXMATRIX m;
m = (*pMatWorld) * m_matView * m_matProj;
m_pEffect->SetMatrix( m_pWVP, &m );
}
else
m_pd3dDevice->SetTransform( D3DTS_WORLD, pMatWorld );
}
void LAMBERT15::CommitChanges()
{
if( m_pEffect )
m_pEffect->CommitChanges();
}
void LAMBERT15::EndPass()
{
if( m_pEffect )
m_pEffect->EndPass();
}
void LAMBERT15::End()
{
if( m_pEffect )
m_pEffect->End();
}
BOOL LAMBERT15::IsOK()
{
if( m_pEffect )
return TRUE;
return FALSE;
}
マスクマップを作成するクラスです。
---LightBloom2.fx---
float4x4 m_WVP; //射影座標系に変換
float4x4 m_WVPT; //テクスチャー座標系に変換
float m_Power; //強さ
sampler tex0 : register(s0); //太陽をレンダリングしたテクスチャー
sampler tex1 : register(s1); //マスクマップ
struct VS_OUTPUT
{
float4 Pos : POSITION;
float2 Tex : TEXCOORD0;
float4 Position : TEXCOORD1; //テクスチャー座標系に変換した頂点座標
};
VS_OUTPUT VS( float4 Pos : POSITION,
float2 Tex : TEXCOORD0 )
{
VS_OUTPUT Out;
Out.Pos = mul( Pos, m_WVP );
Out.Tex = Tex;
//テクスチャー座標系に頂点座標を行列変換
Out.Position = mul( Pos, m_WVPT );
return Out;
}
float4 PS( VS_OUTPUT In ) : COLOR0
{
return tex2D( tex0, In.Tex ) * m_Power * tex2Dproj( tex1, In.Position );
}
technique TShader
{
pass P0
{
VertexShader = compile vs_1_1 VS();
PixelShader = compile ps_2_0 PS();
}
}
モデルのレンダリング時にマスク処理を行うシェーダーです。
---LightBloom.h---
class LIGHTBLOOM2
{
private:
LPD3DXEFFECT m_pEffect;
D3DXHANDLE m_pTechnique, m_pWVP, m_pWVPT, m_pPower;
D3DXMATRIX m_matView, m_matProj;
LPDIRECT3DDEVICE9 m_pd3dDevice;
public:
LIGHTBLOOM2( LPDIRECT3DDEVICE9 pd3dDevice );
~LIGHTBLOOM2();
void Invalidate();
void Restore();
HRESULT Load();
void Begin();
void BeginPass();
void SetPower( float Power );
void SetMatrix( D3DXMATRIX* pMatWorld );
void CommitChanges();
void EndPass();
void End();
BOOL IsOK();
LPD3DXEFFECT GetEffect(){ return m_pEffect; };
};
---LightBloom.cpp---
LIGHTBLOOM2::LIGHTBLOOM2( LPDIRECT3DDEVICE9 pd3dDevice )
{
m_pd3dDevice = pd3dDevice;
m_pEffect = NULL;
}
LIGHTBLOOM2::~LIGHTBLOOM2()
{
//SafeReleaseは関数ではなくマクロ
//#define SafeRelease(x) { if(x) { (x)->Release(); (x)=NULL; } }
SafeRelease( m_pEffect );
}
//デバイスがロストしたときにコールする関数
void LIGHTBLOOM2::Invalidate()
{
if( m_pEffect )
m_pEffect->OnLostDevice();
}
//デバイスがリストアしたときにコールする関数
void LIGHTBLOOM2::Restore()
{
if( m_pEffect )
m_pEffect->OnResetDevice();
}
HRESULT LIGHTBLOOM2::Load()
{
HRESULT hr;
D3DCAPS9 caps;
//ハードウェアがサポートするバーテックスシェーダーとピクセルシェーダーのバージョンをチェックする
m_pd3dDevice->GetDeviceCaps( &caps );
if( caps.VertexShaderVersion >= D3DVS_VERSION( 1, 1 ) && caps.PixelShaderVersion >= D3DPS_VERSION( 2, 0 ) )
{
LPD3DXBUFFER pErr = NULL;
hr = D3DXCreateEffectFromFile( m_pd3dDevice, _T("LightBloom2.fx"), NULL, NULL, 0, NULL, &m_pEffect, &pErr );
if( SUCCEEDED( hr ) )
{
//D3DXHANDLE変数の設定
m_pTechnique = m_pEffect->GetTechniqueByName( "TShader" );
m_pWVP = m_pEffect->GetParameterByName( NULL, "m_WVP" ); //射影座標系へ変換する行列
m_pWVPT = m_pEffect->GetParameterByName( NULL, "m_WVPT" ); //テクスチャー座標系へ変換する行列
m_pPower = m_pEffect->GetParameterByName( NULL, "m_Power" ); //強さ
m_pEffect->SetTechnique( m_pTechnique );
}
else
return -1;
}
else
return -2;
return S_OK;
}
void LIGHTBLOOM2::Begin()
{
if( m_pEffect )
{
m_pd3dDevice->GetTransform( D3DTS_VIEW, &m_matView );
m_pd3dDevice->GetTransform( D3DTS_PROJECTION, &m_matProj );
m_pEffect->Begin( NULL, 0 );
}
}
void LIGHTBLOOM2::BeginPass( UINT Pass )
{
if( m_pEffect )
m_pEffect->BeginPass( Pass );
}
void LIGHTBLOOM2::SetPower( float Power )
{
if( m_pEffect )
{
m_pEffect->SetFloat( m_pPower, Power );
}
}
void LIGHTBLOOM2::SetMatrix( D3DXMATRIX* pMatWorld )
{
if( m_pEffect )
{
D3DXMATRIX m, m1, m2;
D3DXVECTOR4 LightDir;
//射影座標系
m = (*pMatWorld) * m_matView * m_matProj;
m_pEffect->SetMatrix( m_pWVP, &m );
//テクスチャー座標系
D3DXMatrixScaling( &m1, 0.5f, -0.5f, 1.0f );
D3DXMatrixTranslation( &m2, 0.5f, 0.5f, 0.0f );
m = m * m1 * m2;
m_pEffect->SetMatrix( m_pWVPT, &m );
}
else
m_pd3dDevice->SetTransform( D3DTS_WORLD, pMatWorld );
}
void LIGHTBLOOM2::CommitChanges()
{
if( m_pEffect )
m_pEffect->CommitChanges();
}
void LIGHTBLOOM2::EndPass()
{
if( m_pEffect )
m_pEffect->EndPass();
}
void LIGHTBLOOM2::End()
{
if( m_pEffect )
m_pEffect->End();
}
BOOL LIGHTBLOOM2::IsOK()
{
if( m_pEffect )
return TRUE;
return FALSE;
}
マスクします。
---Main.cpp---
LPDIRECT3DDEVICE9 m_pd3dDevice = NULL;
D3DPRESENT_PARAMETERS m_d3dParameters;
D3DCAPS9 Caps;
//シーンのメッシュ
//DirectX SDK(December 2004) に添付されているDXUTMesh.cppファイルにあるヘルパークラス群
CDXUTMesh* m_pMeshBack = NULL; //背景メッシュオブジェクト
CDXUTMesh* m_pMeshLightBloom = NULL; //ライトブルームメッシュオブジェクト。中身はただの矩形
CDXUTMesh* m_pMeshSun = NULL; //太陽メッシュオブジェクト。中身はただの矩形
//D3D2DSQUAREは2Dオブジェクト。詳細は表面化散乱(Subsurface Scattering) を参照
D3D2DSQUARE* m_pSquObj = NULL;
//ランバート拡散照明クラスの宣言
LAMBERT1* m_pLambert1 = NULL;
//マスクマップを作成するクラスの宣言
LAMBERT15* m_pLambert15 = NULL;
//放射状ブラークラス（当サイトの爆発ブラーを参照）の宣言
SHOCKBLUR1* m_pShockBlur1 = NULL;
//ライトブルームクラスの宣言
LIGHTBLOOM2* m_pLightBloom = NULL;
//ブラーフィルタークラス(当サイトのライトブルームその２を参照）の宣言
BLURFILTER3* m_pBlurFilter = NULL;
//マスクマップ
LPDIRECT3DTEXTURE9 m_pMaskTexture = NULL;
LPDIRECT3DSURFACE9 m_pMaskSurface = NULL;
//太陽のレンダリングイメージ
LPDIRECT3DTEXTURE9 m_pSunTexture = NULL;
LPDIRECT3DSURFACE9 m_pSunSurface = NULL;
//浮動小数点フォーマットサーフェイスの色情報をＣＰＵ側で参照するために一時的にコピーするためのサーフェイス
//太陽の表示面積を取得するために使用する
LPDIRECT3DTEXTURE9 m_pCopyTexture = NULL;
LPDIRECT3DSURFACE9 m_pCopySurface = NULL;
//マスクマップに放射状ブラーを適応したイメージ
LPDIRECT3DTEXTURE9 m_pMaskBlurTexture[2];
LPDIRECT3DSURFACE9 m_pMaskBlurSurface[2];
//太陽のレンダリングイメージをブラー処理
LPDIRECT3DTEXTURE9 m_pSunBlurTexture[2];
LPDIRECT3DSURFACE9 m_pSunBlurSurface[2];
UINT nWidth = 1024;
UINT nHeight = 768;
//負荷軽減のためにスクリーンサイズの縦横半分のサイズのサーフェイスを使用する
D3DXVECTOR2 MaskMapSize = D3DXVECTOR2( (float)nWidth * 0.5f, (float)nHeight * 0.5f );
//太陽の位置ベクトル
D3DXVECTOR4 LightPos = D3DXVECTOR4( -50.0f, 150.0f, 700.0f, 0.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_pLambert1 = new LAMBERT1( m_pd3dDevice );
m_pLambert1->Load();
//マスクマップ作成クラスの初期化
m_pLambert15 = new LAMBERT15( m_pd3dDevice );
m_pLambert15->Load();
//放射状ブラークラスの初期化
m_pShockBlur1 = new SHOCKBLUR1( m_pd3dDevice, (UINT)MaskMapSize.x, (UINT)MaskMapSize.y );
m_pShockBlur1->Load();
//ライトブルームクラスの初期化
m_pLightBloom = new LIGHTBLOOM2( m_pd3dDevice );
m_pLightBloom->Load();
//ブラーフィルタークラスの初期化
m_pBlurFilter = new BLURFILTER3( m_pd3dDevice, (UINT)MaskMapSize.x, (UINT)MaskMapSize.y );
m_pBlurFilter->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_pMeshLightBloom = new CDXUTMesh();
m_pMeshLightBloom->Create( m_pd3dDevice, _T("res\\hdr.x") );
m_pMeshLightBloom->SetFVF( m_pd3dDevice, D3DFVF_XYZ | D3DFVF_NORMAL | D3DFVF_TEX1 );
//2Ｄオブジェクトのロード
m_pSquObj = new D3D2DSQUARE( m_pd3dDevice, &m_d3dParameters );
m_pSquObj->Load();
//リストアの必要がないサーフェイスの初期化
//m_pSunSurfaceの内容をコピーするためのサーフェイス
m_pd3dDevice->CreateTexture( (DWORD)MaskMapSize.x,
(DWORD)MaskMapSize.y,
1,
0, //通常のテクスチャー。レンダーターゲットサーフェイスでないためリストア処理は必要ないのでここで初期化する
D3DFMT_R32F, //浮動小数点フォーマットを使用する。
D3DPOOL_SYSTEMMEM, //ロックするためにD3DPOOL_SYSTEMMEMを指定する。
&m_pCopyTexture,
NULL );
m_pCopyTexture->GetSurfaceLevel( 0, &m_pCopySurface );
//平行光源の位置ベクトルから方向ベクトルを計算する
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_pLambert1->Invalidate();
m_pLambert15->Invalidate();
m_pShockBlur1->Invalidate();
m_pLightBloom->Invalidate();
m_pBlurFilter->Invalidate();
SafeRelease( m_pMaskTexture );
SafeRelease( m_pMaskSurface );
SafeRelease( m_pSunTexture );
SafeRelease( m_pSunSurface );
for( int i=0; i<2; i++ )
{
SafeRelease( m_pMaskBlurTexture[i] );
SafeRelease( m_pMaskBlurSurface[i] );
SafeRelease( m_pSunBlurTexture[i] );
SafeRelease( m_pSunBlurSurface[i] );
}
}
//デバイスのリセット後に初期化すべきオブジェクト
void Restore()
{
m_pLambert1->Restore();
m_pLambert15->Restore();
m_pShockBlur1->Restore();
m_pLightBloom->Restore();
m_pBlurFilter->Restore();
D3DXCreateTexture( m_pd3dDevice,
(DWORD)MaskMapSize.x,
(DWORD)MaskMapSize.y,
1,
D3DUSAGE_RENDERTARGET,
D3DFMT_A8R8G8B8,
D3DPOOL_DEFAULT,
&m_pMaskTexture );
m_pMaskTexture->GetSurfaceLevel( 0, &m_pMaskSurface );
D3DSURFACE_DESC pDesc;
m_pCopySurface->GetDesc( &pDesc );
D3DXCreateTexture( m_pd3dDevice,
(DWORD)MaskMapSize.x,
(DWORD)MaskMapSize.y,
1,
D3DUSAGE_RENDERTARGET,
pDesc.Format,
D3DPOOL_DEFAULT,
&m_pSunTexture );
m_pSunTexture->GetSurfaceLevel( 0, &m_pSunSurface );
for( int i=0; i<2; i++ )
{
D3DXCreateTexture( m_pd3dDevice,
(DWORD)MaskMapSize.x,
(DWORD)MaskMapSize.y,
1,
D3DUSAGE_RENDERTARGET,
D3DFMT_A8R8G8B8,
D3DPOOL_DEFAULT,
&m_pMaskBlurTexture[i] );
m_pMaskBlurTexture[i]->GetSurfaceLevel( 0, &m_pMaskBlurSurface[i] );
D3DXCreateTexture( m_pd3dDevice,
(DWORD)MaskMapSize.x,
(DWORD)MaskMapSize.y,
1,
D3DUSAGE_RENDERTARGET,
D3DFMT_A8R8G8B8,
D3DPOOL_DEFAULT,
&m_pSunBlurTexture[i] );
m_pSunBlurTexture[i]->GetSurfaceLevel( 0, &m_pSunBlurSurface[i] );
}
//固定機能パイプラインライティングを設定する
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 matProj, matView, matWorld;
m_pd3dDevice->BeginScene();
//****************************************************************
// (STEP1) 背景を普通にレンダリング
//****************************************************************
//射影座標変換
D3DXMatrixPerspectiveFovLH( &matProj,
D3DX_PI/4.0f,
4.0f / 3.0f,
0.1f,
1000.0f
);
m_pd3dDevice->SetTransform( D3DTS_PROJECTION, &matProj );
//ビュー座標変換
D3DXMatrixIdentity( &matView );
m_pd3dDevice->SetTransform( D3DTS_VIEW, &matView );
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_LINEAR );
m_pd3dDevice->SetSamplerState( 1, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR );
m_pd3dDevice->SetSamplerState( 1, D3DSAMP_MIPFILTER, D3DTEXF_NONE );
//クリア
m_pd3dDevice->Clear( 0L,
NULL,
D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER,
0x0,
1.0f,
0L
);
//空
m_pd3dDevice->SetRenderState( D3DRS_ZWRITEENABLE, FALSE );
m_pLambert1->Begin();
D3DXMatrixIdentity( &matWorld );
m_pLambert1->SetMatrix( &matWorld, &LightDir );
m_pd3dDevice->SetTexture( 0, m_pMeshBack->m_pTextures[1] );
m_pLambert1->SetAmbient( 1.0f );
m_pLambert1->BeginPass();
m_pMeshBack->m_pLocalMesh->DrawSubset( 1 );
m_pLambert1->EndPass();
m_pd3dDevice->SetRenderState( D3DRS_ZWRITEENABLE, TRUE );
//地面
m_pd3dDevice->SetTexture( 0, m_pMeshBack->m_pTextures[0] );
m_pLambert1->SetAmbient( 0.1f );
m_pLambert1->BeginPass();
m_pMeshBack->m_pLocalMesh->DrawSubset( 0 );
m_pLambert1->EndPass();
//やしの樹木
m_pd3dDevice->SetTexture( 0, m_pMeshBack->m_pTextures[3] );
m_pLambert1->SetAmbient( 0.1f );
m_pLambert1->BeginPass();
m_pMeshBack->m_pLocalMesh->DrawSubset( 3 );
m_pLambert1->EndPass();
m_pLambert1->End();
//やしの木の葉(固定機能パイプラインでレンダリング)
D3DXMatrixIdentity( &matWorld );
m_pd3dDevice->SetTransform( D3DTS_WORLD, &matWorld );
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_INVSRCALPHA );
m_pd3dDevice->SetRenderState( D3DRS_ZWRITEENABLE, FALSE );
m_pd3dDevice->SetRenderState( D3DRS_CULLMODE, D3DCULL_NONE );
m_pd3dDevice->SetTexture( 0, m_pMeshBack->m_pTextures[2] );
m_pMeshBack->m_pLocalMesh->DrawSubset( 2 );
m_pd3dDevice->SetRenderState( D3DRS_ZWRITEENABLE, TRUE );
m_pd3dDevice->SetRenderState( D3DRS_ALPHABLENDENABLE, FALSE );
m_pd3dDevice->SetRenderState( D3DRS_CULLMODE, D3DCULL_CCW );
//****************************************************************
// (STEP2) マスクマップをレンダリング
//****************************************************************
//縮小サーフェイスを使用するのでビューポートのレンダリング領域を変更する
D3DVIEWPORT9 OldViewport, NewViewport;
m_pd3dDevice->GetViewport( &OldViewport );
CopyMemory( &NewViewport, &OldViewport, sizeof( D3DVIEWPORT9 ) );
NewViewport.Width = (DWORD)MaskMapSize.x;
NewViewport.Height = (DWORD)MaskMapSize.y;
m_pd3dDevice->SetViewport( &NewViewport );
//バックバッファを退避
LPDIRECT3DSURFACE9 OldSurface = NULL;
m_pd3dDevice->GetRenderTarget( 0, &OldSurface );
//レンダーターゲットサーフェイスを切り替える
m_pd3dDevice->SetRenderTarget( 0, m_pMaskSurface );
//乗算合成
m_pd3dDevice->SetRenderState( D3DRS_BLENDOP, D3DBLENDOP_ADD );
m_pd3dDevice->SetRenderState( D3DRS_SRCBLEND, D3DBLEND_ZERO );
m_pd3dDevice->SetRenderState( D3DRS_DESTBLEND, D3DBLEND_SRCCOLOR );
//αブレンドを有効にする
m_pd3dDevice->SetRenderState( D3DRS_ALPHABLENDENABLE, TRUE );
//シェーダー内でオブジェクトの色を黒で出力し、乗算合成するので真っ白にクリアする
m_pd3dDevice->Clear( 0L,
NULL,
D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER,
0xffffffff,
1.0f,
0L
);
//空の部分は白いままにするので空はレンダリングしない
//地面はレンダリングする
m_pLambert15->Begin();
m_pLambert15->SetMatrix( &matWorld );
//地面などの不透明オブジェクトはパス0を使用する
m_pLambert15->BeginPass(0);
m_pMeshBack->m_pLocalMesh->DrawSubset( 0 );
m_pLambert15->EndPass();
//やしの樹木もレンダリングする
m_pLambert15->BeginPass(0);
m_pMeshBack->m_pLocalMesh->DrawSubset( 3 );
m_pLambert15->EndPass();
//やしの葉もレンダリングする
m_pd3dDevice->SetTexture( 0, m_pMeshBack->m_pTextures[2] );
//やしの葉などの半透明オブジェクトはパス1を使用する
m_pLambert15->BeginPass(1);
m_pMeshBack->m_pLocalMesh->DrawSubset( 2 );
m_pLambert15->EndPass();
m_pLambert15->End();
//αブレンドを無効にする
m_pd3dDevice->SetRenderState( D3DRS_ALPHABLENDENABLE, FALSE );
//****************************************************************
// (STEP3) 太陽をレンダリング
//****************************************************************
//ここから２ＤスプライトオブジェクトによるレンダリングのみとなるのでZバッファを無効にする
m_pd3dDevice->SetRenderState( D3DRS_ZENABLE, D3DZB_FALSE );
m_pd3dDevice->SetRenderTarget( 0, m_pSunSurface );
//クリアもカラーのみとしZバッファはクリアしない
m_pd3dDevice->Clear( 0L,
NULL,
D3DCLEAR_TARGET,
0x0,
1.0f,
0L
);
//太陽オブジェクトのビルボードマトリックスを取得する（注意１）
D3DXMatrixTranslation( &matWorld, LightPos.x, LightPos.y, LightPos.z );
D3DXMATRIX matBillBoard;
matBillBoard = GetBillBoardMatrix( m_pd3dDevice, &matWorld );
m_pd3dDevice->SetTexture( 0, m_pMeshSun->m_pTextures[0] );
m_pd3dDevice->SetTexture( 1, m_pMaskTexture );
m_pLightBloom->SetPower( 5.0f );
m_pLightBloom->SetMatrix( &matBillBoard );
m_pLightBloom->Begin();
m_pLightBloom->BeginPass();
m_pMeshSun->m_pLocalMesh->DrawSubset( 0 );
m_pLightBloom->EndPass();
m_pLightBloom->End();
m_pd3dDevice->SetTexture( 1, NULL );
//太陽の表示面積を取得
//これは後で処理するライトブルームの強さの調整に使用する
//レンダーターゲットサーフェイスを直接ロックできないのでロックできるサーフェイスにいったんコピーする
m_pd3dDevice->GetRenderTargetData( m_pSunSurface, m_pCopySurface );
D3DLOCKED_RECT rc;
//参照するためにロックする
m_pCopyTexture->LockRect( 0, &rc, NULL, 0 );
//色情報のポインタを取得
LPDWORD pTextureBits = (LPDWORD)rc.pBits;
DWORD Color = 0;
//サーフェイスに書き込まれた色情報をすべて加算する
for( UINT y=0; y<MaskMapSize.y; y++ )
{
for( UINT x=0; x<MaskMapSize.x; x++ )
{
//赤成分のみ持つ浮動小数点フォーマットのサーフェイスから色情報が黒以外であるか
// if( ((*pTextureBits)>>16)&0x000000FF )
//真っ黒以外のときカウントする
if( (*pTextureBits) )
Color++;
//次のピクセル位置へポインタを移動
pTextureBits++;
}
}
//アンロックする
m_pCopyTexture->UnlockRect( 0 );
//****************************************************************
// (STEP4) 太陽をブラー
//****************************************************************
//ブラー処理を行うため、CLAMPに切り替える
m_pd3dDevice->SetSamplerState( 0, D3DSAMP_ADDRESSU, D3DTADDRESS_CLAMP );
m_pd3dDevice->SetSamplerState( 0, D3DSAMP_ADDRESSV, D3DTADDRESS_CLAMP );
m_pd3dDevice->SetSamplerState( 0, D3DSAMP_MINFILTER, D3DTEXF_POINT );
m_pd3dDevice->SetSamplerState( 0, D3DSAMP_MAGFILTER, D3DTEXF_POINT );
m_pd3dDevice->SetSamplerState( 0, D3DSAMP_MIPFILTER, D3DTEXF_NONE );
m_pd3dDevice->SetTexture( 0, m_pSunTexture );
for( BYTE i=0; i<2; i++ )
{
m_pd3dDevice->SetRenderTarget( 0, m_pSunBlurSurface[i % 2] );
m_pBlurFilter->Render( i % 2 );
m_pd3dDevice->SetTexture( 0, m_pSunBlurTexture[i % 2] );
}
//****************************************************************
// (STEP5) マスクマップを放射状にブラー
//****************************************************************
//ボケの強さを設定する。0.0f でボケなし。
m_pShockBlur1->SetBlurPower( 30.0f );
//太陽のワールド座標系上での位置からテクスチャー座標系上でのテクセル位置に変換し取得する（注意２）
D3DXVECTOR2 TexelPosition;
TexelPosition = GetTexelPosition( (D3DXVECTOR3*)&LightPos );
m_pShockBlur1->SetCenterTexel( TexelPosition.x, TexelPosition.y );
m_pd3dDevice->SetTexture( 0, m_pMaskTexture );
//適当に繰り返してブラー処理する
int BlurCnt = 3;
for( BYTE i=0; i<BlurCnt; i++ )
{
m_pd3dDevice->SetRenderTarget( 0, m_pMaskBlurSurface[i % 2] );
m_pShockBlur1->Render();
m_pd3dDevice->SetTexture( 0, m_pMaskBlurTexture[i % 2] );
}
//レンダーターゲットサーフェイスをバックバッファに戻す
m_pd3dDevice->SetRenderTarget( 0, OldSurface );
SafeRelease( OldSurface );
m_pd3dDevice->SetSamplerState( 0, D3DSAMP_ADDRESSU, D3DTADDRESS_WRAP );
m_pd3dDevice->SetSamplerState( 0, D3DSAMP_ADDRESSV, D3DTADDRESS_WRAP );
//ビューポートも戻す
m_pd3dDevice->SetViewport( &OldViewport );
//****************************************************************
// (STEP6) 放射ブラーとライトブルームを積算したイメージを加算合成
//****************************************************************
//加算合成
m_pd3dDevice->SetRenderState( D3DRS_BLENDOP, D3DBLENDOP_ADD );
m_pd3dDevice->SetRenderState( D3DRS_SRCBLEND, D3DBLEND_SRCALPHA );
m_pd3dDevice->SetRenderState( D3DRS_DESTBLEND, D3DBLEND_ONE );
//αブレンドを有効にする
m_pd3dDevice->SetRenderState( D3DRS_ALPHABLENDENABLE, TRUE );
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_LINEAR );
m_pd3dDevice->SetSamplerState( 1, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR );
m_pd3dDevice->SetSamplerState( 1, D3DSAMP_MIPFILTER, D3DTEXF_NONE );
m_pd3dDevice->SetTexture( 0, m_pMeshLightBloom->m_pTextures[0] );
m_pd3dDevice->SetTexture( 1, m_pMaskBlurTexture[(BlurCnt+1)%2] );
m_pLightBloom->SetMatrix( &matBillBoard );
//太陽の表示面積によってライトブルームの強さを調整する
//マジックナンバー 12500.0f は、遮蔽物なしで太陽をレンダリングしたときのColor変数の値
//当たり前だがアプリケーションごとに調整すること
m_pLightBloom->SetPower( (float)Color / 12500.0f );
m_pLightBloom->Begin();
m_pLightBloom->BeginPass();
m_pMeshLightBloom->m_pLocalMesh->DrawSubset( 0 );
m_pLightBloom->EndPass();
m_pLightBloom->End();
m_pd3dDevice->SetTexture( 1, NULL );
//****************************************************************
// (STEP7) ブラー処理した太陽を加算合成
//****************************************************************
m_pd3dDevice->SetTexture( 0, m_pSunBlurTexture[1] );
m_pSquObj->Render();
//Zバッファを有効にする
m_pd3dDevice->SetRenderState( D3DRS_ZENABLE, D3DZB_TRUE );
//αブレンドを無効にする
m_pd3dDevice->SetRenderState( D3DRS_ALPHABLENDENABLE, FALSE );
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;
}
以上です。
（注意１） GetBillBoardMatrix()関数は当サイトのビルボードを参照してください。
（注意２） GetTexelPosition()関数は当サイトの爆発ブラーを参照してください。
７ステップは長いな。最適化考慮してないけど、もう少し短くできるかも。