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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 图形图像 > 3D图形编程 > 查看源码
3DWindow.cpp
资源名称：estereo2.zip　[点击查看]
上传用户：fengshi120
上传日期：2014-07-17
资源大小：6155k
文件大小：30k
源码类别：

3D图形编程

开发平台：

C/C++

3DWindow.cpp：源码内容
  1. ////////////////////////////////////////////////////////////////////////////////////////////////
  2. // Copyright: Frey Research 
  3. // Unit Name: 3DWindow.cpp 
  4. // Author:     Gary Gray
  5. // Description: custom control for displaying 3-D shapes
  6. /////////////////////////////////////////////////////////////////////////////////////////////////
  8. // 3DWindowSmall.cpp : implementation file
  9. //
  11. #include "stdafx.h"
  13. #include "StereoPlus.h"
  14. #include "StereoPlusDlg.h"
  16. #include <mmSystem.h>
  17. #include "DxUtil.h"
  18. #include <d3d9types.h>
  22. #include "3DWindow.h"
  23. #include ".3DWindow.h"
  27. #ifdef _DEBUG
  28. #define new DEBUG_NEW
  29. #undef THIS_FILE
  30. static char THIS_FILE[] = __FILE__;
  31. #endif
  32.  
  33. extern CStereoPlusDlg* pMainDialog;
  35. #define DELETENULL(object) if (object) {delete object;object = NULL;}
  36. #define  RELEASENULL(object) if (object) {object->Release();object = NULL;}
  38. //////////////////////////////////////////////////////////////////////////////
  39. // Globals ///////////////////////////////////////////////////////////////////
  40. //////////////////////////////////////////////////////////////////////////////
  44. struct POINT_VERTEX
  45. {
  46.     D3DXVECTOR3 p;
  47.     D3DCOLOR color;
  48. // static const DWORD FVF;
  49. };
  50. const DWORD POINT_VERTEX_FVF = D3DFVF_XYZ | D3DFVF_DIFFUSE ;
  53. struct MESH_VERTEX_TEX
  54. {
  55.     D3DXVECTOR3 p;
  56.     D3DXVECTOR3 n;
  57. FLOAT tu,tv;
  58. // static const DWORD FVF;
  59. };
  60. const DWORD MESH_VERTEX_TEX_FVF = D3DFVF_XYZ | D3DFVF_NORMAL | D3DFVF_TEX1 | D3DFVF_TEXCOORDSIZE2(0);
  63. BOOL C3DWindow::m_Registered = FALSE;
  64. BOOL C3DWindow::m_bInhibitUpdate = FALSE;
  65. /*lint -save*/
  66. /*lint -e620 ignore Suspicious constant (L or one?) these are all from Microsoft !*/
  67. /*lint -e834 ignore comments on confusing operators there not to me !*/
  69. /////////////////////////////////////////////////////////////////////////////
  70. // C3DWindow
  72. C3DWindow::C3DWindow() : CWnd()
  73. {
  75. m_bOrthographic = false;
  76. m_pD3D = NULL;
  77. m_pD3DDevice = NULL;
  78. m_GUITimerID = NULL;
  79. m_fScale = 1.0F;
  81. m_bRenderZAxis = false;
  84. for(int k=0;k<3;k++)
  85. m_pAxesVB[k] = NULL;
  87. //initialise some memory to please PC-Lint
  88. ZeroMemory(&m_light,sizeof(D3DLIGHT9));
  89. ZeroMemory(&m_D3DsdBackBuffer,sizeof(D3DSURFACE_DESC));
  91. m_strRegistry = "3D Orientation";
  93. UINT uNBytes;
  94. CD3DArcBall* pArcBallProfile = NULL;
  95. theApp.GetProfileBinary("3D Window",m_strRegistry,(LPBYTE*)&pArcBallProfile,&uNBytes);
  97. if(uNBytes == sizeof(CD3DArcBall) && pArcBallProfile)
  98. m_ArcBall = *pArcBallProfile;
  100. DELETENULL(pArcBallProfile);
  102. m_pFont = new CD3DFont( _T("Arial"), 10,NULL);// D3DFONT_BOLD );
  103. m_pFontLarge = new CD3DFont( _T("Arial"), 16,NULL);// D3DFONT_BOLD );
  105. m_pTextureAxisLabelX = NULL;
  106. m_pTextureAxisLabelY = NULL;
  107. m_pTextureAxisLabelZ = NULL;
  109. m_pPixelVB  = NULL;
  110. m_nPoints = 0;
  113. for(int iCone = 0;iCone<3;iCone++)
  114. m_pConeMesh[iCone] = NULL;
  116. }
  118. void C3DWindow::SetRegistryKey(CString strRegistry)
  119. {
  120. m_strRegistry = strRegistry;
  122. UINT uNBytes;
  123. CD3DArcBall* pArcBallProfile = NULL;
  125. theApp.GetProfileBinary("3D Window",m_strRegistry,(LPBYTE*)&pArcBallProfile,&uNBytes);
  127. if(uNBytes == sizeof(CD3DArcBall) && pArcBallProfile)
  128. m_ArcBall = *pArcBallProfile;
  130. DELETENULL(pArcBallProfile);
  131. }
  136. C3DWindow::~C3DWindow()
  137. {
  138. try
  139. {
  140.     SAFE_DELETE( m_pFont );
  141.     SAFE_DELETE( m_pFontLarge );
  143. ASSERT(m_pD3D == NULL);
  144. ASSERT(m_pD3DDevice == NULL);
  146. }
  147. catch (...) {};
  149. }
  152. void C3DWindow::OnNcDestroy() 
  153. {
  154. CWnd::OnNcDestroy();
  155. delete this;
  156. }
  159. BEGIN_MESSAGE_MAP(C3DWindow, CWnd)
  160. //{{AFX_MSG_MAP(C3DWindow)
  161. ON_WM_CREATE()
  162. ON_WM_DESTROY()
  163. ON_WM_NCDESTROY()
  164. ON_WM_RBUTTONUP()
  165. ON_WM_INITMENUPOPUP()
  166. //}}AFX_MSG_MAP
  167. ON_WM_PAINT()
  168. ON_WM_CHAR()
  169. ON_WM_TIMER()
  170. ON_WM_MOUSEMOVE()
  171. ON_WM_LBUTTONDOWN()
  172. ON_WM_LBUTTONUP()
  173. ON_WM_LBUTTONDBLCLK()
  174. END_MESSAGE_MAP()
  176. void C3DWindow::InterpretError(HRESULT hr) const
  177. {
  179. CString strError;
  180. strError = DXGetErrorString9 (hr);
  181. #ifdef _DEBUG
  182. AfxMessageBox(strError,MB_OK);
  183. #endif
  185. }
  187. /////////////////////////////////////////////////////////////////////////////
  188. // C3DWindow message handlers
  190. void C3DWindow::OnRButtonUp(UINT nFlags, CPoint point) 
  191. {
  192. long ControlID = GetWindowLong(m_hWnd,GWL_ID);
  193. CWnd* pParent = GetParent();
  194. LRESULT lResult = pParent->SendMessage(WM_COMMAND,MAKEWPARAM(ControlID,WM_RBUTTONUP),(LPARAM)(HWND)m_hWnd);
  196. if(!lResult)
  197. CWnd::OnRButtonUp(nFlags, point);
  199. }
  201. void C3DWindow::ShowMenu(UINT idrMenu)
  202. { 
  203. CMenu Pum, *pPum;
  204. Pum.LoadMenu(idrMenu);
  205. pPum = Pum.GetSubMenu(0);
  206. CPoint pt;
  207. GetCursorPos(&pt);
  209. pPum->TrackPopupMenu(TPM_CENTERALIGN | TPM_LEFTBUTTON, pt.x, pt.y-18, this);
  210. }
  212. BOOL C3DWindow::OnCommand(WPARAM wParam, LPARAM lParam) 
  213. {
  214. if(lParam == 0)
  215. {
  216. }
  217. return CWnd::OnCommand(wParam, lParam);
  218. }
  220. void C3DWindow::OnInitMenuPopup(CMenu* pPopupMenu, UINT /*nIndex*/, BOOL /*bSysMenu*/)
  221. { 
  222. }
  224. HRESULT C3DWindow::ReleaseD3DX()
  225. {
  227. RELEASENULL(m_pD3DDevice);
  228. RELEASENULL(m_pD3D);
  229. return S_OK;
  230. }
  233. HRESULT C3DWindow::InitD3DX(void)
  234. {
  235. CWaitCursor WaitCursor;
  237.     if ((m_pD3D = Direct3DCreate9(D3D_SDK_VERSION)) == 0)
  238. {
  239. AfxMessageBox(_T("DirectX 9.0c not installed.nPlease install this or later version."));
  240. exit(0);
  241. }
  242. else
  243. {
  244. // Get the current desktop display mode
  245. D3DDISPLAYMODE d3ddm;
  246. if(SUCCEEDED(m_pD3D->GetAdapterDisplayMode(D3DADAPTER_DEFAULT, &d3ddm)))
  247. {
  248. HRESULT hr;
  250. if( FAILED( hr = m_pD3D->CheckDeviceFormat( D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, 
  251. d3ddm.Format, D3DUSAGE_DEPTHSTENCIL,
  252. D3DRTYPE_SURFACE, 
  253. D3DFMT_D16 
  254. ) ) )
  255. {
  256. if( hr == D3DERR_NOTAVAILABLE )
  257. AfxMessageBox("POTENTIAL PROBLEM: We need at least a 16-bit z-buffer!",MB_ICONSTOP);
  258. exit(0);
  259. }
  260. //
  261. // Do we support hardware vertex processing? if so, use it. 
  262. // If not, downgrade to software.
  263. //
  265. D3DCAPS9 d3dCaps;
  267. if( FAILED( m_pD3D->GetDeviceCaps( D3DADAPTER_DEFAULT, 
  268. D3DDEVTYPE_HAL, &d3dCaps ) ) )
  269. {
  270. AfxMessageBox("failure of GetDeviceCaps!",MB_ICONSTOP);
  271. exit(0);
  272. }
  274. DWORD dwBehaviorFlags = 0;
  276. if( d3dCaps.VertexProcessingCaps != 0 )
  277. dwBehaviorFlags |= D3DCREATE_HARDWARE_VERTEXPROCESSING;
  278. else
  279. dwBehaviorFlags |= D3DCREATE_SOFTWARE_VERTEXPROCESSING;
  281. //
  282. // Everything checks out - create a simple, windowed device.
  283. //
  285. ZeroMemory(&m_d3dpp, sizeof(m_d3dpp));
  286. m_d3dpp.BackBufferFormat       = d3ddm.Format;
  287. m_d3dpp.SwapEffect             = D3DSWAPEFFECT_DISCARD;
  288. m_d3dpp.Windowed               = TRUE;
  289. m_d3dpp.EnableAutoDepthStencil = TRUE;
  290. m_d3dpp.AutoDepthStencilFormat = D3DFMT_D16;
  291. m_d3dpp.PresentationInterval   = D3DPRESENT_INTERVAL_IMMEDIATE;
  293. CRect rcWindowClient;
  294. GetClientRect(&rcWindowClient);
  295. m_d3dpp.BackBufferWidth  = (UINT)rcWindowClient.Width();
  296. m_d3dpp.BackBufferHeight = (UINT)rcWindowClient.Height();
  298. hr = m_pD3D->CreateDevice(
  299. D3DADAPTER_DEFAULT,
  300. D3DDEVTYPE_HAL,
  301. m_hWnd,
  302. D3DCREATE_HARDWARE_VERTEXPROCESSING | D3DCREATE_FPU_PRESERVE,
  303. &m_d3dpp, 
  304. &m_pD3DDevice);
  307. // Store render target surface desc
  308. LPDIRECT3DSURFACE9 pBackBuffer;
  309. m_pD3DDevice->GetBackBuffer(0, 0, D3DBACKBUFFER_TYPE_MONO, &pBackBuffer );
  310. pBackBuffer->GetDesc( &m_D3DsdBackBuffer );
  311. pBackBuffer->Release();
  313. InitDeviceObjects();
  315. RestoreDeviceObjects();
  317. }
  318. }
  319. return S_OK;
  321. }
  326. HRESULT C3DWindow::RestoreDeviceObjects(void)
  327. {
  328. ASSERT(m_pD3DDevice);
  329.     // Setup render state
  331. D3DMATERIAL9 mtrl;
  332. D3DUtil_InitMaterial( mtrl, 1.0f, 1.0f, 1.0f );
  333. m_pD3DDevice->SetMaterial( &mtrl );
  336. m_pD3DDevice->SetRenderState( D3DRS_WRAP0,     TRUE );
  337.    
  338.     // Set miscellaneous render states
  339.     m_pD3DDevice->SetRenderState( D3DRS_DITHERENABLE,   FALSE );
  340.     m_pD3DDevice->SetRenderState( D3DRS_SPECULARENABLE, FALSE );
  341.     m_pD3DDevice->SetRenderState( D3DRS_ZENABLE,      TRUE );
  342.     // Turn on lighting.
  343. // m_pD3DDevice->SetRenderState( D3DRS_LIGHTING, TRUE );
  345.     // Enable ambient lighting to a dim, grey light, so objects that
  346.     // are not lit by the other lights are not completely black
  347.     m_pD3DDevice->SetRenderState( D3DRS_AMBIENT,D3DCOLOR_COLORVALUE( 0.5, 0.5, 0.5, 1.0 ) );
  350. FLOAT      fAspect = (FLOAT)m_D3DsdBackBuffer.Width / (FLOAT)m_D3DsdBackBuffer.Height;
  351. if(m_bOrthographic)
  352. {
  354.  D3DXMatrixOrthoOffCenterLH (&m_matProj, -10.0f*fAspect, 10.0f*fAspect, -10.0f,10.0f,-100.0f, 100.0f);
  356. }
  357. else
  358. {
  359. // Setup the projection matrix
  360. FLOAT      fAspect = (FLOAT)m_D3DsdBackBuffer.Width / (FLOAT)m_D3DsdBackBuffer.Height;
  361. D3DXMatrixPerspectiveFovLH( &m_matProj, D3DX_PI/4, fAspect,m_fObjectRadius/64.0f, m_fObjectRadius*200.0f ); 
  362. }
  364. m_pD3DDevice->SetTransform( D3DTS_PROJECTION, &m_matProj );
  365.     D3DXMatrixTranspose( &m_matProjT, &m_matProj );
  369. HRESULT hr;
  370.     DWORD dwNumVertices = 2;
  371. for(int k=0;k<3;k++)
  372. {
  373. SAFE_RELEASE(m_pAxesVB[k]);
  375. if(SUCCEEDED(hr = m_pD3DDevice->CreateVertexBuffer( dwNumVertices*sizeof(POINT_VERTEX),
  376. D3DUSAGE_DYNAMIC | D3DUSAGE_WRITEONLY , 
  377. POINT_VERTEX_FVF, D3DPOOL_DEFAULT, &m_pAxesVB[k], NULL )))
  378. {
  379. POINT_VERTEX* pVertices;
  381. if(SUCCEEDED(m_pAxesVB[k]->Lock( 0, 0, (void**)&pVertices, 0 )) )
  382. {
  383. for(DWORD i=0;i<dwNumVertices;i++)
  384. {
  385. pVertices[i].color = D3DCOLOR_ARGB(255,0,255,0);
  386. }
  387. if(k == 0)
  388. {
  389. pVertices[0].p = D3DXVECTOR3(-10.0f,0.0f,0.0f);
  390. pVertices[1].p = D3DXVECTOR3( 10.0f,0.0f,0.0f);
  391. }
  392. else if(k==1)
  393. {//assume 4:3 
  394. pVertices[0].p = D3DXVECTOR3(0.0f,-7.5f,0.0f);
  395. pVertices[1].p = D3DXVECTOR3(0.0f, 7.5f,0.0f);
  396. }
  397. else if(k==2)
  398. {
  399. pVertices[0].p = D3DXVECTOR3(0.0f,0.0f,-10.0f);
  400. pVertices[1].p = D3DXVECTOR3(0.0f,0.0f, 10.0f);
  401. }
  403. m_pAxesVB[k]->Unlock();
  404. }
  406. }
  407. else
  408. {
  409. return E_FAIL;
  410. }
  411. }
  413. if(m_pFont)
  414. {
  415.     m_pFont->InvalidateDeviceObjects();
  416.     m_pFont->RestoreDeviceObjects();
  417. }
  418. if(m_pFontLarge)
  419. {
  420.     m_pFontLarge->InvalidateDeviceObjects();
  421.     m_pFontLarge->RestoreDeviceObjects();
  422. }
  425.     return S_OK;
  426. }
  428. void C3DWindow::SetUpdateTimer(bool bState)
  429. {
  430. if(bState && m_GUITimerID == NULL)
  431. {
  432. m_GUITimerID = SetTimer(GUI_UPDATE_TIMER,33,NULL);
  433. }
  434. else if(!bState && m_GUITimerID != NULL)
  435. {
  436. KillTimer(m_GUITimerID);
  437. m_GUITimerID = NULL;
  438. }
  439. }
  441. int C3DWindow::OnCreate(LPCREATESTRUCT lpCreateStruct) 
  442. {
  444. if (CWnd::OnCreate(lpCreateStruct) == -1)
  445. return -1;
  447. return 0;
  448. }
  450. int C3DWindow::Start(bool bOrthographic) 
  451. {
  453. m_bOrthographic = bOrthographic;
  454.     HRESULT hr = InitD3DX();
  455.     if ( FAILED(hr) )
  456.     {
  457.         InterpretError(hr);
  458. return -1;
  459.     }
  462. m_GUITimerID = SetTimer(GUI_UPDATE_TIMER,33,NULL);
  463. return hr;
  464. }
  466. BOOL C3DWindow::Register()
  467. {
  468. if(m_Registered) return TRUE;
  469. WNDCLASS wc;
  470. wc.style = CS_GLOBALCLASS | CS_HREDRAW | CS_VREDRAW | CS_DBLCLKS;
  471. wc.lpfnWndProc = C3DWindow::Window3DWndProc;
  472. wc.cbClsExtra = 0;
  473. wc.cbWndExtra = 0;
  474. wc.hInstance = NULL;
  475. wc.hIcon = NULL;
  476. wc.hCursor = ::LoadCursor(NULL, IDC_ARROW);
  477. wc.hbrBackground = (HBRUSH)(COLOR_WINDOW+1);
  478. wc.lpszMenuName = 0;
  479. wc.lpszClassName = "3DWindow";
  480. if(!::RegisterClass(&wc))
  481. {
  482. ASSERT(0);
  483. return FALSE;
  484. }
  485. m_Registered = TRUE;
  486. return TRUE;
  487. }
  490. LRESULT CALLBACK C3DWindow::Window3DWndProc(HWND hWnd, UINT uiMsg, WPARAM wParam, LPARAM lParam)
  491. {
  492. if(uiMsg == WM_NCCREATE)
  493. {
  494. C3DWindow *pCtrl = new C3DWindow;
  495. ASSERT(pCtrl);
  496. BOOL b = pCtrl->SubclassWindow(hWnd);
  497. ASSERT(b);
  498. return b;
  499. }
  500. return ::DefWindowProc(hWnd, uiMsg, wParam, lParam);
  501. }
  504. void C3DWindow::OnDestroy() 
  505. {
  506. if(m_GUITimerID)
  507. {
  508. KillTimer(m_GUITimerID);
  509. m_GUITimerID = NULL;
  510. }
  513. DeleteDeviceObjects();
  514. ReleaseD3DX();
  517.   theApp.WriteProfileBinary("3D Window",m_strRegistry,(LPBYTE)&m_ArcBall,sizeof(CD3DArcBall));
  519. CWnd::OnDestroy();
  520. }
  524. //-----------------------------------------------------------------------------
  525. // Name: Render3DEnvironment()
  526. // Desc: Draws the scene.
  527. //-----------------------------------------------------------------------------
  528. HRESULT C3DWindow::Render3DEnvironment(void)
  529. {
  530. if(C3DWindow::m_bInhibitUpdate)
  531. return S_OK;
  534. ASSERT(m_pD3DDevice);
  537.     HRESULT hr;
  539.     // Test the cooperative level to see if it's okay to render
  540.     if( FAILED( hr = m_pD3DDevice->TestCooperativeLevel() ) )
  541.     {
  542.         if (D3DERR_DEVICELOST == hr)
  543. {
  544. //The device has been lost but cannot be reset at this time. Therefore, rendering is not possible.
  545.             return S_OK;
  546. }
  547. else if (D3DERR_DEVICENOTRESET == hr)
  548. {
  549. //The device has been lost but can be reset at this time.
  550. //Normally, you would call Reset(), but we will cheat here for simplicity's sake.
  551. DeleteDeviceObjects();
  552. ReleaseD3DX();
  555. if (FAILED(InitD3DX()))
  556. {
  557. DeleteDeviceObjects();
  558. ReleaseD3DX();
  559. return S_OK;
  560. }
  561. RestoreDeviceObjects();
  563. }
  564.     }
  566.      // Frame move the scene
  567.     D3DXMatrixTranslation( &m_matWorld,-m_vObjectCenter.x,
  568.                                        -m_vObjectCenter.y,
  569.                                        -m_vObjectCenter.z );
  572.     D3DXMatrixMultiply( &m_matWorld, &m_matWorld, m_ArcBall.GetRotationMatrix() );
  573.     D3DXMatrixMultiply( &m_matWorld, &m_matWorld, m_ArcBall.GetTranslationMatrix() );
  574.     m_pD3DDevice->SetTransform( D3DTS_WORLD, &m_matWorld );
  577.     D3DXMATRIX matView;
  579. D3DXVECTOR3 vecEye( 0.0f, 0.0f, -2.0f*m_fObjectRadius ); 
  580. D3DXVECTOR3 vecAt( 0.0f, 0.0f, 0.0f );
  581. D3DXVECTOR3 vecUp( 0.0f, 1.0f, 0.0f ); 
  584.     D3DXMatrixLookAtLH( &matView, &vecEye,&vecAt,&vecUp );
  585.     m_pD3DDevice->SetTransform( D3DTS_VIEW,  &matView );
  588.     // Render the scene as normal
  589.     if( FAILED( hr = Render() ) )
  590.         return hr;
  593.     // Show the frame on the primary surface.
  594.     m_pD3DDevice->Present( NULL, NULL, NULL, NULL );
  596.     return S_OK;
  597. }
  600. HRESULT C3DWindow::Render(void)
  601. {
  602. HRESULT hr = S_OK;;
  604. if(!m_pD3DDevice || !m_hWnd)
  605. return E_FAIL;
  608. //clear the back buffer
  609. D3DXCOLOR colorClear = D3DXCOLOR(0.4f, 0.5f, 0.8f, 1.0f);
  610. m_pD3DDevice->Clear( 0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER,colorClear, 1.0f, 0L );
  611. CString strError;
  614. D3DXVECTOR3 pos(0.0f,0.0f,0.0f);
  615. hr = m_pD3DDevice->BeginScene();
  617. if( SUCCEEDED( hr ) )
  618. {
  620. D3DXMATRIX matView;
  621. D3DXMATRIX matIdentity; 
  622.     m_pD3DDevice->SetRenderState( D3DRS_FILLMODE, D3DFILL_SOLID );
  623. m_pD3DDevice->SetRenderState( D3DRS_LIGHTING, TRUE );
  624.     m_pD3DDevice->SetRenderState( D3DRS_SPECULARENABLE, FALSE );
  625. m_pD3DDevice->SetRenderState( D3DRS_FILLMODE, D3DFILL_WIREFRAME );
  626. m_pD3DDevice->SetRenderState( D3DRS_LIGHTING, FALSE );
  628. for(int iAxes=0;iAxes<3;iAxes++) 
  629. {
  630. if(iAxes != 2 || m_bRenderZAxis ) 
  631. {
  632. m_pD3DDevice->SetStreamSource(0,m_pAxesVB[iAxes],0,sizeof(POINT_VERTEX));
  633.   m_pD3DDevice->SetFVF( POINT_VERTEX_FVF );
  634. m_pD3DDevice->DrawPrimitive(D3DPT_LINELIST,0,1);
  635. }
  636. }
  638. bool bDrawAxesEnds  = false;
  639. if(m_pPixelVB)
  640. bDrawAxesEnds = true;
  642. if(bDrawAxesEnds)
  643. {
  644. m_pD3DDevice->SetRenderState(D3DRS_WRAP0, D3DWRAPCOORD_0);
  646. for(int iCone=0;iCone<3;iCone++) 
  647. {
  649. if(iCone != 2 || m_bRenderZAxis ) 
  650. {
  651. m_pD3DDevice->SetRenderState( D3DRS_FILLMODE, D3DFILL_SOLID );
  652. m_pD3DDevice->SetRenderState( D3DRS_LIGHTING, TRUE );
  653. m_pD3DDevice->SetRenderState( D3DRS_SPECULARENABLE, TRUE );
  654. m_pD3DDevice->SetVertexShader(NULL);
  656. if(m_pConeMesh[iCone])
  657. {
  658.   m_pD3DDevice->SetFVF( MESH_VERTEX_TEX_FVF );
  660. if(iCone == 0 && m_pTextureAxisLabelX)
  661. m_pD3DDevice->SetTexture(0,m_pTextureAxisLabelX);
  662. if(iCone == 1 && m_pTextureAxisLabelY)
  663. m_pD3DDevice->SetTexture(0,m_pTextureAxisLabelY);
  664. if(iCone == 2 && m_pTextureAxisLabelZ)
  665. m_pD3DDevice->SetTexture(0,m_pTextureAxisLabelZ);
  669. m_pD3DDevice->SetTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE );
  670. m_pD3DDevice->SetTextureStageState( 0, D3DTSS_COLORARG2, D3DTA_DIFFUSE );
  672. m_pD3DDevice->SetTextureStageState( 0, D3DTSS_COLOROP,   D3DTOP_MODULATE );
  673. m_pD3DDevice->SetTextureStageState( 0, D3DTSS_ALPHAOP,   D3DTOP_DISABLE );
  676. hr = m_pConeMesh[iCone]->DrawSubset(0);
  678. }
  679. }
  680. }
  682. m_pD3DDevice->SetTexture(0,NULL);
  683. m_pD3DDevice->SetTransform( D3DTS_WORLD, &m_matWorld );
  684. }
  690.   if(m_pPixelVB)
  691. {
  692.     m_pD3DDevice->SetFVF( POINT_VERTEX_FVF );
  693. int np = m_nPoints;
  694. m_pD3DDevice->SetStreamSource(0,m_pPixelVB,0,sizeof(POINT_VERTEX));
  696. if(m_bUsePoints)
  697. {
  698. m_pD3DDevice->SetRenderState( D3DRS_FILLMODE, D3DFILL_WIREFRAME );
  699. m_pD3DDevice->SetRenderState( D3DRS_LIGHTING, FALSE );
  700. m_pD3DDevice->DrawPrimitive(D3DPT_POINTLIST,0,np);
  701. }
  702. else
  703. {
  704. m_pD3DDevice->SetRenderState( D3DRS_FILLMODE, D3DFILL_SOLID ); 
  705.   m_pD3DDevice->SetRenderState( D3DRS_LIGHTING, FALSE );
  706. m_pD3DDevice->SetRenderState(D3DRS_COLORVERTEX,TRUE);
  707. m_pD3DDevice->SetRenderState( D3DRS_SPECULARENABLE, FALSE );
  708. m_pD3DDevice->SetRenderState( D3DRS_DIFFUSEMATERIALSOURCE,  D3DMCS_COLOR1 );
  709. m_pD3DDevice->SetVertexShader(NULL);
  710. m_pD3DDevice->DrawPrimitive(D3DPT_TRIANGLELIST,0,np*4);
  711. }
  713. }
  717. RenderText();
  719. m_pD3DDevice->EndScene();
  720. }
  721. else
  722. {
  723. strError = DXGetErrorString9 (hr);
  724. }
  726.  
  727. return hr;
  728. }
  730. HRESULT C3DWindow::DeleteDeviceObjects(void)
  731. {
  732. for(int k=0;k<3;k++)
  733. {
  734. SAFE_RELEASE(m_pAxesVB[k]);
  735. }
  738. for(int iCone=0;iCone<3;iCone++)
  739. SAFE_RELEASE(m_pConeMesh[iCone]);
  742. SAFE_RELEASE(m_pTextureAxisLabelX);
  743. SAFE_RELEASE(m_pTextureAxisLabelY);
  744. SAFE_RELEASE(m_pTextureAxisLabelZ);
  747. SAFE_RELEASE(m_pPixelVB);
  748. m_nPoints = 0;
  750. if(m_pFont)
  751. m_pFont->DeleteDeviceObjects();
  752. if(m_pFontLarge)
  753. m_pFontLarge->DeleteDeviceObjects();
  755. return S_OK;
  756. }
  761. void C3DWindow::OnPaint()
  762. {
  763. CPaintDC dc(this); // device context for painting
  765. if (m_pD3DDevice)
  766. Render3DEnvironment();
  767. }
  771. BOOL C3DWindow::PreTranslateMessage(MSG* pMsg)
  772. {
  773. // Pass mouse messages to the ArcBall so it can build internal matrices
  774. m_ArcBall.HandleMouseMessages( m_hWnd, pMsg->message,pMsg->wParam,pMsg->lParam );
  776. if(pMsg->message == WM_KEYUP || pMsg->message == WM_KEYDOWN)
  777. {
  778. }
  780. return CWnd::PreTranslateMessage(pMsg);
  781. }
  784. HRESULT C3DWindow::InitDeviceObjects(void)
  785. {
  786. HRESULT hr = S_OK;
  788. ASSERT(m_pD3DDevice);
  791.     // Init the font
  792.     hr = m_pFont->InitDeviceObjects( m_pD3DDevice );
  793.     if( FAILED( hr ) )
  794.         return DXTRACE_ERR( "m_pFont->InitDeviceObjects", hr );
  795.     // Init the other font
  796.     hr = m_pFontLarge->InitDeviceObjects( m_pD3DDevice );
  797.     if( FAILED( hr ) )
  798.         return DXTRACE_ERR( "m_pFontLarge->InitDeviceObjects", hr );
  800. m_vObjectCenter = D3DXVECTOR3(0.0f,0.0f,0.0f);
  803. // Setup the arcball parameters
  805. m_fObjectRadius = 10.0f;
  806. CRect rcClient; 
  807. GetClientRect(&rcClient);
  808.     m_ArcBall.SetWindow( rcClient.Width(), rcClient.Height(), 0.85f );
  809. m_ArcBall.SetRadius( m_fObjectRadius );
  813. m_light.Diffuse.r  = 0.3f;
  814. m_light.Diffuse.g  = 0.3f;
  815. m_light.Diffuse.b  = 0.3f;
  816. m_light.Ambient.r  = 0.1f;
  817. m_light.Ambient.g  = 0.1f;
  818. m_light.Ambient.b  = 0.1f;
  819. m_light.Specular.r = 0.0f;
  820.    m_light.Specular.g = 0.0f;
  821.   m_light.Specular.b = 0.0f; 
  822.     
  823. m_light.Type = D3DLIGHT_POINT;//D3DLIGHT_SPOT;
  824. m_light.Falloff = 1.0f; 
  825. m_light.Direction.x = 0.0f;
  826. m_light.Direction.y = 0.0f;
  827. m_light.Direction.z =  1.0f;
  828. m_light.Attenuation0 = 1.0f; 
  829. m_light.Attenuation1 = 0.0f; 
  830. m_light.Attenuation2 = 0.0f; 
  831.    m_light.Range        = 1000.0f; 
  832. m_light.Position.x   = 0.0f;
  833.   m_light.Position.y   = 0.0f;
  834.   m_light.Position.z   = -18.0f; //the light is behind us 
  835. m_light.Theta  = 0.0f;//these next two control the cone angles of the light
  836.   m_light.Phi  = 0.6f;  
  837. m_pD3DDevice->SetLight( 0, &m_light );
  838.     m_pD3DDevice->LightEnable( 0, TRUE );  
  841. // m_pD3DDevice->SetRenderState(D3DRS_SPECULARMATERIALSOURCE, D3DMCS_MATERIAL);
  842. // m_pD3DDevice->SetRenderState(D3DRS_DIFFUSEMATERIALSOURCE, D3DMCS_MATERIAL);
  843. // m_pD3DDevice->SetRenderState( D3DRS_SPECULARENABLE, TRUE);
  845.    return S_OK;
  846. }
  852. void C3DWindow::OnTimer(UINT nIDEvent)
  853. {
  854. if(m_pD3DDevice && !pMainDialog->m_bClosing)
  855. Render3DEnvironment();
  857. CWnd::OnTimer(nIDEvent);
  858. }
  865. HRESULT C3DWindow::RenderText(void)
  866. {
  867.     D3DCOLOR fontColor        = D3DCOLOR_ARGB(255,255,255,0);
  868.     TCHAR szMsg[MAX_PATH] = TEXT("");
  870.     // Output display stats
  871.     FLOAT fNextLineL = 5.0f; 
  872.     FLOAT fNextLineR = 5.0f; 
  875. if(m_strTopRightTextLine1 != "")
  876. {
  877. lstrcpy( szMsg,m_strTopRightTextLine1 );
  879. FLOAT fTextX = (FLOAT)(m_D3DsdBackBuffer.Width - 150);  
  880. m_pFont->DrawText( fTextX, fNextLineR, fontColor, szMsg );
  881. }
  883. if(m_strTopLeftTextLine1 != "")
  884. {
  885. lstrcpy( szMsg,m_strTopLeftTextLine1 );
  887. FLOAT fTextX = (FLOAT)(5);  
  888. m_pFont->DrawText( fTextX, fNextLineL, fontColor, szMsg );
  889. }
  891. if(m_strBottomLeftTextLine1 != "")
  892. {
  893. lstrcpy( szMsg,m_strBottomLeftTextLine1 );
  895.   FLOAT fTextX = (FLOAT)(5);  
  897.   m_pFontLarge->DrawText( fTextX, (float)(m_d3dpp.BackBufferHeight - 30), fontColor, szMsg );
  898. }
  900.    return S_OK;
  901. }
  908. void C3DWindow::SetLightOutput(float fDiffuse,float fAmbient)
  909. {
  910. m_light.Diffuse.r  = fDiffuse;
  911. m_light.Diffuse.g  = fDiffuse;
  912. m_light.Diffuse.b  = fDiffuse;
  913. m_light.Ambient.r  = fAmbient;
  914. m_light.Ambient.g  = fAmbient;
  915. m_light.Ambient.b  = fAmbient;
  916. m_light.Specular.r = 0.0f;
  917.    m_light.Specular.g = 0.0f;
  918.   m_light.Specular.b = 0.0f; 
  919.     
  920. m_light.Type = D3DLIGHT_POINT;//D3DLIGHT_SPOT;
  921. m_light.Falloff = 1.0f; 
  922. m_light.Direction.x = 0.0f;
  923. m_light.Direction.y = 0.0f;
  924. m_light.Direction.z =  1.0f;
  925. m_light.Attenuation0 = 1.0f; 
  926. m_light.Attenuation1 = 0.0f; 
  927. m_light.Attenuation2 = 0.0f; 
  928.    m_light.Range        = 1000.0f; 
  929. m_light.Position.x   = 0.0f;
  930.   m_light.Position.y   = 0.0f;
  931.   m_light.Position.z   = -18.0f; //the light is behind us 
  932. m_light.Theta  = 0.0f;//these next two control the cone angles of the light
  933.   m_light.Phi  = 0.6f;  
  934. m_pD3DDevice->SetLight( 0, &m_light );
  935.     m_pD3DDevice->LightEnable( 0, TRUE );  
  936. }
  939. HRESULT C3DWindow::MakeConeMeshes(float fConeShiftX,float fConeShiftY, float fConeShiftZ)
  940. {
  941. for(int iCone=0;iCone<3;iCone++)
  942. SAFE_RELEASE(m_pConeMesh[iCone]);
  944. HRESULT hr;
  946. hr = D3DXCreateTextureFromResource(m_pD3DDevice,NULL,MAKEINTRESOURCE(IDB_BITMAP_XAXIS), &m_pTextureAxisLabelX);
  947. hr = D3DXCreateTextureFromResource(m_pD3DDevice,NULL,MAKEINTRESOURCE(IDB_BITMAP_YAXIS), &m_pTextureAxisLabelY);
  948. hr = D3DXCreateTextureFromResource(m_pD3DDevice,NULL,MAKEINTRESOURCE(IDB_BITMAP_ZAXIS), &m_pTextureAxisLabelZ);
  950. MESH_VERTEX_TEX* pConeVertices;
  952. D3DXMATRIX matTranslation;
  953. D3DXMATRIX matRotation;
  956. ID3DXMesh* pPrimativeMesh = NULL;
  957. double dConeHeight = 0.6; 
  958. fConeShiftX += (float)(dConeHeight/2.0);
  959. fConeShiftY += (float)(dConeHeight/2.0);
  960. fConeShiftZ += (float)(dConeHeight/2.0);
  962. float fConeBaseR = 0.2f;
  964. double dTextureAR = (2.0f*D3DX_PI*fConeBaseR)/dConeHeight;
  965.   
  966. if( SUCCEEDED(D3DXCreateCylinder(m_pD3DDevice,fConeBaseR,0.05f,(float)dConeHeight,20,2,&pPrimativeMesh,NULL)) )
  967. {
  968. for(int iCone=0;iCone<3;iCone++)
  969. {
  970.   if( SUCCEEDED( pPrimativeMesh->CloneMeshFVF( D3DXMESH_MANAGED, MESH_VERTEX_TEX_FVF,m_pD3DDevice,&m_pConeMesh[iCone])))
  971. {
  972. if(iCone == 0)
  973. {
  974. D3DXMatrixTranslation(&matTranslation,fConeShiftX,0.0f,0.0f);
  975.   D3DXMatrixRotationY(&matRotation,D3DX_PI/2.0f);
  976.   }
  977. else if(iCone == 1)
  978.   {
  979. D3DXMatrixTranslation(&matTranslation,0.0f,fConeShiftY,0.0f);
  980.     D3DXMatrixRotationX(&matRotation,-D3DX_PI/2.0f);
  981. }
  982. else if(iCone == 2)
  983. {
  984.   D3DXMatrixTranslation(&matTranslation,0.0f,0.0f,fConeShiftZ);
  985. D3DXMatrixRotationY(&matRotation,0.0f);//D3DX_PI/2.0f);
  986. }
  988. int nVertices = m_pConeMesh[iCone]->GetNumVertices();
  990. LPDIRECT3DVERTEXBUFFER9 pVB;
  991.   if( SUCCEEDED( m_pConeMesh[iCone]->GetVertexBuffer(&pVB)) )
  992. {
  993. pVB->Lock( 0, 0, (void**)&pConeVertices, 0 ); 
  996. for(int k=0; k<nVertices; k++)
  997.   {
  998.   double dTheta = atan2((double)pConeVertices[k].p.x,(double)pConeVertices[k].p.y);
  999.    if(dTheta < 0.0)dTheta += 2.0f*D3DX_PI;
  1000.   pConeVertices[k].tv = 0.5f - (float)(pConeVertices[k].p.z/dConeHeight);//0 at bottom 1 at top
  1001. pConeVertices[k].tu = (float)(dTheta/(2.0f*D3DX_PI));
  1003. D3DXVec3TransformCoord(&pConeVertices[k].p,&pConeVertices[k].p,&matRotation);
  1004. D3DXVec3TransformCoord(&pConeVertices[k].p,&pConeVertices[k].p,&matTranslation);
  1005. }
  1008. pVB->Unlock();
  1009. pVB->Release();
  1010. }
  1011. }
  1012. else
  1013. {
  1014. return E_FAIL;
  1015. }
  1016. }
  1018. SAFE_RELEASE(pPrimativeMesh);
  1019. }
  1020. return S_OK;
  1021. }
  1023. void C3DWindow::RemovePixelVB(void)
  1024. {
  1025. m_nPoints = 0;
  1026. SAFE_RELEASE(m_pPixelVB);
  1027. }
  1034. void C3DWindow::ResetArcBall(void)
  1035. {
  1037. UINT uNBytes;
  1038. CD3DArcBall* pArcBallProfile = NULL;
  1039. CString strDefaultArcBall = m_strRegistry + " Default";
  1041. theApp.GetProfileBinary("3D Window",strDefaultArcBall,(LPBYTE*)&pArcBallProfile,&uNBytes);
  1043. if(uNBytes == sizeof(CD3DArcBall) && pArcBallProfile)
  1044. m_ArcBall = *pArcBallProfile;
  1046. DELETENULL(pArcBallProfile);
  1047. }
  1050. HRESULT C3DWindow::ExportPixelVB(CString strFilename)
  1051. {
  1053. if(m_nPoints <= 0)
  1054. return S_FALSE;
  1056. CStdioFile ExportFile; 
  1058. BOOL bFileOpen = FALSE;
  1059. CString strExport;
  1061. bFileOpen = ExportFile.Open(strFilename, CFile::modeWrite|CFile::modeCreate);
  1062. if(!bFileOpen)
  1063. return S_FALSE;
  1065. POINT_VERTEX* pPixelVertices = NULL;
  1067. if(FAILED(m_pPixelVB->Lock( 0, 0, (void**)&pPixelVertices, 0 )) )
  1068. return S_FALSE;
  1070. float x,y,z;
  1071. for(int iPoint=0;iPoint<m_nPoints;iPoint++)
  1072. {
  1073. x = pPixelVertices[iPoint].p.x;
  1074. y = pPixelVertices[iPoint].p.y;
  1075. z = pPixelVertices[iPoint].p.z;
  1077. strExport.Format("%f,%f,%fn",x,y,z);
  1078. ExportFile.WriteString(strExport);
  1079. }
  1081. m_pPixelVB->Unlock();
  1083. ExportFile.Flush();
  1084. ExportFile.Close();
  1086. return S_OK;
  1087. }
  1092. void C3DWindow::OnMouseMove(UINT nFlags, CPoint point)
  1093. {
  1095. CWnd::OnMouseMove(nFlags, point);
  1096. }
  1098. void C3DWindow::OnLButtonDown(UINT nFlags, CPoint point)
  1099. {
  1100. CWnd::OnLButtonDown(nFlags, point);
  1101. }
  1103. void C3DWindow::OnLButtonUp(UINT nFlags, CPoint point)
  1104. {
  1105. CWnd::OnLButtonUp(nFlags, point);
  1106. }
  1108. void C3DWindow::OnLButtonDblClk(UINT nFlags, CPoint point)
  1109. {
  1110. CWnd::OnLButtonDblClk(nFlags, point);
  1111. }
  1120. HRESULT C3DWindow::CreateVB(int nPoints,float* pX,float* pY,float* pZ,Color* pC,float* pS)
  1121. {
  1122. HRESULT hr;
  1124. if(nPoints < 1)
  1125. return FALSE;
  1127. SAFE_RELEASE(m_pPixelVB);
  1129. float fMinX =  3.3E38f;
  1130. float fMaxX = -3.3E38f;
  1131. float fMinY =  3.3E38f;
  1132. float fMaxY = -3.3E38f;
  1133. float fMinZ =  3.3E38f;
  1134. float fMaxZ = -3.3E38f;
  1136. double dXSum = 0.0f;
  1137. double dYSum = 0.0f;
  1138. double dZSum = 0.0f;
  1139. for(int iP=0;iP<nPoints;iP++)
  1140. {
  1141. dXSum += (float)pX[iP];
  1142. dYSum += (float)pY[iP];
  1143. dZSum += (float)pZ[iP];
  1145. fMaxX = max(fMaxX,pX[iP]);
  1146. fMinX = min(fMinX,pX[iP]);
  1147. fMaxY = max(fMaxY,pY[iP]);
  1148. fMinY = min(fMinY,pY[iP]);
  1149. fMaxZ = max(fMaxZ,pZ[iP]);
  1150. fMinZ = min(fMinZ,pZ[iP]);
  1153. }
  1155. float fXOffset = -(float)(dXSum/(double)nPoints);
  1156. float fYOffset = -(float)(dYSum/(double)nPoints);
  1157. float fZOffset = -(float)(dZSum/(double)nPoints);
  1160. float fExtentX = fMaxX - fMinX;
  1161. float fExtentY = fMaxY - fMinY;
  1163. float fMaxExtent = max(fExtentX,fExtentY);
  1165. float fScale = 1.0f;
  1166. if(fMaxExtent > 0.0f) 
  1167. fScale = 20.0f / (fMaxExtent);
  1170. m_bUsePoints = false;  
  1172. if(m_bUsePoints)
  1173. {
  1174. if(FAILED(hr = m_pD3DDevice->CreateVertexBuffer( nPoints*sizeof(POINT_VERTEX),
  1175. D3DUSAGE_WRITEONLY , 
  1176. POINT_VERTEX_FVF, D3DPOOL_MANAGED, &m_pPixelVB, NULL )))
  1177. {
  1178. return FALSE; 
  1179. }
  1182. POINT_VERTEX* pPixelVertices = NULL;
  1184. if(FAILED(m_pPixelVB->Lock( 0, 0, (void**)&pPixelVertices, 0 )) )
  1185. return FALSE;
  1187. for(int iP=0;iP<nPoints;iP++)
  1188. {
  1189. Color c = pC[iP];
  1191. pPixelVertices[iP].p.x =  (fXOffset + pX[iP]) * fScale;
  1192. pPixelVertices[iP].p.y = -(fYOffset + pY[iP]) * fScale; 
  1193. pPixelVertices[iP].p.z =  (fZOffset + pZ[iP]) * fScale;
  1194. pPixelVertices[iP].color = D3DCOLOR_ARGB(255,c.GetR(),c.GetG(),c.GetB());
  1196. }
  1199.     m_pPixelVB->Unlock();
  1200. }
  1201. else
  1202. {
  1203. if(FAILED(hr = m_pD3DDevice->CreateVertexBuffer( 12*nPoints*sizeof(POINT_VERTEX),
  1204. D3DUSAGE_WRITEONLY , 
  1205. POINT_VERTEX_FVF, D3DPOOL_MANAGED, &m_pPixelVB, NULL )))
  1206. {
  1207. return FALSE;
  1208. }
  1211. POINT_VERTEX* pPixelVertices = NULL;
  1213. if(FAILED(m_pPixelVB->Lock( 0, 0, (void**)&pPixelVertices, 0 )) )
  1214. return FALSE;
  1216. POINT_VERTEX Quad[4];
  1217. int iV = 0;
  1218. for(int iP=0;iP<nPoints;iP++)
  1219. {
  1221. float m_fPixelSize = pS[iP];//pixel size in 3-D world
  1222. float fHalf = 0.5f*m_fPixelSize;
  1223. Color c = pC[iP];
  1225. Quad[0].p.x = (fXOffset + pX[iP]-fHalf) * fScale;
  1226. Quad[0].p.y = (fYOffset - pY[iP]-fHalf) * fScale;
  1227. Quad[0].p.z = (fZOffset + pZ[iP]) * fScale;
  1228. Quad[0].color = D3DCOLOR_ARGB(255,c.GetR(),c.GetG(),c.GetB());
  1230. Quad[1].p.x = (fXOffset + pX[iP]+fHalf) * fScale;
  1231. Quad[1].p.y = (fYOffset - pY[iP]-fHalf) * fScale;
  1232. Quad[1].p.z =   Quad[0].p.z ;
  1233. Quad[1].color = Quad[0].color;
  1235. Quad[2].p.x = (fXOffset + pX[iP]+fHalf) * fScale;
  1236. Quad[2].p.y = (fYOffset - pY[iP]+fHalf) * fScale;
  1237. Quad[2].p.z =   Quad[0].p.z ;
  1238. Quad[2].color = Quad[0].color;
  1240. Quad[3].p.x = (fXOffset + pX[iP]-fHalf) * fScale;
  1241. Quad[3].p.y = (fYOffset - pY[iP]+fHalf) * fScale;
  1242. Quad[3].p.z =   Quad[0].p.z ;
  1243. Quad[3].color = Quad[0].color;
  1245. pPixelVertices[iV++] = Quad[0];
  1246. pPixelVertices[iV++] = Quad[2]; 
  1247. pPixelVertices[iV++] = Quad[1];
  1249. pPixelVertices[iV++] = Quad[1];
  1250. pPixelVertices[iV++] = Quad[2]; 
  1251. pPixelVertices[iV++] = Quad[0];
  1253. pPixelVertices[iV++] = Quad[0];
  1254. pPixelVertices[iV++] = Quad[3];
  1255. pPixelVertices[iV++] = Quad[2];
  1257. pPixelVertices[iV++] = Quad[2];
  1258. pPixelVertices[iV++] = Quad[3];
  1259. pPixelVertices[iV++] = Quad[0];
  1262. }
  1265.     m_pPixelVB->Unlock();
  1268. }
  1269. m_nPoints = nPoints;
  1272. float fConeShiftX = 10.0f; 
  1273. float fConeShiftY = 7.5f; 
  1274. float fConeShiftZ =  10.0f;
  1275. MakeConeMeshes(fConeShiftX,fConeShiftY,fConeShiftZ);
  1277. return TRUE;
  1278. }
  1281. /*lint -restore*/