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

■キューブマップ(シェーダー版) Prev  Top  Next
関連ページ:キューブマップ(固定機能パイプライン版)

ドメイン

今回は、キューブマップ(環境マップ)です。キューブマップは、前にもやってますが、今回はシェーダー版です。シェーダーを使用したほうが、他のシェーダーと組み合わせることができるので何かと都合がいいです。 まあまったく同じにするのも芸がないので、2Dテクスチャーを参照して、ピクセル単位で、環境マップの適応率を制御できるようにします。

 
左側がランバート拡散照明で、右側がキューブマップです。 空と地面がトラに映りこんでるのがわかると思います。

キューブマップの概念については既出なので省略します。キューブマップ(固定機能パイプライン版)を参照してください。


今回はキューブマップの適応率をピクセル単位で制御できるようにするので、この辺を説明します。キューブマップの適応率は上のような2Dテクスチャーで制御します。 シェーダー内ではR成分のみ参照します。R成分が1.0fのときオブジェクトのテクスチャーを参照し、0.0fのとき環境マップを参照します。 キューブマップが静的なテクスチャーの場合、そのテクスチャーのアルファ成分にキューブマップの適応率を設定すればメモリの使用量を小さくできますが、 今回はシーンのレンダリングイメージもとに動的にキューブマップを作成するので、キューブマップの適応率は専用テクスチャーに設定します。

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

---CubeMap.fx---


float4x4 m_WVP;                   //ワールド × ビュー × 遠近射影
float4   m_LightDir;              //平行光源の方向ベクトル
float4   m_EyePos;                //視点

sampler tex0 : register(s0);      //オブジェクトのテクスチャー
sampler tex1 : register(s1);      //キューブマップ
sampler tex2 : register(s2);      //キューブマップの反射率

struct VS_OUTPUT
{
   float4 Pos     : POSITION;
   float2 Tex     : TEXCOORD0;    //テクスチャーを参照するためのテクセル
   float3 CubeTex : TEXCOORD1;    //キューブマップを参照するためのテクセル
   float3 Normal  : TEXCOORD2;
};

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 ViewToPos = Pos.xyz - m_EyePos.xyz;
   
   Out.Normal  = normalize( Normal.xyz );
      
   //法線ベクトルを元に視線ベクトルの反射ベクトルを計算する(注意1)
   Out.CubeTex = normalize(reflect(ViewToPos, Out.Normal));

   return Out;
}

float4 PS( VS_OUTPUT In ) : COLOR0
{ 
   //ハーフランバートによる拡散反射率の計算
   float4 Out;
   float p = dot(In.Normal, -m_LightDir.xyz);
   p = p * 0.5f + 0.5;
   p = p * p;
   
   //テクスチャーマッピングと拡散反射率を適応したカラー情報
   Out = tex2D( tex0, In.Tex );

   //キューブマップの適応率を取得
   float R = tex2D( tex2, In.Tex ).r;
   
   //キューブマップを参照したときのカラー情報を取得
   float4 CubeColor = texCUBE( tex1, In.CubeTex );
   
   //テクスチャーによるカラー情報とキューブマップによるカラー情報を線形合成する
   return ( Out * R + CubeColor * ( 1.0f - R ) ) * p;
}

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

キューブマップを適応します。

(注意1) キューブマップを参照するときの位置を調査します。

キューブマップは反射ベクトルをもとに位置を取得します。

---CubeMap.h---


class CUBEMAP
{
private:
   LPD3DXEFFECT m_pEffect;
   D3DXHANDLE m_pTechnique, m_pWVP, m_pLightDir, m_pEyePos;
   D3DXMATRIX m_matView, m_matProj;
   LPDIRECT3DDEVICE9 m_pd3dDevice;

public:
   CUBEMAP( LPDIRECT3DDEVICE9 pd3dDevice );
   ~CUBEMAP();
   void Invalidate();
   void Restore();
   HRESULT Load();
   void Begin();
   void BeginPass();
   void SetAmbient( float Ambient );
   void SetAmbient( D3DXVECTOR4* pAmbient );
   void SetMatrix( D3DXMATRIX* pMatWorld, D3DXVECTOR4* pCameraPos, D3DXVECTOR4* pLightDir );
   void CommitChanges();
   void EndPass();
   void End();
   BOOL IsOK();
   LPD3DXEFFECT GetEffect(){ return m_pEffect; };
};

---CubeMap.cpp---


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

CUBEMAP::~CUBEMAP()
{
   //SafeReleaseは関数ではなくマクロ
   //#define SafeRelease(x) { if(x) { (x)->Release(); (x)=NULL; } }
   SafeRelease( m_pEffect );
}

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

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

HRESULT CUBEMAP::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("CubeMap.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_pLightDir  = m_pEffect->GetParameterByName( NULL, "m_LightDir" );
         m_pEyePos    = m_pEffect->GetParameterByName( NULL, "m_EyePos" );

         m_pEffect->SetTechnique( m_pTechnique );
      }

      else
      {
         return -1;
      }
   }

   else
   {
      return -2;
   }

   return S_OK;

}

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

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

void CUBEMAP::SetAmbient( float Ambient )
{
   if( m_pEffect == NULL )
   {
      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 CUBEMAP::SetAmbient( D3DXVECTOR4* pAmbient )
{
   if( m_pEffect == NULL )
   {
      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 CUBEMAP::SetMatrix( D3DXMATRIX* pMatWorld, D3DXVECTOR4* pCameraPos, D3DXVECTOR4* pLightDir )
{
   if( m_pEffect )
   {
      D3DXMATRIX m, m1;
      D3DXVECTOR4 LightDir;
      D3DXVECTOR4 v;

      m = (*pMatWorld) * m_matView * m_matProj;
      m_pEffect->SetMatrix( m_pWVP, &m );

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

      //Light
      LightDir = *pLightDir;
      D3DXMatrixInverse( &m1, NULL, pMatWorld );
      D3DXVec4Transform( &v, &LightDir, &m1 );
      D3DXVec4Normalize( &v, &v );
      m_pEffect->SetVector( m_pLightDir, &v );
   }

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

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

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

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

BOOL CUBEMAP::IsOK()
{
   if( m_pEffect == NULL )
      return FALSE;

   return TRUE;
}

キューブマップの制御クラスです。

---Main.cpp---


LPDIRECT3DDEVICE9 m_pd3dDevice = NULL;
D3DPRESENT_PARAMETERS m_d3dParameters;

D3DCAPS9 Caps;

//シーンのメッシュ
//DirectX SDK(December 2004) に添付されているDXUTMesh.cppファイルにあるヘルパークラス群
//背景
CDXUTMesh* m_pMeshBack         = NULL;
//ティーポット
CDXUTMesh* m_pMeshTeapot        = NULL;

//キューブマップ
LPDIRECT3DCUBETEXTURE9 m_pCubeTexture = NULL;

//キューブマップ作成時に使用するZバッファ
LPDIRECT3DSURFACE9     m_pZBuffer     = NULL;

//キューブマッピングの影響率
LPDIRECT3DTEXTURE9 m_pCubePowerTexture = NULL;

//ランバート拡散照明クラスの宣言
LAMBERT1* m_pLambert1 = NULL;

//キューブマップクラスの宣言
CUBEMAP* m_pCubeMap = NULL;

UINT nWidth = 1024;
UINT nHeight = 768;

//太陽の位置ベクトル
D3DXVECTOR4 LightPos = D3DXVECTOR4( 72.0f, 100.0f, 620.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_pMeshBack = new CDXUTMesh();
   m_pMeshBack->Create( m_pd3dDevice, _T("res\\back.x") );
   m_pMeshBack->SetFVF( m_pd3dDevice, D3DFVF_XYZ | D3DFVF_NORMAL | D3DFVF_TEX1 );

   //ティーポット
   m_pMeshTeapot = new CDXUTMesh();
   m_pMeshTeapot->Create( m_pd3dDevice, _T("res\\t-pot.x") );
   m_pMeshTeapot->SetFVF( m_pd3dDevice, D3DFVF_XYZ | D3DFVF_NORMAL | D3DFVF_TEX1 );

   m_pd3dDevice->GetDeviceCaps(&Caps);

   //キューブマッピングの影響率を制御するテクスチャーのロード
   D3DXCreateTextureFromFileEx( m_pd3dDevice,
                                "CubePower.bmp",         //ファイル名
                                D3DX_DEFAULT,            //幅
                                D3DX_DEFAULT,            //高さ
                                1,                       //ミップマップレベル
                                0,                       //テクスチャーの使用目的
                                D3DFMT_UNKNOWN,          //フォーマット
                                D3DPOOL_MANAGED,         //メモリ管理方法
                                D3DX_DEFAULT,            //フィルタリング方法
                                D3DX_DEFAULT,            //フィルタリング方法
                                0x0,                     //カラーキー
                                NULL,                    //ファイルの情報を格納する構造体
                                NULL,                    //256色パレットを示す構造体
                                &m_pCubePowerTexture );  //IDirect3DTexture9 インターフェイス

   //ランバート拡散照明クラスの初期化
   m_pLambert1 = new LAMBERT1( m_pd3dDevice );
   m_pLambert1->Load();
   
   //キューブマップクラスの初期化
   m_pCubeMap = new CUBEMAP( m_pd3dDevice );

   //キューブマップが使用できるときのみ初期化する。初期化できないときはキューブマップを使用しないで固定機能パイプラインによりライティングする。
   //2の累乗のサイズでない、キューブマップを作成するときはD3DPTEXTURECAPS_CUBEMAP_POW2もチェックする
   //ミップマップ化キューブテクスチャーを作成するときはD3DPTEXTURECAPS_MIPCUBEMAPもチェックする
   if( (Caps.TextureCaps & D3DPTEXTURECAPS_CUBEMAP) )
      m_pCubeMap->Load();


   //平行光源の光の方向ベクトルを計算
   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_pCubeMap->Invalidate();

   SafeRelease( m_pZBuffer );
   SafeRelease( m_pCubeTexture );
}

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

   if( m_pCubeMap->IsOK() )
   {
      D3DXCreateCubeTexture( m_pd3dDevice,
                             128,                     //キューブマップは湾曲サーフェイスに適用されるため、解像度は小さくてよい
                             1,                       //今回はミップマップを無効にする
                             D3DUSAGE_RENDERTARGET,   //キューブマップにレンダリングを行うため、レンダリングターゲットを指定する
                             D3DFMT_X8R8G8B8,         //フォーマット
                             D3DPOOL_DEFAULT,         //レンダーターゲットサーフェイスを指定するのでD3DPOOL_DEFAULTを指定する
                             &m_pCubeTexture );

      //キューブマップレンダリング時に使用するZバッファサーフェイスを作成する
      m_pd3dDevice->CreateDepthStencilSurface( 128,
                                               128,
                                               D3DFMT_D16,
                                               m_d3dParameters.MultiSampleType,
                                               m_d3dParameters.MultiSampleQuality,
                                               TRUE,
                                               &m_pZBuffer,
                                               NULL );
   }
   

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

//背景のレンダリング
void RenderBackImage( D3DXMATRIX* matWorld )
{
   m_pLambert1->Begin();
   m_pLambert1->SetMatrix( matWorld, &LightDir );
   m_pLambert1->SetAmbient( 1.0f );
   m_pd3dDevice->SetTexture( 0, m_pMeshBack->m_pTextures[0] );
   m_pLambert1->BeginPass();
   m_pMeshBack->GetLocalMesh()->DrawSubset(0);
   m_pLambert1->EndPass();
   m_pLambert1->End();
}

//メッセージループからコールされる関数
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;

      //パースつき射影座標変換
      D3DXMatrixPerspectiveFovLH( &matProj,
                                  D3DX_PI/4.0f,
                                  4.0f / 3.0f,
                                  5.0f,
                                  1000.0f );
      m_pd3dDevice->SetTransform( D3DTS_PROJECTION, &matProj );

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

      //ワールド座標変換
      D3DXMatrixIdentity( &matWorld );

      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->SetSamplerState( 2, D3DSAMP_MINFILTER, D3DTEXF_LINEAR );
      m_pd3dDevice->SetSamplerState( 2, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR );
      m_pd3dDevice->SetSamplerState( 2, D3DSAMP_MIPFILTER, D3DTEXF_NONE );

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

      m_pd3dDevice->BeginScene();
      
      //****************************************************************
      //STEP1 : 環境マップの元となる背景をレンダリング
      //****************************************************************
      
      //背景をレンダリング
      RenderBackImage( &matWorld );
      
      //****************************************************************
      //STEP2 : キューブマップの作成
      //****************************************************************

      //トラの絶対位置座標。キューブマップを作成するときの視点の位置座標にもなる。
      D3DXVECTOR3 Pos = D3DXVECTOR3( 0.0f, 0.0f, 350.0f );
         
      //トラのワールド行列
      D3DXMATRIX matTiger, matScaling, matRotationY, matTranslation;
      D3DXMatrixRotationY( &matRotationY, D3DXToRadian( 0.0f ) );
      D3DXMatrixScaling( &matScaling, 8.0f, 8.0f, 8.0f );
      D3DXMatrixTranslation( &matTranslation, Pos.x, Pos.y, Pos.z );
      matTiger = matRotationY * matScaling * matTranslation;
    
      if( m_pCubeMap->IsOK() )
      {
         //現在のビューと射影座標変換マトリックスを保存する
         D3DXMATRIX matViewSave, matProjSave;
         m_pd3dDevice->GetTransform( D3DTS_VIEW,       &matViewSave );
         m_pd3dDevice->GetTransform( D3DTS_PROJECTION, &matProjSave );
   
         //ビューポートを切り替える
         //サイズはキューブマップサーフェイスのサイズと同じにする
         D3DVIEWPORT9 OldViewport, Viewport;
         m_pd3dDevice->GetViewport( &OldViewport );
         Viewport.Height = 128;
         Viewport.Width  = 128;
         Viewport.MaxZ   = 1.0f;
         Viewport.MinZ   = 0.0f;
         Viewport.X      = 0;
         Viewport.Y      = 0;
         m_pd3dDevice->SetViewport( &Viewport );
   
         //現在のバックバッファとZバッファを保存する
         LPDIRECT3DSURFACE9 OldBackBuffer, OldZBuffer;
         m_pd3dDevice->GetRenderTarget( 0, &OldBackBuffer );
         m_pd3dDevice->GetDepthStencilSurface( &OldZBuffer );
         //Zバッファサーフェイスを切り替える
         m_pd3dDevice->SetDepthStencilSurface( m_pZBuffer );
   
         //射影では 90°の視野を使うことに注意する。
         D3DXMatrixPerspectiveFovLH( &matProj, D3DX_PI / 2, 1.0f, 0.1f, 1000.0f );
         m_pd3dDevice->SetTransform(D3DTS_PROJECTION, &matProj);
   
         //キューブ マップの 6 つの面をそれぞれにレンダリングする
         //上向ベクトルは(0, 1, 0)を定義する 
         D3DXVECTOR3 vLookatPt, LookAt, vUpVec;
   
         for( int i=0; i < 6; i++ )
         {
            switch( i )
            {
            case D3DCUBEMAP_FACE_POSITIVE_X:
               vLookatPt = D3DXVECTOR3(  1.0f,  0.0f,  0.0f );
               vUpVec    = D3DXVECTOR3(  0.0f,  1.0f,  0.0f );
               break;
            case D3DCUBEMAP_FACE_NEGATIVE_X:
               vLookatPt = D3DXVECTOR3( -1.0f,  0.0f,  0.0f );
               vUpVec    = D3DXVECTOR3(  0.0f,  1.0f,  0.0f );
               break;
            case D3DCUBEMAP_FACE_POSITIVE_Y:
               vLookatPt = D3DXVECTOR3(  0.0f,  1.0f,  0.0f );
               vUpVec    = D3DXVECTOR3(  0.0f,  0.0f, -1.0f );
               break;
            case D3DCUBEMAP_FACE_NEGATIVE_Y:
               vLookatPt = D3DXVECTOR3(  0.0f, -1.0f,  0.0f );
               vUpVec    = D3DXVECTOR3(  0.0f,  0.0f,  1.0f );
               break;
            case D3DCUBEMAP_FACE_POSITIVE_Z:
               vLookatPt = D3DXVECTOR3(  0.0f,  0.0f,  1.0f );
               vUpVec    = D3DXVECTOR3(  0.0f,  1.0f,  0.0f );
               break;
            case D3DCUBEMAP_FACE_NEGATIVE_Z:
               vLookatPt = D3DXVECTOR3(  0.0f,  0.0f, -1.0f );
               vUpVec    = D3DXVECTOR3(  0.0f,  1.0f,  0.0f );
               break;
            }
   
            D3DXMATRIX mv;
            
            //トラの位置ベクトル(キューブマップ作成時の視点位置) + 視線ベクトル
            LookAt = Pos + vLookatPt;
            
            //ビューマトリックスを計算
            D3DXMatrixLookAtLH( &mv, &Pos, &LookAt, &vUpVec );
            //ビューマトリックスを設定する
            m_pd3dDevice->SetTransform(D3DTS_VIEW, &mv);
   
            // サーフェイスをレンダリングするために、そのポインタを取得する
            LPDIRECT3DSURFACE9 pFace;
            m_pCubeTexture->GetCubeMapSurface( (D3DCUBEMAP_FACES)i, 0, &pFace );
            m_pd3dDevice->SetRenderTarget( 0, pFace );
   
            //キューブマップの場合、基本的に色情報はすべて塗りつぶすので、Zバッファのみクリアする
            m_pd3dDevice->Clear( 0L,
                                 NULL,
                                 D3DCLEAR_ZBUFFER,
                                 0x0, 
                                 1.0f,
                                 0L );

            //背景のレンダリング
            D3DXMatrixIdentity( &matWorld );
            RenderBackImage( &matWorld );

            SafeRelease( pFace );
         }
         
         //レンダーターゲットをバックバッファに戻す
         m_pd3dDevice->SetRenderTarget( 0, OldBackBuffer );
         //Zバッファを戻す
         m_pd3dDevice->SetDepthStencilSurface( OldZBuffer );

         SafeRelease( OldBackBuffer );
         SafeRelease( OldZBuffer );

         //元の座標変換行列に戻す
         m_pd3dDevice->SetTransform( D3DTS_VIEW,       &matViewSave );
         m_pd3dDevice->SetTransform( D3DTS_PROJECTION, &matProjSave );
          
         //元のビューポートに戻す
         m_pd3dDevice->SetViewport( &OldViewport );
      }


      //****************************************************************
      //STEP3 : キューブマップを適応しトラをレンダリング
      //****************************************************************
      
      m_pd3dDevice->SetTexture( 1, m_pCubeTexture );
      m_pd3dDevice->SetTexture( 2, m_pCubePowerTexture );
      m_pCubeMap->Begin();
      m_pCubeMap->SetMatrix( &matTiger, &EyePos, &LightDir );
      m_pCubeMap->SetAmbient( 0.3f );
      m_pCubeMap->BeginPass();

      for( UINT i=0; im_dwNumMaterials; i++ )
      {
         m_pd3dDevice->SetTexture( 0, m_pMeshTeapot->m_pTextures[i] );
         m_pMeshTeapot->GetLocalMesh()->DrawSubset(i);
      }

      m_pCubeMap->EndPass();
      m_pCubeMap->End();
      m_pd3dDevice->SetTexture( 1, NULL );
      m_pd3dDevice->SetTexture( 2, NULL );

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

以上です。

サンプルが悪くて(いつもだけど)いまいちキューブマップの効果がわからないかもしれません。 本来ステンレスなどの周囲の背景が移りこむ金属の質感のシェーディングに使用します。 金属なんでフォンシェーディングによるハイライトを追加するとリアルになるでしょう。やってみてください。

Prev  Top  Next
inserted by FC2 system