《精通DirectX 3D》 第二十一章 HLSL高级应用 02_HLSLBumpTexture

《精通DirectX 3D》 第二十一章 HLSL高级应用 02_HLSLBumpTexture

效果真不错！凹凸的真实感非常强！





HLSLBumpTexture.fx

// ==============================================================
//  Desc: 效果文件
// ==============================================================

// --------------------------------------------------------------
//  全局变量
// --------------------------------------------------------------
float4x4 matWorldViewProj;    
float4x4 matWorld;    
float4   vecLightDir;
float4   vecEye;

// --------------------------------------------------------------
//  纹理采样器
// --------------------------------------------------------------
texture ColorMap;
sampler ColorMapSampler  =  sampler_state
{
   Texture  =   < ColorMap > ;
   MinFilter  =  Linear;
   MagFilter  =  Linear;
   MipFilter  =  Linear;   
};

texture BumpMap;
sampler BumpMapSampler  =  sampler_state
{
   Texture  =   < BumpMap > ;
   MinFilter  =  Linear;
   MagFilter  =  Linear;
   MipFilter  =  Linear;   
};


// --------------------------------------------------------------
//  顶点渲染器输出结构
// --------------------------------------------------------------
struct  VS_OUTPUT
{
    float4 Pos  : POSITION;
    float2 Tex  : TEXCOORD0;
    float3 Light: TEXCOORD1;    // 纹理空间中灯光方向
    float3 View : TEXCOORD2;    // 纹理空间中法线方向
};


// --------------------------------------------------------------
//   顶点渲染器主函数
// --------------------------------------------------------------
VS_OUTPUT VS(float4 Pos : POSITION, float2 Tex : TEXCOORD, float3 Normal : NORMAL, float3 Tangent : TANGENT  )
{
   VS_OUTPUT Out  =  (VS_OUTPUT) 0 ;
   
    // 顶点坐标变换
   Out.Pos  =  mul(Pos, matWorldViewProj);
  
    // 构建一个3x3变换矩阵  用于完成从世界空间到纹理空间的变换
   float3x3 worldToTangentSpace;
   worldToTangentSpace[ 0 ]  =  mul(Tangent, matWorld);
   worldToTangentSpace[ 1 ]  =  mul(cross(Tangent,Normal), matWorld);
   worldToTangentSpace[ 2 ]  =  mul(Normal, matWorld);

   Out.Tex  =  Tex.xy;
   
    // 顶点在世界空间中的坐标
   float3 PosWorld  =  normalize(mul(Pos, matWorld));

    // 计算纹理空间中灯光方向向量
   float3 Light   =  vecLightDir  -  PosWorld; 
   Out.Light.xyz  =  mul(worldToTangentSpace, Light);

    // 计算纹理空间中的观察方向
   float3 Viewer  =  vecEye  -  PosWorld;                        
   Out.View  =  mul(worldToTangentSpace, Viewer);
      
    return  Out;
}


// --------------------------------------------------------------
// 像素渲染器输出结构
// --------------------------------------------------------------
struct  PS_OUTPUT
{
    float4 Color  : COLOR;
};

// --------------------------------------------------------------
//  Desc: 像素渲染器主函数
// --------------------------------------------------------------
PS_OUTPUT PS(float2 Tex: TEXCOORD0, float3 Light : TEXCOORD1, 
            float3 View : TEXCOORD2, float3 Att : TEXCOORD3)
{
    PS_OUTPUT Out_ps  =  (PS_OUTPUT) 0 ;
    
     // 颜色纹理采样
    float4 color       =  tex2D(ColorMapSampler, Tex);
    
     // 凹凸纹理采样, 得到的是法线向量, 用于代替顶点法线进行光照计算
    float3 bumpNormal  =   2   *  (tex2D(BumpMapSampler, Tex)  -   0.5 );
    
     // 标准化纹理空间中的灯光方向和观察方向
    float3 LightDir  =  normalize(Light);
    float3 ViewDir   =  normalize(View);
    
     // 根据凹凸贴图的发线进行漫反射光照计算
    float4 diff  =  saturate(dot(bumpNormal, LightDir));
    
     // 计算自身遮蔽阴影项
     float  shadow  =  saturate( 4   *  diff);
    
     // 计算镜面反射强度
    float3 Reflect  =  normalize( 2   *  diff  *  bumpNormal  -  LightDir);
    float4 spec     =  min(pow(saturate(dot(Reflect, ViewDir)),  15 ), color.a);

     // 混合纹理颜色和光照颜色, 得到每个像素的最终颜色
    Out_ps.Color  =   0.2   *  color  +  (shadow  *  (color  *  diff  +  spec) );
    
     return  Out_ps;
}


// --------------------------------------------------------------
//  Desc: 技术
// --------------------------------------------------------------
technique TShader
{
    pass P0
    {
        VertexShader  =  compile vs_2_0 VS();
        PixelShader   =  compile ps_2_0 PS();
    }
}

// =============================================================================
//  Desc: 主程序源文件
// =============================================================================
#include  " dxstdafx.h "
#include  " resource.h "

// #define DEBUG_VS    //  Uncomment this line to debug vertex shaders 
// #define DEBUG_PS    //  Uncomment this line to debug pixel shaders 

// -----------------------------------------------------------------------------
//  全局变量k
// -----------------------------------------------------------------------------
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;               // 对话框

LPD3DXMESH                g_pMesh           =  NULL;   // 网格模型
LPDIRECT3DTEXTURE9          g_pBumpMap;                // 凹凸纹理
LPDIRECT3DTEXTURE9          g_pColorMap;               // 颜色纹理
LPD3DXEFFECT              g_pEffect         =  NULL;   // 效果
D3DXMATRIXA16             g_matView, g_matProj, g_matWorld;


// -----------------------------------------------------------------------------
//  控件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();


// -----------------------------------------------------------------------------
//  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 " HLSLBumpTexture "  );
    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 ( pCaps -> VertexShaderVersion  <  D3DVS_VERSION( 2 , 0 ) )
         return  FALSE;

     // 检查像素渲染器
     if ( pCaps -> PixelShaderVersion  <  D3DPS_VERSION( 2 , 0 ) )
         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;
    }

     // 调试像素渲染器需要参考设备
#ifdef DEBUG_VS
     if ( pDeviceSettings -> DeviceType  !=  D3DDEVTYPE_REF )
    {
        pDeviceSettings -> BehaviorFlags  &=   ~ D3DCREATE_HARDWARE_VERTEXPROCESSING;
        pDeviceSettings -> BehaviorFlags  &=   ~ D3DCREATE_PUREDEVICE;                            
        pDeviceSettings -> BehaviorFlags  |=  D3DCREATE_SOFTWARE_VERTEXPROCESSING;
    }
#endif

     // 如果使用参考设备,则弹出警告对话框
#ifdef DEBUG_PS
    pDeviceSettings -> DeviceType  =  D3DDEVTYPE_REF;
#endif

     // 如果使用参考设备,则弹出警告对话框
     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( D3DXLoadMeshFromX( L " sphereearth.x " , D3DXMESH_MANAGED, pd3dDevice, 
                                 NULL, NULL, NULL, NULL,  & g_pMesh ));

    LPD3DXMESH pMeshSysMem  =  g_pMesh;
    D3DVERTEXELEMENT9 decl[] =
    {
        { 0 ,  0 ,  D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION,  0 },
        { 0 ,  12 , D3DDECLTYPE_FLOAT2, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD,  0 },
        { 0 ,  20 , D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_NORMAL,  0 },
        { 0 ,  32 , D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TANGENT,  0 },
        D3DDECL_END()
    };

    LPD3DXMESH  pMeshSysMem2   =  NULL;
    V_RETURN(pMeshSysMem -> CloneMesh(D3DXMESH_MANAGED, decl, pd3dDevice,  & pMeshSysMem2));
    
     // 确保顶点包含法线
    V_RETURN(D3DXComputeNormals(pMeshSysMem2,NULL));

     // 计算切线
    V_RETURN(D3DXComputeTangent( pMeshSysMem2,  0 ,  0 ,  0 ,  true , NULL ));

    D3DVERTEXELEMENT9 decl2[] =
    {
        { 0 ,  0 ,  D3DDECLTYPE_FLOAT4, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION,  0 },
        { 0 ,  16 , D3DDECLTYPE_FLOAT2, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD,  0 },
        { 0 ,  24 , D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_NORMAL,  0 },
        { 0 ,  36 , D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TANGENT,  0 },
        D3DDECL_END()
    };

    V_RETURN(pMeshSysMem2 -> CloneMesh(D3DXMESH_MANAGED, decl2, pd3dDevice,  & g_pMesh ));
    
     // 释放临时网格模型对象
    SAFE_RELEASE(pMeshSysMem);
    SAFE_RELEASE(pMeshSysMem2);

     // 创建纹理
    V_RETURN( D3DXCreateTextureFromFile( pd3dDevice,  L " earth.tga " ,   & g_pColorMap));
    V_RETURN( D3DXCreateTextureFromFile( pd3dDevice,  L " normal.tga " ,  & g_pBumpMap ));

     // 创建效果
    V_RETURN(D3DXCreateEffectFromFile( pd3dDevice, L " HLSLBumpTexture.fx " , NULL, NULL, 
                                       D3DXSHADER_DEBUG, NULL,  & g_pEffect, NULL ) );

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

     // 恢复效果对象
     if ( g_pEffect )
        V_RETURN( g_pEffect -> OnResetDevice() );

     // 构造观察矩阵
    D3DXVECTOR3 vEyePt(  0.0f ,  - 3.0f ,  0.0f );
    D3DXVECTOR3 vLookatPt(  0.0f ,  0.0f ,  0.0f  );
    D3DXVECTOR3 vUpVec(  0.0f ,  1.0f ,  1.0f  );
    D3DXMatrixLookAtLH(  & g_matView,  & vEyePt,  & vLookatPt,  & vUpVec );

     // 设置投影矩阵
     float  fAspectRatio  =  ( float )pBackBufferSurfaceDesc -> Width  /  pBackBufferSurfaceDesc -> Height;
    D3DXMatrixPerspectiveFovLH(  & g_matProj, D3DX_PI / 4 , fAspectRatio,  1.0f ,  100.0f  );

     // 为效果设置摄影机位置和光的方向
    D3DXVECTOR4 vecEyePos  =  D3DXVECTOR4(vEyePt.x,vEyePt.y,vEyePt.z, 0 ); 
    g_pEffect -> SetVector( " vecEye " ,  & vecEyePos);
    D3DXVECTOR4 LightDirection(  - 1.0f ,  - 1.0f ,  - 1.0f ,  1.0f  );
    g_pEffect -> SetVector( " vecLightDir " ,  & LightDirection);

     return  S_OK;
}


// -----------------------------------------------------------------------------
//  Desc: 更新场景
// -----------------------------------------------------------------------------
void  CALLBACK OnFrameMove( IDirect3DDevice9 *  pd3dDevice,  double  fTime, 
                            float  fElapsedTime,  void *  pUserContext )
{
    D3DXMatrixRotationZ(  & g_matWorld, timeGetTime() / 1000.0f  );
    D3DXMATRIX mWorldViewProj  =  g_matWorld  *  g_matView  *  g_matProj;
    g_pEffect -> SetMatrix(  " matWorldViewProj " ,  & mWorldViewProj );
    g_pEffect -> SetMatrix(  " matWorld " ,  & g_matWorld);
}


// -----------------------------------------------------------------------------
//  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() ) )
    {
         if ( g_pEffect  !=  NULL )
        {
            D3DXHANDLE hTechnique  =  g_pEffect -> GetTechniqueByName(  " TShader "  );
            g_pEffect -> SetTechnique( hTechnique );

            g_pEffect -> SetTexture( " ColorMap " , g_pColorMap);
            g_pEffect -> SetTexture( " BumpMap " , g_pBumpMap);

            UINT nPasses;
            g_pEffect -> Begin(  & nPasses,  0  );

             for ( UINT iPass  =   0 ; iPass  <  nPasses; iPass  ++  )
            {
                g_pEffect -> BeginPass( iPass );
                g_pMesh -> DrawSubset(  0  );
                g_pEffect -> EndPass();
            }
            g_pEffect -> End();
        }

         // 渲染文本和控件
        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 " 通过HLSL编程实现凹凸纹理映射 "  );
    
     // 显示简单帮助文本
     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_pMesh);
    SAFE_RELEASE(g_pBumpMap);
    SAFE_RELEASE(g_pColorMap);
    SAFE_RELEASE(g_pEffect);
}