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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 查看源码
d3dutil.cpp
资源名称：Visual_C++GameDevelop.rar　[点击查看]
上传用户：sycq158
上传日期：2008-10-22
资源大小：15361k
文件大小：43k
源码类别：

游戏

开发平台：

Visual C++

d3dutil.cpp：源码内容
  1. //-----------------------------------------------------------------------------
  2. // File: D3DUtil.cpp
  3. //
  4. // Desc: Shortcut macros and functions for using DX objects
  5. //
  6. // Copyright (c) Microsoft Corporation. All rights reserved
  7. //-----------------------------------------------------------------------------
  8. #include "dxstdafx.h"
  9. #ifndef WM_MOUSEWHEEL  
  10. #define WM_MOUSEWHEEL                   0x020A
  11. #endif
  14. //-----------------------------------------------------------------------------
  15. // Name: D3DUtil_GetCubeMapViewMatrix()
  16. // Desc: Returns a view matrix for rendering to a face of a cubemap.
  17. //-----------------------------------------------------------------------------
  18. D3DXMATRIX D3DUtil_GetCubeMapViewMatrix( DWORD dwFace )
  19. {
  20.     D3DXVECTOR3 vEyePt   = D3DXVECTOR3( 0.0f, 0.0f, 0.0f );
  21.     D3DXVECTOR3 vLookDir;
  22.     D3DXVECTOR3 vUpDir;
  24.     switch( dwFace )
  25.     {
  26.         case D3DCUBEMAP_FACE_POSITIVE_X:
  27.             vLookDir = D3DXVECTOR3( 1.0f, 0.0f, 0.0f );
  28.             vUpDir   = D3DXVECTOR3( 0.0f, 1.0f, 0.0f );
  29.             break;
  30.         case D3DCUBEMAP_FACE_NEGATIVE_X:
  31.             vLookDir = D3DXVECTOR3(-1.0f, 0.0f, 0.0f );
  32.             vUpDir   = D3DXVECTOR3( 0.0f, 1.0f, 0.0f );
  33.             break;
  34.         case D3DCUBEMAP_FACE_POSITIVE_Y:
  35.             vLookDir = D3DXVECTOR3( 0.0f, 1.0f, 0.0f );
  36.             vUpDir   = D3DXVECTOR3( 0.0f, 0.0f,-1.0f );
  37.             break;
  38.         case D3DCUBEMAP_FACE_NEGATIVE_Y:
  39.             vLookDir = D3DXVECTOR3( 0.0f,-1.0f, 0.0f );
  40.             vUpDir   = D3DXVECTOR3( 0.0f, 0.0f, 1.0f );
  41.             break;
  42.         case D3DCUBEMAP_FACE_POSITIVE_Z:
  43.             vLookDir = D3DXVECTOR3( 0.0f, 0.0f, 1.0f );
  44.             vUpDir   = D3DXVECTOR3( 0.0f, 1.0f, 0.0f );
  45.             break;
  46.         case D3DCUBEMAP_FACE_NEGATIVE_Z:
  47.             vLookDir = D3DXVECTOR3( 0.0f, 0.0f,-1.0f );
  48.             vUpDir   = D3DXVECTOR3( 0.0f, 1.0f, 0.0f );
  49.             break;
  50.     }
  52.     // Set the view transform for this cubemap surface
  53.     D3DXMATRIXA16 mView;
  54.     D3DXMatrixLookAtLH( &mView, &vEyePt, &vLookDir, &vUpDir );
  55.     return mView;
  56. }
  61. //-----------------------------------------------------------------------------
  62. // Name: D3DUtil_GetRotationFromCursor()
  63. // Desc: Returns a quaternion for the rotation implied by the window's cursor
  64. //       position.
  65. //-----------------------------------------------------------------------------
  66. D3DXQUATERNION D3DUtil_GetRotationFromCursor( HWND hWnd,
  67.                                               FLOAT fTrackBallRadius )
  68. {
  69.     POINT pt;
  70.     RECT  rc;
  71.     GetCursorPos( &pt );
  72.     GetClientRect( hWnd, &rc );
  73.     ScreenToClient( hWnd, &pt );
  74.     FLOAT sx = ( ( ( 2.0f * pt.x ) / (rc.right-rc.left) ) - 1 );
  75.     FLOAT sy = ( ( ( 2.0f * pt.y ) / (rc.bottom-rc.top) ) - 1 );
  76.     FLOAT sz;
  78.     if( sx == 0.0f && sy == 0.0f )
  79.         return D3DXQUATERNION( 0.0f, 0.0f, 0.0f, 1.0f );
  81.     FLOAT d2 = sqrtf( sx*sx + sy*sy );
  83.     if( d2 < fTrackBallRadius * 0.70710678118654752440 ) // Inside sphere
  84.         sz = sqrtf( fTrackBallRadius*fTrackBallRadius - d2*d2 );
  85.     else                                                 // On hyperbola
  86.         sz = (fTrackBallRadius*fTrackBallRadius) / (2.0f*d2);
  88.     // Get two points on trackball's sphere
  89.     D3DXVECTOR3 p1( sx, sy, sz );
  90.     D3DXVECTOR3 p2( 0.0f, 0.0f, fTrackBallRadius );
  92.     // Get axis of rotation, which is cross product of p1 and p2
  93.     D3DXVECTOR3 vAxis;
  94.     D3DXVec3Cross( &vAxis, &p1, &p2);
  96.     // Calculate angle for the rotation about that axis
  97.     D3DXVECTOR3 vecDiff = p2-p1;
  98.     FLOAT t = D3DXVec3Length( &vecDiff ) / ( 2.0f*fTrackBallRadius );
  99.     if( t > +1.0f) t = +1.0f;
  100.     if( t < -1.0f) t = -1.0f;
  101.     FLOAT fAngle = 2.0f * asinf( t );
  103.     // Convert axis to quaternion
  104.     D3DXQUATERNION quat;
  105.     D3DXQuaternionRotationAxis( &quat, &vAxis, fAngle );
  106.     return quat;
  107. }
  112. //-----------------------------------------------------------------------------
  113. // Name: D3DUtil_SetDeviceCursor
  114. // Desc: Gives the D3D device a cursor with image and hotspot from hCursor.
  115. //-----------------------------------------------------------------------------
  116. HRESULT D3DUtil_SetDeviceCursor( LPDIRECT3DDEVICE9 pd3dDevice, HCURSOR hCursor,
  117.                                  BOOL bAddWatermark )
  118. {
  119.     HRESULT hr = E_FAIL;
  120.     ICONINFO iconinfo;
  121.     BOOL bBWCursor;
  122.     LPDIRECT3DSURFACE9 pCursorSurface = NULL;
  123.     HDC hdcColor = NULL;
  124.     HDC hdcMask = NULL;
  125.     HDC hdcScreen = NULL;
  126.     BITMAP bm;
  127.     DWORD dwWidth;
  128.     DWORD dwHeightSrc;
  129.     DWORD dwHeightDest;
  130.     COLORREF crColor;
  131.     COLORREF crMask;
  132.     UINT x;
  133.     UINT y;
  134.     BITMAPINFO bmi;
  135.     COLORREF* pcrArrayColor = NULL;
  136.     COLORREF* pcrArrayMask = NULL;
  137.     DWORD* pBitmap;
  138.     HGDIOBJ hgdiobjOld;
  140.     ZeroMemory( &iconinfo, sizeof(iconinfo) );
  141.     if( !GetIconInfo( hCursor, &iconinfo ) )
  142.         goto End;
  144.     if (0 == GetObject((HGDIOBJ)iconinfo.hbmMask, sizeof(BITMAP), (LPVOID)&bm))
  145.         goto End;
  146.     dwWidth = bm.bmWidth;
  147.     dwHeightSrc = bm.bmHeight;
  149.     if( iconinfo.hbmColor == NULL )
  150.     {
  151.         bBWCursor = TRUE;
  152.         dwHeightDest = dwHeightSrc / 2;
  153.     }
  154.     else 
  155.     {
  156.         bBWCursor = FALSE;
  157.         dwHeightDest = dwHeightSrc;
  158.     }
  160.     // Create a surface for the fullscreen cursor
  161.     if( FAILED( hr = pd3dDevice->CreateOffscreenPlainSurface( dwWidth, dwHeightDest, 
  162.         D3DFMT_A8R8G8B8, D3DPOOL_SCRATCH, &pCursorSurface, NULL ) ) )
  163.     {
  164.         goto End;
  165.     }
  167.     pcrArrayMask = new DWORD[dwWidth * dwHeightSrc];
  169.     ZeroMemory(&bmi, sizeof(bmi));
  170.     bmi.bmiHeader.biSize = sizeof(bmi.bmiHeader);
  171.     bmi.bmiHeader.biWidth = dwWidth;
  172.     bmi.bmiHeader.biHeight = dwHeightSrc;
  173.     bmi.bmiHeader.biPlanes = 1;
  174.     bmi.bmiHeader.biBitCount = 32;
  175.     bmi.bmiHeader.biCompression = BI_RGB;
  177.     hdcScreen = GetDC( NULL );
  178.     hdcMask = CreateCompatibleDC( hdcScreen );
  179.     if( hdcMask == NULL )
  180.     {
  181.         hr = E_FAIL;
  182.         goto End;
  183.     }
  184.     hgdiobjOld = SelectObject(hdcMask, iconinfo.hbmMask);
  185.     GetDIBits(hdcMask, iconinfo.hbmMask, 0, dwHeightSrc, 
  186.         pcrArrayMask, &bmi, DIB_RGB_COLORS);
  187.     SelectObject(hdcMask, hgdiobjOld);
  189.     if (!bBWCursor)
  190.     {
  191.         pcrArrayColor = new DWORD[dwWidth * dwHeightDest];
  192.         hdcColor = CreateCompatibleDC( hdcScreen );
  193.         if( hdcColor == NULL )
  194.         {
  195.             hr = E_FAIL;
  196.             goto End;
  197.         }
  198.         SelectObject(hdcColor, iconinfo.hbmColor);
  199.         GetDIBits(hdcColor, iconinfo.hbmColor, 0, dwHeightDest, 
  200.             pcrArrayColor, &bmi, DIB_RGB_COLORS);
  201.     }
  203.     // Transfer cursor image into the surface
  204.     D3DLOCKED_RECT lr;
  205.     pCursorSurface->LockRect( &lr, NULL, 0 );
  206.     pBitmap = (DWORD*)lr.pBits;
  207.     for( y = 0; y < dwHeightDest; y++ )
  208.     {
  209.         for( x = 0; x < dwWidth; x++ )
  210.         {
  211.             if (bBWCursor)
  212.             {
  213.                 crColor = pcrArrayMask[dwWidth*(dwHeightDest-1-y) + x];
  214.                 crMask = pcrArrayMask[dwWidth*(dwHeightSrc-1-y) + x];
  215.             }
  216.             else
  217.             {
  218.                 crColor = pcrArrayColor[dwWidth*(dwHeightDest-1-y) + x];
  219.                 crMask = pcrArrayMask[dwWidth*(dwHeightDest-1-y) + x];
  220.             }
  221.             if (crMask == 0)
  222.                 pBitmap[dwWidth*y + x] = 0xff000000 | crColor;
  223.             else
  224.                 pBitmap[dwWidth*y + x] = 0x00000000;
  226.             // It may be helpful to make the D3D cursor look slightly 
  227.             // different from the Windows cursor so you can distinguish 
  228.             // between the two when developing/testing code.  When
  229.             // bAddWatermark is TRUE, the following code adds some
  230.             // small grey "D3D" characters to the upper-left corner of
  231.             // the D3D cursor image.
  232.             if( bAddWatermark && x < 12 && y < 5 )
  233.             {
  234.                 // 11.. 11.. 11.. .... CCC0
  235.                 // 1.1. ..1. 1.1. .... A2A0
  236.                 // 1.1. .1.. 1.1. .... A4A0
  237.                 // 1.1. ..1. 1.1. .... A2A0
  238.                 // 11.. 11.. 11.. .... CCC0
  240.                 const WORD wMask[5] = { 0xccc0, 0xa2a0, 0xa4a0, 0xa2a0, 0xccc0 };
  241.                 if( wMask[y] & (1 << (15 - x)) )
  242.                 {
  243.                     pBitmap[dwWidth*y + x] |= 0xff808080;
  244.                 }
  245.             }
  246.         }
  247.     }
  248.     pCursorSurface->UnlockRect();
  250.     // Set the device cursor
  251.     if( FAILED( hr = pd3dDevice->SetCursorProperties( iconinfo.xHotspot, 
  252.         iconinfo.yHotspot, pCursorSurface ) ) )
  253.     {
  254.         goto End;
  255.     }
  257.     hr = S_OK;
  259. End:
  260.     if( iconinfo.hbmMask != NULL )
  261.         DeleteObject( iconinfo.hbmMask );
  262.     if( iconinfo.hbmColor != NULL )
  263.         DeleteObject( iconinfo.hbmColor );
  264.     if( hdcScreen != NULL )
  265.         ReleaseDC( NULL, hdcScreen );
  266.     if( hdcColor != NULL )
  267.         DeleteDC( hdcColor );
  268.     if( hdcMask != NULL )
  269.         DeleteDC( hdcMask );
  270.     SAFE_DELETE_ARRAY( pcrArrayColor );
  271.     SAFE_DELETE_ARRAY( pcrArrayMask );
  272.     SAFE_RELEASE( pCursorSurface );
  273.     return hr;
  274. }
  278. //-----------------------------------------------------------------------------
  279. // Name: D3DFormatToString
  280. // Desc: Returns the string for the given D3DFORMAT.
  281. //-----------------------------------------------------------------------------
  282. LPCTSTR D3DUtil_D3DFormatToString( D3DFORMAT format, bool bWithPrefix )
  283. {
  284.     TCHAR* pstr = NULL;
  285.     switch( format )
  286.     {
  287.     case D3DFMT_UNKNOWN:         pstr = TEXT("D3DFMT_UNKNOWN"); break;
  288.     case D3DFMT_R8G8B8:          pstr = TEXT("D3DFMT_R8G8B8"); break;
  289.     case D3DFMT_A8R8G8B8:        pstr = TEXT("D3DFMT_A8R8G8B8"); break;
  290.     case D3DFMT_X8R8G8B8:        pstr = TEXT("D3DFMT_X8R8G8B8"); break;
  291.     case D3DFMT_R5G6B5:          pstr = TEXT("D3DFMT_R5G6B5"); break;
  292.     case D3DFMT_X1R5G5B5:        pstr = TEXT("D3DFMT_X1R5G5B5"); break;
  293.     case D3DFMT_A1R5G5B5:        pstr = TEXT("D3DFMT_A1R5G5B5"); break;
  294.     case D3DFMT_A4R4G4B4:        pstr = TEXT("D3DFMT_A4R4G4B4"); break;
  295.     case D3DFMT_R3G3B2:          pstr = TEXT("D3DFMT_R3G3B2"); break;
  296.     case D3DFMT_A8:              pstr = TEXT("D3DFMT_A8"); break;
  297.     case D3DFMT_A8R3G3B2:        pstr = TEXT("D3DFMT_A8R3G3B2"); break;
  298.     case D3DFMT_X4R4G4B4:        pstr = TEXT("D3DFMT_X4R4G4B4"); break;
  299.     case D3DFMT_A2B10G10R10:     pstr = TEXT("D3DFMT_A2B10G10R10"); break;
  300.     case D3DFMT_A8B8G8R8:        pstr = TEXT("D3DFMT_A8B8G8R8"); break;
  301.     case D3DFMT_X8B8G8R8:        pstr = TEXT("D3DFMT_X8B8G8R8"); break;
  302.     case D3DFMT_G16R16:          pstr = TEXT("D3DFMT_G16R16"); break;
  303.     case D3DFMT_A2R10G10B10:     pstr = TEXT("D3DFMT_A2R10G10B10"); break;
  304.     case D3DFMT_A16B16G16R16:    pstr = TEXT("D3DFMT_A16B16G16R16"); break;
  305.     case D3DFMT_A8P8:            pstr = TEXT("D3DFMT_A8P8"); break;
  306.     case D3DFMT_P8:              pstr = TEXT("D3DFMT_P8"); break;
  307.     case D3DFMT_L8:              pstr = TEXT("D3DFMT_L8"); break;
  308.     case D3DFMT_A8L8:            pstr = TEXT("D3DFMT_A8L8"); break;
  309.     case D3DFMT_A4L4:            pstr = TEXT("D3DFMT_A4L4"); break;
  310.     case D3DFMT_V8U8:            pstr = TEXT("D3DFMT_V8U8"); break;
  311.     case D3DFMT_L6V5U5:          pstr = TEXT("D3DFMT_L6V5U5"); break;
  312.     case D3DFMT_X8L8V8U8:        pstr = TEXT("D3DFMT_X8L8V8U8"); break;
  313.     case D3DFMT_Q8W8V8U8:        pstr = TEXT("D3DFMT_Q8W8V8U8"); break;
  314.     case D3DFMT_V16U16:          pstr = TEXT("D3DFMT_V16U16"); break;
  315.     case D3DFMT_A2W10V10U10:     pstr = TEXT("D3DFMT_A2W10V10U10"); break;
  316.     case D3DFMT_UYVY:            pstr = TEXT("D3DFMT_UYVY"); break;
  317.     case D3DFMT_YUY2:            pstr = TEXT("D3DFMT_YUY2"); break;
  318.     case D3DFMT_DXT1:            pstr = TEXT("D3DFMT_DXT1"); break;
  319.     case D3DFMT_DXT2:            pstr = TEXT("D3DFMT_DXT2"); break;
  320.     case D3DFMT_DXT3:            pstr = TEXT("D3DFMT_DXT3"); break;
  321.     case D3DFMT_DXT4:            pstr = TEXT("D3DFMT_DXT4"); break;
  322.     case D3DFMT_DXT5:            pstr = TEXT("D3DFMT_DXT5"); break;
  323.     case D3DFMT_D16_LOCKABLE:    pstr = TEXT("D3DFMT_D16_LOCKABLE"); break;
  324.     case D3DFMT_D32:             pstr = TEXT("D3DFMT_D32"); break;
  325.     case D3DFMT_D15S1:           pstr = TEXT("D3DFMT_D15S1"); break;
  326.     case D3DFMT_D24S8:           pstr = TEXT("D3DFMT_D24S8"); break;
  327.     case D3DFMT_D24X8:           pstr = TEXT("D3DFMT_D24X8"); break;
  328.     case D3DFMT_D24X4S4:         pstr = TEXT("D3DFMT_D24X4S4"); break;
  329.     case D3DFMT_D16:             pstr = TEXT("D3DFMT_D16"); break;
  330.     case D3DFMT_L16:             pstr = TEXT("D3DFMT_L16"); break;
  331.     case D3DFMT_VERTEXDATA:      pstr = TEXT("D3DFMT_VERTEXDATA"); break;
  332.     case D3DFMT_INDEX16:         pstr = TEXT("D3DFMT_INDEX16"); break;
  333.     case D3DFMT_INDEX32:         pstr = TEXT("D3DFMT_INDEX32"); break;
  334.     case D3DFMT_Q16W16V16U16:    pstr = TEXT("D3DFMT_Q16W16V16U16"); break;
  335.     case D3DFMT_MULTI2_ARGB8:    pstr = TEXT("D3DFMT_MULTI2_ARGB8"); break;
  336.     case D3DFMT_R16F:            pstr = TEXT("D3DFMT_R16F"); break;
  337.     case D3DFMT_G16R16F:         pstr = TEXT("D3DFMT_G16R16F"); break;
  338.     case D3DFMT_A16B16G16R16F:   pstr = TEXT("D3DFMT_A16B16G16R16F"); break;
  339.     case D3DFMT_R32F:            pstr = TEXT("D3DFMT_R32F"); break;
  340.     case D3DFMT_G32R32F:         pstr = TEXT("D3DFMT_G32R32F"); break;
  341.     case D3DFMT_A32B32G32R32F:   pstr = TEXT("D3DFMT_A32B32G32R32F"); break;
  342.     case D3DFMT_CxV8U8:          pstr = TEXT("D3DFMT_CxV8U8"); break;
  343.     default:                     pstr = TEXT("Unknown format"); break;
  344.     }
  345.     if( bWithPrefix || _tcsstr( pstr, TEXT("D3DFMT_") )== NULL )
  346.         return pstr;
  347.     else
  348.         return pstr + lstrlen( TEXT("D3DFMT_") );
  349. }
  352. //-----------------------------------------------------------------------------
  353. // Name: D3DUtil_QuaternionUnitAxisToUnitAxis2
  354. // Desc: Axis to axis quaternion double angle (no normalization)
  355. //       Takes two points on unit sphere an angle THETA apart, returns
  356. //       quaternion that represents a rotation around cross product by 2*THETA.
  357. //-----------------------------------------------------------------------------
  358. inline D3DXQUATERNION* WINAPI D3DUtil_QuaternionUnitAxisToUnitAxis2( D3DXQUATERNION *pOut, 
  359.                                                                      const D3DXVECTOR3 *pvFrom, 
  360.                                                                      const D3DXVECTOR3 *pvTo )
  361. {
  362.     D3DXVECTOR3 vAxis;
  363.     D3DXVec3Cross(&vAxis, pvFrom, pvTo);    // proportional to sin(theta)
  364.     pOut->x = vAxis.x;
  365.     pOut->y = vAxis.y;
  366.     pOut->z = vAxis.z;
  367.     pOut->w = D3DXVec3Dot( pvFrom, pvTo );
  368.     return pOut;
  369. }
  374. //-----------------------------------------------------------------------------
  375. // Name: D3DUtil_QuaternionAxisToAxis
  376. // Desc: Axis to axis quaternion 
  377. //       Takes two points on unit sphere an angle THETA apart, returns
  378. //       quaternion that represents a rotation around cross product by theta.
  379. //-----------------------------------------------------------------------------
  380. inline D3DXQUATERNION* WINAPI D3DUtil_QuaternionAxisToAxis( D3DXQUATERNION *pOut, 
  381.                                                             const D3DXVECTOR3 *pvFrom, 
  382.                                                             const D3DXVECTOR3 *pvTo)
  383. {
  384.     D3DXVECTOR3 vA, vB;
  385.     D3DXVec3Normalize(&vA, pvFrom);
  386.     D3DXVec3Normalize(&vB, pvTo);
  387.     D3DXVECTOR3 vHalf(vA + vB);
  388.     D3DXVec3Normalize(&vHalf, &vHalf);
  389.     return D3DUtil_QuaternionUnitAxisToUnitAxis2(pOut, &vA, &vHalf);
  390. }
  395. //-----------------------------------------------------------------------------
  396. // Name:
  397. // Desc:
  398. //-----------------------------------------------------------------------------
  399. CD3DArcBall::CD3DArcBall()
  400. {
  401.     Reset();
  402. m_vDownPt = D3DXVECTOR3(0,0,0);
  403. m_vCurrentPt = D3DXVECTOR3(0,0,0);
  405.     RECT rc;
  406.     GetClientRect( GetForegroundWindow(), &rc );
  407.     SetWindow( rc.right, rc.bottom );
  408. }
  414. //-----------------------------------------------------------------------------
  415. // Name:
  416. // Desc:
  417. //-----------------------------------------------------------------------------
  418. void CD3DArcBall::Reset()
  419. {
  420.     D3DXQuaternionIdentity( &m_qDown );
  421.     D3DXQuaternionIdentity( &m_qNow );
  422.     D3DXMatrixIdentity( &m_mRotation );
  423.     D3DXMatrixIdentity( &m_mTranslation );
  424.     D3DXMatrixIdentity( &m_mTranslationDelta );
  425.     m_bDrag = FALSE;
  426.     m_fRadiusTranslation = 1.0f;
  427.     m_fRadius = 1.0f;
  428. }
  433. //-----------------------------------------------------------------------------
  434. // Name:
  435. // Desc:
  436. //-----------------------------------------------------------------------------
  437. D3DXVECTOR3 CD3DArcBall::ScreenToVector( float fScreenPtX, float fScreenPtY )
  438. {
  439.     // Scale to screen
  440.     FLOAT x   = -(fScreenPtX - m_nWidth/2)  / (m_fRadius*m_nWidth/2);
  441.     FLOAT y   =  (fScreenPtY - m_nHeight/2) / (m_fRadius*m_nHeight/2);
  443.     FLOAT z   = 0.0f;
  444.     FLOAT mag = x*x + y*y;
  446.     if( mag > 1.0f )
  447.     {
  448.         FLOAT scale = 1.0f/sqrtf(mag);
  449.         x *= scale;
  450.         y *= scale;
  451.     }
  452.     else
  453.         z = sqrtf( 1.0f - mag );
  455.     // Return vector
  456.     return D3DXVECTOR3( x, y, z );
  457. }
  462. //-----------------------------------------------------------------------------
  463. // Name:
  464. // Desc:
  465. //-----------------------------------------------------------------------------
  466. D3DXQUATERNION CD3DArcBall::QuatFromBallPoints(const D3DXVECTOR3 &vFrom, const D3DXVECTOR3 &vTo)
  467. {
  468. D3DXVECTOR3 vPart;
  469. float fDot = D3DXVec3Dot(&vFrom, &vTo);
  470.     D3DXVec3Cross(&vPart, &vFrom, &vTo);
  472. return D3DXQUATERNION(vPart.x, vPart.y, vPart.z, fDot);
  473. }
  478. //-----------------------------------------------------------------------------
  479. // Name:
  480. // Desc:
  481. //-----------------------------------------------------------------------------
  482. void CD3DArcBall::OnBegin( int nX, int nY )
  483. {
  484. m_bDrag = true;
  485. m_vDownPt = ScreenToVector( (float)nX, (float)nY );
  486. }
  491. //-----------------------------------------------------------------------------
  492. // Name:
  493. // Desc:
  494. //-----------------------------------------------------------------------------
  495. void CD3DArcBall::OnMove( int nX, int nY )
  496. {
  497. if (m_bDrag) 
  498.     { 
  499. m_vCurrentPt = ScreenToVector( (float)nX, (float)nY );
  500.         m_qNow = m_qDown * QuatFromBallPoints( m_vDownPt, m_vCurrentPt );
  501.     }
  502. }
  507. //-----------------------------------------------------------------------------
  508. // Name:
  509. // Desc:
  510. //-----------------------------------------------------------------------------
  511. void CD3DArcBall::OnEnd()
  512. {
  513. m_bDrag = false;
  514. m_qDown = m_qNow;
  515. }
  520. //-----------------------------------------------------------------------------
  521. // Name: HandleMessages
  522. // Desc:
  523. //-----------------------------------------------------------------------------
  524. LRESULT CD3DArcBall::HandleMessages( HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam )
  525. {
  526.     UNREFERENCED_PARAMETER( hWnd );
  528.     // Current mouse position
  529.     int iMouseX = GET_X_LPARAM(lParam);
  530.     int iMouseY = GET_Y_LPARAM(lParam);
  532.     switch( uMsg )
  533.     {
  534.         case WM_LBUTTONDOWN:
  535.             OnBegin( iMouseX, iMouseY );
  536.             return TRUE;
  538.         case WM_LBUTTONUP:
  539.             OnEnd();
  540.             return TRUE;
  542.         case WM_RBUTTONDOWN:
  543.         case WM_MBUTTONDOWN:
  544.             // Store off the position of the cursor when the button is pressed
  545.             m_ptLastMouse.x = iMouseX;
  546.             m_ptLastMouse.y = iMouseY;
  547.             return TRUE;
  549.         case WM_MOUSEMOVE:
  550.             if( MK_LBUTTON&wParam )
  551.             {
  552.                 OnMove( iMouseX, iMouseY );
  553.             }
  554.             else if( (MK_RBUTTON&wParam) || (MK_MBUTTON&wParam) )
  555.             {
  556.                 // Normalize based on size of window and bounding sphere radius
  557.                 FLOAT fDeltaX = ( m_ptLastMouse.x-iMouseX ) * m_fRadiusTranslation / m_nWidth;
  558.                 FLOAT fDeltaY = ( m_ptLastMouse.y-iMouseY ) * m_fRadiusTranslation / m_nHeight;
  560.                 if( wParam & MK_RBUTTON )
  561.                 {
  562.                     D3DXMatrixTranslation( &m_mTranslationDelta, -2*fDeltaX, 2*fDeltaY, 0.0f );
  563.                     D3DXMatrixMultiply( &m_mTranslation, &m_mTranslation, &m_mTranslationDelta );
  564.                 }
  565.                 else  // wParam & MK_MBUTTON
  566.                 {
  567.                     D3DXMatrixTranslation( &m_mTranslationDelta, 0.0f, 0.0f, 5*fDeltaY );
  568.                     D3DXMatrixMultiply( &m_mTranslation, &m_mTranslation, &m_mTranslationDelta );
  569.                 }
  571.                 // Store mouse coordinate
  572.                 m_ptLastMouse.x = iMouseX;
  573.                 m_ptLastMouse.y = iMouseY;
  574.             }
  575.             return TRUE;
  576.     }
  578.     return FALSE;
  579. }
  584. //-----------------------------------------------------------------------------
  585. // Name: CBaseCamera
  586. // Desc: Constructor
  587. //-----------------------------------------------------------------------------
  588. CBaseCamera::CBaseCamera()
  589. {
  590.     ZeroMemory( m_aKeys, sizeof(BYTE)*CAM_MAX_KEYS );
  592.     // Set attributes for the view matrix
  593.     D3DXVECTOR3 vEyePt    = D3DXVECTOR3(0.0f,0.0f,0.0f);
  594.     D3DXVECTOR3 vLookatPt = D3DXVECTOR3(0.0f,0.0f,1.0f);
  596.     // Setup the view matrix
  597.     SetViewParams( &vEyePt, &vLookatPt );
  599.     // Setup the projection matrix
  600.     SetProjParams( D3DX_PI/4, 1.0f, 1.0f, 1000.0f );
  602.     GetCursorPos( &m_ptLastMousePosition );
  603.     m_bMouseLButtonDown = false;
  604.     m_bMouseMButtonDown = false;
  605.     m_bMouseRButtonDown = false;
  606.     m_nCurrentButtonMask = 0;
  607.     m_nMouseWheelDelta = 0;
  609.     m_fCameraYawAngle = 0.0f;
  610.     m_fCameraPitchAngle = 0.0f;
  612.     m_vVelocity     = D3DXVECTOR3(0,0,0);
  613.     m_bMovementDrag = false;
  614.     m_vVelocityDrag = D3DXVECTOR3(0,0,0);
  615.     m_fDragTimer    = 0.0f;
  616.     m_fTotalDragTimeToZero = 0.25;
  617.     m_vRotVelocity = D3DXVECTOR2(0,0);
  619.     m_fRotationScaler = 0.01f;           
  620.     m_fMoveScaler = 5.0f;           
  622.     m_bInvertPitch = false;
  623.     m_bEnableYAxisMovement = true;
  624.     m_bEnablePositionMovement = true;
  626.     m_vMouseDelta   = D3DXVECTOR2(0,0);
  627.     m_fFramesToSmoothMouseData = 2.0f;
  629.     m_bClipToBoundary = false;
  630.     m_vMinBoundary = D3DXVECTOR3(-1,-1,-1);
  631.     m_vMaxBoundary = D3DXVECTOR3(1,1,1);
  633.     m_bResetCursorAfterMove = false;
  634. }
  637. //-----------------------------------------------------------------------------
  638. // Name: SetViewParams
  639. // Desc: Client can call this to change the position and direction of camrea
  640. //-----------------------------------------------------------------------------
  641. VOID CBaseCamera::SetViewParams( D3DXVECTOR3* pvEyePt, D3DXVECTOR3* pvLookatPt )
  642. {
  643.     if( NULL == pvEyePt || NULL == pvLookatPt )
  644.         return;
  646.     m_vDefaultEye = m_vEye = *pvEyePt;
  647.     m_vDefaultLookAt = m_vLookAt = *pvLookatPt;
  649.     // Calc the view matrix
  650.     D3DXVECTOR3 vUp(0,1,0);
  651.     D3DXMatrixLookAtLH( &m_mView, pvEyePt, pvLookatPt, &vUp );
  653.     D3DXMATRIX mInvView;
  654.     D3DXMatrixInverse( &mInvView, NULL, &m_mView );
  656.     // The axis basis vectors and camera position are stored inside the 
  657.     // position matrix in the 4 rows of the camera's world matrix.
  658.     // To figuire out the yaw/pitch of the camera, we just need the Z basis vector
  659.     D3DXVECTOR3* pZBasis = (D3DXVECTOR3*) &mInvView._31;
  661.     m_fCameraYawAngle   = atan2f( pZBasis->x, pZBasis->z );
  662.     float fLen = sqrtf(pZBasis->z*pZBasis->z + pZBasis->x*pZBasis->x);
  663.     m_fCameraPitchAngle = -atan2f( pZBasis->y, fLen );
  664. }
  669. //-----------------------------------------------------------------------------
  670. // Name: SetProjParams
  671. // Desc: Calculates the projection matrix based on input params
  672. //-----------------------------------------------------------------------------
  673. VOID CBaseCamera::SetProjParams( FLOAT fFOV, FLOAT fAspect, FLOAT fNearPlane,
  674.                                    FLOAT fFarPlane )
  675. {
  676.     // Set attributes for the projection matrix
  677.     m_fFOV        = fFOV;
  678.     m_fAspect     = fAspect;
  679.     m_fNearPlane  = fNearPlane;
  680.     m_fFarPlane   = fFarPlane;
  682.     D3DXMatrixPerspectiveFovLH( &m_mProj, fFOV, fAspect, fNearPlane, fFarPlane );
  683. }
  688. //-----------------------------------------------------------------------------
  689. // Name: HandleMessages
  690. // Desc: Call this from your message proc so this class can handle window messages
  691. //-----------------------------------------------------------------------------
  692. LRESULT CBaseCamera::HandleMessages( HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam )
  693. {
  694.     UNREFERENCED_PARAMETER( hWnd );
  695.     UNREFERENCED_PARAMETER( lParam );
  697.     switch( uMsg )
  698.     {
  699.         case WM_KEYDOWN:
  700.         {
  701.             // Map this key to a D3DUtil_CameraKeys enum and update the
  702.             // state of m_aKeys[] by adding the KEY_WAS_DOWN_MASK|KEY_IS_DOWN_MASK mask
  703.             // only if the key is not down
  704.             D3DUtil_CameraKeys mappedKey = MapKey( (UINT)wParam );
  705.             if( mappedKey != CAM_UNKNOWN )
  706.             {
  707.                 if( FALSE == IsKeyDown(m_aKeys[mappedKey]) )
  708.                     m_aKeys[ mappedKey ] = KEY_WAS_DOWN_MASK | KEY_IS_DOWN_MASK;
  709.             }
  710.             break;
  711.         }
  713.         case WM_KEYUP:
  714.         {
  715.             // Map this key to a D3DUtil_CameraKeys enum and update the
  716.             // state of m_aKeys[] by removing the KEY_IS_DOWN_MASK mask.
  717.             D3DUtil_CameraKeys mappedKey = MapKey( (UINT)wParam );
  718.             if( mappedKey != CAM_UNKNOWN )
  719.                 m_aKeys[ mappedKey ] &= ~KEY_IS_DOWN_MASK;
  720.             break;
  721.         }
  723.         case WM_RBUTTONDOWN: 
  724.         case WM_MBUTTONDOWN: 
  725.         case WM_LBUTTONDOWN: 
  726.         {
  727.             // Update member var state
  728.             if( uMsg == WM_LBUTTONDOWN ) { m_bMouseLButtonDown = true; m_nCurrentButtonMask |= MOUSE_LEFT_BUTTON; }
  729.             if( uMsg == WM_MBUTTONDOWN ) { m_bMouseMButtonDown = true; m_nCurrentButtonMask |= MOUSE_MIDDLE_BUTTON; }
  730.             if( uMsg == WM_RBUTTONDOWN ) { m_bMouseRButtonDown = true; m_nCurrentButtonMask |= MOUSE_RIGHT_BUTTON; }
  732.             // Capture the mouse, so if the mouse button is 
  733.             // released outside the window, we'll get the WM_LBUTTONUP message
  734.             SetCapture(hWnd);
  735.             GetCursorPos( &m_ptLastMousePosition ); 
  736.             return TRUE;
  737.         }
  739.         case WM_RBUTTONUP: 
  740.         case WM_MBUTTONUP: 
  741.         case WM_LBUTTONUP:   
  742.         {
  743.             // Update member var state
  744.             if( uMsg == WM_LBUTTONUP ) { m_bMouseLButtonDown = false; m_nCurrentButtonMask &= ~MOUSE_LEFT_BUTTON; }
  745.             if( uMsg == WM_MBUTTONUP ) { m_bMouseMButtonDown = false; m_nCurrentButtonMask &= ~MOUSE_MIDDLE_BUTTON; }
  746.             if( uMsg == WM_RBUTTONUP ) { m_bMouseRButtonDown = false; m_nCurrentButtonMask &= ~MOUSE_RIGHT_BUTTON; }
  748.             // Release the capture if no mouse buttons down
  749.             if( !m_bMouseLButtonDown  && 
  750.                 !m_bMouseRButtonDown &&
  751.                 !m_bMouseMButtonDown )
  752.             {
  753.                 ReleaseCapture();
  754.             }
  755.             break;
  756.         }
  758.         case WM_MOUSEWHEEL:
  759.             // Update member var state
  760.             m_nMouseWheelDelta = (short)HIWORD(wParam) / 120;
  761.             break;
  762.     }
  764.     return FALSE;
  765. }
  770. //-----------------------------------------------------------------------------
  771. // Name: UpdateMouseDelta
  772. // Desc: Figure out the mouse delta based on mouse movement
  773. //-----------------------------------------------------------------------------
  774. void CBaseCamera::UpdateMouseDelta( float fElapsedTime )
  775. {
  776.     UNREFERENCED_PARAMETER( fElapsedTime );
  778.     POINT ptCurMouseDelta;
  779.     POINT ptCurMousePos;
  780.     
  781.     // Get current position of mouse
  782.     GetCursorPos( &ptCurMousePos );
  784.     // Calc how far it's moved since last frame
  785.     ptCurMouseDelta.x = ptCurMousePos.x - m_ptLastMousePosition.x;
  786.     ptCurMouseDelta.y = ptCurMousePos.y - m_ptLastMousePosition.y;
  788.     // Record current position for next time
  789.     m_ptLastMousePosition = ptCurMousePos;
  791.     if( m_bResetCursorAfterMove )
  792.     {
  793.         // Set position of camera to center of desktop, 
  794.         // so it always has room to move.  This is very useful
  795.         // if the cursor is hidden.  If this isn't done and cursor is hidden, 
  796.         // then invisible cursor will hit the edge of the screen 
  797.         // and the user can't tell what happened
  798.         POINT ptCenter;
  799.         RECT rcDesktop;
  800.         GetWindowRect( GetDesktopWindow(), &rcDesktop );
  801.         ptCenter.x = (rcDesktop.right - rcDesktop.left) / 2;
  802.         ptCenter.y = (rcDesktop.bottom - rcDesktop.top) / 2;   
  803.         SetCursorPos( ptCenter.x, ptCenter.y );
  804.         m_ptLastMousePosition = ptCenter;
  805.     }
  807.     // Smooth the relative mouse data over a few frames so it isn't 
  808.     // jerky when moving slowly at low frame rates.
  809.     float fPercentOfNew =  1.0f / m_fFramesToSmoothMouseData;
  810.     float fPercentOfOld =  1.0f - fPercentOfNew;
  811.     m_vMouseDelta.x = m_vMouseDelta.x*fPercentOfOld + ptCurMouseDelta.x*fPercentOfNew;
  812.     m_vMouseDelta.y = m_vMouseDelta.y*fPercentOfOld + ptCurMouseDelta.y*fPercentOfNew;
  814.     m_vRotVelocity = m_vMouseDelta * m_fRotationScaler;
  815. }
  820. //-----------------------------------------------------------------------------
  821. // Name: UpdateVelocity
  822. // Desc: Figure out the velocity based on keyboard input & drag if any
  823. //-----------------------------------------------------------------------------
  824. void CBaseCamera::UpdateVelocity( float fElapsedTime )
  825. {
  826.     D3DXMATRIX mRotDelta;
  827.     D3DXVECTOR3 vAccel = D3DXVECTOR3(0,0,0);
  829.     if( m_bEnablePositionMovement )
  830.     {
  831.         // Update acceleration vector based on keyboard state
  832.         if( IsKeyDown(m_aKeys[CAM_MOVE_FORWARD]) )
  833.             vAccel.z += 1.0f;
  834.         if( IsKeyDown(m_aKeys[CAM_MOVE_BACKWARD]) )
  835.             vAccel.z -= 1.0f;
  836.         if( m_bEnableYAxisMovement )
  837.         {
  838.             if( IsKeyDown(m_aKeys[CAM_MOVE_UP]) )
  839.                 vAccel.y += 1.0f;
  840.             if( IsKeyDown(m_aKeys[CAM_MOVE_DOWN]) )
  841.                 vAccel.y -= 1.0f;
  842.         }
  843.         if( IsKeyDown(m_aKeys[CAM_STRAFE_RIGHT]) )
  844.             vAccel.x += 1.0f;
  845.         if( IsKeyDown(m_aKeys[CAM_STRAFE_LEFT]) )
  846.             vAccel.x -= 1.0f;
  847.     }
  849.     // Normalize vector so if moving 2 dirs (left & forward), 
  850.     // the camera doesn't move faster than if moving in 1 dir
  851.     D3DXVec3Normalize( &vAccel, &vAccel );
  853.     // Scale the acceleration vector
  854.     vAccel *= m_fMoveScaler;
  856.     if( m_bMovementDrag )
  857.     {
  858.         // Is there any acceleration this frame?
  859.         if( D3DXVec3LengthSq( &vAccel ) > 0 )
  860.         {
  861.             // If so, then this means the user has pressed a movement key
  862.             // so change the velocity immediately to acceleration 
  863.             // upon keyboard input.  This isn't normal physics
  864.             // but it will give a quick response to keyboard input
  865.             m_vVelocity = vAccel;
  866.             m_fDragTimer = m_fTotalDragTimeToZero;
  867.             m_vVelocityDrag = vAccel / m_fDragTimer;
  868.         }
  869.         else 
  870.         {
  871.             // If no key being pressed, then slowly decrease velocity to 0
  872.             if( m_fDragTimer > 0 )
  873.             {
  874.                 // Drag until timer is <= 0
  875.                 m_vVelocity -= m_vVelocityDrag * fElapsedTime;
  876.                 m_fDragTimer -= fElapsedTime;
  877.             }
  878.             else
  879.             {
  880.                 // Zero velocity
  881.                 m_vVelocity = D3DXVECTOR3(0,0,0);
  882.             }
  883.         }
  884.     }
  885.     else
  886.     {
  887.         // No drag, so immediatly change the velocity
  888.         m_vVelocity = vAccel;
  889.     }
  890. }
  895. //-----------------------------------------------------------------------------
  896. // Name: ConstrainToBoundary
  897. // Desc: Clamps pV to lie inside m_vMinBoundary & m_vMaxBoundary
  898. //-----------------------------------------------------------------------------
  899. void CBaseCamera::ConstrainToBoundary( D3DXVECTOR3* pV )
  900. {
  901.     // Constrain vector to a bounding box 
  902.     pV->x = max(pV->x, m_vMinBoundary.x);
  903.     pV->y = max(pV->y, m_vMinBoundary.y);
  904.     pV->z = max(pV->z, m_vMinBoundary.z);
  906.     pV->x = min(pV->x, m_vMaxBoundary.x);
  907.     pV->y = min(pV->y, m_vMaxBoundary.y);
  908.     pV->z = min(pV->z, m_vMaxBoundary.z);
  909. }
  914. //-----------------------------------------------------------------------------
  915. // Name: MapKey
  916. // Desc: Maps a windows virtual key to an enum
  917. //-----------------------------------------------------------------------------
  918. D3DUtil_CameraKeys CBaseCamera::MapKey( UINT nKey )
  919. {
  920.     // This could be upgraded to a method that's user-definable but for 
  921.     // simplisity, we'll use a hardcoded mapping.
  922.     switch( nKey )
  923.     {
  924.         case VK_LEFT:  return CAM_STRAFE_LEFT;
  925.         case VK_RIGHT: return CAM_STRAFE_RIGHT;
  926.         case VK_UP:    return CAM_MOVE_FORWARD;
  927.         case VK_DOWN:  return CAM_MOVE_BACKWARD;
  928.         case VK_PRIOR: return CAM_MOVE_UP;        // pgup
  929.         case VK_NEXT:  return CAM_MOVE_DOWN;      // pgdn
  931.         case 'A':      return CAM_STRAFE_LEFT;
  932.         case 'D':      return CAM_STRAFE_RIGHT;
  933.         case 'W':      return CAM_MOVE_FORWARD;
  934.         case 'S':      return CAM_MOVE_BACKWARD;
  935.         case 'Q':      return CAM_MOVE_DOWN;
  936.         case 'E':      return CAM_MOVE_UP;
  938.         case VK_NUMPAD4: return CAM_STRAFE_LEFT;
  939.         case VK_NUMPAD6: return CAM_STRAFE_RIGHT;
  940.         case VK_NUMPAD8: return CAM_MOVE_FORWARD;
  941.         case VK_NUMPAD2: return CAM_MOVE_BACKWARD;
  942.         case VK_NUMPAD9: return CAM_MOVE_UP;        
  943.         case VK_NUMPAD3: return CAM_MOVE_DOWN;      
  945.         case VK_HOME:   return CAM_RESET;
  946.     }
  948.     return CAM_UNKNOWN;
  949. }
  954. //-----------------------------------------------------------------------------
  955. // Name: Reset
  956. // Desc: Reset the camera's position back to the default
  957. //-----------------------------------------------------------------------------
  958. VOID CBaseCamera::Reset()
  959. {
  960.     SetViewParams( &m_vDefaultEye, &m_vDefaultLookAt );
  961. }
  966. //-----------------------------------------------------------------------------
  967. // Name: CFirstPersonCamera
  968. // Desc: Constructor
  969. //-----------------------------------------------------------------------------
  970. CFirstPersonCamera::CFirstPersonCamera()
  971. {
  972. }
  977. //-----------------------------------------------------------------------------
  978. // Name: FrameMove
  979. // Desc: Update the view matrix based on user input & elapsed time
  980. //-----------------------------------------------------------------------------
  981. VOID CFirstPersonCamera::FrameMove( FLOAT fElapsedTime )
  982. {
  983.     if( IsKeyDown(m_aKeys[CAM_RESET]) )
  984.         Reset();
  986.     // Get the mouse movement (if any) if the mouse button are down
  987.     if( m_bMouseLButtonDown || m_bMouseMButtonDown || m_bMouseRButtonDown ) 
  988.         UpdateMouseDelta( fElapsedTime );
  990.     // Get amount of velocity based on the keyboard input and drag (if any)
  991.     UpdateVelocity( fElapsedTime );
  993.     // Simple euler method to calculate position delta
  994.     D3DXVECTOR3 vPosDelta = m_vVelocity * fElapsedTime;
  996.     // If rotating the camera 
  997.     if( m_bMouseLButtonDown ||  m_bMouseMButtonDown || m_bMouseRButtonDown )
  998.     {
  999.         // Update the pitch & yaw angle based on mouse movement
  1000.         float fYawDelta   = m_vRotVelocity.x;
  1001.         float fPitchDelta = m_vRotVelocity.y;
  1003.         // Invert pitch if requested
  1004.         if( m_bInvertPitch )
  1005.             fPitchDelta = -fPitchDelta;
  1007.         m_fCameraPitchAngle += fPitchDelta;
  1008.         m_fCameraYawAngle   += fYawDelta;
  1010.         // Limit pitch to straight up or straight down
  1011.         m_fCameraPitchAngle = max( -D3DX_PI/2.0f,  m_fCameraPitchAngle );
  1012.         m_fCameraPitchAngle = min( +D3DX_PI/2.0f,  m_fCameraPitchAngle );
  1013.     }
  1015.     // Make a rotation matrix based on the camera's yaw & pitch
  1016.     D3DXMATRIX mCameraRot;
  1017.     D3DXMatrixRotationYawPitchRoll( &mCameraRot, m_fCameraYawAngle, m_fCameraPitchAngle, 0 );
  1019.     // Transform vectors based on camera's rotation matrix
  1020.     D3DXVECTOR3 vWorldUp, vWorldAhead;
  1021.     D3DXVECTOR3 vLocalUp    = D3DXVECTOR3(0,1,0);
  1022.     D3DXVECTOR3 vLocalAhead = D3DXVECTOR3(0,0,1);
  1023.     D3DXVec3TransformCoord( &vWorldUp, &vLocalUp, &mCameraRot );
  1024.     D3DXVec3TransformCoord( &vWorldAhead, &vLocalAhead, &mCameraRot );
  1026.     // Transform the position delta by the camera's rotation 
  1027.     D3DXVECTOR3 vPosDeltaWorld;
  1028.     D3DXVec3TransformCoord( &vPosDeltaWorld, &vPosDelta, &mCameraRot );
  1029.     if( !m_bEnableYAxisMovement )
  1030.         vPosDeltaWorld.y = 0.0f;
  1032.     // Move the eye position 
  1033.     m_vEye += vPosDeltaWorld;
  1034.     if( m_bClipToBoundary )
  1035.         ConstrainToBoundary( &m_vEye );
  1037.     // Update the lookAt position based on the eye position 
  1038.     m_vLookAt = m_vEye + vWorldAhead;
  1040.     // Update the view matrix
  1041.     D3DXMatrixLookAtLH( &m_mView, &m_vEye, &m_vLookAt, &vWorldUp );
  1043.     D3DXMatrixInverse( &m_mCameraWorld, NULL, &m_mView );
  1044. }
  1049. //-----------------------------------------------------------------------------
  1050. // Name: CModelViewerCamera
  1051. // Desc: Constructor 
  1052. //-----------------------------------------------------------------------------
  1053. CModelViewerCamera::CModelViewerCamera()
  1054. {
  1055.     D3DXMatrixIdentity( &m_mWorld );
  1056.     D3DXMatrixIdentity( &m_mModelRot );
  1057.     D3DXMatrixIdentity( &m_mModelLastRot );    
  1058.     m_vModelCenter = D3DXVECTOR3(0,0,0);
  1059.     m_fRadius    = 5.0f;
  1060.     m_fDefaultRadius = 5.0f;
  1061.     m_fMinRadius = 1.0f;
  1062.     m_fMaxRadius = FLT_MAX;
  1063.     m_bLimitPitch = false;
  1064.     m_bEnablePositionMovement = false;
  1066.     m_nRotateModelButtonMask  = MOUSE_LEFT_BUTTON;
  1067.     m_nZoomButtonMask         = MOUSE_WHEEL;
  1068.     m_nRotateCameraButtonMask = MOUSE_RIGHT_BUTTON;
  1069. }
  1074. //-----------------------------------------------------------------------------
  1075. // Name: FrameMove
  1076. // Desc: Update the view matrix & the model's world matrix based 
  1077. //       on user input & elapsed time
  1078. //-----------------------------------------------------------------------------
  1079. VOID CModelViewerCamera::FrameMove( FLOAT fElapsedTime )
  1080. {
  1081.     if( IsKeyDown(m_aKeys[CAM_RESET]) )
  1082.         Reset();
  1084.     // Get the mouse movement (if any) if the mouse button are down
  1085.     if( m_nCurrentButtonMask != 0 ) 
  1086.         UpdateMouseDelta( fElapsedTime );
  1088.     // Get amount of velocity based on the keyboard input and drag (if any)
  1089.     UpdateVelocity( fElapsedTime );
  1091.     // Simple euler method to calculate position delta
  1092.     D3DXVECTOR3 vPosDelta = m_vVelocity * fElapsedTime;
  1094.     // Change the radius from the camera to the model based on wheel scrolling
  1095.     if( m_nMouseWheelDelta && m_nZoomButtonMask == MOUSE_WHEEL )
  1096.         m_fRadius -= m_nMouseWheelDelta * m_fRadius * 0.1f;
  1097.     m_fRadius = min( m_fMaxRadius, m_fRadius );
  1098.     m_fRadius = max( m_fMinRadius, m_fRadius );
  1099.     m_nMouseWheelDelta = 0;
  1101.     // Get the inverse of the arcball's rotation matrix
  1102.     D3DXMATRIX mCameraRot;
  1103.     D3DXMatrixInverse( &mCameraRot, NULL, m_ViewArcBall.GetRotationMatrix() );
  1105.     // Transform vectors based on camera's rotation matrix
  1106.     D3DXVECTOR3 vWorldUp, vWorldAhead;
  1107.     D3DXVECTOR3 vLocalUp    = D3DXVECTOR3(0,1,0);
  1108.     D3DXVECTOR3 vLocalAhead = D3DXVECTOR3(0,0,1);
  1109.     D3DXVec3TransformCoord( &vWorldUp, &vLocalUp, &mCameraRot );
  1110.     D3DXVec3TransformCoord( &vWorldAhead, &vLocalAhead, &mCameraRot );
  1112.     // Transform the position delta by the camera's rotation 
  1113.     D3DXVECTOR3 vPosDeltaWorld;
  1114.     D3DXVec3TransformCoord( &vPosDeltaWorld, &vPosDelta, &mCameraRot );
  1116.     // Move the lookAt position 
  1117.     m_vLookAt += vPosDeltaWorld;
  1118.     if( m_bClipToBoundary )
  1119.         ConstrainToBoundary( &m_vLookAt );
  1121.     // Update the eye point based on a radius away from the lookAt position
  1122.     m_vEye = m_vLookAt - vWorldAhead * m_fRadius;
  1124.     // Update the view matrix
  1125.     D3DXMatrixLookAtLH( &m_mView, &m_vEye, &m_vLookAt, &vWorldUp );
  1127.     D3DXMATRIX mInvView;
  1128.     D3DXMatrixInverse( &mInvView, NULL, &m_mView );
  1129.     mInvView._41 = mInvView._42 = mInvView._43 = 0;
  1131.     D3DXMATRIX mModelLastRotInv;
  1132.     D3DXMatrixInverse(&mModelLastRotInv, NULL, &m_mModelLastRot);
  1134.     // Accumulate the delta of the arcball's rotation in view space.
  1135.     // Note that per-frame delta rotations could be problematic over long periods of time.
  1136.     D3DXMATRIX mModelRot;
  1137.     mModelRot = *m_WorldArcBall.GetRotationMatrix();
  1138.     m_mModelRot *= m_mView * mModelLastRotInv * mModelRot * mInvView;
  1139.     m_mModelLastRot = mModelRot;
  1141.     // Since we're accumulating delta rotations, we need to orthonormalize 
  1142.     // the matrix to prevent eventual matrix skew
  1143.     D3DXVECTOR3* pXBasis = (D3DXVECTOR3*) &m_mWorld._11;
  1144.     D3DXVECTOR3* pYBasis = (D3DXVECTOR3*) &m_mWorld._21;
  1145.     D3DXVECTOR3* pZBasis = (D3DXVECTOR3*) &m_mWorld._31;
  1146.     D3DXVec3Normalize( pXBasis, pXBasis );
  1147.     D3DXVec3Cross( pYBasis, pZBasis, pXBasis );
  1148.     D3DXVec3Normalize( pYBasis, pYBasis );
  1149.     D3DXVec3Cross( pZBasis, pXBasis, pYBasis );
  1151.     // Translate the rotation matrix to the same position as the lookAt position
  1152.     m_mModelRot._41 = m_vLookAt.x;
  1153.     m_mModelRot._42 = m_vLookAt.y;
  1154.     m_mModelRot._43 = m_vLookAt.z;
  1156.     // Translate world matrix so its at the center of the model
  1157.     D3DXMATRIX mTrans;
  1158.     D3DXMatrixTranslation( &mTrans, -m_vModelCenter.x, -m_vModelCenter.y, -m_vModelCenter.z );
  1159.     m_mWorld = mTrans * m_mModelRot;
  1160. }
  1165. //-----------------------------------------------------------------------------
  1166. // Name: Reset
  1167. // Desc: Reset the camera's position back to the default
  1168. //-----------------------------------------------------------------------------
  1169. VOID CModelViewerCamera::Reset()
  1170. {
  1171.     CBaseCamera::Reset();
  1173.     D3DXMatrixIdentity( &m_mWorld );
  1174.     m_fRadius = m_fDefaultRadius;
  1175.     m_WorldArcBall.Reset();
  1176.     m_ViewArcBall.Reset();
  1177. }
  1181. //-----------------------------------------------------------------------------
  1182. // Name: HandleMessages
  1183. // Desc: Call this from your message proc so this class can handle window messages
  1184. //-----------------------------------------------------------------------------
  1185. LRESULT CModelViewerCamera::HandleMessages( HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam )
  1186. {
  1187.     CBaseCamera::HandleMessages( hWnd, uMsg, wParam, lParam );
  1189.     if( (uMsg == WM_LBUTTONDOWN && m_nRotateModelButtonMask == MOUSE_LEFT_BUTTON) ||
  1190.         (uMsg == WM_MBUTTONDOWN && m_nRotateModelButtonMask == MOUSE_MIDDLE_BUTTON) ||
  1191.         (uMsg == WM_RBUTTONDOWN && m_nRotateModelButtonMask == MOUSE_RIGHT_BUTTON) )
  1192.     {
  1193.         int iMouseX = GET_X_LPARAM(lParam);
  1194.         int iMouseY = GET_Y_LPARAM(lParam);
  1195.         m_WorldArcBall.OnBegin( iMouseX, iMouseY );            
  1196.     }
  1198.     if( (uMsg == WM_LBUTTONDOWN && m_nRotateCameraButtonMask == MOUSE_LEFT_BUTTON) ||
  1199.         (uMsg == WM_MBUTTONDOWN && m_nRotateCameraButtonMask == MOUSE_MIDDLE_BUTTON) ||
  1200.         (uMsg == WM_RBUTTONDOWN && m_nRotateCameraButtonMask == MOUSE_RIGHT_BUTTON) )
  1201.     {
  1202.         int iMouseX = GET_X_LPARAM(lParam);
  1203.         int iMouseY = GET_Y_LPARAM(lParam);
  1204.         m_ViewArcBall.OnBegin( iMouseX, iMouseY );            
  1205.     }
  1207.     if( uMsg == WM_MOUSEMOVE )
  1208.     {
  1209.         int iMouseX = GET_X_LPARAM(lParam);
  1210.         int iMouseY = GET_Y_LPARAM(lParam);
  1211.         m_WorldArcBall.OnMove( iMouseX, iMouseY );
  1212.         m_ViewArcBall.OnMove( iMouseX, iMouseY );
  1213.     }
  1215.     if( (uMsg == WM_LBUTTONUP && m_nRotateModelButtonMask == MOUSE_LEFT_BUTTON) ||
  1216.         (uMsg == WM_MBUTTONUP && m_nRotateModelButtonMask == MOUSE_MIDDLE_BUTTON) ||
  1217.         (uMsg == WM_RBUTTONUP && m_nRotateModelButtonMask == MOUSE_RIGHT_BUTTON) )
  1218.     {
  1219.         m_WorldArcBall.OnEnd();
  1220.     }
  1222.     if( (uMsg == WM_LBUTTONUP && m_nRotateCameraButtonMask == MOUSE_LEFT_BUTTON) ||
  1223.         (uMsg == WM_MBUTTONUP && m_nRotateCameraButtonMask == MOUSE_MIDDLE_BUTTON) ||
  1224.         (uMsg == WM_RBUTTONUP && m_nRotateCameraButtonMask == MOUSE_RIGHT_BUTTON) )
  1225.     {
  1226.         m_ViewArcBall.OnEnd();
  1227.     }
  1229.     return FALSE;
  1230. }