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 |
| 関連ページ：ブラーフィルターその１ 視差マッピング 波シェーダー |
|
今回は、ひさびさに水関係をやります。かなり大変です。長いです。面倒です。しかも最適化を考慮してなかったりします。まあそれでも見たい方はどうぞ。
まずはタイトルにあるフレネル効果について簡単に説明します。フレネル効果は、水やガラスなどの透明な物体において観測者が見る角度によって光の反射率や透明度が変わる現象です。
この場合、視線ベクトルと水の法線ベクトルの角度が大きいので、水面で反射するイメージが強く反映されます。
この場合、視線ベクトルと水の法線ベクトルの角度が小さいので、水底がよく見えるようになります。
フレネル効果がわかったところでサンプルイメージです。
フレネル効果のサンプルです。視線ベクトルと水面の法線ベクトルの角度が大きいため、トラの水面下の足とかがほとんど見えなくなっています。
また反射イメージが水面に発生する波によりゆがんでいるのもわかります。
フレネル効果のサンプルです。視線ベクトルと水面の法線ベクトルの角度が小さいため、トラの水面下の足とかがよくみえます。
他にも視線方向への水の厚みによって透明度を調整してます。このため水面と地面との境界が滑らかになっています。
処理フローは次のようになります。
１．波マップの作成します。波マップの作成は波シェーダーを参照してください。
２．反射イメージをレンダリングします。反射イメージは水面の高さがすべて同じであることを条件とし、
水面の高さを基準にオブジェクトを Y 方向にオブジェクトを逆転させてレンダリングすることにより作成します。
したがって水面の高さが変わる川などでは使用できないので注意してください。
３．２で作成した反射イメージをぼかします。
４．シーンをレンダーターゲットサーフェイスにレンダリングします。シーンのＺ値を後で使用するので
レンダーターゲットサーフェイスのα成分にＺ値を出力しておきます。
５．水面のマスクマップをレンダリングします。Ｚバッファは４で作成したものをそのまま使用するため初期化しないようにします。
マスクマップは、反射イメージや水底イメージが水面の波によりゆがませる処理を行いとき
正しく処理できるようにするためのマスクマップです。これを考慮してない場合下のイメージのようになります。
６．４をバックバッファにコピーします。
７．１と３と４と５をもとにフレネル効果とか屈折とか透明度とかいろいろ考慮して合成します。
ここでもＺバッファは４で作成したものをそのまま使用するため初期化しないようにします。
マスクを使用しないためにエラーが発生しています。赤丸のところです。わかりにくいかもしれませんが、
水面下のゆがみにより参照するテクセル位置がトラの顔の部分となっているため水面の色にトラの顔の色があふれています。
ではソースをみていきます。
---Reflect.fx---
float4x4 m_WVPP; //ワールド行列 × ビュー × 遠近射影行列
float4x4 m_W; //ワールド行列のみ
float4 m_LightDir;
float4 m_Ambient = 0.0f;
float m_Height;
//オブジェクトのテクスチャー
sampler tex0 : register(s0);
struct VS_OUTPUT
{
float4 Pos : POSITION;
float4 Col : COLOR0;
float2 Tex : TEXCOORD0;
float4 WPos : TEXCOORD1;
};
VS_OUTPUT VS( float4 Pos : POSITION,
float4 Normal : NORMAL,
float2 Tex : TEXCOORD0 )
{
VS_OUTPUT Out;
Out.Pos = mul( Pos, m_WVPP );
Out.Tex = Tex;
float3 L = -m_LightDir.xyz;
float3 N = normalize( Normal.xyz );
Out.Col = max( m_Ambient, dot(N, L) );
Out.WPos = mul( Pos, m_W );
return Out;
}
float4 PS( VS_OUTPUT In ) : COLOR0
{
float4 Out;
//反射イメージのワールド座標形状での頂点の Y 座標がm_Height変数より高いとき描画しないようにする
//これにより水面下のイメージのみレンダリングする
clip( m_Height - In.WPos.y );
//色情報をRGBに格納する
Out.rgb = tex2D( tex0, In.Tex ).rgb * In.Col.rgb;
Out.a = 0.0f;
return Out;
}
technique TShader
{
pass P0
{
VertexShader = compile vs_1_1 VS();
PixelShader = compile ps_2_0 PS();
}
}
---Reflect.h---
class REFLECT
{
private:
LPD3DXEFFECT m_pEffect;
D3DXHANDLE m_pTechnique, m_pW, m_pWVPP, m_pLightDir, m_pAmbient, m_pHeight;
D3DXMATRIX m_matView, m_matProj;
LPDIRECT3DDEVICE9 m_pd3dDevice;
public:
REFLECT( PDIRECT3DDEVICE9 pd3dDevice );
~REFLECT();
HRESULT Load();
void Invalidate();
void Restore();
void Begin();
void BeginPass();
void SetHeight( float Height );
void SetAmbient( float Ambient );
void SetAmbient( D3DXVECTOR4* pAmbient );
void SetMatrix( D3DXMATRIX* pMatWorld, D3DXVECTOR4* pLightDir );
void EndPass();
void End();
void CommitChanges();
BOOL IsOK();
LPD3DXEFFECT GetEffect(){ return m_pEffect; };
};
---Reflect.cpp---
REFLECT::REFLECT( LPDIRECT3DDEVICE9 pd3dDevice )
{
m_pd3dDevice = pd3dDevice;
m_pEffect = NULL;
}
REFLECT::~REFLECT()
{
SafeRelease( m_pEffect );
}
void REFLECT::Invalidate()
{
if( m_pEffect )
m_pEffect->OnLostDevice();
}
void REFLECT::Restore()
{
if( m_pEffect )
m_pEffect->OnResetDevice();
}
HRESULT REFLECT::Load()
{
D3DCAPS9 caps;
HRESULT hr;
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("Reflect.fx"), NULL, NULL, 0, NULL, &m_pEffect, &pErr );
if( FAILED( hr ) )
return -2;
m_pTechnique = m_pEffect->GetTechniqueByName( "TShader" );
m_pW = m_pEffect->GetParameterByName( NULL, "m_W" );
m_pWVPP = m_pEffect->GetParameterByName( NULL, "m_WVPP" );
m_pLightDir = m_pEffect->GetParameterByName( NULL, "m_LightDir" );
m_pAmbient = m_pEffect->GetParameterByName( NULL, "m_Ambient" );
m_pHeight = m_pEffect->GetParameterByName( NULL, "m_Height" );
m_pEffect->SetTechnique( m_pTechnique );
}
else
{
return -3;
}
return S_OK;
}
void REFLECT::Begin()
{
if( m_pEffect )
{
m_pd3dDevice->GetTransform( D3DTS_VIEW, &m_matView );
m_pd3dDevice->GetTransform( D3DTS_PROJECTION, &m_matProj );
m_pEffect->Begin( NULL, 0 );
}
}
void REFLECT::BeginPass()
{
if( m_pEffect )
m_pEffect->BeginPass( 0 );
}
//水面の高さを設定
void REFLECT::SetHeight( float Height )
{
if( m_pEffect )
m_pEffect->SetFloat( m_pHeight, Height );
}
void REFLECT::SetAmbient( float Ambient )
{
if( m_pEffect )
{
D3DXVECTOR4 A;
A = D3DXVECTOR4( Ambient, Ambient, Ambient, 1.0f );
m_pEffect->SetVector( m_pAmbient, &A );
}
else
{
D3DMATERIAL9 old_material;
m_pd3dDevice->GetMaterial( &old_material );
old_material.Ambient.r = Ambient;
old_material.Ambient.g = Ambient;
old_material.Ambient.b = Ambient;
old_material.Ambient.a = 1.0f;
m_pd3dDevice->SetMaterial( &old_material );
}
}
void REFLECT::SetAmbient( D3DXVECTOR4* pAmbient )
{
if( m_pEffect )
m_pEffect->SetVector( m_pAmbient, pAmbient );
else
{
D3DMATERIAL9 old_material;
m_pd3dDevice->GetMaterial( &old_material );
old_material.Ambient.r = pAmbient->x;
old_material.Ambient.g = pAmbient->y;
old_material.Ambient.b = pAmbient->z;
old_material.Ambient.a = pAmbient->w;
m_pd3dDevice->SetMaterial( &old_material );
}
}
void REFLECT::SetMatrix( D3DXMATRIX* pMatWorld, D3DXVECTOR4* pLightDir )
{
if( m_pEffect )
{
D3DXMATRIX m;
D3DXVECTOR4 v;
m_pEffect->SetMatrix( m_pW, pMatWorld );
m = (*pMatWorld) * m_matView * m_matProj;
m_pEffect->SetMatrix( m_pWVPP, &m );
//Light
D3DXMatrixInverse( &m, NULL, pMatWorld );
D3DXVec4Transform( &v, pLightDir, &m );
D3DXVec4Normalize( &v, &v );
m_pEffect->SetVector( m_pLightDir, &v );
}
else
m_pd3dDevice->SetTransform( D3DTS_WORLD, pMatWorld );
}
void REFLECT::EndPass()
{
if( m_pEffect )
{
m_pEffect->EndPass();
}
}
void REFLECT::End()
{
if( m_pEffect )
{
m_pEffect->End();
}
}
void REFLECT::CommitChanges()
{
if( m_pEffect )
m_pEffect->CommitChanges();
}
BOOL REFLECT::IsOK()
{
if( m_pEffect )
return TRUE;
return FALSE;
}
反射マップを作成するシェーダークラスです。先に説明したとおり水面の高さはすべての面で同じです。この高さより高い位置にある 頂点は描画しないという、ただそれだけのシェーダーです。
次に反射マップをぼかします。これには既出のBLURFILTER1クラスを使用しますが、今回D3D2DSQUARE使用版に修正しました。 申し訳ないけど、修正してください。BLURFILTER2クラスでなくボケ率の低いBLURFILTER1を使用したのは、 縮小サーフェイスを使用すれば十分ボケるし、最終的にゆがませるから精度が低くても目立たないため 負荷の小さい方を使用することにしたからです。
---Lambert18.fx---
float4x4 m_WVPP; //ワールド行列 × ビュー × 遠近射影行列
float4 m_LightDir; //平行光源の方向ベクトル
float4 m_Ambient = 0.0f; //環境光
bool m_ZEnable; //true:Ｚ値をα成分に出力する false:1.0fをα成分に出力する
float m_ZF; //遠近射影行列の最遠近距離
//オブジェクトのテクスチャー
sampler tex0 : register(s0);
struct VS_OUTPUT
{
float4 Pos : POSITION;
float4 Col : COLOR0;
float2 Tex : TEXCOORD0;
float4 PosWVP : TEXCOORD1;
};
VS_OUTPUT VS( float4 Pos : POSITION,
float4 Normal : NORMAL,
float2 Tex : TEXCOORD0 )
{
VS_OUTPUT Out;
Out.Pos = mul( Pos, m_WVPP );
Out.Tex = Tex;
float3 L = -m_LightDir.xyz;
float3 N = normalize( Normal.xyz );
Out.Col = max( m_Ambient, dot(N, L) );
Out.PosWVP = Out.Pos;
return Out;
}
float4 PS( VS_OUTPUT In ) : COLOR0
{
float4 Out;
//色情報をRGBに格納する
Out = tex2D( tex0, In.Tex );
Out.rgb *= In.Col.rgb;
//Z値を格納する
if( m_ZEnable )
Out.a = In.PosWVP.z / m_ZF;
else
Out.a = 1.0f;
return Out;
}
technique TShader
{
pass P0
{
VertexShader = compile vs_1_1 VS();
PixelShader = compile ps_2_0 PS();
}
}
Z値の出力方法についてはメモ書きを参照してください。
---Lambert.h---
class LAMBERT18
{
private:
LPD3DXEFFECT m_pEffect;
D3DXHANDLE m_pTechnique, m_pWVPP, m_pLightDir, m_pAmbient, m_pZEnable, m_pZF;
D3DXMATRIX m_matView, m_matProj;
LPDIRECT3DDEVICE9 m_pd3dDevice;
public:
LAMBERT18( LPDIRECT3DDEVICE9 pd3dDevice );
~LAMBERT18();
void Invalidate();
void Restore();
HRESULT Load();
void Begin();
void BeginPass( UINT Pass );
void SetZEnable( bool ZEnable );
void SetAmbient( float Ambient );
void SetAmbient( D3DXVECTOR4* pAmbient );
void SetMatrix( D3DXMATRIX* pMatWorld, D3DXVECTOR4* pLightDir, float pZF );
void CommitChanges();
void EndPass();
void End();
BOOL IsOK();
LPD3DXEFFECT GetEffect(){ return m_pEffect; };
};
---Lambert.cpp---
LAMBERT18::LAMBERT18( LPDIRECT3DDEVICE9 pd3dDevice )
{
m_pd3dDevice = pd3dDevice;
m_pEffect = NULL;
}
LAMBERT18::~LAMBERT18()
{
SafeRelease( m_pEffect );
}
void LAMBERT18::Invalidate()
{
if( m_pEffect )
m_pEffect->OnLostDevice();
}
void LAMBERT18::Restore()
{
if( m_pEffect )
m_pEffect->OnResetDevice();
}
HRESULT LAMBERT18::Load()
{
D3DCAPS9 caps;
m_pd3dDevice->GetDeviceCaps( &caps );
if( caps.VertexShaderVersion >= D3DVS_VERSION( 1, 1 ) && caps.PixelShaderVersion >= D3DPS_VERSION( 2, 0 ) )
{
LPD3DXBUFFER pErr = NULL;
HRESULT hr = D3DXCreateEffectFromFile( m_pd3dDevice, _T("Lambert18.fx"), NULL, NULL, 0, NULL, &m_pEffect, &pErr );
if( FAILED( hr ) )
return -2;
m_pTechnique = m_pEffect->GetTechniqueByName( "TShader" );
m_pWVPP = m_pEffect->GetParameterByName( NULL, "m_WVPP" );
m_pLightDir = m_pEffect->GetParameterByName( NULL, "m_LightDir" );
m_pAmbient = m_pEffect->GetParameterByName( NULL, "m_Ambient" );
m_pZEnable = m_pEffect->GetParameterByName( NULL, "m_ZEnable" );
m_pZF = m_pEffect->GetParameterByName( NULL, "m_ZF" );
m_pEffect->SetTechnique( m_pTechnique );
}
else
{
return -3;
}
return S_OK;
}
void LAMBERT18::SetZEnable( bool ZEnable )
{
if( m_pEffect )
{
m_pEffect->SetBool( m_pZEnable, ZEnable );
}
}
void LAMBERT18::SetAmbient( float Ambient )
{
if( m_pEffect )
{
D3DXVECTOR4 A;
A = D3DXVECTOR4( Ambient, Ambient, Ambient, 1.0f );
m_pEffect->SetVector( m_pAmbient, &A );
}
else
{
D3DMATERIAL9 old_material;
m_pd3dDevice->GetMaterial( &old_material );
old_material.Ambient.r = Ambient;
old_material.Ambient.g = Ambient;
old_material.Ambient.b = Ambient;
old_material.Ambient.a = 1.0f;
m_pd3dDevice->SetMaterial( &old_material );
}
}
void LAMBERT18::SetAmbient( D3DXVECTOR4* pAmbient )
{
if( m_pEffect )
m_pEffect->SetVector( m_pAmbient, pAmbient );
else
{
D3DMATERIAL9 old_material;
m_pd3dDevice->GetMaterial( &old_material );
old_material.Ambient.r = pAmbient->x;
old_material.Ambient.g = pAmbient->y;
old_material.Ambient.b = pAmbient->z;
old_material.Ambient.a = pAmbient->w;
m_pd3dDevice->SetMaterial( &old_material );
}
}
//ローカル座標系
void LAMBERT18::SetMatrix( D3DXMATRIX* pMatWorld, D3DXVECTOR4* pLightDir, float pZF )
{
if( m_pEffect )
{
D3DXMATRIX m;
D3DXVECTOR4 v;
m = (*pMatWorld) * m_matView * m_matProj;
m_pEffect->SetMatrix( m_pWVPP, &m );
//Light
D3DXMatrixInverse( &m, NULL, pMatWorld );
D3DXVec4Transform( &v, pLightDir, &m );
D3DXVec4Normalize( &v, &v );
m_pEffect->SetVector( m_pLightDir, &v );
//遠近射影行列の最遠近距離
m_pEffect->SetFloat( m_pZF, pZF );
}
else
m_pd3dDevice->SetTransform( D3DTS_WORLD, pMatWorld );
}
void LAMBERT18::Begin()
{
if( m_pEffect )
{
m_pd3dDevice->GetTransform( D3DTS_VIEW, &m_matView );
m_pd3dDevice->GetTransform( D3DTS_PROJECTION, &m_matProj );
m_pEffect->Begin( NULL, 0 );
}
}
void LAMBERT18::BeginPass( UINT Pass )
{
if( m_pEffect )
{
m_pEffect->BeginPass( Pass );
}
}
void LAMBERT18::CommitChanges()
{
if( m_pEffect )
m_pEffect->CommitChanges();
}
void LAMBERT18::EndPass()
{
if( m_pEffect )
{
m_pEffect->EndPass();
}
}
void LAMBERT18::End()
{
if( m_pEffect )
{
m_pEffect->End();
}
}
BOOL LAMBERT18::IsOK()
{
if( m_pEffect )
return TRUE;
return FALSE;
}
シーンをレンダリングします。このときシーンのＺ値をレンダーターゲットサーフェイスのα成分に出力します。 SetZEnable()関数でα成分にオブジェクトのＺ値を出力するかの制御を行います。通常trueに設定しますが、 空とか太陽のようにＺ値を考慮する必要がない場合、falseに設定し、サーフェイスのα成分を一番奥のＺ値で更新します。
---Mask.fx---
float4x4 m_WVP;
struct VS_OUTPUT
{
float4 Pos : POSITION;
};
VS_OUTPUT VS( float3 Pos : POSITION,
float3 Tangent : TANGENT0,
float3 Binormal : BINORMAL0,
float3 Normal : NORMAL,
float2 Tex : TEXCOORD0 )
{
VS_OUTPUT Out;
Out.Pos = mul( float4( Pos, 1.0f ), m_WVP );
return Out;
}
float4 PS( VS_OUTPUT In ) : COLOR0
{
return 1.0f;
}
technique TShader
{
pass P0
{
VertexShader = compile vs_1_1 VS();
PixelShader = compile ps_1_1 PS();
}
}
---Lambert.h---
class MASK_MAP
{
private:
LPD3DXEFFECT m_pEffect;
D3DXHANDLE m_pTechnique, m_pWVP;
D3DXMATRIX m_matView, m_matProj;
LPDIRECT3DDEVICE9 m_pd3dDevice;
public:
MASK_MAP( LPDIRECT3DDEVICE9 pd3dDevice );
~MASK_MAP();
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---
MASK_MAP::MASK_MAP( LPDIRECT3DDEVICE9 pd3dDevice )
{
m_pd3dDevice = pd3dDevice;
m_pEffect = NULL;
}
MASK_MAP::~MASK_MAP()
{
SafeRelease( m_pEffect );
}
void MASK_MAP::Invalidate()
{
if( m_pEffect )
m_pEffect->OnLostDevice();
}
void MASK_MAP::Restore()
{
if( m_pEffect )
m_pEffect->OnResetDevice();
}
HRESULT MASK_MAP::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("Mask.fx"), NULL, NULL, 0, NULL, &m_pEffect, &pErr );
if( FAILED( hr ) )
return -2;
m_pTechnique = m_pEffect->GetTechniqueByName( "TShader" );
m_pWVP = m_pEffect->GetParameterByName( NULL, "m_WVP" );
m_pEffect->SetTechnique( m_pTechnique );
}
else
{
return -3;
}
return S_OK;
}
//ローカル座標系
void MASK_MAP::SetMatrix( D3DXMATRIX* pMatWorld )
{
if( m_pEffect )
{
D3DXMATRIX m;
m = (*pMatWorld) * m_matView * m_matProj;
m_pEffect->SetMatrix( m_pWVP, &m );
}
}
void MASK_MAP::Begin()
{
if( m_pEffect )
{
m_pd3dDevice->GetTransform( D3DTS_VIEW, &m_matView );
m_pd3dDevice->GetTransform( D3DTS_PROJECTION, &m_matProj );
m_pEffect->Begin( NULL, 0 );
}
}
void MASK_MAP::BeginPass( UINT Pass )
{
if( m_pEffect )
{
m_pEffect->BeginPass( Pass );
}
}
void MASK_MAP::CommitChanges()
{
if( m_pEffect )
m_pEffect->CommitChanges();
}
void MASK_MAP::EndPass()
{
if( m_pEffect )
{
m_pEffect->EndPass();
}
}
void MASK_MAP::End()
{
if( m_pEffect )
{
m_pEffect->End();
}
}
BOOL MASK_MAP::IsOK()
{
if( m_pEffect )
return TRUE;
return FALSE;
}
0.0で初期化されたレンダーターゲットサーフェイスに 1.0f で出力するだけのどうってことないシェーダーです。
次にシーンのレンダリングイメージのコピーだが。つーかマルチレンダーターゲット使用すればこれいらなかったりして。まあいいや。次。
---ParallaxMapping2.fx---
float4x4 m_WVPP;
float4x4 m_WVPPT;
float4 m_LightDir;
float4 m_EyePos;
float4 m_Ambient = 1.0f;
float m_Specular = 0.0f;
float m_SpecularPower = 0.0f;
float m_Height = 0.16f; //高さの最大値。大きくするほど高くなる。
float m_Refraction = 40.0f; //屈折率
float m_ZF; //遠近射影行列の遠近距離
sampler tex0 : register(s0); //水面のテクスチャー
sampler tex1 : register(s1); //法線マップ(アルファ成分に高さ情報を格納)
sampler tex2 : register(s2); //シーンのレンダリングイメージテクスチャー
sampler tex3 : register(s3); //反射マップテクスチャー
sampler tex4 : register(s4); //水面のマスクマップテクスチャー
struct VS_OUTPUT
{
float4 Pos : POSITION;
float2 Tex : TEXCOORD0;
float3 Eye : TEXCOORD1;
float3 Light : TEXCOORD2;
float3 RocalPos : TEXCOORD3;
float4 PosWVP : TEXCOORD4;
float4 WVPPTPos : TEXCOORD5;
float3 Normal : TEXCOORD6;
};
VS_OUTPUT VS( float3 Pos : POSITION,
float3 Tangent : TANGENT0,
float3 Binormal : BINORMAL0,
float3 Normal : NORMAL,
float2 Tex : TEXCOORD0 )
{
VS_OUTPUT Out;
Out.Pos = mul( float4( Pos, 1.0f ), m_WVPP );
Out.Tex = Tex;
//視線ベクトルを計算
float3 Eye = normalize( m_EyePos.xyz - Pos.xyz );
//視線ベクトルを頂点座標系に変換する
Out.Eye.x = dot( Eye, Tangent );
Out.Eye.y = dot( Eye, Binormal );
Out.Eye.z = dot( Eye, Normal );
Out.Eye = normalize( Out.Eye );
//オブジェクトの頂点座標 -> ライトの位置ベクトル に変換する
float3 Light = -m_LightDir.xyz;
//ライトベクトルを頂点座標系に変換する
Out.Light.x = dot( Light, Tangent );
Out.Light.y = dot( Light, Binormal );
Out.Light.z = dot( Light, Normal );
Out.Light = normalize( Out.Light );
//ローカル座標系上での頂点の座標
Out.RocalPos = Pos;
//ワールド座標系の頂点の座標
Out.PosWVP = Out.Pos;
//スクリーン座標形状での頂点の座標
Out.WVPPTPos = mul( float4( Pos, 1.0f ), m_WVPPT );
//法線ベクトル
Out.Normal = Normal;
return Out;
}
float4 PS( VS_OUTPUT In ) : COLOR
{
//*********************************************************************************************************
//視差マッピング
//*********************************************************************************************************
//高さマップを参照し、高さを取得する
float h = tex2D( tex1, In.Tex ).a;
//テクセルを頂点座標系での視線ベクトル方向に重みをつけてずらす。
float2 Tex = In.Tex + m_Height * h * In.Eye.xy;
//法線マップを参照し、法線を取得する
//法線マップは -1.0f 〜 1.0f の値を 0.0f 〜 1.0f の範囲に保存してあるので変換する
float3 Normal = 2.0f * tex2D( tex1, Tex ).xyz - 1.0f;
//フォンシェーディングによるスペキュラーの色を計算する
//頂点 -> ライト位置ベクトル + 頂点 -> 視点ベクトル
float3 H = normalize( In.Light + In.Eye );
//スペキュラーカラーを計算する
float S = pow( max( 0.0f, dot( Normal, H ) ), m_Specular ) * m_SpecularPower;
//拡散反射率
float4 Diffuse = max( m_Ambient, dot( Normal, In.Light ) );
//水面が暗いので調整
float p = 0.5f;
Diffuse = Diffuse * p + ( 1.0f - p );
//水面のマテリアル
float3 WaterCol = tex2D( tex0, Tex ).rgb;
//海底のＺ値
float SeabedZ = tex2Dproj( tex2, In.WVPPTPos ).a;
//水の厚みを計算する
float Z = SeabedZ - In.PosWVP.z / m_ZF;
//*********************************************************************************************************
//屈折
//*********************************************************************************************************
//ゆがみ量の計算
//水の厚みが薄くなるほど屈折しないようにする
float4 Offset = float4( ( Normal - In.Eye ).xy * Z * m_Refraction, 0.0f, 0.0f );
//海底の色
float3 SeabedCol;
//反射マップの色
float3 ReflectCol;
//水面のマスクマップを参照
float Mask = tex2Dproj( tex4, In.WVPPTPos + Offset ).r;
//マスクマップを参照したら水の部分だったのでゆがませる
if( Mask == 1 )
{
//海底の色
SeabedCol = tex2Dproj( tex2, In.WVPPTPos + Offset ).rgb;
//反射マップの色
ReflectCol = tex2Dproj( tex3, In.WVPPTPos + Offset ).rgb;
}
//マスクマップを参照したら水の部分でなかったのでゆがませない
else
{
//海底の色
SeabedCol = tex2Dproj( tex2, In.WVPPTPos ).rgb;
//反射マップの色
ReflectCol = tex2Dproj( tex3, In.WVPPTPos ).rgb;
}
//*********************************************************************************************************
//フレネル効果
//*********************************************************************************************************
//頂点 → 視点ベクトル と 法線ベクトルの内積を計算
float fresnel = dot( normalize( m_EyePos.xyz - In.RocalPos ), normalize( In.Normal ) );
//内積の結果が 0.0f に近いほど反射マップの色が強くなり、 1.0f に近いほど海底マップの色が強くなるように線形合成する
float4 Col;
Col.rgb = lerp( ReflectCol, SeabedCol, fresnel );
Col.rgb = Col.rgb * Diffuse * WaterCol + S;
//*********************************************************************************************************
//透明度
//*********************************************************************************************************
//Ｚ値が小さくなるほど透明度を高くする（注意１）
Z = min( Z * 20.0f, 1.0f );
Col.rgb = lerp( SeabedCol, Col.rgb, Z );
Col.a = 1.0f;
return Col;
}
technique TShader
{
pass P0
{
VertexShader = compile vs_1_1 VS();
PixelShader = compile ps_2_0 PS();
}
}
---ParallaxMapping.h---
class PARALLAX_MAPPING2
{
private:
LPD3DXEFFECT m_pEffect;
D3DXHANDLE m_pTechnique, m_pWVPP, m_pWVPPT, m_pLightDir, m_pEyePos, m_pAmbient, m_pSpecular, m_pSpecularPower, m_pHeight, m_pDistortion, m_pRefraction, m_pZF;
D3DXMATRIX m_matView, m_matProj;
LPDIRECT3DDEVICE9 m_pd3dDevice;
public:
PARALLAX_MAPPING2( PDIRECT3DDEVICE9 pd3dDevice );
~PARALLAX_MAPPING2();
void Invalidate();
void Restore();
HRESULT Load();
void Begin();
void BeginPass( UINT Pass );
void SetAmbient( float Ambient );
void SetAmbient( D3DXVECTOR4* pAmbient );
void SetSpecular( float Specular );
void SetSpecularPower( float SpecularPower );
//高さに対する係数
void SetHeight( float Height );
//屈折率
void SetRefraction( float Refraction );
void SetMatrix( D3DXMATRIX* pMatWorld, D3DXVECTOR4* pCameraPos, D3DXVECTOR4* pLightDir, float pZF );
void EndPass();
void End();
void CommitChanges();
BOOL IsOK();
LPD3DXEFFECT GetEffect(){ return m_pEffect; };
};
---ParallaxMapping.cpp---
PARALLAX_MAPPING2::PARALLAX_MAPPING2( LPDIRECT3DDEVICE9 pd3dDevice )
{
m_pd3dDevice = pd3dDevice;
m_pEffect = NULL;
}
PARALLAX_MAPPING2::~PARALLAX_MAPPING2()
{
SafeRelease( m_pEffect );
}
void PARALLAX_MAPPING2::Invalidate()
{
if( m_pEffect )
m_pEffect->OnLostDevice();
}
void PARALLAX_MAPPING2::Restore()
{
if( m_pEffect )
m_pEffect->OnResetDevice();
}
HRESULT PARALLAX_MAPPING2::Load()
{
D3DCAPS9 caps;
HRESULT hr;
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("ParallaxMapping2.fx"), NULL, NULL, 0, NULL, &m_pEffect, &pErr );
if( FAILED( hr ) )
return -2;
m_pTechnique = m_pEffect->GetTechniqueByName( "TShader" );
m_pWVPP = m_pEffect->GetParameterByName( NULL, "m_WVPP" );
m_pWVPPT = m_pEffect->GetParameterByName( NULL, "m_WVPPT" );
m_pLightDir = m_pEffect->GetParameterByName( NULL, "m_LightDir" );
m_pEyePos = m_pEffect->GetParameterByName( NULL, "m_EyePos" );
m_pAmbient = m_pEffect->GetParameterByName( NULL, "m_Ambient" );
m_pSpecularPower = m_pEffect->GetParameterByName( NULL, "m_SpecularPower" );
m_pSpecular = m_pEffect->GetParameterByName( NULL, "m_Specular" );
m_pHeight = m_pEffect->GetParameterByName( NULL, "m_Height" );
m_pRefraction = m_pEffect->GetParameterByName( NULL, "m_Refraction" );
m_pZF = m_pEffect->GetParameterByName( NULL, "m_ZF" );
m_pEffect->SetTechnique( m_pTechnique );
}
else
{
return -3;
}
return S_OK;
}
void PARALLAX_MAPPING2::Begin()
{
if( m_pEffect )
{
m_pd3dDevice->GetTransform( D3DTS_VIEW, &m_matView );
m_pd3dDevice->GetTransform( D3DTS_PROJECTION, &m_matProj );
m_pEffect->Begin( NULL, 0 );
}
}
void PARALLAX_MAPPING2::BeginPass( UINT Pass )
{
if( m_pEffect )
m_pEffect->BeginPass( Pass );
}
void PARALLAX_MAPPING2::SetAmbient( float Ambient )
{
if( m_pEffect )
{
D3DXVECTOR4 A;
A = D3DXVECTOR4( Ambient, Ambient, Ambient, 1.0f );
m_pEffect->SetVector( m_pAmbient, &A );
}
else
{
D3DMATERIAL9 old_material;
m_pd3dDevice->GetMaterial( &old_material );
old_material.Ambient.r = Ambient;
old_material.Ambient.g = Ambient;
old_material.Ambient.b = Ambient;
old_material.Ambient.a = 1.0f;
m_pd3dDevice->SetMaterial( &old_material );
}
}
void PARALLAX_MAPPING2::SetAmbient( D3DXVECTOR4* pAmbient )
{
if( m_pEffect )
m_pEffect->SetVector( m_pAmbient, pAmbient );
else
{
D3DMATERIAL9 old_material;
m_pd3dDevice->GetMaterial( &old_material );
old_material.Ambient.r = pAmbient->x;
old_material.Ambient.g = pAmbient->y;
old_material.Ambient.b = pAmbient->z;
old_material.Ambient.a = pAmbient->w;
m_pd3dDevice->SetMaterial( &old_material );
}
}
void PARALLAX_MAPPING2::SetSpecular( float Specular )
{
if( m_pEffect )
m_pEffect->SetFloat( m_pSpecular, Specular );
}
void PARALLAX_MAPPING2::SetSpecularPower( float SpecularPower )
{
if( m_pEffect )
m_pEffect->SetFloat( m_pSpecularPower, SpecularPower );
}
//高さに対する係数
void PARALLAX_MAPPING2::SetHeight( float Height )
{
if( m_pEffect )
m_pEffect->SetFloat( m_pHeight, Height );
}
//屈折率
void PARALLAX_MAPPING2::SetRefraction( float Refraction )
{
if( m_pEffect )
m_pEffect->SetFloat( m_pRefraction, Refraction );
}
void PARALLAX_MAPPING2::SetMatrix( D3DXMATRIX* pMatWorld, D3DXVECTOR4* pCameraPos, D3DXVECTOR4* pLightDir, float pZF )
{
if( m_pEffect )
{
D3DXMATRIX m, m1, m2;
D3DXVECTOR4 v;
m = (*pMatWorld) * m_matView * m_matProj;
m_pEffect->SetMatrix( m_pWVPP, &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_pWVPPT, &m );
//カメラ位置
m1 = (*pMatWorld) * m_matView;
D3DXMatrixInverse( &m1, NULL, &m1 );
D3DXVec4Transform( &v, pCameraPos, &m1 );
m_pEffect->SetVector( m_pEyePos, &v );
//Light
D3DXMatrixInverse( &m, NULL, pMatWorld );
D3DXVec4Transform( &v, pLightDir, &m );
D3DXVec3Normalize( (D3DXVECTOR3*)&v, (D3DXVECTOR3*)&v );
m_pEffect->SetVector( m_pLightDir, &v );
//遠近射影行列の最遠近距離をセット
m_pEffect->SetFloat( m_pZF, pZF );
}
else
m_pd3dDevice->SetTransform( D3DTS_WORLD, pMatWorld );
}
void PARALLAX_MAPPING2::EndPass()
{
if( m_pEffect )
{
m_pEffect->EndPass();
}
}
void PARALLAX_MAPPING2::End()
{
if( m_pEffect )
{
m_pEffect->End();
}
}
void PARALLAX_MAPPING2::CommitChanges()
{
if( m_pEffect )
m_pEffect->CommitChanges();
}
BOOL PARALLAX_MAPPING2::IsOK()
{
if( m_pEffect )
return TRUE;
return FALSE;
}
なんとなくわかっていただけましたでしょうか？
---Main.cpp---
LPDIRECT3D9 m_pdirect3d9 = NULL;
LPDIRECT3DDEVICE9 m_pd3dDevice = NULL;
D3DPRESENT_PARAMETERS m_d3dParameters;
D3DCAPS9 Caps;
//シーンのメッシュ
//DirectX SDK(December 2004) に添付されているDXUTMesh.cppファイルにあるヘルパークラス群
CDXUTMesh* m_pMeshBack = NULL;
CDXUTMesh* m_pMeshSun = NULL;
CDXUTMesh* m_pMeshWave = NULL;
CDXUTMesh* m_pMeshTiger = NULL;
//2Dオブジェクト(表面化散乱(Subsurface Scattering) ページ参照)
D3D2DSQUARE* m_pSquObj = NULL;
//波マップ作成シェーダークラスの宣言
WAVE* m_pWave = NULL;
//シーンの色とＺ値をサーフェイスのα成分に出力するランバート拡散照明クラスの宣言
LAMBERT18* m_pLambert18 = NULL;
//反射マップ作成シェーダークラスの宣言
REFLECT* m_pReflect = NULL;
//ブラーフィルタークラスの宣言
BLURFILTER1* m_pBlurFilter = NULL;
//水面のマスクマップ作成クラスの宣言
MASK_MAP* m_pMaskMap = NULL;
//フレネル効果を考慮した視差マッピングクラスの宣言
PARALLAX_MAPPING2* m_pParallaxMapping2 = NULL;
//シーンのレンダリング
LPDIRECT3DTEXTURE9 m_pColorTexture = NULL;
LPDIRECT3DSURFACE9 m_pColorSurface = NULL;
//反射マップ
LPDIRECT3DTEXTURE9 m_pReflectTexture = NULL;
LPDIRECT3DSURFACE9 m_pReflectSurface = NULL;
//水面のマスクマップ
LPDIRECT3DTEXTURE9 m_pWaterTexture = NULL;
LPDIRECT3DSURFACE9 m_pWaterSurface = NULL;
//ブラー処理
LPDIRECT3DTEXTURE9 m_pBlurFilterTexture = NULL;
LPDIRECT3DSURFACE9 m_pBlurFilterSurface = NULL;
//スクリーンの解像度
UINT nWidth = 1024;
UINT nHeight = 768;
//太陽の位置ベクトル
D3DXVECTOR4 LightPos = D3DXVECTOR4( 100.0f, 100.0f, -300.0f, 1.0f );
//平行光源の光の方向ベクトル
D3DXVECTOR4 LightDir;
//視点の位置ベクトル
D3DXVECTOR4 EyePos = D3DXVECTOR4( 0.0f, 0.0f, 0.0f, 1.0f );
bool RenderOK = false;
int APIENTRY WinMain( HINSTANCE hInstance,
HINSTANCE /*hPrevInstance*/,
LPSTR /*lpCmpLine*/,
INT /*nCmdShow*/)
{
char* AppName = "Tutrial";
MSG msg;
ZeroMemory(&msg, sizeof(MSG));
HWND hWnd = NULL;
WNDCLASSEX wc;
wc.cbSize = sizeof(WNDCLASSEX);
wc.style = CS_VREDRAW | CS_HREDRAW;
wc.lpfnWndProc = (WNDPROC)WndProc;
wc.cbClsExtra = 0;
wc.cbWndExtra = sizeof(DWORD);
wc.hCursor = LoadCursor(NULL, IDC_ARROW);
wc.hIcon = NULL;
wc.hIconSm = NULL;
wc.lpszMenuName = NULL;
wc.lpszClassName = AppName;
wc.hbrBackground = (HBRUSH)GetStockObject( BLACK_BRUSH );
wc.hInstance = hInstance;
RegisterClassEx(&wc);
//****************************************************************
//ここでウィンドウの作成処理
//****************************************************************
//****************************************************************
//ここでDirect3Dの初期化を行う。
//****************************************************************
m_pd3dDevice->GetDeviceCaps(&Caps);
//波マップ作成シェーダークラスの初期化
m_pWave = new WAVE( m_pd3dDevice, 512, 512 );
m_pWave->Load();
//シーンの色とＺ値をサーフェイスのα成分に出力するランバート拡散照明クラスの初期化
m_pLambert18 = new LAMBERT18( m_pd3dDevice );
m_pLambert18->Load();
//反射マップ作成シェーダークラスの初期化
m_pReflect = new REFLECT( m_pd3dDevice );
m_pReflect->Load();
//ブラーフィルタークラスの初期化
//サーフェイスは縮小バッファを使用する
m_pBlurFilter = new BLURFILTER1( m_pd3dDevice, nWidth / 4, nHeight / 4 );
m_pBlurFilter->Load();
//水面のマスクマップ作成クラスの初期化
m_pMaskMap = new MASK_MAP( m_pd3dDevice );
m_pMaskMap->Load();
//視差マッピングクラスの初期化
m_pParallaxMapping2 = new PARALLAX_MAPPING2( m_pd3dDevice );
m_pParallaxMapping2->Load();
//2Ｄオブジェクトのロード
m_pSquObj = new D3D2DSQUARE( m_pd3dDevice, &m_d3dParameters );
m_pSquObj->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_pMeshWave = new CDXUTMesh();
m_pMeshWave->Create( m_pd3dDevice, _T("res\\wave.x") );
//視差マッピングを使用するためカスタマイズ
D3DVERTEXELEMENT9 decl[] =
{
{0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0},
{0, 12, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TANGENT, 0},
{0, 24, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_BINORMAL, 0},
{0, 36, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_NORMAL, 0},
{0, 48, D3DDECLTYPE_FLOAT2, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 0},
D3DDECL_END()
};
m_pMeshWave->SetVertexDecl( m_pd3dDevice, decl );
//トラ
m_pMeshTiger = new CDXUTMesh();
m_pMeshTiger->Create( m_pd3dDevice, _T("res\\tiger.x") );
m_pMeshTiger->SetFVF( m_pd3dDevice, D3DFVF_XYZ | D3DFVF_NORMAL | D3DFVF_TEX1 );
//平行光源の位置ベクトルから方向ベクトルを計算する
LightDir = D3DXVECTOR4( -LightPos.x, -LightPos.y, -LightPos.z, 0.0f );
D3DXVec3Normalize( (D3DXVECTOR3*)&LightDir, (D3DXVECTOR3*)&LightDir );
RenderOK = true;
//デバイス消失後にリストアする必要があるオブジェクトの初期化
Restore();
::ShowWindow(hWnd, SW_SHOW);
::UpdateWindow(hWnd);
do
{
if( ::PeekMessage( &msg, 0, 0, 0, PM_REMOVE ) )
{
::TranslateMessage(&msg);
::DispatchMessage(&msg);
}
else
{
if( MainLoop(hWnd) == FALSE )
::DestroyWindow( hWnd );
}
}while( msg.message != WM_QUIT );
::UnregisterClass( AppName, hInstance );
return msg.wParam;
}
//デバイスのリセット前に開放すべきオブジェクト
void Invalidate()
{
m_pWave->Invalidate();
m_pReflect->Invalidate();
m_pLambert18->Invalidate();
m_pParallaxMapping2->Invalidate();
m_pBlurFilter->Invalidate();
m_pMaskMap->Invalidate();
SafeRelease( m_pColorSurface );
SafeRelease( m_pColorTexture );
SafeRelease( m_pReflectSurface );
SafeRelease( m_pReflectTexture );
SafeRelease( m_pBlurFilterSurface );
SafeRelease( m_pBlurFilterTexture );
SafeRelease( m_pWaterSurface );
SafeRelease( m_pWaterTexture );
}
//デバイスのリセット後に初期化すべきオブジェクト
void Restore()
{
m_pWave->Restore();
m_pReflect->Restore();
m_pLambert18->Restore();
m_pParallaxMapping2->Restore();
m_pBlurFilter->Restore();
m_pMaskMap->Restore();
//シーンのレンダリングイメージ
m_pd3dDevice->CreateTexture( nWidth,
nHeight,
1,
D3DUSAGE_RENDERTARGET,
D3DFMT_A8R8G8B8,
D3DPOOL_DEFAULT,
&m_pColorTexture,
NULL );
m_pColorTexture->GetSurfaceLevel( 0, &m_pColorSurface );
//反射マップ(縮小サーフェイス)
m_pd3dDevice->CreateTexture( m_pBlurFilter->GetWidth(),
m_pBlurFilter->GetHeight(),
1,
D3DUSAGE_RENDERTARGET,
D3DFMT_A8R8G8B8,
D3DPOOL_DEFAULT,
&m_pReflectTexture,
NULL );
m_pReflectTexture->GetSurfaceLevel( 0, &m_pReflectSurface );
//ブラーフィルター適応後サーフェイス(これも縮小サーフェイス)
m_pd3dDevice->CreateTexture( m_pBlurFilter->GetWidth(),
m_pBlurFilter->GetHeight(),
1,
D3DUSAGE_RENDERTARGET,
D3DFMT_A8R8G8B8,
D3DPOOL_DEFAULT,
&m_pBlurFilterTexture,
NULL );
m_pBlurFilterTexture->GetSurfaceLevel( 0, &m_pBlurFilterSurface );
//水面のマスクマップ
m_pd3dDevice->CreateTexture( nWidth,
nHeight,
1,
D3DUSAGE_RENDERTARGET,
D3DFMT_A8R8G8B8,
D3DPOOL_DEFAULT,
&m_pWaterTexture,
NULL );
m_pWaterTexture->GetSurfaceLevel( 0, &m_pWaterSurface );
//固定機能パイプラインライティングを設定する
D3DLIGHT9 Light;
ZeroMemory(&Light, sizeof(D3DLIGHT9));
Light.Type = D3DLIGHT_DIRECTIONAL;
Light.Direction = D3DXVECTOR3( LightDir.x, LightDir.y, LightDir.z );
Light.Ambient = D3DXCOLOR( 1.0f, 1.0f, 1.0f, 1.0f );
Light.Diffuse = D3DXCOLOR( 1.0f, 1.0f, 1.0f, 1.0f );
Light.Specular = D3DXCOLOR( 0.0f, 0.0f, 0.0f, 0.0f );
m_pd3dDevice->SetLight(0, &Light);
m_pd3dDevice->LightEnable(0, TRUE);
D3DMATERIAL9 Material;
ZeroMemory( &Material, sizeof( Material ) );
Material.Diffuse.r = 1.0f;
Material.Diffuse.g = 1.0f;
Material.Diffuse.b = 1.0f;
Material.Diffuse.a = 1.0f;
m_pd3dDevice->SetMaterial( &Material );
}
//メッセージループからコールされる関数
BOOL MainLoop( HWND HWnd )
{
HRESULT hr;
//レンダリング不可能
if( RenderOK == false )
{
hr = m_pd3dDevice->TestCooperativeLevel();
switch( hr )
{
//デバイスは消失しているがReset可能
case D3DERR_DEVICENOTRESET:
//開放
Invalidate();
//デバイスをリセットする
hr = m_pd3dDevice->Reset( &m_d3dParameters );
switch( hr )
{
//デバイスロスト
case D3DERR_DEVICELOST:
break;
//内部ドライバーエラー
case D3DERR_DRIVERINTERNALERROR:
return FALSE;
break;
//メソッドの呼び出しが無効です
case D3DERR_INVALIDCALL:
return FALSE;
break;
case S_OK:
//初期化
Restore();
RenderOK = true;
}
break;
}
}
//レンダリング可能
else
{
D3DXMATRIX matWVP, matPProj, matView, matWorld, matTiger, matScaling, matTranslation, matReflect;
//遠近射影座標変換
//クリップ面はアプリケーションごとに調整すること
float zf = 700.0f;
D3DXMatrixPerspectiveFovLH( &matPProj,
D3DX_PI/4.0f,
4.0f / 3.0f,
30.0f,
zf );
m_pd3dDevice->SetTransform( D3DTS_PROJECTION, &matPProj );
//ビュー座標変換
D3DXMatrixIdentity( &matView );
m_pd3dDevice->SetTransform( D3DTS_VIEW, &matView );
m_pd3dDevice->BeginScene();
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->SetSamplerState( 2, D3DSAMP_MINFILTER, D3DTEXF_POINT );
m_pd3dDevice->SetSamplerState( 2, D3DSAMP_MAGFILTER, D3DTEXF_POINT );
m_pd3dDevice->SetSamplerState( 2, D3DSAMP_MIPFILTER, D3DTEXF_NONE );
m_pd3dDevice->SetSamplerState( 3, D3DSAMP_MINFILTER, D3DTEXF_POINT );
m_pd3dDevice->SetSamplerState( 3, D3DSAMP_MAGFILTER, D3DTEXF_POINT );
m_pd3dDevice->SetSamplerState( 3, D3DSAMP_MIPFILTER, D3DTEXF_NONE );
m_pd3dDevice->SetSamplerState( 4, D3DSAMP_MINFILTER, D3DTEXF_POINT );
m_pd3dDevice->SetSamplerState( 4, D3DSAMP_MAGFILTER, D3DTEXF_POINT );
m_pd3dDevice->SetSamplerState( 4, D3DSAMP_MIPFILTER, D3DTEXF_NONE );
//****************************************************************
//ステップ１：波マップの更新
//****************************************************************
//WAVEクラス内で浮動小数点フォーマットを使用している
//浮動小数点フォーマットはビデオカードによっては「LINEAR」がきかないのでここでは「POINT」に設定しておく
m_pd3dDevice->SetSamplerState( 0, D3DSAMP_MINFILTER, D3DTEXF_POINT );
m_pd3dDevice->SetSamplerState( 0, D3DSAMP_MAGFILTER, D3DTEXF_POINT );
m_pd3dDevice->SetSamplerState( 0, D3DSAMP_MIPFILTER, D3DTEXF_NONE );
//2Dスプライトオブジェクトを使用してレンダリングするのでＺバッファへの書き込みを無効にする
m_pd3dDevice->SetRenderState( D3DRS_ZWRITEENABLE, FALSE );
//ばね係数を設定
m_pWave->SetSpringPower( 0.2f );
//適当に波を新規作成する
//追加する波の高さを設定できるように修正. 詳細は波シェーダーページを参照
// m_pWave->AddWavePos( (float)(rand()%100) * 0.01f, (float)(rand()%100) * 0.01f );
m_pWave->AddWave( (float)(rand()%100) * 0.01f, (float)(rand()%100) * 0.01f, (float)(rand()%100-50) * 0.002f );
//更新した波マップを取得
LPDIRECT3DTEXTURE9 BumpMap = m_pWave->Render();
m_pd3dDevice->SetRenderState( D3DRS_ZWRITEENABLE, 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 );
D3DVIEWPORT9 OldViewport, NewViewport;
//縮小サーフェイスを使用するため、ビューポートを反射マップのサイズに合わせる
m_pd3dDevice->GetViewport( &OldViewport );
CopyMemory( &NewViewport, &OldViewport, sizeof( D3DVIEWPORT9 ) );
NewViewport.Width = m_pBlurFilter->GetWidth();
NewViewport.Height = m_pBlurFilter->GetHeight();
m_pd3dDevice->SetViewport( &NewViewport );
LPDIRECT3DSURFACE9 OldSurface = NULL;
m_pd3dDevice->GetRenderTarget( 0, &OldSurface );
m_pd3dDevice->SetRenderTarget( 0, m_pReflectSurface );
m_pd3dDevice->Clear( 0L,
NULL,
D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER,
0x0,
1.0f,
0L
);
//Y 方向に反転してレンダリングするのでレンダリング面も反転させる
m_pd3dDevice->SetRenderState( D3DRS_CULLMODE, D3DCULL_CW );
//ここから水面で Y 方向に反転させる行列を作成処理
D3DXPLANE Plane;
D3DXVECTOR3 Point, Normal;
D3DXVECTOR4 LightDirReflect = LightDir;
LightDirReflect.y *= -1.0f;
//水面の任意一点の座標
Point = D3DXVECTOR3( 0.0f, 0.0f, 0.0f );
//水面の法線ベクトル
Normal = D3DXVECTOR3( 0.0f, 1.0f, 0.0f );
//水面の平面を定義
D3DXPlaneFromPointNormal( &Plane, &Point, &Normal );
//定義から反射行列を取得
D3DXMatrixReflect( &matReflect, &Plane );
//ここから背景レンダリング開始
//まず水面の高さをセット
m_pReflect->SetHeight( Point.y );
m_pReflect->Begin();
D3DXMatrixIdentity( &matWorld );
//ワールド行列を作成し、Y 方向に反転する行列を作成
matWorld = matWorld * matReflect;
m_pReflect->SetMatrix( &matWorld, &LightDirReflect );
m_pd3dDevice->SetTexture( 0, m_pMeshBack->m_pTextures[0] );
m_pReflect->SetAmbient( 0.1f );
m_pReflect->BeginPass();
m_pMeshBack->m_pLocalMesh->DrawSubset( 0 );
m_pReflect->EndPass();
//トラ
D3DXMatrixScaling( &matScaling, 30.0f, 40.0f, 30.0f );
D3DXMatrixTranslation( &matTranslation, 50.0f, -10.0f, 330.0 );
matTiger = matScaling * matTranslation;
matWorld = matTiger * matReflect;
m_pReflect->SetMatrix( &matWorld, &LightDirReflect );
m_pd3dDevice->SetTexture( 0, m_pMeshTiger->m_pTextures[0] );
m_pReflect->SetAmbient( 0.1f );
m_pReflect->BeginPass();
m_pMeshTiger->m_pLocalMesh->DrawSubset( 0 );
m_pReflect->EndPass();
//Zバッファ書込み禁止
m_pd3dDevice->SetRenderState( D3DRS_ZWRITEENABLE, FALSE );
//空レンダリング
m_pd3dDevice->SetTexture( 0, m_pMeshBack->m_pTextures[1] );
D3DXMatrixIdentity( &matWorld );
matWorld = matWorld * matReflect;
m_pReflect->SetMatrix( &matWorld, &LightDirReflect );
m_pReflect->SetAmbient( 1.0f );
m_pReflect->BeginPass();
m_pMeshBack->m_pLocalMesh->DrawSubset( 1 );
m_pReflect->EndPass();
//太陽レンダリング
//αブレンドを有効にする
m_pd3dDevice->SetRenderState( D3DRS_ALPHABLENDENABLE, TRUE );
//加算合成
m_pd3dDevice->SetRenderState( D3DRS_BLENDOP, D3DBLENDOP_ADD );
m_pd3dDevice->SetRenderState( D3DRS_SRCBLEND, D3DBLEND_SRCALPHA );
m_pd3dDevice->SetRenderState( D3DRS_DESTBLEND, D3DBLEND_ONE );
D3DXMatrixTranslation( &matTranslation, LightPos.x, LightPos.y, LightPos.z );
m_pd3dDevice->SetTexture( 0, m_pMeshSun->m_pTextures[0] );
//ビルボードマトリックスを取得(ビルボード ページ参照)
matWorld = matTranslation * matReflect;
matWorld = GetBillBoardMatrix( m_pd3dDevice, &matWorld );
m_pReflect->SetMatrix( &matWorld, &LightDirReflect );
m_pReflect->SetAmbient( 1.0f );
m_pReflect->BeginPass();
m_pMeshSun->m_pLocalMesh->DrawSubset( 0 );
m_pReflect->EndPass();
m_pReflect->End();
//レンダーステートを戻す
m_pd3dDevice->SetRenderState( D3DRS_ZWRITEENABLE, TRUE );
m_pd3dDevice->SetRenderState( D3DRS_ALPHABLENDENABLE, FALSE );
m_pd3dDevice->SetRenderState( D3DRS_CULLMODE, D3DCULL_CCW );
//****************************************************************
//ステップ３ : 反射マップをぼかす
//****************************************************************
//ブラーをかけるのでCLAMPにする
m_pd3dDevice->SetSamplerState( 0, D3DSAMP_ADDRESSU, D3DTADDRESS_CLAMP );
m_pd3dDevice->SetSamplerState( 0, D3DSAMP_ADDRESSV, D3DTADDRESS_CLAMP );
m_pd3dDevice->SetRenderState( D3DRS_ZENABLE, D3DZB_FALSE );
m_pd3dDevice->SetRenderTarget( 0, m_pBlurFilterSurface );
m_pd3dDevice->SetTexture( 0, m_pReflectTexture );
m_pBlurFilter->Render();
m_pd3dDevice->SetRenderState( D3DRS_ZENABLE, D3DZB_TRUE );
m_pd3dDevice->SetSamplerState( 0, D3DSAMP_ADDRESSU, D3DTADDRESS_WRAP );
m_pd3dDevice->SetSamplerState( 0, D3DSAMP_ADDRESSV, D3DTADDRESS_WRAP );
//ビューポートをもどす
m_pd3dDevice->SetViewport( &OldViewport );
//****************************************************************
//ステップ４ : シーンのレンダリング
//****************************************************************
m_pd3dDevice->SetRenderTarget( 0, m_pColorSurface );
m_pd3dDevice->Clear( 0L,
NULL,
D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER,
0xFF000000, //Ｚ値をα成分に出力するためα成分を1.0fで初期化する
1.0f,
0L
);
//背景レンダリング
m_pLambert18->Begin();
D3DXMatrixIdentity( &matWorld );
m_pLambert18->SetMatrix( &matWorld, &LightDir, zf );
m_pd3dDevice->SetTexture( 0, m_pMeshBack->m_pTextures[0] );
m_pLambert18->SetAmbient( 0.1f );
m_pLambert18->SetZEnable( true );
m_pLambert18->BeginPass(0);
m_pMeshBack->m_pLocalMesh->DrawSubset( 0 );
m_pLambert18->EndPass();
//トラ
m_pLambert18->SetMatrix( &matTiger, &LightDir, zf );
m_pd3dDevice->SetTexture( 0, m_pMeshTiger->m_pTextures[0] );
m_pLambert18->SetAmbient( 0.1f );
m_pLambert18->SetZEnable( true );
m_pLambert18->BeginPass(0);
m_pMeshTiger->m_pLocalMesh->DrawSubset( 0 );
m_pLambert18->EndPass();
//空レンダリング
//Zバッファ書込み禁止
m_pd3dDevice->SetRenderState( D3DRS_ZWRITEENABLE, FALSE );
m_pd3dDevice->SetTexture( 0, m_pMeshBack->m_pTextures[1] );
D3DXMatrixIdentity( &matWorld );
m_pLambert18->SetMatrix( &matWorld, &LightDir, zf );
m_pLambert18->SetAmbient( 1.0f );
m_pLambert18->SetZEnable( false );
m_pLambert18->BeginPass(0);
m_pMeshBack->m_pLocalMesh->DrawSubset( 1 );
m_pLambert18->EndPass();
//太陽レンダリング
//αブレンドを有効にする
m_pd3dDevice->SetRenderState( D3DRS_ALPHABLENDENABLE, TRUE );
//加算合成
m_pd3dDevice->SetRenderState( D3DRS_BLENDOP, D3DBLENDOP_ADD );
m_pd3dDevice->SetRenderState( D3DRS_SRCBLEND, D3DBLEND_SRCALPHA );
m_pd3dDevice->SetRenderState( D3DRS_DESTBLEND, D3DBLEND_ONE );
m_pd3dDevice->SetTexture( 0, m_pMeshSun->m_pTextures[0] );
D3DXMatrixTranslation( &matTranslation, LightPos.x, LightPos.y, LightPos.z );
//ビルボードマトリックスを取得(ビルボード ページ参照)
matWorld = GetBillBoardMatrix( m_pd3dDevice, &matTranslation );
m_pLambert18->SetMatrix( &matWorld, &LightDir, zf );
m_pLambert18->SetAmbient( 1.0f );
m_pLambert18->SetZEnable( false );
m_pLambert18->BeginPass(0);
m_pMeshSun->m_pLocalMesh->DrawSubset( 0 );
m_pLambert18->EndPass();
m_pLambert18->End();
m_pd3dDevice->SetRenderState( D3DRS_ALPHABLENDENABLE, FALSE );
//****************************************************************
//ステップ５ : 水面のマスクマップをレンダリング
//****************************************************************
//Zバッファに書き込みしない
m_pd3dDevice->SetRenderState( D3DRS_ZWRITEENABLE, FALSE );
m_pd3dDevice->SetRenderTarget( 0, m_pWaterSurface );
m_pd3dDevice->SetTexture( 0, NULL );
//Zバッファはステップ４の結果を使用するため初期化しない
m_pd3dDevice->Clear( 0L,
NULL,
D3DCLEAR_TARGET,
0x0,
1.0f,
0L
);
m_pMaskMap->Begin();
D3DXMatrixIdentity( &matWorld );
m_pMaskMap->SetMatrix( &matWorld );
m_pMaskMap->BeginPass(0);
m_pMeshWave->m_pLocalMesh->DrawSubset( 0 );
m_pMaskMap->EndPass();
m_pMaskMap->End();
//****************************************************************
//ステップ６ : シーンのレンダリングイメージをバックバッファにレンダリングする
//****************************************************************
m_pd3dDevice->SetRenderTarget( 0, OldSurface );
SafeRelease( OldSurface );
m_pd3dDevice->SetTexture( 0, m_pColorTexture );
m_pSquObj->Render();
m_pd3dDevice->SetRenderState( D3DRS_ZWRITEENABLE, TRUE );
//****************************************************************
//ステップ７ : 合成
//****************************************************************
//ステージ２と３はゆがみ処理を行うためCLAMPにする
m_pd3dDevice->SetSamplerState( 2, D3DSAMP_ADDRESSU, D3DTADDRESS_CLAMP );
m_pd3dDevice->SetSamplerState( 2, D3DSAMP_ADDRESSV, D3DTADDRESS_CLAMP );
m_pd3dDevice->SetSamplerState( 3, D3DSAMP_ADDRESSU, D3DTADDRESS_CLAMP );
m_pd3dDevice->SetSamplerState( 3, D3DSAMP_ADDRESSV, D3DTADDRESS_CLAMP );
m_pd3dDevice->SetSamplerState( 4, D3DSAMP_ADDRESSU, D3DTADDRESS_WRAP );
m_pd3dDevice->SetSamplerState( 4, D3DSAMP_ADDRESSV, D3DTADDRESS_WRAP );
m_pd3dDevice->SetTexture( 0, m_pMeshWave->m_pTextures[0] );
m_pd3dDevice->SetTexture( 1, BumpMap );
m_pd3dDevice->SetTexture( 2, m_pColorTexture );
m_pd3dDevice->SetTexture( 3, m_pBlurFilterTexture );
m_pd3dDevice->SetTexture( 4, m_pWaterTexture );
m_pParallaxMapping2->Begin();
m_pParallaxMapping2->SetAmbient( 0.0f );
m_pParallaxMapping2->SetSpecular( 5.0f );
m_pParallaxMapping2->SetSpecularPower( 0.75f );
m_pParallaxMapping2->SetHeight( 0.16f );
m_pParallaxMapping2->SetRefraction( 50.0f );
D3DXMatrixIdentity( &matWorld );
m_pParallaxMapping2->SetMatrix( &matWorld, &EyePos, &LightDir, zf );
m_pParallaxMapping2->BeginPass(0);
m_pMeshWave->m_pLocalMesh->DrawSubset( 0 );
m_pParallaxMapping2->EndPass();
m_pParallaxMapping2->End();
m_pd3dDevice->SetTexture( 1, NULL );
m_pd3dDevice->SetTexture( 2, NULL );
m_pd3dDevice->SetTexture( 3, NULL );
m_pd3dDevice->SetTexture( 4, NULL );
m_pd3dDevice->SetSamplerState( 2, D3DSAMP_ADDRESSU, D3DTADDRESS_WRAP );
m_pd3dDevice->SetSamplerState( 2, D3DSAMP_ADDRESSV, D3DTADDRESS_WRAP );
m_pd3dDevice->SetSamplerState( 3, D3DSAMP_ADDRESSU, D3DTADDRESS_WRAP );
m_pd3dDevice->SetSamplerState( 3, D3DSAMP_ADDRESSV, D3DTADDRESS_WRAP );
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;
}
以上です。ほんと長かった。冒頭でも書きましたが、最適化してないので修正してください。
もう一点注意事項。反射マップをぼかしてますが、本来水面と同じくこれもマスクマップを参照してぼかす必要があります。
ですが、水の厚みが薄くなるほど水の透明度を上げる処理を入れているため水と地面との境界付近が滑らかになり
結果的に目立たなくなるため、省略しました。
ですが（注意１）の20.0fの値を極端に大きくすると、つまり境界がはっきりするようにすると
この問題が表面化するので必要であれば修正してください。
しかしこれだけやってもコースティックとかまだやってないことあるんだから困ったものです。 コースティックといえば、今回、鏡面反射にフォンシェーディング使用しましたが、これほとんど利いてないんですよね。 フォンシェーディングではなくコースティックを使用すればいい感じになるかも。あくまで予想ですが。