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

■雲シェーダー Prev  Top  Next
関連ページ:なし
2009/08/20: ビルボートマトリックスの作成方法を変更

無料レンタルサーバー

太陽が逆光

太陽が順光

今回は雲シェーダーです。元ネタは、GAME Watchです。 なんか調整にすっごい苦労したんだが、そのわりにあんまりよくないです(笑)。 もともと立体感のある雲を矩形の平面ポリゴン1枚で表現しようとすること自体無理があるため、仕方がないのかもしれませんが。

では実装方法です。

太陽が逆光位置にあるときは、光を透過し散乱するため雲が明るくなるようにします。また順光の場合は、普通にライティングします。 ライティングは空光源と太陽光源の2つの光源を使用します。

1.雲ポリゴン
まず先にも説明したとおり、雲は矩形の平面ポリゴン1枚で表現します。なのでこのポリゴンの法線ベクトルはちょっと細工します。
雲ポリゴンの法線ベクトル
矢印が法線ベクトルです。法線ベクトルは通常、面に対して垂直になります。 ですが今回は立体の雲を無理やり平面で表現するため、こんな感じにします。

2.雲テクスチャー
RG成分を使用します。Rをアルファチャンネル、Gは雲の厚み情報となります。
雲テクスチャー

3.雲パーティクル
上のサンプルではやってないですが、雲はパーティクルシステムでレンダリングします。

ではソースです。

---CloudShader.fx---


float4x4 m_WVP;                  //ワールド × ビュー × 遠近射影 行列
float4 m_PointLightPos;          //太陽の位置ベクトル
float4 m_SkyLightDir;            //空光源の方向ベクトル
float4 m_EyePos;                 //視点ベクトル
float4 m_CloudColor;             //雲の色

sampler tex0 : register(s0);     //雲の厚み

struct VS_OUTPUT
{
   float4 Pos    : POSITION;
   float4 Col    : COLOR0;
   float2 Tex    : TEXCOORD0;
   float  VC     : TEXCOORD1;
};

VS_OUTPUT VS( float4 Pos     : POSITION,
              float4 Normal  : NORMAL,
              float2 Tex     : TEXCOORD0 )
{
   VS_OUTPUT Out;
   
   Out.Pos    = mul( Pos, m_WVP );
   Out.Tex    = Tex;
   
   float3 N = normalize( Normal.xyz );

   //空によるライティング
   //微妙に調整してみる
   float c1 = dot( N, -normalize( m_SkyLightDir.xyz ) );
//   c1 = c1 * 0.5f + 0.5f;
   c1 = c1 * 0.5f + 0.4f;
   
   //太陽によるライティング
   float c2 = dot( N, normalize( m_PointLightPos.xyz - Pos.xyz ) );
   c2 = c2 * 0.5f + 0.5f;

   //適当に調整
   float c = c1 + c2;
   c = c * c * c;
   Out.Col = c * m_CloudColor;

   //逆光時の光の透過を表現するために 頂点←視点 と 太陽の位置←頂点 との内積を計算する
   float v = dot( normalize( Pos.xyz - m_EyePos.xyz ), normalize( m_PointLightPos.xyz - Pos.xyz ) );

   //0.0f 〜 1.0fに変換
   v = v * 0.5f + 0.5f;

   //暗い領域を適当に大きくする
   v = pow( v, 20000.0f );

   Out.VC = v;
   
   return Out;
}

float4 PS( VS_OUTPUT In ) : COLOR0
{  
   float4 Out;
   
   float4 CloudMap = tex2D( tex0, In.Tex );
   
   //雲の厚みの薄い部分は色を加算する
   Out.rgb = In.Col.rgb + In.VC * CloudMap.g;
   
   //雲の透明度
   Out.a = CloudMap.r;
   
   return Out;
}

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

雲シェーダーです。ぐちゃぐちゃいじったんですが、いまだ納得できず。 もっとクォリティ向上できるかもしれません。 なお今回はライティング計算を頂点シェーダー内で行います。

---CloudShader.h---


class CLOUDSHADER
{
private:
   LPD3DXEFFECT m_pEffect;
   D3DXHANDLE m_pTechnique, m_pWVP, m_pPointLightPos, m_pSkyLightDir, m_pEyePos, m_pCloudColor;
   D3DXMATRIX m_matView, m_matProj;
   LPDIRECT3DDEVICE9 m_pd3dDevice;

public:
   CLOUDSHADER( LPDIRECT3DDEVICE9 pd3dDevice );
   ~CLOUDSHADER();
   void Invalidate();
   void Restore();
   HRESULT Load();
   void Begin();
   void BeginPass();
   void SetMatrix( D3DXMATRIX* pMatWorld, D3DXVECTOR4* pCameraPos, D3DXVECTOR4* pPointLightPos, D3DXVECTOR4* pSkyLightDir );
   void SetCloudColor( float R, float G, float B, float A );
   void SetCloudColor( float CloudColor );
   void CommitChanges();
   void EndPass();
   void End();
   BOOL IsOK();
   LPD3DXEFFECT GetEffect(){ return m_pEffect; };
};

---CloudShader.cpp---


CLOUDSHADER::CLOUDSHADER( LPDIRECT3DDEVICE9 pd3dDevice )
{
   m_pd3dDevice = pd3dDevice;
   m_pEffect = NULL;
}

CLOUDSHADER::~CLOUDSHADER()
{
   SafeRelease( m_pEffect );
}

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

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

HRESULT CLOUDSHADER::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("CloudShader.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_pPointLightPos   = m_pEffect->GetParameterByName( NULL, "m_PointLightPos" );
         m_pSkyLightDir     = m_pEffect->GetParameterByName( NULL, "m_SkyLightDir" );
         m_pEyePos          = m_pEffect->GetParameterByName( NULL, "m_EyePos" );
         m_pCloudColor      = m_pEffect->GetParameterByName( NULL, "m_CloudColor" );

         m_pEffect->SetTechnique( m_pTechnique );
      }

      else
      {
         return -1;
      }
   }

   else
   {
      return -2;
   }

   return S_OK;
}

void CLOUDSHADER::Begin()
{
   if(  m_pEffect )
   {
      m_pd3dDevice->GetTransform( D3DTS_VIEW, &m_matView );
      m_pd3dDevice->GetTransform( D3DTS_PROJECTION, &m_matProj );
      m_pEffect->Begin( NULL, 0 );
   }
}

void CLOUDSHADER::BeginPass()
{
   if( m_pEffect )
   {
      m_pEffect->BeginPass( 0 );
   }
}

void CLOUDSHADER::SetCloudColor( float CloudColor )
{
   if( m_pEffect )
   {
      D3DXVECTOR4 Color = D3DXVECTOR4( CloudColor, CloudColor, CloudColor, 1.0f );
      m_pEffect->SetVector( m_pCloudColor, &Color );
   }
}

void CLOUDSHADER::SetCloudColor( float R, float G, float B, float A )
{
   if( m_pEffect )
   {
      D3DXVECTOR4 Color = D3DXVECTOR4( R, G, B, A );
      m_pEffect->SetVector( m_pCloudColor, &Color );
   }
}


//ローカル座標系
void CLOUDSHADER::SetMatrix( D3DXMATRIX* pMatWorld, D3DXVECTOR4* pCameraPos, D3DXVECTOR4* pPointLightPos, D3DXVECTOR4* pSkyLightDir )
{
   if( m_pEffect )
   {
      D3DXMATRIX m;
      D3DXVECTOR4 v;

      //ワールド × ビュー × 遠近射影行列
      m = (*pMatWorld) * m_matView * m_matProj;
      m_pEffect->SetMatrix( m_pWVP, &m );

      //カメラ位置
      m = (*pMatWorld) * m_matView;
      D3DXMatrixInverse( &m, NULL, &m );
      D3DXVec4Transform( &v, pCameraPos, &m );
      m_pEffect->SetVector( m_pEyePos, &v );

      //太陽光源の位置ベクトル
      D3DXMatrixInverse( &m, NULL, pMatWorld );
      D3DXVec4Transform( &v, pPointLightPos, &m );
      m_pEffect->SetVector( m_pPointLightPos, &v );

      //空光源の方向ベクトル
      D3DXMatrixInverse( &m, NULL, pMatWorld );
      D3DXVec4Transform( &v, pSkyLightDir, &m );      
      D3DXVec3Normalize( (D3DXVECTOR3*)&v, (D3DXVECTOR3*)&v );
      m_pEffect->SetVector( m_pSkyLightDir, &v );
   }

   else
      m_pd3dDevice->SetTransform( D3DTS_WORLD, pMatWorld );
}

void CLOUDSHADER::CommitChanges()
{
   if( m_pEffect )
      m_pEffect->CommitChanges();
}

void CLOUDSHADER::EndPass()
{
   if( m_pEffect )
   {
      m_pEffect->EndPass();
   }
}

void CLOUDSHADER::End()
{
   if( m_pEffect )
   {
      m_pEffect->End();
   }
}

BOOL CLOUDSHADER::IsOK()
{
   if( m_pEffect )
      return TRUE;

   return FALSE;
}

新しいことは何もないので説明はいらないでしょう。

---Main.cpp---


LPDIRECT3D9 m_pdirect3d9 = NULL;
LPDIRECT3DDEVICE9 m_pd3dDevice = NULL;
D3DPRESENT_PARAMETERS m_d3dParameters;

D3DCAPS9 Caps;

//雲パーティクル
typedef struct _PARTICLE
{
   float x, y, z;      //頂点座標
   float nx, ny, nz;   //法線ベクトル
   float tu, tv;       //テクセル座標
}PARTICLE;
PARTICLE m_pParticle[4] = {
                             { -1.0f,        1.0f,        0.0f,
                               -0.6917144f,  0.6917144f, -0.2075143f,
                                0.0f,        0.0f,
                             },
                             {  1.0f,        1.0f,        0.0f,
                                0.6917144f,  0.6917144f, -0.2075143f,
                                1.0f,        0.0f,
                             },
                             { -1.0f,       -1.0f,        0.0f,
                               -0.6917144f, -0.6917144f, -0.2075143f,
                                0.0f,        1.0f,
                             },
                             {  1.0f,       -1.0f,        0.0f,
                                0.6917144f, -0.6917144f, -0.2075143f,
                                1.0f,        1.0f,
                             }
                          };
DWORD FVF = D3DFVF_XYZ | D3DFVF_NORMAL | D3DFVF_TEX1;

LPDIRECT3DTEXTURE9 m_pCloudTexture = NULL;

//雲シェーダー
CLOUDSHADER* m_pCloudShader = NULL;

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

D3DXVECTOR4 LightPos = D3DXVECTOR4( 50.0f, 100.0f, 750.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_pCloudShader = new CLOUDSHADER( m_pd3dDevice );
   m_pCloudShader->Load();


   //雲テクスチャー
   D3DXCreateTextureFromFileEx( m_pd3dDevice,
                                _T("Cloud.bmp"),   //雲テクスチャーのファイル名
                                D3DX_DEFAULT,
                                D3DX_DEFAULT,
                                1,
                                0,
                                D3DFMT_UNKNOWN,
                                D3DPOOL_MANAGED,
                                D3DX_DEFAULT,
                                D3DX_DEFAULT,
                                0x0,
                                NULL,
                                NULL,
                                &m_pCloudTexture );


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

//デバイスのリセット後に初期化すべきオブジェクト
void Restore()
{
   m_pCloudShader->Restore();


   //固定機能パイプラインライティングを設定する
   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, matScaling, matTranslation;

      //遠近射影座標変換
      //クリップ面はアプリケーションごとに調整すること
      D3DXMatrixPerspectiveFovLH( &matPProj,
                                  D3DX_PI/4.0f,
                                  4.0f / 3.0f,
//                                  30.0f,
                                  0.01f,
                                  700.0f );
      m_pd3dDevice->SetTransform( D3DTS_PROJECTION, &matPProj );


      //ビュー座標変換
      D3DXMatrixIdentity( &matView );
      m_pd3dDevice->SetTransform( D3DTS_VIEW, &matView );

      m_pd3dDevice->BeginScene();

      m_pd3dDevice->SetSamplerState( 0, D3DSAMP_MINFILTER, D3DTEXF_LINEAR );
      m_pd3dDevice->SetSamplerState( 0, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR );
      m_pd3dDevice->SetSamplerState( 0, D3DSAMP_MIPFILTER, D3DTEXF_NONE );

      m_pd3dDevice->Clear( 0L,
                           NULL,
                           D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER,
                           0x00000000,
                           1.0f,
                           0L
                         );

      //雲レンダリング
      //アルファブレンドを有効にする
      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 );
      
      D3DXVECTOR3 CloudPos = D3DXVECTOR3( 0.0f, 70.0f, 200.0f );

      D3DXMatrixScaling( &matScaling, 50.0f, 50.0f, 1.0f );
//      D3DXMatrixTranslation( &matTranslation, 0.0f, 70.0f, 200.0f );
      D3DXMatrixTranslation( &matTranslation, CloudPos.x, CloudPos.y, CloudPos.z );

/*
      matWorld = matScaling * matTranslation;
      //ビルボードマトリックスを取得する
      //当サイトのビルボードページを参照すること
      matWorld = GetBillBoardMatrix( m_pd3dDevice, &matWorld );
*/
      //視点→雲の位置ベクトル にたいし常に正面を向くような回転行列を作成する
      
      D3DXMATRIX lookCloudMatrix, invViewMatrix;
      D3DXVECTOR3 Eye, Up;

      //ビュー行列の逆行列を作成する
      D3DXMatrixInverse( &invViewMatrix, NULL, &matView );

      //まずビュー行列から視点の位置ベクトルを取得
      D3DXVec3TransformCoord( &Eye, (D3DXVECTOR3*)&EyePos, &invViewMatrix );

      //次にアップベクトルを作成する
      Up = D3DXVECTOR3( 0.0f, 1.0f, 0.0f );
      //方向ベクトルなので平行移動成分は無効にする
      invViewMatrix._41 = invViewMatrix._42 = invViewMatrix._43 = 0.0f;
      D3DXVec3TransformCoord( &Up, (D3DXVECTOR3*)&Up, &invViewMatrix );

      //ビュー行列を作成する
      D3DXMatrixLookAtLH( &lookCloudMatrix, &Eye, &CloudPos, &Up );
      //ワールド空間上で雲を回転させるので、逆行列にする
      D3DXMatrixInverse( &lookCloudMatrix, NULL, &lookCloudMatrix );
      //平行移動は無効にする
      lookCloudMatrix._41 = lookCloudMatrix._42 = lookCloudMatrix._43 = 0.0f;

      matWorld = matScaling * lookCloudMatrix * matTranslation;

      m_pCloudShader->Begin();
      m_pCloudShader->SetCloudColor( 1.0f );
      m_pd3dDevice->SetTexture( 0, m_pCloudTexture );
      m_pd3dDevice->SetFVF( FVF );
      D3DXVECTOR4 SkyLightDir = D3DXVECTOR4( 0.0f, -1.0f, 0.0f, 0.0f );
      m_pCloudShader->SetMatrix( &matWorld, &EyePos, &LightPos, &SkyLightDir );
      m_pCloudShader->BeginPass();
      m_pd3dDevice->DrawPrimitiveUP( D3DPT_TRIANGLESTRIP, 2, m_pParticle, sizeof( PARTICLE ) );
      m_pCloudShader->EndPass();
      m_pCloudShader->End();

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

以上です。

「GAME Watch」で紹介されている雲シェーダーではソフトパーティクルや陰生成など他にもいろいろやってます。 燃え尽きたのでやりません(笑)。

さてビルボードマトリックスの作成方法を修正しました。

 
これはカメラを移動させないで上下に回転させたイメージです。カメラを回転させただけなので、本来なら雲の陰に影響があるはずないです。 しかし、修正前のビルボードマトリックスではこのように影響されます。
図1
変な画像だな、あいかわらず(笑)。これはシーンを横から見たイメージです。雲は真横から見てるので直線にみえます。 さて雲の明るさですが、図1の場合暗くなります。

図2
図2の場合は雲が明るくなります。

修正前のビルボードマトリックスの場合、カメラの視線ベクトルに対し垂直に見えるように雲を回転させます。 そのためカメラを回転させただけで雲の陰に影響が出てしまうのです。 修正後のビルボードマトリックスは、カメラ位置から雲の位置への方向ベクトルに対し、垂直に見えるように雲を回転させます。 ソース見るとめんどくさいことになってます。あってると思うけど、どっか間違ってたら指摘してください。


Prev  Top  Next
inserted by FC2 system