《精通DirectX 3D》 第三十三章 凹凸纹理映射应用 02_BumpWaves

《精通DirectX 3D》 第三十三章 凹凸纹理映射应用 02_BumpWaves

效果啧啧啊！活的水！

// =============================================================================
//  Desc: 主程序源代码
// =============================================================================
#include  " dxstdafx.h "
#include  " resource.h "


// -----------------------------------------------------------------------------
//  Desc: 全局变量
// -----------------------------------------------------------------------------
ID3DXFont *                  g_pFont  =  NULL;           // ID3DXFont字体对象
ID3DXSprite *                g_pTextSprite  =  NULL;     // ID3DXSprite文本精灵对象
bool                        g_bShowHelp  =   true ;       // 标识是否显示简单说明文本

CDXUTDialogResourceManager g_DialogResourceManager;  // 对话框资源管理器
CD3DSettingsDlg            g_SettingsDlg;            // Direct3D设备设置对话框
CDXUTDialog                g_HUD;                    // 对话框
CDXUTDialog                g_SampleUI;               // 对话框

LPDIRECT3DVERTEXBUFFER9    g_pBackgroundVB;          // 背景矩形顶点缓冲区
LPDIRECT3DTEXTURE9         g_pBackgroundTexture;     // 背景纹理
LPDIRECT3DVERTEXBUFFER9    g_pWaterVB;               // 水波网格模型顶点缓冲区
LPDIRECT3DTEXTURE9         g_psBumpMap;              // 凹凸纹理
D3DXMATRIXA16              g_matBumpMat;             // 世界矩阵

const  UINT g_n  =   2 ;                             // 水波网格模型x轴方向的顶点数目
const  UINT g_m  =   2 ;                             // 水波网格模型y轴方向的顶点数目
const  UINT g_nTriangles  =  (g_n - 1 ) * (g_m - 1 ) * 2 ;    // 水波网格模型的三角形数目


// -----------------------------------------------------------------------------
//  Desc: 顶点结构与顶点格式
// -----------------------------------------------------------------------------
struct  VERTEX
{
    D3DXVECTOR3 p;
     float  tu, tv;
     static   const  DWORD FVF;
};
const  DWORD VERTEX::FVF  =  D3DFVF_XYZ  |  D3DFVF_TEX1;


// -----------------------------------------------------------------------------
//  Desc: 控件ID
// -----------------------------------------------------------------------------
#define  IDC_TOGGLEFULLSCREEN      1
#define  IDC_TOGGLEREF             2
#define  IDC_CHANGEDEVICE          3


// -----------------------------------------------------------------------------
//  Desc: 函数声明
// ------------------------------------------------------------------------------
bool     CALLBACK IsDeviceAcceptable( D3DCAPS9 *  pCaps, D3DFORMAT AdapterFormat, D3DFORMAT BackBufferFormat,  bool  bWindowed,  void *  pUserContext );
bool     CALLBACK ModifyDeviceSettings( DXUTDeviceSettings *  pDeviceSettings,  const  D3DCAPS9 *  pCaps,  void *  pUserContext );
HRESULT CALLBACK OnCreateDevice( IDirect3DDevice9 *  pd3dDevice,  const  D3DSURFACE_DESC *  pBackBufferSurfaceDesc,  void *  pUserContext );
HRESULT CALLBACK OnResetDevice( IDirect3DDevice9 *  pd3dDevice,  const  D3DSURFACE_DESC *  pBackBufferSurfaceDesc,  void *  pUserContext );
void     CALLBACK OnFrameMove( IDirect3DDevice9 *  pd3dDevice,  double  fTime,  float  fElapsedTime,  void *  pUserContext );
void     CALLBACK OnFrameRender( IDirect3DDevice9 *  pd3dDevice,  double  fTime,  float  fElapsedTime,  void *  pUserContext );
LRESULT CALLBACK MsgProc( HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam,  bool *  pbNoFurtherProcessing,  void *  pUserContext );
void     CALLBACK KeyboardProc( UINT nChar,  bool  bKeyDown,  bool  bAltDown,  void *  pUserContext );
void     CALLBACK OnGUIEvent( UINT nEvent,  int  nControlID, CDXUTControl *  pControl,  void *  pUserContext );
void     CALLBACK OnLostDevice(  void *  pUserContext );
void     CALLBACK OnDestroyDevice(  void *  pUserContext );

void     InitApp();
void     RenderText();

HRESULT CreateBumpMap(IDirect3DDevice9 *  pd3dDevice);
HRESULT SetEMBMStates(IDirect3DDevice9 *  pd3dDevice,  float  fTime);
inline DWORD F2DW( FLOAT f ) {  return   * ((DWORD * ) & f); }


// -----------------------------------------------------------------------------
//  Desc: 入口函数
// -----------------------------------------------------------------------------
INT WINAPI WinMain( HINSTANCE, HINSTANCE, LPSTR,  int  )
{
     // 为Debug配置启用运行时内存检查功能
#if  defined(DEBUG) | defined(_DEBUG)
    _CrtSetDbgFlag( _CRTDBG_ALLOC_MEM_DF  |  _CRTDBG_LEAK_CHECK_DF );
#endif

     // 设置回调函数
    DXUTSetCallbackDeviceCreated( OnCreateDevice );
    DXUTSetCallbackDeviceReset( OnResetDevice );
    DXUTSetCallbackDeviceLost( OnLostDevice );
    DXUTSetCallbackDeviceDestroyed( OnDestroyDevice );
    DXUTSetCallbackMsgProc( MsgProc );
    DXUTSetCallbackKeyboard( KeyboardProc );
    DXUTSetCallbackFrameRender( OnFrameRender );
    DXUTSetCallbackFrameMove( OnFrameMove );

     // 应用程序相关的初始化
    InitApp();

     // 初始化DXUT, 创建窗口, 创建Direct3D设备对象
    DXUTInit(  true ,  true ,  true  );
    DXUTSetCursorSettings(  true ,  true  );
    DXUTCreateWindow( L " BumpWaves "  );
    DXUTCreateDevice( D3DADAPTER_DEFAULT,  true ,  640 ,  480 , 
        IsDeviceAcceptable, ModifyDeviceSettings );

     // 进入消息循环和场景渲染
    DXUTMainLoop();

     // 在此进行应用程序相关的清除工作

     return  DXUTGetExitCode();
}


// -----------------------------------------------------------------------------
//  Desc: 应用程序相关初始化
// -----------------------------------------------------------------------------
void  InitApp()
{
     // 初始化对话框
    g_SettingsDlg.Init(  & g_DialogResourceManager );
    g_HUD.Init(  & g_DialogResourceManager );
    g_SampleUI.Init(  & g_DialogResourceManager );

     // 为g_HUD对话框设置消息处理函数,添加控件
    g_HUD.SetCallback( OnGUIEvent );  int  iY  =   10 ; 
    g_HUD.AddButton( IDC_TOGGLEFULLSCREEN, L " Toggle full screen " ,  35 , iY,  125 ,  22  );
    g_HUD.AddButton( IDC_TOGGLEREF, L " Toggle REF (F3) " ,  35 , iY  +=   24 ,  125 ,  22  );
    g_HUD.AddButton( IDC_CHANGEDEVICE, L " Change device (F2) " ,  35 , iY  +=   24 ,  125 ,  22 , VK_F2 );
}


// -----------------------------------------------------------------------------
//  Desc: 设备能力检查
// -----------------------------------------------------------------------------
bool  CALLBACK IsDeviceAcceptable( D3DCAPS9 *  pCaps, D3DFORMAT AdapterFormat, 
                                  D3DFORMAT BackBufferFormat,  bool  bWindowed, 
                                   void *  pUserContext )
{
     // 检查后台缓冲区格式是否支持Alpha混合等操作(post pixel blending operations)
    IDirect3D9 *  pD3D  =  DXUTGetD3DObject(); 
     if ( FAILED( pD3D -> CheckDeviceFormat( pCaps -> AdapterOrdinal, pCaps -> DeviceType,
                    AdapterFormat, D3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING, 
                    D3DRTYPE_TEXTURE, BackBufferFormat ) ) )
         return   false ;

     // 检查当前设备是否支持凹凸纹理映射
     if (  0   ==  ( pCaps -> TextureOpCaps  &  D3DTEXOPCAPS_BUMPENVMAPLUMINANCE ) )
         return   false ;

     // 检查当前设备是否支持D3DFMT_V8U8 格式的纹理
     if ( FAILED( pD3D -> CheckDeviceFormat( pCaps -> AdapterOrdinal,
                                         pCaps -> DeviceType, AdapterFormat,
                                          0 , D3DRTYPE_TEXTURE,
                                         D3DFMT_V8U8 ) ) )
         return   false ;

     return   true ;
}


// -----------------------------------------------------------------------------
//  Desc: 修改Direct3D渲染设备设置
// -----------------------------------------------------------------------------
bool  CALLBACK ModifyDeviceSettings( DXUTDeviceSettings *  pDeviceSettings, 
                                     const  D3DCAPS9 *  pCaps,  void *  pUserContext )
{
     // 如果不支持硬件顶点处理则使用软件顶点处理
     if ( (pCaps -> DevCaps  &  D3DDEVCAPS_HWTRANSFORMANDLIGHT)  ==   0 )
    {
        pDeviceSettings -> BehaviorFlags  =  D3DCREATE_SOFTWARE_VERTEXPROCESSING;
    }

     // 如果使用参考设备,则弹出警告对话框
     static   bool  s_bFirstTime  =   true ;
     if ( s_bFirstTime )
    {
        s_bFirstTime  =   false ;
         if ( pDeviceSettings -> DeviceType  ==  D3DDEVTYPE_REF )
            DXUTDisplaySwitchingToREFWarning();
    }

     return   true ;
}


// -----------------------------------------------------------------------------
//  Desc: 在此创建管理内存资源对象
// -----------------------------------------------------------------------------
HRESULT CALLBACK OnCreateDevice( IDirect3DDevice9 *  pd3dDevice, 
                                 const  D3DSURFACE_DESC *  pBackBufferSurfaceDesc, 
                                 void *  pUserContext )
{
    HRESULT hr;

    V_RETURN( g_DialogResourceManager.OnCreateDevice( pd3dDevice ) );
    V_RETURN( g_SettingsDlg.OnCreateDevice( pd3dDevice ) );
    
     // 创建字体
    V_RETURN( D3DXCreateFont( pd3dDevice,  15 ,  0 , FW_BOLD,  1 , FALSE, DEFAULT_CHARSET, 
                         OUT_DEFAULT_PRECIS, DEFAULT_QUALITY, DEFAULT_PITCH  |  FF_DONTCARE, 
                         L " Arial " ,  & g_pFont ) );

     // 创建背景纹理
    V_RETURN( D3DXCreateTextureFromFile( pd3dDevice, L " Lake.bmp " ,  & g_pBackgroundTexture ));
    
     // 创建凹凸纹理
     CreateBumpMap(pd3dDevice);
     if ( NULL  ==  g_psBumpMap )
         return  E_FAIL;

     // 创建背景矩形顶点缓冲区
    V_RETURN( pd3dDevice -> CreateVertexBuffer(  4 * sizeof (VERTEX),
                                              D3DUSAGE_WRITEONLY, VERTEX::FVF,
                                              D3DPOOL_MANAGED,  & g_pBackgroundVB, NULL ));

     // 填充背景矩形顶点缓冲区
    VERTEX *  v;
    g_pBackgroundVB -> Lock(  0 ,  0 , ( void ** ) & v,  0  );
    v[ 0 ].p   =  D3DXVECTOR3( - 1000.0f ,     0.0f ,  0.0f  );
    v[ 1 ].p   =  D3DXVECTOR3( - 1000.0f ,  1000.0f ,  0.0f  );
    v[ 2 ].p   =  D3DXVECTOR3(  1000.0f ,     0.0f ,  0.0f  );
    v[ 3 ].p   =  D3DXVECTOR3(  1000.0f ,  1000.0f ,  0.0f  );
    v[ 0 ].tu  =   0.0f ; v[ 0 ].tv  =   147 / 256.0f ;
    v[ 1 ].tu  =   0.0f ; v[ 1 ].tv  =   0.0f ;
    v[ 2 ].tu  =   1.0f ; v[ 2 ].tv  =   147 / 256.0f ;
    v[ 3 ].tu  =   1.0f ; v[ 3 ].tv  =   0.0f ;
    g_pBackgroundVB -> Unlock();
  
     // 创建水波网格模型顶点缓冲区
    V_RETURN( pd3dDevice -> CreateVertexBuffer( g_nTriangles * 3 * sizeof (VERTEX),
                                              D3DUSAGE_WRITEONLY, VERTEX::FVF,
                                              D3DPOOL_MANAGED,  & g_pWaterVB, NULL ));

     // 填充水波网格模型顶点缓冲区
    g_pWaterVB -> Lock(  0 ,  0 , ( void ** ) & v,  0  );
     float  dX  =   2000.0f / (g_n - 1 );
     float  dZ  =   1250.0f / (g_m - 1 );
     float  x0  =   - 1000 ;
     float  z0  =   - 1250 ;
     float  dU  =   1.0f / (g_n - 1 );
     float  dV  =   0.7f / (g_m - 1 );
    UINT k  =   0 ;
     for  (UINT z = 0 ; z  <  (g_m - 1 ); z ++ )
    {
         for  (UINT x = 0 ; x  <  (g_n - 1 ); x ++ )
        {
            v[k].p   =  D3DXVECTOR3(x0  +  x * dX,  0.0f , z0  +  z * dZ );
            v[k].tu  =  x * dU;
            v[k].tv  =  z * dV;
            k ++ ;
            v[k].p   =  D3DXVECTOR3(x0  +  x * dX,  0.0f , z0  +  (z + 1 ) * dZ );
            v[k].tu  =  x * dU;
            v[k].tv  =  (z + 1 ) * dV;
            k ++ ;
            v[k].p   =  D3DXVECTOR3(x0  +  (x + 1 ) * dX,  0.0f , z0  +  (z + 1 ) * dZ );
            v[k].tu  =  (x + 1 ) * dU;
            v[k].tv  =  (z + 1 ) * dV;
            k ++ ;
            v[k].p   =  D3DXVECTOR3(x0  +  x * dX,  0.0f , z0  +  z * dZ );
            v[k].tu  =  x * dU;
            v[k].tv  =  z * dV;
            k ++ ;
            v[k].p   =  D3DXVECTOR3(x0  +  (x + 1 ) * dX,  0.0f , z0  +  (z + 1 ) * dZ );
            v[k].tu  =  (x + 1 ) * dU;
            v[k].tv  =  (z + 1 ) * dV;
            k ++ ;
            v[k].p   =  D3DXVECTOR3(x0  +  (x + 1 ) * dX,  0.0f , z0  +  z * dZ );
            v[k].tu  =  (x + 1 ) * dU;
            v[k].tv  =  z * dV;
            k ++ ;
        }
    }
    g_pWaterVB -> Unlock();

     return  S_OK;
}


// -----------------------------------------------------------------------------
//  Desc: 在此创建默认内存类型资源对象
// -----------------------------------------------------------------------------
HRESULT CALLBACK OnResetDevice( IDirect3DDevice9 *  pd3dDevice, 
                                 const  D3DSURFACE_DESC *  pBackBufferSurfaceDesc, 
                                 void *  pUserContext )
{
    HRESULT hr;

    V_RETURN( g_DialogResourceManager.OnResetDevice() );
    V_RETURN( g_SettingsDlg.OnResetDevice() );

     // 设置对话框位置和尺寸
    g_HUD.SetLocation( pBackBufferSurfaceDesc -> Width - 170 ,  0  );
    g_HUD.SetSize(  170 ,  170  );
    g_SampleUI.SetLocation( pBackBufferSurfaceDesc -> Width - 170 , 
                            pBackBufferSurfaceDesc -> Height - 350  );
    g_SampleUI.SetSize(  170 ,  300  );

     // 恢复字体
     if ( g_pFont )
        V_RETURN( g_pFont -> OnResetDevice() );
   
     // 创建ID3DXSprite接口对象
    V_RETURN( D3DXCreateSprite( pd3dDevice,  & g_pTextSprite ) );

     // 设置世界变换矩阵
    D3DXMATRIXA16 matWorld;
    D3DXMatrixIdentity(  & matWorld );
    pd3dDevice -> SetTransform( D3DTS_WORLD,  & matWorld );

     // 设置观察矩阵
    D3DXMATRIXA16 matView;
    D3DXVECTOR3 vEyePt(     0.0f ,  400.0f ,  - 1650.0f  );
    D3DXVECTOR3 vLookatPt(  0.0f ,    0.0f ,      0.0f  );
    D3DXVECTOR3 vUpVec(     0.0f ,    1.0f ,      0.0f  );
    D3DXMatrixLookAtLH(  & matView,  & vEyePt,  & vLookatPt,  & vUpVec );
    pd3dDevice -> SetTransform( D3DTS_VIEW,  & matView );

     // 设置投影矩阵
    D3DXMATRIXA16 matProj;
    D3DXMatrixPerspectiveFovLH(  & matProj,  1.00f ,  1.0f ,  1.0f ,  10000.0f  );
    pd3dDevice -> SetTransform( D3DTS_PROJECTION,  & matProj );

     // 设置纹理过滤方式
    pd3dDevice -> SetSamplerState(  0 , D3DSAMP_MINFILTER, D3DTEXF_LINEAR );
    pd3dDevice -> SetSamplerState(  0 , D3DSAMP_MAGFILTER, D3DTEXF_LINEAR );
    pd3dDevice -> SetSamplerState(  1 , D3DSAMP_MINFILTER, D3DTEXF_LINEAR );
    pd3dDevice -> SetSamplerState(  1 , D3DSAMP_MAGFILTER, D3DTEXF_LINEAR );

     return  S_OK;
}


// -----------------------------------------------------------------------------
//  Desc: 更新场景
// -----------------------------------------------------------------------------
void  CALLBACK OnFrameMove( IDirect3DDevice9 *  pd3dDevice,  double  fTime, 
                            float  fElapsedTime,  void *  pUserContext )
{
}


// -----------------------------------------------------------------------------
//  Desc: 渲染场景
// -----------------------------------------------------------------------------
void  CALLBACK OnFrameRender( IDirect3DDevice9 *  pd3dDevice,  double  fTime, 
                             float  fElapsedTime,  void *  pUserContext )
{
    HRESULT hr;
  
     // 如果正在利用Direct3D设备设置对话框进行设置, 则不渲染场景
     if ( g_SettingsDlg.IsActive() )
    {
        g_SettingsDlg.OnRender( fElapsedTime );
         return ;
    }

     // 清除后台颜色缓冲区和深度缓冲区
    V( pd3dDevice -> Clear( 0 , NULL, D3DCLEAR_TARGET  |  D3DCLEAR_ZBUFFER, 
                         D3DCOLOR_ARGB( 0 ,  45 ,  50 ,  170 ),  1.0f ,  0 ) );

     // 渲染场景
     if ( SUCCEEDED( pd3dDevice -> BeginScene() ) )
    {

         // 为渲染背景举行设置纹理渲染状态
        pd3dDevice -> SetTexture(  0 , g_pBackgroundTexture );
        pd3dDevice -> SetTextureStageState(  0 , D3DTSS_COLORARG1, D3DTA_TEXTURE );
        pd3dDevice -> SetTextureStageState(  0 , D3DTSS_COLOROP,   D3DTOP_SELECTARG1 );
        pd3dDevice -> SetTextureStageState(  1 , D3DTSS_COLOROP,   D3DTOP_DISABLE );

         // 渲染背景矩形
        pd3dDevice -> SetFVF( VERTEX::FVF );
        pd3dDevice -> SetStreamSource(  0 , g_pBackgroundVB,  0 ,  sizeof (VERTEX) );
        pd3dDevice -> DrawPrimitive( D3DPT_TRIANGLESTRIP,  0 ,  2  );

         // 为渲染水波设置纹理渲染状态
        SetEMBMStates( pd3dDevice, ( float )fTime );

         // 渲染水波网格模型
        pd3dDevice -> SetFVF( VERTEX::FVF );
        pd3dDevice -> SetStreamSource(  0 , g_pWaterVB,  0 ,  sizeof (VERTEX) );
        pd3dDevice -> DrawPrimitive( D3DPT_TRIANGLELIST,  0 , g_nTriangles );

         // 渲染文本和控件
        DXUT_BeginPerfEvent( DXUT_PERFEVENTCOLOR, L " HUD / Stats "  ); 
        RenderText();
        V( g_HUD.OnRender( fElapsedTime ) );
        V( g_SampleUI.OnRender( fElapsedTime ) );
        DXUT_EndPerfEvent();

         // 结束渲染场景
        V( pd3dDevice -> EndScene() );
    }
}


// -----------------------------------------------------------------------------
//  Desc: 渲染文本
// -----------------------------------------------------------------------------
void  RenderText()
{
    CDXUTTextHelper txtHelper( g_pFont, g_pTextSprite,  15  );

     // 显示当前Direct3D设备状态和渲染帧速率
    txtHelper.Begin();
    txtHelper.SetInsertionPos(  5 ,  5  );
    txtHelper.SetForegroundColor( D3DXCOLOR(  1.0f ,  1.0f ,  0.0f ,  1.0f  ) );
    txtHelper.DrawTextLine( DXUTGetFrameStats( true ) );
    txtHelper.DrawTextLine( DXUTGetDeviceStats() );

     // 显示其他简要信息
    txtHelper.SetForegroundColor( D3DXCOLOR(  1.0f ,  1.0f ,  1.0f ,  1.0f  ) );
    txtHelper.DrawTextLine( L " 水波效果模拟 "  );
    
     // 显示简单帮助文本
     const  D3DSURFACE_DESC *  pd3dsdBackBuffer  =  DXUTGetBackBufferSurfaceDesc();
     if ( g_bShowHelp )
    {
        txtHelper.SetInsertionPos(  10 , pd3dsdBackBuffer -> Height - 15 * 6  );
        txtHelper.SetForegroundColor( D3DXCOLOR(  1.0f ,  0.75f ,  0.0f ,  1.0f  ) );
        txtHelper.DrawTextLine( L " Controls (F1 to hide): "  );

        txtHelper.SetInsertionPos(  40 , pd3dsdBackBuffer -> Height - 15 * 5  );
        txtHelper.DrawTextLine( L " Quit: ESC "  );
    }
     else
    {
        txtHelper.SetInsertionPos(  10 , pd3dsdBackBuffer -> Height - 15 * 2  );
        txtHelper.SetForegroundColor( D3DXCOLOR(  1.0f ,  1.0f ,  1.0f ,  1.0f  ) );
        txtHelper.DrawTextLine( L " Press F1 for help "  );
    }
    txtHelper.End();
}


// -----------------------------------------------------------------------------
//  Desc: 消息处理
// -----------------------------------------------------------------------------
LRESULT CALLBACK MsgProc( HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam, 
                          bool *  pbNoFurtherProcessing,  void *  pUserContext )
{
     * pbNoFurtherProcessing  =  g_DialogResourceManager.MsgProc( hWnd, uMsg, wParam, lParam );
     if (  * pbNoFurtherProcessing )
         return   0 ;

     if ( g_SettingsDlg.IsActive() )
    {
        g_SettingsDlg.MsgProc( hWnd, uMsg, wParam, lParam );
         return   0 ;
    }

     * pbNoFurtherProcessing  =  g_HUD.MsgProc( hWnd, uMsg, wParam, lParam );
     if (  * pbNoFurtherProcessing )
         return   0 ;
   
     * pbNoFurtherProcessing  =  g_SampleUI.MsgProc( hWnd, uMsg, wParam, lParam );
     if (  * pbNoFurtherProcessing )
         return   0 ;

     return   0 ;
}


// -----------------------------------------------------------------------------
//  Desc: 键盘消息处理
// -----------------------------------------------------------------------------
void  CALLBACK KeyboardProc( UINT nChar,  bool  bKeyDown,  bool  bAltDown,  void *  pUserContext )
{
     if ( bKeyDown )
    {
         switch ( nChar )
        {
             case  VK_F1: g_bShowHelp  =   ! g_bShowHelp;  break ;
        }
    }
}


// -----------------------------------------------------------------------------
//  Desc: 处理各种控件消息
// -----------------------------------------------------------------------------
void  CALLBACK OnGUIEvent( UINT nEvent,  int  nControlID, CDXUTControl *  pControl, 
                          void *  pUserContext )
{
     switch ( nControlID )
    {
         case  IDC_TOGGLEFULLSCREEN:
            DXUTToggleFullScreen(); 
             break ;

         case  IDC_TOGGLEREF:
            DXUTToggleREF(); 
             break ;

         case  IDC_CHANGEDEVICE:
            g_SettingsDlg.SetActive(  ! g_SettingsDlg.IsActive() ); 
             break ;
    }
}


// -----------------------------------------------------------------------------
//  Desc: 释放在OnResetDevice()中创建的资源
// -----------------------------------------------------------------------------
void  CALLBACK OnLostDevice(  void *  pUserContext )
{
    g_DialogResourceManager.OnLostDevice();
    g_SettingsDlg.OnLostDevice();
     if ( g_pFont )
        g_pFont -> OnLostDevice();
    SAFE_RELEASE( g_pTextSprite );
}


// ------------------------------------------------------------------------------
//  Desc: 释放在OnCreateDevice()中创建的资源
// ------------------------------------------------------------------------------
void  CALLBACK OnDestroyDevice(  void *  pUserContext )
{
    g_DialogResourceManager.OnDestroyDevice();
    g_SettingsDlg.OnDestroyDevice();
    SAFE_RELEASE( g_pFont );

    SAFE_RELEASE( g_pBackgroundTexture );
    SAFE_RELEASE( g_psBumpMap );
    SAFE_RELEASE( g_pBackgroundVB );
    SAFE_RELEASE( g_pWaterVB );
}


// -----------------------------------------------------------------------------
//  Desc: 创建凹凸纹理对象
// -----------------------------------------------------------------------------
HRESULT CreateBumpMap(IDirect3DDevice9 *  pd3dDevice)
{
    HRESULT hr  =  S_OK;
    UINT iWidth   =   256 ;
    UINT iHeight  =   256 ;

     // 创建凹凸纹理
   V_RETURN( pd3dDevice -> CreateTexture( iWidth, iWidth,  1 ,  0 , D3DFMT_V8U8, 
                                        D3DPOOL_MANAGED,  & g_psBumpMap, NULL ));

     // 填充纹理元素 
    D3DLOCKED_RECT d3dlr;
    g_psBumpMap -> LockRect(  0 ,  & d3dlr,  0 ,  0  );
    CHAR *  pDst  =  (CHAR * )d3dlr.pBits;
    CHAR  iDu, iDv;

     for ( DWORD y = 0 ; y < iHeight; y ++  )
    {
        CHAR *  pPixel  =  pDst;

         for ( DWORD x = 0 ; x < iWidth; x ++  )
        {
             float  fx  =  x / (FLOAT)iWidth  -   0.5f ;
             float  fy  =  y / (FLOAT)iHeight  -   0.2f ;

             float  r  =  sqrtf( fx * fx  +  fy * fy );

            iDu  =  (CHAR)(  64   *  cosf(  300.0f   *  r )  *  expf(  - r  *   5.0f  ) );
            iDu  =  iDu  +  (CHAR)(  32   *  cosf(  150.0f   *  ( fx  +  fy ) ) );
            iDu  =  iDu  + (CHAR)(  16   *  cosf(  140.0f   *  ( fx  *   0.85f   -  fy ) ) );

            iDv  =  (CHAR)(  64   *  sinf(  300.0f   *  r )  *  expf(  - r  *   5.0f  ) );
            iDv  =  iDv  +  (CHAR)(  32   *  sinf(  150.0f   *  ( fx  +  fy ) ) );
            iDv  =  iDv  +  (CHAR)(  16   *  sinf(  140.0f   *  ( fx  *   0.85f   -  fy ) ) );

             * pPixel ++   =  iDu;
             * pPixel ++   =  iDv;
        }
        pDst  +=  d3dlr.Pitch;
    }
    g_psBumpMap -> UnlockRect( 0 );

     return  hr;
}


// -----------------------------------------------------------------------------
//  Desc: 设置纹理层渲染状态
// -----------------------------------------------------------------------------
HRESULT SetEMBMStates(IDirect3DDevice9 *  pd3dDevice,  float  fTime)
{
     // 设置纹理层 0 的纹理渲染状态
    pd3dDevice -> SetTexture(  0 , g_psBumpMap );
    pd3dDevice -> SetTextureStageState(  0 , D3DTSS_COLOROP,   D3DTOP_BUMPENVMAPLUMINANCE );
    
     static   float  r  =   0.04f ;
    g_matBumpMat._11  =   r  *  cosf( ( float )fTime  *   9.0f  );
    g_matBumpMat._12  =   - r  *  sinf( ( float )fTime  *   9.0f  );
    g_matBumpMat._21  =   r  *  sinf( ( float )fTime  *   9.0f  );
    g_matBumpMat._22  =   r  *  cosf( ( float )fTime  *   9.0f  );

    pd3dDevice -> SetTextureStageState(  0 , D3DTSS_BUMPENVMAT00,   F2DW( g_matBumpMat._11 ) );
    pd3dDevice -> SetTextureStageState(  0 , D3DTSS_BUMPENVMAT01,   F2DW( g_matBumpMat._12 ) );
    pd3dDevice -> SetTextureStageState(  0 , D3DTSS_BUMPENVMAT10,   F2DW( g_matBumpMat._21 ) );
    pd3dDevice -> SetTextureStageState(  0 , D3DTSS_BUMPENVMAT11,   F2DW( g_matBumpMat._22 ) );
    pd3dDevice -> SetTextureStageState(  0 , D3DTSS_BUMPENVLSCALE,  F2DW( 0.8f ) );
    pd3dDevice -> SetTextureStageState(  0 , D3DTSS_BUMPENVLOFFSET, F2DW( 0.0f ) );
    
     // 设置纹理层 1 的纹理渲染状态
    pd3dDevice -> SetTexture(  1 , g_pBackgroundTexture );
    pd3dDevice -> SetTextureStageState(  1 , D3DTSS_COLOROP,   D3DTOP_SELECTARG1 );
    pd3dDevice -> SetTextureStageState(  1 , D3DTSS_COLORARG1, D3DTA_TEXTURE );
    pd3dDevice -> SetTextureStageState(  1 , D3DTSS_TEXCOORDINDEX, D3DTSS_TCI_CAMERASPACEPOSITION  |   1  );
    pd3dDevice -> SetTextureStageState(  1 , D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_COUNT3 | D3DTTFF_PROJECTED );
    
     // 设置纹理坐标变换矩阵
     static  D3DXMATRIXA16 mat;
    mat._11  =   0.8f ; mat._12  =   0.0f ; mat._13  =   0.0f ;
    mat._21  =   0.0f ; mat._22  =   0.8f ; mat._23  =   0.0f ;
    mat._31  =   0.5f ; mat._32  =- 0.5f ; mat._33  =   1.0f ;
    mat._41  =   0.0f ; mat._42  =   0.0f ; mat._43  =   0.0f ;
    pd3dDevice -> SetTransform( D3DTS_TEXTURE1,  & mat );
        
     return  S_OK;
}