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

■パーリンノイズ Prev  Top  Next
関連ページ:ボリュームテクスチャー

無料レンタルサーバー

今回は、パーリンノイズをやります。今給黎氏の著書「DirectX 9 シェーダプログラミングブック」を参考にしてます。パーリンノイズについて詳しく説明されていますので、詳細はそちらを参照してください。(また手抜きか)


なにやら不思議な模様がティーポットに描いてあります。この模様がうにょうにょ動きます。 異次元シーンとかそんなシーンの背景に使用できるのではないでしょうか。

さて今回のポイントは
1.パーリンノイズをボリュームテクスチャーに生成し、
2.生成したランダムな情報をテクセル位置とし、テクスチャーをサンプリングすることによりさまざまなパターンの模様を生成すること
となります。

アニメーションはボリュームテクスチャーのZ方向のテクセル位置をリアルタイムに変更することにより行います。 このへんはボリュームテクスチャーでやってるのでまずそちらを参照するといいでしょう。

---main.cpp---


VOID WINAPI ColorVolumeFill( D3DXVECTOR4* pOut, const D3DXVECTOR3* pTexCoord, const D3DXVECTOR3* pTexelSize, LPVOID pData )
{
   pOut->x = pOut->y = pOut->z = pOut->w = (float)rand() / RAND_MAX;
}

まずパーリンノイズを生成します。この関数はD3DXFillVolumeTexture()関数から呼ばれるコールバック関数です。関数名は何でもいいですが、引数は同じにする必要があります。 引数の意味は引数名を見ればまあわかるでしょう。pDataはテクスチャーの情報とは無関係に渡すことができる引数で、D3DXFillVolumeTexture()関数で渡すことができます。 ここでやってることは単純にピクセルごとに乱数を発生させ0.0f〜1.0fの範囲内に変換しています。計算式を変更すればノイズパターンも変わります。最も重要な処理です。

---PerlinNoise.fx---


float4x4 m_WVP;             //ワールド × ビュー × 射影 行列
float4 m_LightDir;          //平行光源の方向ベクトル
float4 m_Ambient = 0.0f;    //環境光
float  m_Timer = 0.0f;      //アニメーションするためのタイマー。0.0f 〜 1.0f の範囲。

sampler tex0 : register(s0); //パーリンノイズから取得したテクセル情報をもとにサンプリングするテクスチャー
sampler tex1 : register(s1); //ボリュームテクスチャー

struct VS_OUTPUT
{
   float4 Pos   : POSITION;
   float4 Col   : COLOR0;
   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;
   
   //ライティングはランバート拡散照明による
   float3 L = -m_LightDir.xyz;   
   float3 N = normalize( Normal.xyz );
   Out.Col = max( m_Ambient, dot(N, L) );
    
   return Out;
}

float4 PS( VS_OUTPUT In ) : COLOR0
{  
   float4 Out;

   //ボリュームテクスチャーから色情報を取得し、その値をテクセル位置のTV成分とする
   float T = tex3D( tex1, float3( In.Tex, m_Timer ) ).r;
   
   //取得したテクセル位置をもとにテクスチャーをサンプリングし色情報を取得し、その値と拡散反射率を積算する
   Out = tex2D( tex0, float2( 0.0f, T ) ) * In.Col;
   
   return Out;
}

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

「DirectX 9 シェーダプログラミングブック」によるとピクセルシェーダー内でボリュームテクスチャーから テクセル情報を取得するとき、周囲のテクセル位置の情報も一緒に取得しそれらを線形合成してます。ですがフィルターをLINEARにして ボリュームテクスチャーをサンプリングすればぼけてくれるのでイマイチこれをやる必要性がわかりません。まあ理由はあるのでしょうけど。 そんなわけで本のサンプルとは内容が異なってるんですが、どちらがいいのかは自分で判断してください。

---PerlinNoise.h---


class PERLIN_NOISE
{
private:
   LPD3DXEFFECT m_pEffect;
   D3DXHANDLE m_pTechnique, m_pWVP, m_pLightDir, m_pAmbient, m_pTimer;
   D3DXMATRIX m_matView, m_matProj;
   LPDIRECT3DDEVICE9 m_pd3dDevice;

   //テクスチャー
   LPDIRECT3DTEXTURE9 m_pTexture;

   //ボリュームテクスチャー
   LPDIRECT3DVOLUMETEXTURE9 m_pVolumeTexture;

   float Timer;

public:
   PERLIN_NOISE( LPDIRECT3DDEVICE9 pd3dDevice );
   ~PERLIN_NOISE();
   void Invalidate();
   void Restore();
   HRESULT Load( LPD3DXFILL3D pFunction, LPVOID pData, char* pVolumeTextureFileName, char* pTextureFileName, UINT MaxVolumeTextureSize = 64 );
   void Begin();
   void BeginPass();
   void SetAmbient( float Ambient );
   void SetAmbient( D3DXVECTOR4* pAmbient );
   void SetMatrix( D3DXMATRIX* pMatWorld, D3DXVECTOR4* pLightDir );
   void AddTimer( float AddTimer );
   void SetTexture();
   void CommitChanges();
   void EndPass();
   void End();
   BOOL IsOK();
   LPD3DXEFFECT GetEffect(){ return m_pEffect; };
};

---PerlinNoise.cpp---


PERLIN_NOISE::PERLIN_NOISE( LPDIRECT3DDEVICE9 pd3dDevice )
{
   m_pd3dDevice = pd3dDevice;
   
   m_pEffect = NULL;

   m_pTexture = NULL;
   m_pVolumeTexture = NULL;
}

PERLIN_NOISE::~PERLIN_NOISE()
{
   SafeRelease( m_pEffect );
   SafeRelease( m_pTexture );
   SafeRelease( m_pVolumeTexture );
}

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

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

HRESULT PERLIN_NOISE::Load( LPD3DXFILL3D pFunction, LPVOID pData, char* pVolumeTextureFileName, char* pTextureFileName, UINT MaxVolumeTextureSize )
{
   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("PerlinNoise.fx"), NULL, NULL, 0, NULL, &m_pEffect, &pErr );
      if( SUCCEEDED( hr ) )
      {
         //ハードウェアで使用できるボリュームテクスチャーの大きさをチェックする
         UINT VolumeTextureSize = MaxVolumeTextureSize;

         //使用可能な大きさのうち最も大きいサイズを取得する
         while( caps.MaxVolumeExtent < VolumeTextureSize )
         {
            VolumeTextureSize = VolumeTextureSize>>1;
         }

         //小さいボリュームテクスチャーしか作成できないときはシェーダーを無効にする
         if( VolumeTextureSize <= 4 )
            return -1;

         if( pVolumeTextureFileName == NULL )
         {
            //不正な引数
            if( pFunction == NULL )
               return -2;

            //ボリュームテクスチャーを作成
            hr = m_pd3dDevice->CreateVolumeTexture( VolumeTextureSize,
                                                    VolumeTextureSize,
                                                    VolumeTextureSize,
                                                    1,
                                                    0,
                                                    D3DFMT_A8R8G8B8,
                                                    D3DPOOL_MANAGED,
                                                    &m_pVolumeTexture,
                                                    NULL );
            if( FAILED( hr ) )
               return -3;

            //ボリュームテクスチャーに動的に書き込み
            hr = D3DXFillVolumeTexture( m_pVolumeTexture, pFunction, pData );
            if( FAILED( hr ) )
               return -4;
         }
         else
         {
            //ボリュームテクスチャーをファイルからロードする
            hr = D3DXCreateVolumeTextureFromFile( m_pd3dDevice,
                                                  pVolumeTextureFileName,  //ボリュームテクスチャーのファイル名
                                                  &m_pVolumeTexture );
            if( FAILED( hr ) )
               return -5;
         }

         if( pTextureFileName )
         {
            //テクスチャーの初期化
            hr = D3DXCreateTextureFromFileEx( m_pd3dDevice,
                                              pTextureFileName,     //ファイル名
                                              D3DX_DEFAULT,         //幅
                                              D3DX_DEFAULT,         //高さ
                                              1,                    //ミップマップレベル
                                              0,                    //テクスチャーの使用目的
                                              D3DFMT_UNKNOWN,       //フォーマット
                                              D3DPOOL_MANAGED,      //メモリ管理方法
                                              D3DX_DEFAULT,         //フィルタリング方法
                                              D3DX_DEFAULT,         //フィルタリング方法
                                              0x0,                  //カラーキー
                                              NULL,                 //ファイルの情報を格納する構造体
                                              NULL,                 //256色パレットを示す構造体
                                              &m_pTexture );        //IDirect3DTexture9 インターフェイス
            if( FAILED( hr ) )
               return -6;
         }
         else
         {
            if( FAILED( hr ) )
               return -7;
         }

         m_pTechnique = m_pEffect->GetTechniqueByName( "TShader" );
         m_pWVP       = m_pEffect->GetParameterByName( NULL, "m_WVP" );
         m_pLightDir  = m_pEffect->GetParameterByName( NULL, "m_LightDir" );
         m_pAmbient   = m_pEffect->GetParameterByName( NULL, "m_Ambient" );
         m_pTimer     = m_pEffect->GetParameterByName( NULL, "m_Timer" );

         m_pEffect->SetTechnique( m_pTechnique );

         Timer = 0.0f;
      }

      else
         return -8;
   }
   
   else
      return -9;

   return S_OK;
}

void PERLIN_NOISE::Begin()
{
   if(  m_pEffect )
   {
      m_pd3dDevice->GetTransform( D3DTS_VIEW, &m_matView );
      m_pd3dDevice->GetTransform( D3DTS_PROJECTION, &m_matProj );

      m_pEffect->Begin( NULL, 0 );
   }
}

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

void PERLIN_NOISE::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 PERLIN_NOISE::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 PERLIN_NOISE::SetMatrix( D3DXMATRIX* pMatWorld, D3DXVECTOR4* pLightDir )
{
   if( m_pEffect )
   {
      D3DXMATRIX m;
      D3DXVECTOR4 LightDir;
      D3DXVECTOR4 v;

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

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

   //シェーダーを使用できないときは固定機能パイプラインで処理する。
   //ただし等サンプルでは基本的に固定機能パイプライン処理は考慮しないことにしてるため
   //シェーダーの内容によっては意味がない場合があるので注意すること!!
   else
      m_pd3dDevice->SetTransform( D3DTS_WORLD, pMatWorld );
}

void PERLIN_NOISE::AddTimer( float AddTimer )
{
   if( m_pEffect )
   {
      Timer+=AddTimer;
      if( Timer > 1.0f )
         Timer -= 1.0f;
      else if( Timer < 0.0f )
         Timer += 1.0f;

      m_pEffect->SetFloat( m_pTimer, Timer );
   }
}

void PERLIN_NOISE::SetTexture()
{
   if( m_pEffect )
   {
      m_pd3dDevice->SetTexture( 0, m_pTexture );
      m_pd3dDevice->SetTexture( 1, m_pVolumeTexture );
   }
}

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

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

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

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

   return FALSE;
}

めずらしくまじめにエラーチェックしてます(笑)。
D3DXFillVolumeTexture()関数の第二引数のコールバック関数はパーリンノイズクラスの外部から引数として渡されるように設計しました。 この関数は内部の処理方法によりパーリンノイズの模様が替わるため基本的にカスタマイズ可能にする必要があるためです。

---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_pMeshTeapot = NULL;

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

//パーリンノイズクラスの宣言
PERLIN_NOISE* m_pPerlinNoise = NULL;

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

//太陽の位置ベクトル
D3DXVECTOR4 LightPos = D3DXVECTOR4( 52.0f, 30.0f, -30.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_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_pLambert = new LAMBERT1( m_pd3dDevice );
   m_pLambert->Load();
   
   //パーリンノイズクラスの初期化
   m_pPerlinNoise = new PERLIN_NOISE( m_pd3dDevice );
   m_pPerlinNoise->Load( (LPD3DXFILL3D)ColorVolumeFill, NULL, NULL, _T("res\\wood.bmp"), 64 );


   //平行光源の位置ベクトルから方向ベクトルを計算する
   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_pLambert->Invalidate();
   m_pPerlinNoise->Invalidate();
}

//デバイスのリセット後に初期化すべきオブジェクト
void Restore()
{
   m_pLambert->Restore();
   m_pPerlinNoise->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 matProj, matView, matWorld;

      m_pd3dDevice->BeginScene();

      //射影座標変換
      D3DXMatrixPerspectiveFovLH( &matProj,
                                  D3DX_PI/4.0f,
                                  4.0f / 3.0f,
                                  1.0f,
                                  1000.0f
                                );
      m_pd3dDevice->SetTransform( D3DTS_PROJECTION, &matProj );

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

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

      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_pLambert->Begin();
      D3DXMatrixIdentity( &matWorld );
      m_pLambert->SetMatrix( &matWorld, &LightDir );
      m_pd3dDevice->SetTexture( 0, m_pMeshBack->m_pTextures[0] );
      m_pLambert->SetAmbient( 0.0f );
      m_pLambert->BeginPass();
      m_pMeshBack->m_pLocalMesh->DrawSubset( 0 );
      m_pLambert->EndPass();

      //空
      m_pd3dDevice->SetTexture( 0, m_pMeshBack->m_pTextures[1] );
      m_pLambert->SetAmbient( 1.0f );
      m_pLambert->BeginPass();
      m_pMeshBack->m_pLocalMesh->DrawSubset( 1 );
      m_pLambert->EndPass();
      m_pLambert->End();

      //ティーポット
      m_pPerlinNoise->Begin();
      m_pPerlinNoise->SetMatrix( &matTeaPot, &LightDir );
      m_pPerlinNoise->SetAmbient( 0.1f );
      m_pPerlinNoise->AddTimer( 0.0001F );
      m_pPerlinNoise->SetTexture();
      m_pPerlinNoise->BeginPass();
      m_pMeshTeapot->m_pLocalMesh->DrawSubset( 0 );
      m_pPerlinNoise->EndPass();
      m_pPerlinNoise->End();

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

以上です。

パーリンノイズクラスの初期化でwood.bmpというファイルをロードしています。こんなファイルです。
木テクスチャー
この模様を差し替えればティーポットにかかる模様が変わります。いろいろ試してみると面白いと思います。

Prev  Top  Next
inserted by FC2 system