开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > DirextX编程 > 查看源码
DXUTmisc.cpp
资源名称：Direct3D.rar　[点击查看]
上传用户：junlon
上传日期：2022-01-05
资源大小：39075k
文件大小：130k
源码类别：

DirextX编程

开发平台：

Visual C++

DXUTmisc.cpp：源码内容
  4. //--------------------------------------------------------------------------------------
  5. // Clamps pV to lie inside m_vMinBoundary & m_vMaxBoundary
  6. //--------------------------------------------------------------------------------------
  7. void CBaseCamera::ConstrainToBoundary( D3DXVECTOR3* pV )
  8. {
  9.     // Constrain vector to a bounding box 
  10.     pV->x = __max(pV->x, m_vMinBoundary.x);
  11.     pV->y = __max(pV->y, m_vMinBoundary.y);
  12.     pV->z = __max(pV->z, m_vMinBoundary.z);
  14.     pV->x = __min(pV->x, m_vMaxBoundary.x);
  15.     pV->y = __min(pV->y, m_vMaxBoundary.y);
  16.     pV->z = __min(pV->z, m_vMaxBoundary.z);
  17. }
  22. //--------------------------------------------------------------------------------------
  23. // Maps a windows virtual key to an enum
  24. //--------------------------------------------------------------------------------------
  25. D3DUtil_CameraKeys CBaseCamera::MapKey( UINT nKey )
  26. {
  27.     // This could be upgraded to a method that's user-definable but for 
  28.     // simplicity, we'll use a hardcoded mapping.
  29.     switch( nKey )
  30.     {
  31.         case VK_CONTROL:  return CAM_CONTROLDOWN;
  32.         case VK_LEFT:  return CAM_STRAFE_LEFT;
  33.         case VK_RIGHT: return CAM_STRAFE_RIGHT;
  34.         case VK_UP:    return CAM_MOVE_FORWARD;
  35.         case VK_DOWN:  return CAM_MOVE_BACKWARD;
  36.         case VK_PRIOR: return CAM_MOVE_UP;        // pgup
  37.         case VK_NEXT:  return CAM_MOVE_DOWN;      // pgdn
  39.         case 'A':      return CAM_STRAFE_LEFT;
  40.         case 'D':      return CAM_STRAFE_RIGHT;
  41.         case 'W':      return CAM_MOVE_FORWARD;
  42.         case 'S':      return CAM_MOVE_BACKWARD;
  43.         case 'Q':      return CAM_MOVE_DOWN;
  44.         case 'E':      return CAM_MOVE_UP;
  46.         case VK_NUMPAD4: return CAM_STRAFE_LEFT;
  47.         case VK_NUMPAD6: return CAM_STRAFE_RIGHT;
  48.         case VK_NUMPAD8: return CAM_MOVE_FORWARD;
  49.         case VK_NUMPAD2: return CAM_MOVE_BACKWARD;
  50.         case VK_NUMPAD9: return CAM_MOVE_UP;        
  51.         case VK_NUMPAD3: return CAM_MOVE_DOWN;      
  53.         case VK_HOME:   return CAM_RESET;
  54.     }
  56.     return CAM_UNKNOWN;
  57. }
  62. //--------------------------------------------------------------------------------------
  63. // Reset the camera's position back to the default
  64. //--------------------------------------------------------------------------------------
  65. VOID CBaseCamera::Reset()
  66. {
  67.     SetViewParams( &m_vDefaultEye, &m_vDefaultLookAt );
  68. }
  73. //--------------------------------------------------------------------------------------
  74. // Constructor
  75. //--------------------------------------------------------------------------------------
  76. CFirstPersonCamera::CFirstPersonCamera() :
  77.     m_nActiveButtonMask( 0x07 )
  78. {
  79.     m_bRotateWithoutButtonDown = false;
  80. }
  85. //--------------------------------------------------------------------------------------
  86. // Update the view matrix based on user input & elapsed time
  87. //--------------------------------------------------------------------------------------
  88. VOID CFirstPersonCamera::FrameMove( FLOAT fElapsedTime )
  89. {
  90.     if( DXUTGetGlobalTimer()->IsStopped() )
  91.         fElapsedTime = 1.0f / DXUTGetFPS();
  93.     if( IsKeyDown(m_aKeys[CAM_RESET]) )
  94.         Reset();
  96.     // Get keyboard/mouse/gamepad input
  97.     GetInput( m_bEnablePositionMovement, (m_nActiveButtonMask & m_nCurrentButtonMask) || m_bRotateWithoutButtonDown, true, m_bResetCursorAfterMove );
  99.     // Get amount of velocity based on the keyboard input and drag (if any)
  100.     UpdateVelocity( fElapsedTime );
  102.     // Simple euler method to calculate position delta
  103.     D3DXVECTOR3 vPosDelta = m_vVelocity * fElapsedTime;
  105.     // If rotating the camera 
  106.     if( (m_nActiveButtonMask & m_nCurrentButtonMask) || 
  107.         m_bRotateWithoutButtonDown || 
  108.         m_vGamePadRightThumb.x != 0 || 
  109.         m_vGamePadRightThumb.z != 0 )
  110.     {
  111.         // Update the pitch & yaw angle based on mouse movement
  112.         float fYawDelta   = m_vRotVelocity.x;
  113.         float fPitchDelta = m_vRotVelocity.y;
  115.         // Invert pitch if requested
  116.         if( m_bInvertPitch )
  117.             fPitchDelta = -fPitchDelta;
  119.         m_fCameraPitchAngle += fPitchDelta;
  120.         m_fCameraYawAngle   += fYawDelta;
  122.         // Limit pitch to straight up or straight down
  123.         m_fCameraPitchAngle = __max( -D3DX_PI/2.0f,  m_fCameraPitchAngle );
  124.         m_fCameraPitchAngle = __min( +D3DX_PI/2.0f,  m_fCameraPitchAngle );
  125.     }
  127.     // Make a rotation matrix based on the camera's yaw & pitch
  128.     D3DXMATRIX mCameraRot;
  129.     D3DXMatrixRotationYawPitchRoll( &mCameraRot, m_fCameraYawAngle, m_fCameraPitchAngle, 0 );
  131.     // Transform vectors based on camera's rotation matrix
  132.     D3DXVECTOR3 vWorldUp, vWorldAhead;
  133.     D3DXVECTOR3 vLocalUp    = D3DXVECTOR3(0,1,0);
  134.     D3DXVECTOR3 vLocalAhead = D3DXVECTOR3(0,0,1);
  135.     D3DXVec3TransformCoord( &vWorldUp, &vLocalUp, &mCameraRot );
  136.     D3DXVec3TransformCoord( &vWorldAhead, &vLocalAhead, &mCameraRot );
  138.     // Transform the position delta by the camera's rotation 
  139.     D3DXVECTOR3 vPosDeltaWorld;
  140.     if( !m_bEnableYAxisMovement )
  141.     {
  142.         // If restricting Y movement, do not include pitch
  143.         // when transforming position delta vector.
  144.         D3DXMatrixRotationYawPitchRoll( &mCameraRot, m_fCameraYawAngle, 0.0f, 0.0f );
  145.     }
  146.     D3DXVec3TransformCoord( &vPosDeltaWorld, &vPosDelta, &mCameraRot );
  148.     // Move the eye position 
  149.     m_vEye += vPosDeltaWorld;
  150.     if( m_bClipToBoundary )
  151.         ConstrainToBoundary( &m_vEye );
  153.     // Update the lookAt position based on the eye position 
  154.     m_vLookAt = m_vEye + vWorldAhead;
  156.     // Update the view matrix
  157.     D3DXMatrixLookAtLH( &m_mView, &m_vEye, &m_vLookAt, &vWorldUp );
  159.     D3DXMatrixInverse( &m_mCameraWorld, NULL, &m_mView );
  160. }
  163. //--------------------------------------------------------------------------------------
  164. // Enable or disable each of the mouse buttons for rotation drag.
  165. //--------------------------------------------------------------------------------------
  166. void CFirstPersonCamera::SetRotateButtons( bool bLeft, bool bMiddle, bool bRight, bool bRotateWithoutButtonDown )
  167. {
  168.     m_nActiveButtonMask = ( bLeft ? MOUSE_LEFT_BUTTON : 0 ) |
  169.                           ( bMiddle ? MOUSE_MIDDLE_BUTTON : 0 ) |
  170.                           ( bRight ? MOUSE_RIGHT_BUTTON : 0 );
  171.     m_bRotateWithoutButtonDown = bRotateWithoutButtonDown;
  172. }
  175. //--------------------------------------------------------------------------------------
  176. // Constructor 
  177. //--------------------------------------------------------------------------------------
  178. CModelViewerCamera::CModelViewerCamera()
  179. {
  180.     D3DXMatrixIdentity( &m_mWorld );
  181.     D3DXMatrixIdentity( &m_mModelRot );
  182.     D3DXMatrixIdentity( &m_mModelLastRot );    
  183.     D3DXMatrixIdentity( &m_mCameraRotLast );    
  184.     m_vModelCenter = D3DXVECTOR3(0,0,0);
  185.     m_fRadius    = 5.0f;
  186.     m_fDefaultRadius = 5.0f;
  187.     m_fMinRadius = 1.0f;
  188.     m_fMaxRadius = FLT_MAX;
  189.     m_bLimitPitch = false;
  190.     m_bEnablePositionMovement = false;
  191.     m_bAttachCameraToModel = false;
  193.     m_nRotateModelButtonMask  = MOUSE_LEFT_BUTTON;
  194.     m_nZoomButtonMask         = MOUSE_WHEEL;
  195.     m_nRotateCameraButtonMask = MOUSE_RIGHT_BUTTON;
  196.     m_bDragSinceLastUpdate    = true;
  197. }
  202. //--------------------------------------------------------------------------------------
  203. // Update the view matrix & the model's world matrix based 
  204. //       on user input & elapsed time
  205. //--------------------------------------------------------------------------------------
  206. VOID CModelViewerCamera::FrameMove( FLOAT fElapsedTime )
  207. {
  208.     if( IsKeyDown(m_aKeys[CAM_RESET]) )
  209.         Reset();
  211.     // If no dragged has happend since last time FrameMove is called,
  212.     // and no camera key is held down, then no need to handle again.
  213.     if( !m_bDragSinceLastUpdate && 0 == m_cKeysDown )
  214.         return;
  215.     m_bDragSinceLastUpdate = false;
  217.     // Get keyboard/mouse/gamepad input
  218.     GetInput( m_bEnablePositionMovement, m_nCurrentButtonMask != 0, true, false );
  220.     // Get amount of velocity based on the keyboard input and drag (if any)
  221.     UpdateVelocity( fElapsedTime );
  223.     // Simple euler method to calculate position delta
  224.     D3DXVECTOR3 vPosDelta = m_vVelocity * fElapsedTime;
  226.     // Change the radius from the camera to the model based on wheel scrolling
  227.     if( m_nMouseWheelDelta && m_nZoomButtonMask == MOUSE_WHEEL )
  228.         m_fRadius -= m_nMouseWheelDelta * m_fRadius * 0.1f;
  229.     m_fRadius = __min( m_fMaxRadius, m_fRadius );
  230.     m_fRadius = __max( m_fMinRadius, m_fRadius );
  231.     m_nMouseWheelDelta = 0;
  233.     // Get the inverse of the arcball's rotation matrix
  234.     D3DXMATRIX mCameraRot;
  235.     D3DXMatrixInverse( &mCameraRot, NULL, m_ViewArcBall.GetRotationMatrix() );
  237.     // Transform vectors based on camera's rotation matrix
  238.     D3DXVECTOR3 vWorldUp, vWorldAhead;
  239.     D3DXVECTOR3 vLocalUp    = D3DXVECTOR3(0,1,0);
  240.     D3DXVECTOR3 vLocalAhead = D3DXVECTOR3(0,0,1);
  241.     D3DXVec3TransformCoord( &vWorldUp, &vLocalUp, &mCameraRot );
  242.     D3DXVec3TransformCoord( &vWorldAhead, &vLocalAhead, &mCameraRot );
  244.     // Transform the position delta by the camera's rotation 
  245.     D3DXVECTOR3 vPosDeltaWorld;
  246.     D3DXVec3TransformCoord( &vPosDeltaWorld, &vPosDelta, &mCameraRot );
  248.     // Move the lookAt position 
  249.     m_vLookAt += vPosDeltaWorld;
  250.     if( m_bClipToBoundary )
  251.         ConstrainToBoundary( &m_vLookAt );
  253.     // Update the eye point based on a radius away from the lookAt position
  254.     m_vEye = m_vLookAt - vWorldAhead * m_fRadius;
  256.     // Update the view matrix
  257.     D3DXMatrixLookAtLH( &m_mView, &m_vEye, &m_vLookAt, &vWorldUp );
  259.     D3DXMATRIX mInvView;
  260.     D3DXMatrixInverse( &mInvView, NULL, &m_mView );
  261.     mInvView._41 = mInvView._42 = mInvView._43 = 0;
  263.     D3DXMATRIX mModelLastRotInv;
  264.     D3DXMatrixInverse(&mModelLastRotInv, NULL, &m_mModelLastRot);
  266.     // Accumulate the delta of the arcball's rotation in view space.
  267.     // Note that per-frame delta rotations could be problematic over long periods of time.
  268.     D3DXMATRIX mModelRot;
  269.     mModelRot = *m_WorldArcBall.GetRotationMatrix();
  270.     m_mModelRot *= m_mView * mModelLastRotInv * mModelRot * mInvView;
  272.     if( m_ViewArcBall.IsBeingDragged() && m_bAttachCameraToModel && !IsKeyDown(m_aKeys[CAM_CONTROLDOWN]) )
  273.     {
  274.         // Attach camera to model by inverse of the model rotation
  275.         D3DXMATRIX mCameraLastRotInv;
  276.         D3DXMatrixInverse(&mCameraLastRotInv, NULL, &m_mCameraRotLast);
  277.         D3DXMATRIX mCameraRotDelta = mCameraLastRotInv * mCameraRot; // local to world matrix
  278.         m_mModelRot *= mCameraRotDelta;
  279.     }
  280.     m_mCameraRotLast = mCameraRot; 
  282.     m_mModelLastRot = mModelRot;
  284.     // Since we're accumulating delta rotations, we need to orthonormalize 
  285.     // the matrix to prevent eventual matrix skew
  286.     D3DXVECTOR3* pXBasis = (D3DXVECTOR3*) &m_mModelRot._11;
  287.     D3DXVECTOR3* pYBasis = (D3DXVECTOR3*) &m_mModelRot._21;
  288.     D3DXVECTOR3* pZBasis = (D3DXVECTOR3*) &m_mModelRot._31;
  289.     D3DXVec3Normalize( pXBasis, pXBasis );
  290.     D3DXVec3Cross( pYBasis, pZBasis, pXBasis );
  291.     D3DXVec3Normalize( pYBasis, pYBasis );
  292.     D3DXVec3Cross( pZBasis, pXBasis, pYBasis );
  294.     // Translate the rotation matrix to the same position as the lookAt position
  295.     m_mModelRot._41 = m_vLookAt.x;
  296.     m_mModelRot._42 = m_vLookAt.y;
  297.     m_mModelRot._43 = m_vLookAt.z;
  299.     // Translate world matrix so its at the center of the model
  300.     D3DXMATRIX mTrans;
  301.     D3DXMatrixTranslation( &mTrans, -m_vModelCenter.x, -m_vModelCenter.y, -m_vModelCenter.z );
  302.     m_mWorld = mTrans * m_mModelRot;
  303. }
  306. void CModelViewerCamera::SetDragRect( RECT &rc )
  307. {
  308.     CBaseCamera::SetDragRect( rc );
  310.     m_WorldArcBall.SetOffset( rc.left, rc.top );
  311.     m_ViewArcBall.SetOffset( rc.left, rc.top );
  312.     SetWindow( rc.right - rc.left, rc.bottom - rc.top );
  313. }
  316. //--------------------------------------------------------------------------------------
  317. // Reset the camera's position back to the default
  318. //--------------------------------------------------------------------------------------
  319. VOID CModelViewerCamera::Reset()
  320. {
  321.     CBaseCamera::Reset();
  323.     D3DXMatrixIdentity( &m_mWorld );
  324.     D3DXMatrixIdentity( &m_mModelRot );
  325.     D3DXMatrixIdentity( &m_mModelLastRot );    
  326.     D3DXMatrixIdentity( &m_mCameraRotLast );    
  328.     m_fRadius = m_fDefaultRadius;
  329.     m_WorldArcBall.Reset();
  330.     m_ViewArcBall.Reset();
  331. }
  334. //--------------------------------------------------------------------------------------
  335. // Override for setting the view parameters
  336. //--------------------------------------------------------------------------------------
  337. void CModelViewerCamera::SetViewParams( D3DXVECTOR3* pvEyePt, D3DXVECTOR3* pvLookatPt )
  338. {
  339.     CBaseCamera::SetViewParams( pvEyePt, pvLookatPt );
  341.     // Propogate changes to the member arcball
  342.     D3DXQUATERNION quat;
  343.     D3DXMATRIXA16 mRotation;
  344.     D3DXVECTOR3 vUp(0,1,0);
  345.     D3DXMatrixLookAtLH( &mRotation, pvEyePt, pvLookatPt, &vUp );
  346.     D3DXQuaternionRotationMatrix( &quat, &mRotation );
  347.     m_ViewArcBall.SetQuatNow( quat );
  349.     // Set the radius according to the distance
  350.     D3DXVECTOR3 vEyeToPoint;
  351.     D3DXVec3Subtract( &vEyeToPoint, pvLookatPt, pvEyePt );
  352.     SetRadius( D3DXVec3Length( &vEyeToPoint ) );
  354.     // View information changed. FrameMove should be called.
  355.     m_bDragSinceLastUpdate = true;
  356. }
  358. void CModelViewerCamera::SetViewParams( D3DXVECTOR3* pvEyePt, D3DXVECTOR3* pvLookatPt, D3DXVECTOR3* pvUpVec )
  359. {
  360.     CBaseCamera::SetViewParams( pvEyePt, pvLookatPt, pvUpVec );
  362.     // Propogate changes to the member arcball
  363.     D3DXQUATERNION quat;
  364.     D3DXMATRIXA16 mRotation;
  365. //    D3DXVECTOR3 vUp(0,1,0);
  366.     D3DXMatrixLookAtLH( &mRotation, pvEyePt, pvLookatPt, pvUpVec );
  367.     D3DXQuaternionRotationMatrix( &quat, &mRotation );
  368.     m_ViewArcBall.SetQuatNow( quat );
  370.     // Set the radius according to the distance
  371.     D3DXVECTOR3 vEyeToPoint;
  372.     D3DXVec3Subtract( &vEyeToPoint, pvLookatPt, pvEyePt );
  373.     SetRadius( D3DXVec3Length( &vEyeToPoint ) );
  375.     // View information changed. FrameMove should be called.
  376.     m_bDragSinceLastUpdate = true;
  377. }
  379. //--------------------------------------------------------------------------------------
  380. // Call this from your message proc so this class can handle window messages
  381. //--------------------------------------------------------------------------------------
  382. LRESULT CModelViewerCamera::HandleMessages( HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam )
  383. {
  384.     CBaseCamera::HandleMessages( hWnd, uMsg, wParam, lParam );
  386.     if( ( (uMsg == WM_LBUTTONDOWN || uMsg == WM_LBUTTONDBLCLK ) && m_nRotateModelButtonMask & MOUSE_LEFT_BUTTON) ||
  387.         ( (uMsg == WM_MBUTTONDOWN || uMsg == WM_MBUTTONDBLCLK ) && m_nRotateModelButtonMask & MOUSE_MIDDLE_BUTTON) ||
  388.         ( (uMsg == WM_RBUTTONDOWN || uMsg == WM_RBUTTONDBLCLK ) && m_nRotateModelButtonMask & MOUSE_RIGHT_BUTTON) )
  389.     {
  390.         int iMouseX = (short)LOWORD(lParam);
  391.         int iMouseY = (short)HIWORD(lParam);
  392.         m_WorldArcBall.OnBegin( iMouseX, iMouseY );
  393.     }
  395.     if( ( (uMsg == WM_LBUTTONDOWN || uMsg == WM_LBUTTONDBLCLK ) && m_nRotateCameraButtonMask & MOUSE_LEFT_BUTTON) ||
  396.         ( (uMsg == WM_MBUTTONDOWN || uMsg == WM_MBUTTONDBLCLK ) && m_nRotateCameraButtonMask & MOUSE_MIDDLE_BUTTON) ||
  397.         ( (uMsg == WM_RBUTTONDOWN || uMsg == WM_RBUTTONDBLCLK ) && m_nRotateCameraButtonMask & MOUSE_RIGHT_BUTTON) )
  398.     {
  399.         int iMouseX = (short)LOWORD(lParam);
  400.         int iMouseY = (short)HIWORD(lParam);
  401.         m_ViewArcBall.OnBegin( iMouseX, iMouseY );
  402.     }
  404.     if( uMsg == WM_MOUSEMOVE )
  405.     {
  406.         int iMouseX = (short)LOWORD(lParam);
  407.         int iMouseY = (short)HIWORD(lParam);
  408.         m_WorldArcBall.OnMove( iMouseX, iMouseY );
  409.         m_ViewArcBall.OnMove( iMouseX, iMouseY );
  410.     }
  412.     if( (uMsg == WM_LBUTTONUP && m_nRotateModelButtonMask & MOUSE_LEFT_BUTTON) ||
  413.         (uMsg == WM_MBUTTONUP && m_nRotateModelButtonMask & MOUSE_MIDDLE_BUTTON) ||
  414.         (uMsg == WM_RBUTTONUP && m_nRotateModelButtonMask & MOUSE_RIGHT_BUTTON) )
  415.     {
  416.         m_WorldArcBall.OnEnd();
  417.     }
  419.     if( (uMsg == WM_LBUTTONUP && m_nRotateCameraButtonMask & MOUSE_LEFT_BUTTON) ||
  420.         (uMsg == WM_MBUTTONUP && m_nRotateCameraButtonMask & MOUSE_MIDDLE_BUTTON) ||
  421.         (uMsg == WM_RBUTTONUP && m_nRotateCameraButtonMask & MOUSE_RIGHT_BUTTON) )
  422.     {
  423.         m_ViewArcBall.OnEnd();
  424.     }
  426.     if( uMsg == WM_CAPTURECHANGED )
  427.     {
  428.         if( (HWND)lParam != hWnd )
  429.         {
  430.             if( (m_nRotateModelButtonMask & MOUSE_LEFT_BUTTON) ||
  431.                 (m_nRotateModelButtonMask & MOUSE_MIDDLE_BUTTON) ||
  432.                 (m_nRotateModelButtonMask & MOUSE_RIGHT_BUTTON) )
  433.             {
  434.                 m_WorldArcBall.OnEnd();
  435.             }
  436.         
  437.             if( (m_nRotateCameraButtonMask & MOUSE_LEFT_BUTTON) ||
  438.                 (m_nRotateCameraButtonMask & MOUSE_MIDDLE_BUTTON) ||
  439.                 (m_nRotateCameraButtonMask & MOUSE_RIGHT_BUTTON) )
  440.             {
  441.                 m_ViewArcBall.OnEnd();
  442.             }
  443.         }
  444.     }
  446.     if( uMsg == WM_LBUTTONDOWN ||
  447.         uMsg == WM_LBUTTONDBLCLK ||
  448.         uMsg == WM_MBUTTONDOWN ||
  449.         uMsg == WM_MBUTTONDBLCLK ||
  450.         uMsg == WM_RBUTTONDOWN ||
  451.         uMsg == WM_RBUTTONDBLCLK ||
  452.         uMsg == WM_LBUTTONUP ||
  453.         uMsg == WM_MBUTTONUP ||
  454.         uMsg == WM_RBUTTONUP ||
  455.         uMsg == WM_MOUSEWHEEL ||
  456.         uMsg == WM_MOUSEMOVE )
  457.     {
  458.         m_bDragSinceLastUpdate = true;
  459.     }
  461.     return FALSE;
  462. }
  467. //--------------------------------------------------------------------------------------
  468. // Desc: Returns a view matrix for rendering to a face of a cubemap.
  469. //--------------------------------------------------------------------------------------
  470. D3DXMATRIX DXUTGetCubeMapViewMatrix( DWORD dwFace )
  471. {
  472.     D3DXVECTOR3 vEyePt   = D3DXVECTOR3( 0.0f, 0.0f, 0.0f );
  473.     D3DXVECTOR3 vLookDir;
  474.     D3DXVECTOR3 vUpDir;
  476.     switch( dwFace )
  477.     {
  478.         case D3DCUBEMAP_FACE_POSITIVE_X:
  479.             vLookDir = D3DXVECTOR3( 1.0f, 0.0f, 0.0f );
  480.             vUpDir   = D3DXVECTOR3( 0.0f, 1.0f, 0.0f );
  481.             break;
  482.         case D3DCUBEMAP_FACE_NEGATIVE_X:
  483.             vLookDir = D3DXVECTOR3(-1.0f, 0.0f, 0.0f );
  484.             vUpDir   = D3DXVECTOR3( 0.0f, 1.0f, 0.0f );
  485.             break;
  486.         case D3DCUBEMAP_FACE_POSITIVE_Y:
  487.             vLookDir = D3DXVECTOR3( 0.0f, 1.0f, 0.0f );
  488.             vUpDir   = D3DXVECTOR3( 0.0f, 0.0f,-1.0f );
  489.             break;
  490.         case D3DCUBEMAP_FACE_NEGATIVE_Y:
  491.             vLookDir = D3DXVECTOR3( 0.0f,-1.0f, 0.0f );
  492.             vUpDir   = D3DXVECTOR3( 0.0f, 0.0f, 1.0f );
  493.             break;
  494.         case D3DCUBEMAP_FACE_POSITIVE_Z:
  495.             vLookDir = D3DXVECTOR3( 0.0f, 0.0f, 1.0f );
  496.             vUpDir   = D3DXVECTOR3( 0.0f, 1.0f, 0.0f );
  497.             break;
  498.         case D3DCUBEMAP_FACE_NEGATIVE_Z:
  499.             vLookDir = D3DXVECTOR3( 0.0f, 0.0f,-1.0f );
  500.             vUpDir   = D3DXVECTOR3( 0.0f, 1.0f, 0.0f );
  501.             break;
  502.     }
  504.     // Set the view transform for this cubemap surface
  505.     D3DXMATRIXA16 mView;
  506.     D3DXMatrixLookAtLH( &mView, &vEyePt, &vLookDir, &vUpDir );
  507.     return mView;
  508. }
  511. //--------------------------------------------------------------------------------------
  512. // Returns the string for the given D3DFORMAT.
  513. //--------------------------------------------------------------------------------------
  514. LPCWSTR DXUTD3DFormatToString( D3DFORMAT format, bool bWithPrefix )
  515. {
  516.     WCHAR* pstr = NULL;
  517.     switch( format )
  518.     {
  519.     case D3DFMT_UNKNOWN:         pstr = L"D3DFMT_UNKNOWN"; break;
  520.     case D3DFMT_R8G8B8:          pstr = L"D3DFMT_R8G8B8"; break;
  521.     case D3DFMT_A8R8G8B8:        pstr = L"D3DFMT_A8R8G8B8"; break;
  522.     case D3DFMT_X8R8G8B8:        pstr = L"D3DFMT_X8R8G8B8"; break;
  523.     case D3DFMT_R5G6B5:          pstr = L"D3DFMT_R5G6B5"; break;
  524.     case D3DFMT_X1R5G5B5:        pstr = L"D3DFMT_X1R5G5B5"; break;
  525.     case D3DFMT_A1R5G5B5:        pstr = L"D3DFMT_A1R5G5B5"; break;
  526.     case D3DFMT_A4R4G4B4:        pstr = L"D3DFMT_A4R4G4B4"; break;
  527.     case D3DFMT_R3G3B2:          pstr = L"D3DFMT_R3G3B2"; break;
  528.     case D3DFMT_A8:              pstr = L"D3DFMT_A8"; break;
  529.     case D3DFMT_A8R3G3B2:        pstr = L"D3DFMT_A8R3G3B2"; break;
  530.     case D3DFMT_X4R4G4B4:        pstr = L"D3DFMT_X4R4G4B4"; break;
  531.     case D3DFMT_A2B10G10R10:     pstr = L"D3DFMT_A2B10G10R10"; break;
  532.     case D3DFMT_A8B8G8R8:        pstr = L"D3DFMT_A8B8G8R8"; break;
  533.     case D3DFMT_X8B8G8R8:        pstr = L"D3DFMT_X8B8G8R8"; break;
  534.     case D3DFMT_G16R16:          pstr = L"D3DFMT_G16R16"; break;
  535.     case D3DFMT_A2R10G10B10:     pstr = L"D3DFMT_A2R10G10B10"; break;
  536.     case D3DFMT_A16B16G16R16:    pstr = L"D3DFMT_A16B16G16R16"; break;
  537.     case D3DFMT_A8P8:            pstr = L"D3DFMT_A8P8"; break;
  538.     case D3DFMT_P8:              pstr = L"D3DFMT_P8"; break;
  539.     case D3DFMT_L8:              pstr = L"D3DFMT_L8"; break;
  540.     case D3DFMT_A8L8:            pstr = L"D3DFMT_A8L8"; break;
  541.     case D3DFMT_A4L4:            pstr = L"D3DFMT_A4L4"; break;
  542.     case D3DFMT_V8U8:            pstr = L"D3DFMT_V8U8"; break;
  543.     case D3DFMT_L6V5U5:          pstr = L"D3DFMT_L6V5U5"; break;
  544.     case D3DFMT_X8L8V8U8:        pstr = L"D3DFMT_X8L8V8U8"; break;
  545.     case D3DFMT_Q8W8V8U8:        pstr = L"D3DFMT_Q8W8V8U8"; break;
  546.     case D3DFMT_V16U16:          pstr = L"D3DFMT_V16U16"; break;
  547.     case D3DFMT_A2W10V10U10:     pstr = L"D3DFMT_A2W10V10U10"; break;
  548.     case D3DFMT_UYVY:            pstr = L"D3DFMT_UYVY"; break;
  549.     case D3DFMT_YUY2:            pstr = L"D3DFMT_YUY2"; break;
  550.     case D3DFMT_DXT1:            pstr = L"D3DFMT_DXT1"; break;
  551.     case D3DFMT_DXT2:            pstr = L"D3DFMT_DXT2"; break;
  552.     case D3DFMT_DXT3:            pstr = L"D3DFMT_DXT3"; break;
  553.     case D3DFMT_DXT4:            pstr = L"D3DFMT_DXT4"; break;
  554.     case D3DFMT_DXT5:            pstr = L"D3DFMT_DXT5"; break;
  555.     case D3DFMT_D16_LOCKABLE:    pstr = L"D3DFMT_D16_LOCKABLE"; break;
  556.     case D3DFMT_D32:             pstr = L"D3DFMT_D32"; break;
  557.     case D3DFMT_D15S1:           pstr = L"D3DFMT_D15S1"; break;
  558.     case D3DFMT_D24S8:           pstr = L"D3DFMT_D24S8"; break;
  559.     case D3DFMT_D24X8:           pstr = L"D3DFMT_D24X8"; break;
  560.     case D3DFMT_D24X4S4:         pstr = L"D3DFMT_D24X4S4"; break;
  561.     case D3DFMT_D16:             pstr = L"D3DFMT_D16"; break;
  562.     case D3DFMT_L16:             pstr = L"D3DFMT_L16"; break;
  563.     case D3DFMT_VERTEXDATA:      pstr = L"D3DFMT_VERTEXDATA"; break;
  564.     case D3DFMT_INDEX16:         pstr = L"D3DFMT_INDEX16"; break;
  565.     case D3DFMT_INDEX32:         pstr = L"D3DFMT_INDEX32"; break;
  566.     case D3DFMT_Q16W16V16U16:    pstr = L"D3DFMT_Q16W16V16U16"; break;
  567.     case D3DFMT_MULTI2_ARGB8:    pstr = L"D3DFMT_MULTI2_ARGB8"; break;
  568.     case D3DFMT_R16F:            pstr = L"D3DFMT_R16F"; break;
  569.     case D3DFMT_G16R16F:         pstr = L"D3DFMT_G16R16F"; break;
  570.     case D3DFMT_A16B16G16R16F:   pstr = L"D3DFMT_A16B16G16R16F"; break;
  571.     case D3DFMT_R32F:            pstr = L"D3DFMT_R32F"; break;
  572.     case D3DFMT_G32R32F:         pstr = L"D3DFMT_G32R32F"; break;
  573.     case D3DFMT_A32B32G32R32F:   pstr = L"D3DFMT_A32B32G32R32F"; break;
  574.     case D3DFMT_CxV8U8:          pstr = L"D3DFMT_CxV8U8"; break;
  575.     default:                     pstr = L"Unknown format"; break;
  576.     }
  577.     if( bWithPrefix || wcsstr( pstr, L"D3DFMT_" )== NULL )
  578.         return pstr;
  579.     else
  580.         return pstr + lstrlen( L"D3DFMT_" );
  581. }
  585. //--------------------------------------------------------------------------------------
  586. // Outputs to the debug stream a formatted Unicode string with a variable-argument list.
  587. //--------------------------------------------------------------------------------------
  588. VOID DXUTOutputDebugStringW( LPCWSTR strMsg, ... )
  589. {
  590. #if defined(DEBUG) || defined(_DEBUG)
  591.     WCHAR strBuffer[512];
  592.     
  593.     va_list args;
  594.     va_start(args, strMsg);
  595.     StringCchVPrintfW( strBuffer, 512, strMsg, args );
  596.     strBuffer[511] = L'';
  597.     va_end(args);
  599.     OutputDebugString( strBuffer );
  600. #else
  601.     UNREFERENCED_PARAMETER(strMsg);
  602. #endif
  603. }
  606. //--------------------------------------------------------------------------------------
  607. // Outputs to the debug stream a formatted MBCS string with a variable-argument list.
  608. //--------------------------------------------------------------------------------------
  609. VOID DXUTOutputDebugStringA( LPCSTR strMsg, ... )
  610. {
  611. #if defined(DEBUG) || defined(_DEBUG)
  612.     CHAR strBuffer[512];
  613.     
  614.     va_list args;
  615.     va_start(args, strMsg);
  616.     StringCchVPrintfA( strBuffer, 512, strMsg, args );
  617.     strBuffer[511] = '';
  618.     va_end(args);
  620.     OutputDebugStringA( strBuffer );
  621. #else
  622.     UNREFERENCED_PARAMETER(strMsg);
  623. #endif
  624. }
  627. //--------------------------------------------------------------------------------------
  628. CDXUTLineManager::CDXUTLineManager()
  629. {
  630.     m_pd3dDevice = NULL;
  631.     m_pD3DXLine = NULL;
  632. }
  635. //--------------------------------------------------------------------------------------
  636. CDXUTLineManager::~CDXUTLineManager()
  637. {
  638.     OnDeletedDevice();
  639. }
  642. //--------------------------------------------------------------------------------------
  643. HRESULT CDXUTLineManager::OnCreatedDevice( IDirect3DDevice9* pd3dDevice )
  644. {
  645.     m_pd3dDevice = pd3dDevice;
  647.     HRESULT hr;
  648.     hr = D3DXCreateLine( m_pd3dDevice, &m_pD3DXLine );
  649.     if( FAILED(hr) )
  650.         return hr;
  652.     return S_OK;
  653. }
  656. //--------------------------------------------------------------------------------------
  657. HRESULT CDXUTLineManager::OnResetDevice()
  658. {
  659.     if( m_pD3DXLine )
  660.         m_pD3DXLine->OnResetDevice();
  662.     return S_OK;
  663. }
  666. //--------------------------------------------------------------------------------------
  667. HRESULT CDXUTLineManager::OnRender()
  668. {
  669.     HRESULT hr;
  670.     if( NULL == m_pD3DXLine )
  671.         return E_INVALIDARG;
  673.     bool bDrawingHasBegun = false;
  674.     float fLastWidth = 0.0f;
  675.     bool bLastAntiAlias = false;
  676.     
  677.     for( int i=0; i<m_LinesList.GetSize(); i++ )
  678.     {
  679.         LINE_NODE* pLineNode = m_LinesList.GetAt(i);
  680.         if( pLineNode )
  681.         {
  682.             if( !bDrawingHasBegun || 
  683.                 fLastWidth != pLineNode->fWidth || 
  684.                 bLastAntiAlias != pLineNode->bAntiAlias )
  685.             {
  686.                 if( bDrawingHasBegun )
  687.                 {
  688.                     hr = m_pD3DXLine->End();
  689.                     if( FAILED(hr) )
  690.                         return hr;
  691.                 }
  693.                 m_pD3DXLine->SetWidth( pLineNode->fWidth );
  694.                 m_pD3DXLine->SetAntialias( pLineNode->bAntiAlias );
  696.                 fLastWidth = pLineNode->fWidth;
  697.                 bLastAntiAlias = pLineNode->bAntiAlias;
  699.                 hr = m_pD3DXLine->Begin();
  700.                 if( FAILED(hr) )
  701.                     return hr;
  702.                 bDrawingHasBegun = true;
  703.             }
  705.             hr = m_pD3DXLine->Draw( pLineNode->pVertexList, pLineNode->dwVertexListCount, pLineNode->Color );
  706.             if( FAILED(hr) )
  707.                 return hr;
  708.         }
  709.     }
  711.     if( bDrawingHasBegun )
  712.     {
  713.         hr = m_pD3DXLine->End();
  714.         if( FAILED(hr) )
  715.             return hr;
  716.     }
  718.     return S_OK;
  719. }
  722. //--------------------------------------------------------------------------------------
  723. HRESULT CDXUTLineManager::OnLostDevice()
  724. {
  725.     if( m_pD3DXLine )
  726.         m_pD3DXLine->OnLostDevice();
  728.     return S_OK;
  729. }
  732. //--------------------------------------------------------------------------------------
  733. HRESULT CDXUTLineManager::OnDeletedDevice()
  734. {
  735.     RemoveAllLines();
  736.     SAFE_RELEASE( m_pD3DXLine );
  738.     return S_OK;
  739. }
  742. //--------------------------------------------------------------------------------------
  743. HRESULT CDXUTLineManager::AddLine( int* pnLineID, D3DXVECTOR2* pVertexList, DWORD dwVertexListCount, D3DCOLOR Color, float fWidth, float fScaleRatio, bool bAntiAlias )
  744. {
  745.     if( pVertexList == NULL || dwVertexListCount == 0 )
  746.         return E_INVALIDARG;
  748.     LINE_NODE* pLineNode = new LINE_NODE;
  749.     if( pLineNode == NULL )
  750.         return E_OUTOFMEMORY;
  751.     ZeroMemory( pLineNode, sizeof(LINE_NODE) );
  753.     pLineNode->nLineID = m_LinesList.GetSize();
  754.     pLineNode->Color = Color;
  755.     pLineNode->fWidth = fWidth;
  756.     pLineNode->bAntiAlias = bAntiAlias;
  757.     pLineNode->dwVertexListCount = dwVertexListCount;
  759.     if( pnLineID )
  760.         *pnLineID = pLineNode->nLineID;
  762.     pLineNode->pVertexList = new D3DXVECTOR2[dwVertexListCount];
  763.     if( pLineNode->pVertexList == NULL )
  764.     {
  765.         delete pLineNode;
  766.         return E_OUTOFMEMORY;
  767.     }
  768.     for( DWORD i=0; i<dwVertexListCount; i++ )
  769.     {
  770.         pLineNode->pVertexList[i] = pVertexList[i] * fScaleRatio;
  771.     }
  773.     m_LinesList.Add( pLineNode );
  775.     return S_OK;
  776. }
  779. //--------------------------------------------------------------------------------------
  780. HRESULT CDXUTLineManager::AddRect( int* pnLineID, RECT rc, D3DCOLOR Color, float fWidth, float fScaleRatio, bool bAntiAlias )
  781. {
  782.     if( fWidth > 2.0f )
  783.     {
  784.         D3DXVECTOR2 vertexList[8];
  786.         vertexList[0].x = (float)rc.left;
  787.         vertexList[0].y = (float)rc.top - (fWidth/2.0f);
  789.         vertexList[1].x = (float)rc.left;
  790.         vertexList[1].y = (float)rc.bottom + (fWidth/2.0f);
  792.         vertexList[2].x = (float)rc.left;
  793.         vertexList[2].y = (float)rc.bottom - 0.5f;
  795.         vertexList[3].x = (float)rc.right;
  796.         vertexList[3].y = (float)rc.bottom - 0.5f;
  798.         vertexList[4].x = (float)rc.right;
  799.         vertexList[4].y = (float)rc.bottom + (fWidth/2.0f);
  801.         vertexList[5].x = (float)rc.right;
  802.         vertexList[5].y = (float)rc.top - (fWidth/2.0f);
  804.         vertexList[6].x = (float)rc.right;
  805.         vertexList[6].y = (float)rc.top;
  807.         vertexList[7].x = (float)rc.left;
  808.         vertexList[7].y = (float)rc.top;
  809.         
  810.         return AddLine( pnLineID, vertexList, 8, Color, fWidth, fScaleRatio, bAntiAlias );
  811.     }
  812.     else
  813.     {
  814.         D3DXVECTOR2 vertexList[5];
  815.         vertexList[0].x = (float)rc.left;
  816.         vertexList[0].y = (float)rc.top;
  818.         vertexList[1].x = (float)rc.left;
  819.         vertexList[1].y = (float)rc.bottom;
  821.         vertexList[2].x = (float)rc.right;
  822.         vertexList[2].y = (float)rc.bottom;
  824.         vertexList[3].x = (float)rc.right;
  825.         vertexList[3].y = (float)rc.top;
  827.         vertexList[4].x = (float)rc.left;
  828.         vertexList[4].y = (float)rc.top;
  829.         
  830.         return AddLine( pnLineID, vertexList, 5, Color, fWidth, fScaleRatio, bAntiAlias );
  831.     }
  832. }
  836. //--------------------------------------------------------------------------------------
  837. HRESULT CDXUTLineManager::RemoveLine( int nLineID )
  838. {
  839.     for( int i=0; i<m_LinesList.GetSize(); i++ )
  840.     {
  841.         LINE_NODE* pLineNode = m_LinesList.GetAt(i);
  842.         if( pLineNode && pLineNode->nLineID == nLineID )
  843.         {
  844.             SAFE_DELETE_ARRAY( pLineNode->pVertexList );
  845.             delete pLineNode;
  846.             m_LinesList.SetAt(i, NULL);
  847.         }
  848.     }
  850.     return S_OK;
  851. }
  854. //--------------------------------------------------------------------------------------
  855. HRESULT CDXUTLineManager::RemoveAllLines()
  856. {
  857.     for( int i=0; i<m_LinesList.GetSize(); i++ )
  858.     {
  859.         LINE_NODE* pLineNode = m_LinesList.GetAt(i);
  860.         if( pLineNode )
  861.         {
  862.             SAFE_DELETE_ARRAY( pLineNode->pVertexList );
  863.             delete pLineNode;
  864.         }
  865.     }
  866.     m_LinesList.RemoveAll();
  868.     return S_OK;
  869. }
  872. //--------------------------------------------------------------------------------------
  873. CDXUTTextHelper::CDXUTTextHelper( ID3DXFont* pFont, ID3DXSprite* pSprite, int nLineHeight )
  874. {
  875.     m_pFont = pFont;
  876.     m_pSprite = pSprite;
  877.     m_clr = D3DXCOLOR(1,1,1,1);
  878.     m_pt.x = 0; 
  879.     m_pt.y = 0; 
  880.     m_nLineHeight = nLineHeight;
  881. }
  884. //--------------------------------------------------------------------------------------
  885. HRESULT CDXUTTextHelper::DrawFormattedTextLine( const WCHAR* strMsg, ... )
  886. {
  887.     WCHAR strBuffer[512];
  888.     
  889.     va_list args;
  890.     va_start(args, strMsg);
  891.     StringCchVPrintf( strBuffer, 512, strMsg, args );
  892.     strBuffer[511] = L'';
  893.     va_end(args);
  895.     return DrawTextLine( strBuffer );
  896. }
  899. //--------------------------------------------------------------------------------------
  900. HRESULT CDXUTTextHelper::DrawTextLine( const WCHAR* strMsg )
  901. {
  902.     if( NULL == m_pFont ) 
  903.         return DXUT_ERR_MSGBOX( L"DrawTextLine", E_INVALIDARG );
  905.     HRESULT hr;
  906.     RECT rc;
  907.     SetRect( &rc, m_pt.x, m_pt.y, 0, 0 ); 
  908.     hr = m_pFont->DrawText( m_pSprite, strMsg, -1, &rc, DT_NOCLIP, m_clr );
  909.     if( FAILED(hr) )
  910.         return DXTRACE_ERR_MSGBOX( L"DrawText", hr );
  912.     m_pt.y += m_nLineHeight;
  914.     return S_OK;
  915. }
  918. HRESULT CDXUTTextHelper::DrawFormattedTextLine( RECT &rc, DWORD dwFlags, const WCHAR* strMsg, ... )
  919. {
  920.     WCHAR strBuffer[512];
  921.     
  922.     va_list args;
  923.     va_start(args, strMsg);
  924.     StringCchVPrintf( strBuffer, 512, strMsg, args );
  925.     strBuffer[511] = L'';
  926.     va_end(args);
  928.     return DrawTextLine( rc, dwFlags, strBuffer );
  929. }
  932. HRESULT CDXUTTextHelper::DrawTextLine( RECT &rc, DWORD dwFlags, const WCHAR* strMsg )
  933. {
  934.     if( NULL == m_pFont ) 
  935.         return DXUT_ERR_MSGBOX( L"DrawTextLine", E_INVALIDARG );
  937.     HRESULT hr;
  938.     hr = m_pFont->DrawText( m_pSprite, strMsg, -1, &rc, dwFlags, m_clr );
  939.     if( FAILED(hr) )
  940.         return DXTRACE_ERR_MSGBOX( L"DrawText", hr );
  942.     m_pt.y += m_nLineHeight;
  944.     return S_OK;
  945. }
  948. //--------------------------------------------------------------------------------------
  949. void CDXUTTextHelper::Begin()
  950. {
  951.     if( m_pSprite )
  952.         m_pSprite->Begin( D3DXSPRITE_ALPHABLEND | D3DXSPRITE_SORT_TEXTURE );
  953. }
  954. void CDXUTTextHelper::End()
  955. {
  956.     if( m_pSprite )
  957.         m_pSprite->End();
  958. }
  961. //--------------------------------------------------------------------------------------
  962. IDirect3DDevice9* CDXUTDirectionWidget::s_pd3dDevice = NULL;
  963. ID3DXEffect*      CDXUTDirectionWidget::s_pEffect = NULL;       
  964. ID3DXMesh*        CDXUTDirectionWidget::s_pMesh = NULL;    
  967. //--------------------------------------------------------------------------------------
  968. CDXUTDirectionWidget::CDXUTDirectionWidget()
  969. {
  970.     m_fRadius = 1.0f;
  971.     m_vDefaultDir = D3DXVECTOR3(0,1,0);
  972.     m_vCurrentDir = m_vDefaultDir;
  973.     m_nRotateMask = MOUSE_RIGHT_BUTTON;
  975.     D3DXMatrixIdentity( &m_mView );
  976.     D3DXMatrixIdentity( &m_mRot );
  977.     D3DXMatrixIdentity( &m_mRotSnapshot );
  978. }
  981. //--------------------------------------------------------------------------------------
  982. HRESULT CDXUTDirectionWidget::StaticOnCreateDevice( IDirect3DDevice9* pd3dDevice )
  983. {
  984.     HRESULT hr;
  986.     s_pd3dDevice = pd3dDevice;
  988.     const char* g_strBuffer = 
  989.     "float4 g_MaterialDiffuseColor;      // Material's diffuse colorrn"
  990.     "float3 g_LightDir;                  // Light's direction in world spacern"
  991.     "float4x4 g_mWorld;                  // World matrix for objectrn"
  992.     "float4x4 g_mWorldViewProjection;    // World * View * Projection matrixrn"
  993.     "rn"
  994.     "struct VS_OUTPUTrn"
  995.     "{rn"
  996.     "    float4 Position   : POSITION;   // vertex positionrn"
  997.     "    float4 Diffuse    : COLOR0;     // vertex diffuse colorrn"
  998.     "};rn"
  999.     "rn"
  1000.     "VS_OUTPUT RenderWith1LightNoTextureVS( float4 vPos : POSITION,rn"
  1001.     "                                       float3 vNormal : NORMAL )rn"
  1002.     "{rn"
  1003.     "    VS_OUTPUT Output;rn"
  1004.     "rn"
  1005.     "    // Transform the position from object space to homogeneous projection spacern"
  1006.     "    Output.Position = mul(vPos, g_mWorldViewProjection);rn"
  1007.     "rn"
  1008.     "    // Transform the normal from object space to world spacern"
  1009.     "    float3 vNormalWorldSpace;rn"
  1010.     "    vNormalWorldSpace = normalize(mul(vNormal, (float3x3)g_mWorld)); // normal (world space)rn"
  1011.     "rn"
  1012.     "    // Compute simple directional lighting equationrn"
  1013.     "    Output.Diffuse.rgb = g_MaterialDiffuseColor * max(0,dot(vNormalWorldSpace, g_LightDir));rn"
  1014.     "    Output.Diffuse.a = 1.0f;rn"
  1015.     "rn"
  1016.     "    return Output;rn"
  1017.     "}rn"
  1018.     "rn"
  1019.     "float4 RenderWith1LightNoTexturePS( float4 Diffuse : COLOR0 ) : COLOR0rn"
  1020.     "{rn"
  1021.     "    return Diffuse;rn"
  1022.     "}rn"
  1023.     "rn"
  1024.     "technique RenderWith1LightNoTexturern"
  1025.     "{rn"
  1026.     "    pass P0rn"
  1027.     "    {rn"
  1028.     "        VertexShader = compile vs_1_1 RenderWith1LightNoTextureVS();rn"
  1029.     "        PixelShader  = compile ps_1_1 RenderWith1LightNoTexturePS();rn"
  1030.     "    }rn"
  1031.     "}rn"
  1032.     "";
  1034.     UINT dwBufferSize = (UINT)strlen(g_strBuffer) + 1; 
  1036.     V_RETURN( D3DXCreateEffect( s_pd3dDevice, g_strBuffer, dwBufferSize, NULL, NULL, D3DXFX_NOT_CLONEABLE, NULL, &s_pEffect, NULL ) );
  1038.     // Load the mesh with D3DX and get back a ID3DXMesh*.  For this
  1039.     // sample we'll ignore the X file's embedded materials since we know 
  1040.     // exactly the model we're loading.  See the mesh samples such as
  1041.     // "OptimizedMesh" for a more generic mesh loading example.
  1042.     V_RETURN( DXUTCreateArrowMeshFromInternalArray( s_pd3dDevice, &s_pMesh ) );
  1044.     // Optimize the mesh for this graphics card's vertex cache 
  1045.     // so when rendering the mesh's triangle list the vertices will 
  1046.     // cache hit more often so it won't have to re-execute the vertex shader 
  1047.     // on those vertices so it will improve perf.     
  1048.     DWORD* rgdwAdjacency = new DWORD[s_pMesh->GetNumFaces() * 3];
  1049.     if( rgdwAdjacency == NULL )
  1050.         return E_OUTOFMEMORY;
  1051.     V( s_pMesh->GenerateAdjacency(1e-6f,rgdwAdjacency) );
  1052.     V( s_pMesh->OptimizeInplace(D3DXMESHOPT_VERTEXCACHE, rgdwAdjacency, NULL, NULL, NULL) );
  1053.     delete []rgdwAdjacency;
  1055.     return S_OK;
  1056. }
  1059. //--------------------------------------------------------------------------------------
  1060. HRESULT CDXUTDirectionWidget::OnResetDevice( const D3DSURFACE_DESC* pBackBufferSurfaceDesc )
  1061. {
  1062.     m_ArcBall.SetWindow( pBackBufferSurfaceDesc->Width, pBackBufferSurfaceDesc->Height );
  1063.     return S_OK;
  1064. }
  1067. //--------------------------------------------------------------------------------------
  1068. void CDXUTDirectionWidget::StaticOnLostDevice()
  1069. {
  1070.     if( s_pEffect )
  1071.         s_pEffect->OnLostDevice();
  1072. }
  1075. //--------------------------------------------------------------------------------------
  1076. void CDXUTDirectionWidget::StaticOnDestroyDevice()
  1077. {
  1078.     SAFE_RELEASE(s_pEffect);
  1079.     SAFE_RELEASE(s_pMesh);
  1080. }    
  1083. //--------------------------------------------------------------------------------------
  1084. LRESULT CDXUTDirectionWidget::HandleMessages( HWND hWnd, UINT uMsg, 
  1085.                                               WPARAM wParam, LPARAM lParam )
  1086. {
  1087.     switch( uMsg )
  1088.     {
  1089.         case WM_LBUTTONDOWN:
  1090.         case WM_MBUTTONDOWN:
  1091.         case WM_RBUTTONDOWN:
  1092.         {
  1093.             if( ((m_nRotateMask & MOUSE_LEFT_BUTTON) != 0 && uMsg == WM_LBUTTONDOWN) ||
  1094.                 ((m_nRotateMask & MOUSE_MIDDLE_BUTTON) != 0 && uMsg == WM_MBUTTONDOWN) ||
  1095.                 ((m_nRotateMask & MOUSE_RIGHT_BUTTON) != 0 && uMsg == WM_RBUTTONDOWN) )
  1096.             {
  1097.                 int iMouseX = (int)(short)LOWORD(lParam);
  1098.                 int iMouseY = (int)(short)HIWORD(lParam);
  1099.                 m_ArcBall.OnBegin( iMouseX, iMouseY );
  1100.                 SetCapture(hWnd);
  1101.             }
  1102.             return TRUE;
  1103.         }
  1105.         case WM_MOUSEMOVE:
  1106.         {
  1107.             if( m_ArcBall.IsBeingDragged() )
  1108.             {
  1109.                 int iMouseX = (int)(short)LOWORD(lParam);
  1110.                 int iMouseY = (int)(short)HIWORD(lParam);
  1111.                 m_ArcBall.OnMove( iMouseX, iMouseY );
  1112.                 UpdateLightDir();
  1113.             }
  1114.             return TRUE;
  1115.         }
  1117.         case WM_LBUTTONUP:
  1118.         case WM_MBUTTONUP:
  1119.         case WM_RBUTTONUP:
  1120.         {
  1121.             if( ((m_nRotateMask & MOUSE_LEFT_BUTTON) != 0 && uMsg == WM_LBUTTONUP) ||
  1122.                 ((m_nRotateMask & MOUSE_MIDDLE_BUTTON) != 0 && uMsg == WM_MBUTTONUP) ||
  1123.                 ((m_nRotateMask & MOUSE_RIGHT_BUTTON) != 0 && uMsg == WM_RBUTTONUP) )
  1124.             {
  1125.                 m_ArcBall.OnEnd();
  1126.                 ReleaseCapture();
  1127.             }
  1129.             UpdateLightDir();
  1130.             return TRUE;
  1131.         }
  1133.         case WM_CAPTURECHANGED:
  1134.         {
  1135.             if( (HWND)lParam != hWnd )
  1136.             {
  1137.                 if( (m_nRotateMask & MOUSE_LEFT_BUTTON) ||
  1138.                     (m_nRotateMask & MOUSE_MIDDLE_BUTTON) ||
  1139.                     (m_nRotateMask & MOUSE_RIGHT_BUTTON) )
  1140.                 {
  1141.                     m_ArcBall.OnEnd();
  1142.                     ReleaseCapture();
  1143.                 }
  1144.             }
  1146.             return TRUE;
  1147.         }
  1148.     }
  1150.     return 0;
  1151. }
  1154. //--------------------------------------------------------------------------------------
  1155. HRESULT CDXUTDirectionWidget::OnRender( D3DXCOLOR color, const D3DXMATRIX* pmView, 
  1156.                                         const D3DXMATRIX* pmProj, const D3DXVECTOR3* pEyePt )
  1157. {
  1158.     m_mView = *pmView;
  1160.     // Render the light spheres so the user can visually see the light dir
  1161.     UINT iPass, cPasses;
  1162.     D3DXMATRIX mRotate;
  1163.     D3DXMATRIX mScale;
  1164.     D3DXMATRIX mTrans;
  1165.     D3DXMATRIXA16 mWorldViewProj;
  1166.     HRESULT hr;
  1168.     V( s_pEffect->SetTechnique( "RenderWith1LightNoTexture" ) );
  1169.     V( s_pEffect->SetVector( "g_MaterialDiffuseColor", (D3DXVECTOR4*)&color ) );
  1171.     D3DXVECTOR3 vEyePt;
  1172.     D3DXVec3Normalize( &vEyePt, pEyePt );
  1173.     V( s_pEffect->SetValue( "g_LightDir", &vEyePt, sizeof(D3DXVECTOR3) ) );
  1175.     // Rotate arrow model to point towards origin
  1176.     D3DXMATRIX mRotateA, mRotateB;
  1177.     D3DXVECTOR3 vAt = D3DXVECTOR3(0,0,0);
  1178.     D3DXVECTOR3 vUp = D3DXVECTOR3(0,1,0);
  1179.     D3DXMatrixRotationX( &mRotateB, D3DX_PI );
  1180.     D3DXMatrixLookAtLH( &mRotateA, &m_vCurrentDir, &vAt, &vUp );
  1181.     D3DXMatrixInverse( &mRotateA, NULL, &mRotateA );
  1182.     mRotate = mRotateB * mRotateA;
  1184.     D3DXVECTOR3 vL = m_vCurrentDir * m_fRadius * 1.0f;
  1185.     D3DXMatrixTranslation( &mTrans, vL.x, vL.y, vL.z );
  1186.     D3DXMatrixScaling( &mScale, m_fRadius*0.2f, m_fRadius*0.2f, m_fRadius*0.2f );
  1188.     D3DXMATRIX mWorld = mRotate * mScale * mTrans;
  1189.     mWorldViewProj = mWorld * (m_mView) * (*pmProj);
  1191.     V( s_pEffect->SetMatrix( "g_mWorldViewProjection", &mWorldViewProj ) );
  1192.     V( s_pEffect->SetMatrix( "g_mWorld", &mWorld ) );
  1194.     for( int iSubset=0; iSubset<2; iSubset++ )
  1195.     {
  1196.         V( s_pEffect->Begin(&cPasses, 0) );
  1197.         for (iPass = 0; iPass < cPasses; iPass++)
  1198.         {
  1199.             V( s_pEffect->BeginPass(iPass) );
  1200.             V( s_pMesh->DrawSubset(iSubset) );
  1201.             V( s_pEffect->EndPass() );
  1202.         }
  1203.         V( s_pEffect->End() );
  1204.     }
  1206.     return S_OK;
  1207. }
  1210. //--------------------------------------------------------------------------------------
  1211. HRESULT CDXUTDirectionWidget::UpdateLightDir()
  1212. {
  1213.     D3DXMATRIX mInvView;
  1214.     D3DXMatrixInverse(&mInvView, NULL, &m_mView);
  1215.     mInvView._41 = mInvView._42 = mInvView._43 = 0;
  1217.     D3DXMATRIX mLastRotInv;
  1218.     D3DXMatrixInverse(&mLastRotInv, NULL, &m_mRotSnapshot);
  1220.     D3DXMATRIX mRot = *m_ArcBall.GetRotationMatrix();
  1221.     m_mRotSnapshot = mRot;
  1223.     // Accumulate the delta of the arcball's rotation in view space.
  1224.     // Note that per-frame delta rotations could be problematic over long periods of time.
  1225.     m_mRot *= m_mView * mLastRotInv * mRot * mInvView;
  1227.     // Since we're accumulating delta rotations, we need to orthonormalize 
  1228.     // the matrix to prevent eventual matrix skew
  1229.     D3DXVECTOR3* pXBasis = (D3DXVECTOR3*) &m_mRot._11;
  1230.     D3DXVECTOR3* pYBasis = (D3DXVECTOR3*) &m_mRot._21;
  1231.     D3DXVECTOR3* pZBasis = (D3DXVECTOR3*) &m_mRot._31;
  1232.     D3DXVec3Normalize( pXBasis, pXBasis );
  1233.     D3DXVec3Cross( pYBasis, pZBasis, pXBasis );
  1234.     D3DXVec3Normalize( pYBasis, pYBasis );
  1235.     D3DXVec3Cross( pZBasis, pXBasis, pYBasis );
  1237.     // Transform the default direction vector by the light's rotation matrix
  1238.     D3DXVec3TransformNormal( &m_vCurrentDir, &m_vDefaultDir, &m_mRot );
  1240.     return S_OK;
  1241. }
  1243. //--------------------------------------------------------------------------------------
  1244. // Direct3D9 dynamic linking support -- calls top-level D3D9 APIs with graceful
  1245. // failure if APIs are not present.
  1246. //--------------------------------------------------------------------------------------
  1248. // Function prototypes
  1249. typedef IDirect3D9* (WINAPI * LPDIRECT3DCREATE9) (UINT);
  1250. typedef INT         (WINAPI * LPD3DPERF_BEGINEVENT)(D3DCOLOR, LPCWSTR);
  1251. typedef INT         (WINAPI * LPD3DPERF_ENDEVENT)(void);
  1252. typedef VOID        (WINAPI * LPD3DPERF_SETMARKER)(D3DCOLOR, LPCWSTR);
  1253. typedef VOID        (WINAPI * LPD3DPERF_SETREGION)(D3DCOLOR, LPCWSTR);
  1254. typedef BOOL        (WINAPI * LPD3DPERF_QUERYREPEATFRAME)(void);
  1255. typedef VOID        (WINAPI * LPD3DPERF_SETOPTIONS)( DWORD dwOptions );
  1256. typedef DWORD       (WINAPI * LPD3DPERF_GETSTATUS)( void );
  1258. // Module and function pointers
  1259. static HMODULE s_hModD3D9 = NULL;
  1260. static LPDIRECT3DCREATE9 s_DynamicDirect3DCreate9 = NULL;
  1261. static LPD3DPERF_BEGINEVENT s_DynamicD3DPERF_BeginEvent = NULL;
  1262. static LPD3DPERF_ENDEVENT s_DynamicD3DPERF_EndEvent = NULL;
  1263. static LPD3DPERF_SETMARKER s_DynamicD3DPERF_SetMarker = NULL;
  1264. static LPD3DPERF_SETREGION s_DynamicD3DPERF_SetRegion = NULL;
  1265. static LPD3DPERF_QUERYREPEATFRAME s_DynamicD3DPERF_QueryRepeatFrame = NULL;
  1266. static LPD3DPERF_SETOPTIONS s_DynamicD3DPERF_SetOptions = NULL;
  1267. static LPD3DPERF_GETSTATUS s_DynamicD3DPERF_GetStatus = NULL;
  1269. // Ensure function pointers are initialized
  1270. static bool DXUT_EnsureD3DAPIs( void )
  1271. {
  1272.     // If module is non-NULL, this function has already been called.  Note
  1273.     // that this doesn't guarantee that all D3D9 procaddresses were found.
  1274.     if( s_hModD3D9 != NULL )
  1275.         return true;
  1277.     // This may fail if DirectX 9 isn't installed
  1278.     WCHAR wszPath[MAX_PATH+1];
  1279.     if( !::GetSystemDirectory( wszPath, MAX_PATH+1 ) )
  1280.         return false;
  1281.     StringCchCat( wszPath, MAX_PATH, L"\d3d9.dll" );
  1282.     s_hModD3D9 = LoadLibrary( wszPath );
  1283.     if( s_hModD3D9 == NULL ) 
  1284.         return false;
  1285.     s_DynamicDirect3DCreate9 = (LPDIRECT3DCREATE9)GetProcAddress( s_hModD3D9, "Direct3DCreate9" );
  1286.     s_DynamicD3DPERF_BeginEvent = (LPD3DPERF_BEGINEVENT)GetProcAddress( s_hModD3D9, "D3DPERF_BeginEvent" );
  1287.     s_DynamicD3DPERF_EndEvent = (LPD3DPERF_ENDEVENT)GetProcAddress( s_hModD3D9, "D3DPERF_EndEvent" );
  1288.     s_DynamicD3DPERF_SetMarker = (LPD3DPERF_SETMARKER)GetProcAddress( s_hModD3D9, "D3DPERF_SetMarker" );
  1289.     s_DynamicD3DPERF_SetRegion = (LPD3DPERF_SETREGION)GetProcAddress( s_hModD3D9, "D3DPERF_SetRegion" );
  1290.     s_DynamicD3DPERF_QueryRepeatFrame = (LPD3DPERF_QUERYREPEATFRAME)GetProcAddress( s_hModD3D9, "D3DPERF_QueryRepeatFrame" );
  1291.     s_DynamicD3DPERF_SetOptions = (LPD3DPERF_SETOPTIONS)GetProcAddress( s_hModD3D9, "D3DPERF_SetOptions" );
  1292.     s_DynamicD3DPERF_GetStatus = (LPD3DPERF_GETSTATUS)GetProcAddress( s_hModD3D9, "D3DPERF_GetStatus" );
  1293.     return true;
  1294. }
  1296. IDirect3D9 * WINAPI DXUT_Dynamic_Direct3DCreate9(UINT SDKVersion) 
  1297. {
  1298.     if( DXUT_EnsureD3DAPIs() && s_DynamicDirect3DCreate9 != NULL )
  1299.         return s_DynamicDirect3DCreate9( SDKVersion );
  1300.     else
  1301.         return NULL;
  1302. }
  1304. int WINAPI DXUT_Dynamic_D3DPERF_BeginEvent( D3DCOLOR col, LPCWSTR wszName )
  1305. {
  1306.     if( DXUT_EnsureD3DAPIs() && s_DynamicD3DPERF_BeginEvent != NULL )
  1307.         return s_DynamicD3DPERF_BeginEvent( col, wszName );
  1308.     else
  1309.         return -1;
  1310. }
  1312. int WINAPI DXUT_Dynamic_D3DPERF_EndEvent( void )
  1313. {
  1314.     if( DXUT_EnsureD3DAPIs() && s_DynamicD3DPERF_EndEvent != NULL )
  1315.         return s_DynamicD3DPERF_EndEvent();
  1316.     else
  1317.         return -1;
  1318. }
  1320. void WINAPI DXUT_Dynamic_D3DPERF_SetMarker( D3DCOLOR col, LPCWSTR wszName )
  1321. {
  1322.     if( DXUT_EnsureD3DAPIs() && s_DynamicD3DPERF_SetMarker != NULL )
  1323.         s_DynamicD3DPERF_SetMarker( col, wszName );
  1324. }
  1326. void WINAPI DXUT_Dynamic_D3DPERF_SetRegion( D3DCOLOR col, LPCWSTR wszName )
  1327. {
  1328.     if( DXUT_EnsureD3DAPIs() && s_DynamicD3DPERF_SetRegion != NULL )
  1329.         s_DynamicD3DPERF_SetRegion( col, wszName );
  1330. }
  1332. BOOL WINAPI DXUT_Dynamic_D3DPERF_QueryRepeatFrame( void )
  1333. {
  1334.     if( DXUT_EnsureD3DAPIs() && s_DynamicD3DPERF_QueryRepeatFrame != NULL )
  1335.         return s_DynamicD3DPERF_QueryRepeatFrame();
  1336.     else
  1337.         return FALSE;
  1338. }
  1340. void WINAPI DXUT_Dynamic_D3DPERF_SetOptions( DWORD dwOptions )
  1341. {
  1342.     if( DXUT_EnsureD3DAPIs() && s_DynamicD3DPERF_SetOptions != NULL )
  1343.         s_DynamicD3DPERF_SetOptions( dwOptions );
  1344. }
  1346. DWORD WINAPI DXUT_Dynamic_D3DPERF_GetStatus( void )
  1347. {
  1348.     if( DXUT_EnsureD3DAPIs() && s_DynamicD3DPERF_GetStatus != NULL )
  1349.         return s_DynamicD3DPERF_GetStatus();
  1350.     else
  1351.         return 0;
  1352. }
  1355. //--------------------------------------------------------------------------------------
  1356. // Trace a string description of a decl 
  1357. //--------------------------------------------------------------------------------------
  1358. void DXUTTraceDecl( D3DVERTEXELEMENT9 decl[MAX_FVF_DECL_SIZE] )
  1359. {
  1360.     int iDecl=0;
  1361.     for( iDecl=0; iDecl<MAX_FVF_DECL_SIZE; iDecl++ )
  1362.     {
  1363.         if( decl[iDecl].Stream == 0xFF )
  1364.             break;
  1366.         DXUTOutputDebugString( L"decl[%d]=Stream:%d, Offset:%d, %s, %s, %s, UsageIndex:%dn", iDecl, 
  1367.                     decl[iDecl].Stream,
  1368.                     decl[iDecl].Offset,
  1369.                     DXUTTraceD3DDECLTYPEtoString( decl[iDecl].Type ),
  1370.                     DXUTTraceD3DDECLMETHODtoString( decl[iDecl].Method ),
  1371.                     DXUTTraceD3DDECLUSAGEtoString( decl[iDecl].Usage ),
  1372.                     decl[iDecl].UsageIndex );
  1373.     }
  1375.     DXUTOutputDebugString( L"decl[%d]=D3DDECL_ENDn", iDecl );
  1376. }
  1379. //--------------------------------------------------------------------------------------
  1380. WCHAR* DXUTTraceD3DDECLTYPEtoString( BYTE t )
  1381. {
  1382.     switch( t )
  1383.     {
  1384.         case D3DDECLTYPE_FLOAT1: return L"D3DDECLTYPE_FLOAT1";
  1385.         case D3DDECLTYPE_FLOAT2: return L"D3DDECLTYPE_FLOAT2";
  1386.         case D3DDECLTYPE_FLOAT3: return L"D3DDECLTYPE_FLOAT3";
  1387.         case D3DDECLTYPE_FLOAT4: return L"D3DDECLTYPE_FLOAT4";
  1388.         case D3DDECLTYPE_D3DCOLOR: return L"D3DDECLTYPE_D3DCOLOR";
  1389.         case D3DDECLTYPE_UBYTE4: return L"D3DDECLTYPE_UBYTE4";
  1390.         case D3DDECLTYPE_SHORT2: return L"D3DDECLTYPE_SHORT2";
  1391.         case D3DDECLTYPE_SHORT4: return L"D3DDECLTYPE_SHORT4";
  1392.         case D3DDECLTYPE_UBYTE4N: return L"D3DDECLTYPE_UBYTE4N";
  1393.         case D3DDECLTYPE_SHORT2N: return L"D3DDECLTYPE_SHORT2N";
  1394.         case D3DDECLTYPE_SHORT4N: return L"D3DDECLTYPE_SHORT4N";
  1395.         case D3DDECLTYPE_USHORT2N: return L"D3DDECLTYPE_USHORT2N";
  1396.         case D3DDECLTYPE_USHORT4N: return L"D3DDECLTYPE_USHORT4N";
  1397.         case D3DDECLTYPE_UDEC3: return L"D3DDECLTYPE_UDEC3";
  1398.         case D3DDECLTYPE_DEC3N: return L"D3DDECLTYPE_DEC3N";
  1399.         case D3DDECLTYPE_FLOAT16_2: return L"D3DDECLTYPE_FLOAT16_2";
  1400.         case D3DDECLTYPE_FLOAT16_4: return L"D3DDECLTYPE_FLOAT16_4";
  1401.         case D3DDECLTYPE_UNUSED: return L"D3DDECLTYPE_UNUSED";
  1402.         default: return L"D3DDECLTYPE Unknown";
  1403.     }
  1404. }
  1406. WCHAR* DXUTTraceD3DDECLMETHODtoString( BYTE m )
  1407. {
  1408.     switch( m )
  1409.     {
  1410.         case D3DDECLMETHOD_DEFAULT: return L"D3DDECLMETHOD_DEFAULT";
  1411.         case D3DDECLMETHOD_PARTIALU: return L"D3DDECLMETHOD_PARTIALU";
  1412.         case D3DDECLMETHOD_PARTIALV: return L"D3DDECLMETHOD_PARTIALV";
  1413.         case D3DDECLMETHOD_CROSSUV: return L"D3DDECLMETHOD_CROSSUV";
  1414.         case D3DDECLMETHOD_UV: return L"D3DDECLMETHOD_UV";
  1415.         case D3DDECLMETHOD_LOOKUP: return L"D3DDECLMETHOD_LOOKUP";
  1416.         case D3DDECLMETHOD_LOOKUPPRESAMPLED: return L"D3DDECLMETHOD_LOOKUPPRESAMPLED";
  1417.         default: return L"D3DDECLMETHOD Unknown";
  1418.     }
  1419. }
  1421. WCHAR* DXUTTraceD3DDECLUSAGEtoString( BYTE u )
  1422. {
  1423.     switch( u )
  1424.     {
  1425.         case D3DDECLUSAGE_POSITION: return L"D3DDECLUSAGE_POSITION";
  1426.         case D3DDECLUSAGE_BLENDWEIGHT: return L"D3DDECLUSAGE_BLENDWEIGHT";
  1427.         case D3DDECLUSAGE_BLENDINDICES: return L"D3DDECLUSAGE_BLENDINDICES";
  1428.         case D3DDECLUSAGE_NORMAL: return L"D3DDECLUSAGE_NORMAL";
  1429.         case D3DDECLUSAGE_PSIZE: return L"D3DDECLUSAGE_PSIZE";
  1430.         case D3DDECLUSAGE_TEXCOORD: return L"D3DDECLUSAGE_TEXCOORD";
  1431.         case D3DDECLUSAGE_TANGENT: return L"D3DDECLUSAGE_TANGENT";
  1432.         case D3DDECLUSAGE_BINORMAL: return L"D3DDECLUSAGE_BINORMAL";
  1433.         case D3DDECLUSAGE_TESSFACTOR: return L"D3DDECLUSAGE_TESSFACTOR";
  1434.         case D3DDECLUSAGE_POSITIONT: return L"D3DDECLUSAGE_POSITIONT";
  1435.         case D3DDECLUSAGE_COLOR: return L"D3DDECLUSAGE_COLOR";
  1436.         case D3DDECLUSAGE_FOG: return L"D3DDECLUSAGE_FOG";
  1437.         case D3DDECLUSAGE_DEPTH: return L"D3DDECLUSAGE_DEPTH";
  1438.         case D3DDECLUSAGE_SAMPLE: return L"D3DDECLUSAGE_SAMPLE";
  1439.         default: return L"D3DDECLUSAGE Unknown";
  1440.     }
  1441. }
  1444. //--------------------------------------------------------------------------------------
  1445. // Multimon API handling for OSes with or without multimon API support
  1446. //--------------------------------------------------------------------------------------
  1447. #define DXUT_PRIMARY_MONITOR ((HMONITOR)0x12340042)
  1448. typedef HMONITOR (WINAPI* LPMONITORFROMWINDOW)(HWND, DWORD);
  1449. typedef BOOL     (WINAPI* LPGETMONITORINFO)(HMONITOR, LPMONITORINFO);
  1451. BOOL DXUTGetMonitorInfo(HMONITOR hMonitor, LPMONITORINFO lpMonitorInfo)
  1452. {
  1453.     static bool s_bInited = false;
  1454.     static LPGETMONITORINFO s_pFnGetMonitorInfo = NULL;
  1455.     if( !s_bInited )        
  1456.     {
  1457.         s_bInited = true;
  1458.         HMODULE hUser32 = GetModuleHandle( L"USER32" );
  1459.         if (hUser32 ) 
  1460.         {
  1461.             OSVERSIONINFOA osvi = {0}; osvi.dwOSVersionInfoSize = sizeof(osvi); GetVersionExA((OSVERSIONINFOA*)&osvi);
  1462.             bool bNT = (VER_PLATFORM_WIN32_NT == osvi.dwPlatformId);    
  1463.             s_pFnGetMonitorInfo = (LPGETMONITORINFO) (bNT ? GetProcAddress(hUser32,"GetMonitorInfoW") : GetProcAddress(hUser32,"GetMonitorInfoA"));
  1464.         }
  1465.     }
  1467.     if( s_pFnGetMonitorInfo ) 
  1468.         return s_pFnGetMonitorInfo(hMonitor, lpMonitorInfo);
  1470.     RECT rcWork;
  1471.     if ((hMonitor == DXUT_PRIMARY_MONITOR) && lpMonitorInfo && (lpMonitorInfo->cbSize >= sizeof(MONITORINFO)) && SystemParametersInfoA(SPI_GETWORKAREA, 0, &rcWork, 0))
  1472.     {
  1473.         lpMonitorInfo->rcMonitor.left = 0;
  1474.         lpMonitorInfo->rcMonitor.top  = 0;
  1475.         lpMonitorInfo->rcMonitor.right  = GetSystemMetrics(SM_CXSCREEN);
  1476.         lpMonitorInfo->rcMonitor.bottom = GetSystemMetrics(SM_CYSCREEN);
  1477.         lpMonitorInfo->rcWork = rcWork;
  1478.         lpMonitorInfo->dwFlags = MONITORINFOF_PRIMARY;
  1479.         return TRUE;
  1480.     }
  1481.     return FALSE;
  1482. }
  1485. HMONITOR DXUTMonitorFromWindow(HWND hWnd, DWORD dwFlags)
  1486. {
  1487.     static bool s_bInited = false;
  1488.     static LPMONITORFROMWINDOW s_pFnGetMonitorFronWindow = NULL;
  1489.     if( !s_bInited )        
  1490.     {
  1491.         s_bInited = true;
  1492.         HMODULE hUser32 = GetModuleHandle( L"USER32" );
  1493.         if (hUser32 ) s_pFnGetMonitorFronWindow = (LPMONITORFROMWINDOW) GetProcAddress(hUser32,"MonitorFromWindow");
  1494.     }
  1496.     if( s_pFnGetMonitorFronWindow ) 
  1497.         return s_pFnGetMonitorFronWindow(hWnd, dwFlags);
  1498.     if (dwFlags & (MONITOR_DEFAULTTOPRIMARY | MONITOR_DEFAULTTONEAREST))
  1499.         return DXUT_PRIMARY_MONITOR;
  1500.     return NULL;
  1501. }
  1504. //--------------------------------------------------------------------------------------
  1505. // Get the desktop resolution of an adapter. This isn't the same as the current resolution 
  1506. // from GetAdapterDisplayMode since the device might be fullscreen 
  1507. //--------------------------------------------------------------------------------------
  1508. void DXUTGetDesktopResolution( UINT AdapterOrdinal, UINT* pWidth, UINT* pHeight )
  1509. {
  1510.     CD3DEnumeration* pd3dEnum = DXUTGetEnumeration();
  1511.     CD3DEnumAdapterInfo* pAdapterInfo = pd3dEnum->GetAdapterInfo( AdapterOrdinal );                       
  1512.     DEVMODE devMode;
  1513.     ZeroMemory( &devMode, sizeof(DEVMODE) );
  1514.     devMode.dmSize = sizeof(DEVMODE);
  1515.     WCHAR strDeviceName[256];
  1516.     MultiByteToWideChar( CP_ACP, 0, pAdapterInfo->AdapterIdentifier.DeviceName, -1, strDeviceName, 256 );
  1517.     strDeviceName[255] = 0;
  1518.     EnumDisplaySettings( strDeviceName, ENUM_REGISTRY_SETTINGS, &devMode );
  1519.     
  1520.     if( pWidth )
  1521.         *pWidth = devMode.dmPelsWidth;
  1522.     if( pHeight )
  1523.         *pHeight = devMode.dmPelsHeight;
  1524. }
  1527. //--------------------------------------------------------------------------------------
  1528. IDirect3DDevice9* DXUTCreateRefDevice( HWND hWnd, bool bNullRef )
  1529. {
  1530.     HRESULT hr;
  1531.     IDirect3D9* pD3D = DXUT_Dynamic_Direct3DCreate9( D3D_SDK_VERSION );
  1532.     if( NULL == pD3D )
  1533.         return NULL;
  1535.     D3DDISPLAYMODE Mode;
  1536.     pD3D->GetAdapterDisplayMode(0, &Mode);
  1538.     D3DPRESENT_PARAMETERS pp;
  1539.     ZeroMemory( &pp, sizeof(D3DPRESENT_PARAMETERS) );
  1540.     pp.BackBufferWidth  = 1;
  1541.     pp.BackBufferHeight = 1;
  1542.     pp.BackBufferFormat = Mode.Format;
  1543.     pp.BackBufferCount  = 1;
  1544.     pp.SwapEffect       = D3DSWAPEFFECT_COPY;
  1545.     pp.Windowed         = TRUE;
  1546.     pp.hDeviceWindow    = hWnd;
  1548.     IDirect3DDevice9* pd3dDevice = NULL;
  1549.     hr = pD3D->CreateDevice( D3DADAPTER_DEFAULT, bNullRef ? D3DDEVTYPE_NULLREF : D3DDEVTYPE_REF,
  1550.                              hWnd, D3DCREATE_HARDWARE_VERTEXPROCESSING, &pp, &pd3dDevice );
  1552.     SAFE_RELEASE( pD3D );
  1553.     return pd3dDevice;
  1554. }
  1557. typedef DWORD (WINAPI* LPXINPUTGETSTATE)(DWORD dwUserIndex, XINPUT_STATE* pState );
  1558. typedef DWORD (WINAPI* LPXINPUTSETSTATE)(DWORD dwUserIndex, XINPUT_VIBRATION* pVibration );
  1559. typedef DWORD (WINAPI* LPXINPUTGETCAPABILITIES)( DWORD dwUserIndex, DWORD dwFlags, XINPUT_CAPABILITIES* pCapabilities );
  1563. //--------------------------------------------------------------------------------------
  1564. // Does extra processing on XInput data to make it slightly more convenient to use
  1565. //--------------------------------------------------------------------------------------
  1566. HRESULT DXUTGetGamepadState( DWORD dwPort, DXUT_GAMEPAD* pGamePad, bool bThumbstickDeadZone, bool bSnapThumbstickToCardinals )
  1567. {
  1568.     if( dwPort >= DXUT_MAX_CONTROLLERS || pGamePad == NULL )
  1569.         return E_FAIL;
  1571.     static LPXINPUTGETSTATE s_pXInputGetState = NULL;
  1572.     static LPXINPUTGETCAPABILITIES s_pXInputGetCapabilities = NULL;
  1573.     if( NULL == s_pXInputGetState || NULL == s_pXInputGetCapabilities )
  1574.     {
  1575.         WCHAR wszPath[MAX_PATH];
  1576.         if( GetSystemDirectory( wszPath, MAX_PATH ) )
  1577.         {
  1578.             StringCchCat( wszPath, MAX_PATH, L"\" );
  1579.             StringCchCat( wszPath, MAX_PATH, XINPUT_DLL );
  1580.             HINSTANCE hInst = LoadLibrary( wszPath );
  1581.             if( hInst ) 
  1582.             {
  1583.                 s_pXInputGetState = (LPXINPUTGETSTATE)GetProcAddress( hInst, "XInputGetState" );
  1584.                 s_pXInputGetCapabilities = (LPXINPUTGETCAPABILITIES)GetProcAddress( hInst, "XInputGetCapabilities" );
  1585.             }
  1586.         }
  1587.     }
  1588.     if( s_pXInputGetState == NULL )
  1589.         return E_FAIL;
  1591.     XINPUT_STATE InputState;
  1592.     DWORD dwResult = s_pXInputGetState( dwPort, &InputState );
  1594.     // Track insertion and removals
  1595.     BOOL bWasConnected = pGamePad->bConnected;
  1596.     pGamePad->bConnected = (dwResult == ERROR_SUCCESS);
  1597.     pGamePad->bRemoved  = (  bWasConnected && !pGamePad->bConnected );
  1598.     pGamePad->bInserted = ( !bWasConnected &&  pGamePad->bConnected );
  1600.     // Don't update rest of the state if not connected
  1601.     if( !pGamePad->bConnected )
  1602.         return S_OK;
  1604.     // Store the capabilities of the device
  1605.     if( pGamePad->bInserted )
  1606.     {
  1607.         ZeroMemory( pGamePad, sizeof(DXUT_GAMEPAD) );
  1608.         pGamePad->bConnected = true;
  1609.         pGamePad->bInserted  = true;
  1610.         if( s_pXInputGetCapabilities )
  1611.             s_pXInputGetCapabilities( dwPort, XINPUT_DEVTYPE_GAMEPAD, &pGamePad->caps );
  1612.     }
  1614.     // Copy gamepad to local structure (assumes that XINPUT_GAMEPAD at the front in CONTROLER_STATE)
  1615.     memcpy( pGamePad, &InputState.Gamepad, sizeof(XINPUT_GAMEPAD) );
  1617.     if( bSnapThumbstickToCardinals )
  1618.     {
  1619.         // Apply deadzone to each axis independantly to slightly snap to up/down/left/right
  1620.         if( pGamePad->sThumbLX < XINPUT_GAMEPAD_LEFT_THUMB_DEADZONE && pGamePad->sThumbLX > -XINPUT_GAMEPAD_LEFT_THUMB_DEADZONE )
  1621.             pGamePad->sThumbLX = 0;
  1622.         if( pGamePad->sThumbLY < XINPUT_GAMEPAD_LEFT_THUMB_DEADZONE && pGamePad->sThumbLY > -XINPUT_GAMEPAD_LEFT_THUMB_DEADZONE ) 
  1623.             pGamePad->sThumbLY = 0;
  1624.         if( pGamePad->sThumbRX < XINPUT_GAMEPAD_RIGHT_THUMB_DEADZONE && pGamePad->sThumbRX > -XINPUT_GAMEPAD_RIGHT_THUMB_DEADZONE )
  1625.             pGamePad->sThumbRX = 0;
  1626.         if( pGamePad->sThumbRY < XINPUT_GAMEPAD_RIGHT_THUMB_DEADZONE && pGamePad->sThumbRY > -XINPUT_GAMEPAD_RIGHT_THUMB_DEADZONE ) 
  1627.             pGamePad->sThumbRY = 0;
  1628.     }
  1629.     else if( bThumbstickDeadZone )
  1630.     {
  1631.         // Apply deadzone if centered
  1632.         if( (pGamePad->sThumbLX < XINPUT_GAMEPAD_LEFT_THUMB_DEADZONE && pGamePad->sThumbLX > -XINPUT_GAMEPAD_LEFT_THUMB_DEADZONE) && 
  1633.             (pGamePad->sThumbLY < XINPUT_GAMEPAD_LEFT_THUMB_DEADZONE && pGamePad->sThumbLY > -XINPUT_GAMEPAD_LEFT_THUMB_DEADZONE) ) 
  1634.         {   
  1635.             pGamePad->sThumbLX = 0;
  1636.             pGamePad->sThumbLY = 0;
  1637.         }
  1638.         if( (pGamePad->sThumbRX < XINPUT_GAMEPAD_RIGHT_THUMB_DEADZONE && pGamePad->sThumbRX > -XINPUT_GAMEPAD_RIGHT_THUMB_DEADZONE) && 
  1639.             (pGamePad->sThumbRY < XINPUT_GAMEPAD_RIGHT_THUMB_DEADZONE && pGamePad->sThumbRY > -XINPUT_GAMEPAD_RIGHT_THUMB_DEADZONE) ) 
  1640.         {
  1641.             pGamePad->sThumbRX = 0;
  1642.             pGamePad->sThumbRY = 0;
  1643.         }
  1644.     }
  1646.     // Convert [-1,+1] range
  1647.     pGamePad->fThumbLX = pGamePad->sThumbLX / 32767.0f;
  1648.     pGamePad->fThumbLY = pGamePad->sThumbLY / 32767.0f;
  1649.     pGamePad->fThumbRX = pGamePad->sThumbRX / 32767.0f;
  1650.     pGamePad->fThumbRY = pGamePad->sThumbRY / 32767.0f;
  1652.     // Get the boolean buttons that have been pressed since the last call. 
  1653.     // Each button is represented by one bit.
  1654.     pGamePad->wPressedButtons = ( pGamePad->wLastButtons ^ pGamePad->wButtons ) & pGamePad->wButtons;
  1655.     pGamePad->wLastButtons    = pGamePad->wButtons;
  1657.     // Figure out if the left trigger has been pressed or released
  1658.     bool bPressed = ( pGamePad->bLeftTrigger > DXUT_GAMEPAD_TRIGGER_THRESHOLD );
  1659.     pGamePad->bPressedLeftTrigger = ( bPressed ) ? !pGamePad->bLastLeftTrigger : false;
  1660.     pGamePad->bLastLeftTrigger = bPressed;
  1662.     // Figure out if the right trigger has been pressed or released
  1663.     bPressed = ( pGamePad->bRightTrigger > DXUT_GAMEPAD_TRIGGER_THRESHOLD );
  1664.     pGamePad->bPressedRightTrigger = ( bPressed ) ? !pGamePad->bLastRightTrigger : false;
  1665.     pGamePad->bLastRightTrigger = bPressed;
  1667.     return S_OK;
  1668. }
  1671. //--------------------------------------------------------------------------------------
  1672. // Don't pause the game or deactive the window without first stopping rumble otherwise 
  1673. // the controller will continue to rumble
  1674. //--------------------------------------------------------------------------------------
  1675. HRESULT DXUTStopRumbleOnAllControllers()
  1676. {
  1677.     static LPXINPUTSETSTATE s_pXInputSetState = NULL;
  1678.     if( NULL == s_pXInputSetState )
  1679.     {
  1680.         WCHAR wszPath[MAX_PATH];
  1681.         if( GetSystemDirectory( wszPath, MAX_PATH ) )
  1682.         {
  1683.             StringCchCat( wszPath, MAX_PATH, L"\" );
  1684.             StringCchCat( wszPath, MAX_PATH, XINPUT_DLL );
  1685.             HINSTANCE hInst = LoadLibrary( wszPath );
  1686.             if( hInst ) 
  1687.                 s_pXInputSetState = (LPXINPUTSETSTATE)GetProcAddress( hInst, "XInputSetState" );
  1688.         }
  1689.     }
  1690.     if( s_pXInputSetState == NULL )
  1691.         return E_FAIL;
  1693.     XINPUT_VIBRATION vibration;
  1694.     vibration.wLeftMotorSpeed  = 0;
  1695.     vibration.wRightMotorSpeed = 0;
  1696.     for( int iUserIndex=0; iUserIndex<DXUT_MAX_CONTROLLERS; iUserIndex++ )
  1697.         s_pXInputSetState( iUserIndex, &vibration );
  1699.     return S_OK;
  1700. }
  1703. //--------------------------------------------------------------------------------------
  1704. // Helper function to launch the Media Center UI after the program terminates
  1705. //--------------------------------------------------------------------------------------
  1706. bool DXUTReLaunchMediaCenter()
  1707. {
  1708.     // Skip if not running on a Media Center
  1709.     if( GetSystemMetrics( 87 ) == 0 ) //  SM_MEDIACENTER == 87, but is only defined if _WIN32_WINNT >= 0x0501
  1710.         return false;
  1711.  
  1712.     // Get the path to Media Center
  1713.     WCHAR szExpandedPath[MAX_PATH];
  1714.     if( !ExpandEnvironmentStrings( L"%SystemRoot%\ehome\ehshell.exe", szExpandedPath, MAX_PATH) )
  1715.         return false;
  1717.     // Skip if ehshell.exe doesn't exist
  1718.     if( GetFileAttributes( szExpandedPath ) == 0xFFFFFFFF )
  1719.         return false;
  1720.  
  1721.     // Launch ehshell.exe 
  1722.     INT_PTR result = (INT_PTR)ShellExecute( NULL, TEXT("open"), szExpandedPath, NULL, NULL, SW_SHOWNORMAL);
  1723.     return (result > 32);
  1724. }