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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 图形图像 > OpenGL > 查看源码
MyglView.cpp
资源名称：modelmagic3d.zip　[点击查看]
上传用户：cding2008
上传日期：2007-01-03
资源大小：1812k
文件大小：57k
源码类别：

OpenGL

开发平台：

Visual C++

MyglView.cpp：源码内容
  1. /////////////////////////////////////////////////////////////////////////////
  2. // MyglView.cpp : implementation of the CMyglView class
  3. //
  4. // ModelMagic 3D and 'glOOP' (OpenGL Object Oriented Programming library)
  5. // Copyright (c) Craig Fahrnbach 1997, 1999
  6. //
  7. // OpenGL is a registered trademark of Silicon Graphics
  8. //
  9. //
  10. // This program is provided for educational and personal use only and
  11. // is provided without guarantee or warrantee expressed or implied.
  12. //
  13. // Commercial use is strickly prohibited without written permission
  14. // from ImageWare Development.
  15. //
  16. /////////////////////////////////////////////////////////////////////////////
  18. #include "stdafx.h"
  19. #include "ModelMagic3D.h"
  20. #include <math.h>
  21. #include <wingdi.h>
  24. #ifdef _DEBUG
  25. #define new DEBUG_NEW
  26. #undef THIS_FILE
  27. static char THIS_FILE[] = __FILE__;
  28. #endif
  31. /////////////////////////////////////////////////////////////////////////////
  32. // CMyglView local variables
  33. //
  35. static Matx4x4 g_SelctedObjMatrix; // User selected object transform matrix
  36. // (used for object point transfomation)
  39. static BOOL g_bStretchBlt  = FALSE; // Printer device capability flags
  40. static BOOL g_bStretchDIBits = FALSE;
  42. static CTextureDibImage g_DibImage; // DIB image for screen print
  43. static BITMAPINFO* g_pBitmapInfo = NULL; // CMyglView global DIB pointers
  44. static GLubyte* g_pBitmapBits = NULL; // Bitmap pits
  46. static float g_fMarginTop = 0.75f; // CMyglView global margin settings
  47. static float g_fMarginBottom = 0.75f;
  48. static float g_fMarginLeft = 0.75f;
  49. static float g_fMarginRight = 0.75f;
  53. /////////////////////////////////////////////////////////////////////////////
  54. // CMyglView
  56. IMPLEMENT_DYNCREATE(CMyglView, CView)
  58. BEGIN_MESSAGE_MAP(CMyglView, CView)
  59. //{{AFX_MSG_MAP(CMyglView)
  60. ON_WM_ERASEBKGND()
  61. ON_WM_SIZE()
  62. ON_WM_CREATE()
  63. ON_WM_PALETTECHANGED()
  64. ON_WM_QUERYNEWPALETTE()
  65. ON_WM_DESTROY()
  66. ON_WM_MOUSEMOVE()
  67. ON_COMMAND(ID_VIEW_PERSPECTIVE, OnViewPerspective)
  68. ON_COMMAND(ID_VIEW_ZOOMIN, OnViewZoomIn)
  69. ON_COMMAND(ID_VIEW_ZOOMOUT, OnViewZoomOut)
  70. ON_UPDATE_COMMAND_UI(ID_VIEW_PERSPECTIVE, OnUpdateViewPerspective)
  71. ON_COMMAND(ID_ANIMATE_SCEEN, OnAnimateSceen)
  72. ON_UPDATE_COMMAND_UI(ID_ANIMATE_SCEEN, OnUpdateAnimateSceen)
  73. ON_COMMAND(ID_VIEW_WIREFRAME, OnViewWireFrame)
  74. ON_UPDATE_COMMAND_UI(ID_VIEW_WIREFRAME, OnUpdateViewWireFrame)
  75. ON_COMMAND(ID_VIEW_FLATSHADE, OnViewFlatShade)
  76. ON_UPDATE_COMMAND_UI(ID_VIEW_FLATSHADE, OnUpdateViewFlatShade)
  77. ON_COMMAND(ID_VIEW_DISPLAYAXIS, OnViewDisplayAxis)
  78. ON_UPDATE_COMMAND_UI(ID_VIEW_DISPLAYAXIS, OnUpdateViewDisplayAxis)
  79. ON_COMMAND(ID_VIEW_DISPLAYGRID, OnViewDisplayGrid)
  80. ON_UPDATE_COMMAND_UI(ID_VIEW_DISPLAYGRID, OnUpdateViewDisplayGrid)
  81. ON_COMMAND(ID_VIEW_ISO, OnViewIso)
  82. ON_UPDATE_COMMAND_UI(ID_VIEW_ISO, OnUpdateViewIso)
  83. ON_COMMAND(ID_VIEW_FRONT, OnViewFront)
  84. ON_UPDATE_COMMAND_UI(ID_VIEW_FRONT, OnUpdateViewFront)
  85. ON_COMMAND(ID_VIEW_SIDE, OnViewSide)
  86. ON_UPDATE_COMMAND_UI(ID_VIEW_SIDE, OnUpdateViewSide)
  87. ON_COMMAND(ID_VIEW_TOP, OnViewTop)
  88. ON_UPDATE_COMMAND_UI(ID_VIEW_TOP, OnUpdateViewTop)
  89. ON_COMMAND(ID_VIEW_SMOOTHSHADE, OnViewSmoothShade)
  90. ON_UPDATE_COMMAND_UI(ID_VIEW_SMOOTHSHADE, OnUpdateViewSmoothShade)
  91. ON_WM_KEYDOWN()
  92. ON_COMMAND(ID_CAMERA_EDIT, OnCameraEdit)
  93. ON_WM_LBUTTONDOWN()
  94. ON_COMMAND(ID_VIEW_CULLFACES, OnViewCullfaces)
  95. ON_UPDATE_COMMAND_UI(ID_VIEW_CULLFACES, OnUpdateViewCullfaces)
  96. ON_WM_LBUTTONDBLCLK()
  97. ON_COMMAND(ID_FILE_PRINT_PREVIEW, OnFilePrintPreview)
  98. ON_COMMAND(ID_FILE_PAGE_SETUP, OnFilePageSetup)
  99. ON_COMMAND(ID_FILE_SAVE_IMAGE, OnFileSaveImage)
  100. ON_WM_RBUTTONDOWN()
  101. ON_WM_LBUTTONUP()
  102. ON_WM_SETCURSOR()
  103. ON_COMMAND(ID_VIEW_OUTLINE, OnViewOutline)
  104. ON_UPDATE_COMMAND_UI(ID_VIEW_OUTLINE, OnUpdateViewOutline)
  105. //}}AFX_MSG_MAP
  106. // Standard printing commands
  107. ON_COMMAND(ID_FILE_PRINT, CView::OnFilePrint)
  108. ON_COMMAND(ID_FILE_PRINT_DIRECT, CView::OnFilePrint)
  109. ON_COMMAND(ID_FILE_PRINT_PREVIEW, CView::OnFilePrintPreview)
  110. END_MESSAGE_MAP()
  113. /////////////////////////////////////////////////////////////////////////////
  114. // CMyglView construction/destruction
  116. CMyglView::CMyglView()
  117. {
  118. // Initialize our member variables
  119. m_pDC = NULL;
  120. m_hRC = NULL;
  121. m_nMouseZ = 0;
  123. m_CPointLeftButtonDown.x = 0;
  124. m_CPointLeftButtonDown.y = 0;
  126. m_fMouseZCoord = 0.0f;
  127. VecClear3f(m_fSelectedCoord);
  128. VecClear3f(m_fSelectedCoord2);
  129. VecClear3f(m_fLeftButtonDownCoord);
  130. }
  132. CMyglView::~CMyglView()
  133. {
  134. }
  137. /////////////////////////////////////////////////////////////////////////////
  138. // CMyglView Camera view functions
  140. void CMyglView::ViewIso() 
  141. {
  142. // Set the camera view type
  143. m_Camera.m_iViewType = VIEW_ISO;
  145. // Rotate about the X & Z-Axis 
  146. m_Camera.SetRotation(-75.0f, 0.0f, -15.0f);
  147. }
  149. void CMyglView::ViewFront() 
  150. {
  151. // Set the camera view type
  152. m_Camera.m_iViewType = VIEW_FRONT;
  154. // Rotate about the X-Axis
  155. m_Camera.SetRotation(-90.0f, 0.0f, 0.0f);
  156. }
  158. void CMyglView::ViewSide() 
  159. {
  160. // Set the camera view type
  161. m_Camera.m_iViewType = VIEW_SIDE;
  163. // Rotate about the X & Z-Axis 
  164. m_Camera.SetRotation(-90.0f, 0.0f, -90.0f);
  165. }
  167. void CMyglView::ViewTop() 
  168. {
  169. // Set the camera view type
  170. m_Camera.m_iViewType = VIEW_TOP;
  172. // No Rotation 
  173. m_Camera.SetRotation(0.0f, 0.0f, 0.0f);
  175. // No X or Y-Axis offsets 
  176. m_Camera.m_fOrigin[X] = 0.0f;
  177. m_Camera.m_fOrigin[Y] = 0.0f;
  178. }
  181. /////////////////////////////////////////////////////////////////////////////
  182. // CMyglView drawing
  184. void CMyglView::OnDraw(CDC* pDC)
  185. {
  186. // Get a pointer to our view's document
  187. CMyglDoc* pDoc = GetDocument();
  188. ASSERT_VALID(pDoc);
  190. // Get a pointer to our document's 3dWorld
  191. C3dWorld* pWorld = pDoc->m_pWorld;
  192. ASSERT_VALID(pWorld);
  194. // Make this view the current OpenGL rendering context...
  195. if(!the3dEngine.EnableRC(pDC->GetSafeHdc(), m_hRC, TRUE))
  196. return;
  198. // Display the world
  199. pWorld->DisplayWorld(pDC->GetSafeHdc(), &m_Camera, pDoc->m_dTime);
  201. // Releases the device context that is used by the rendering context
  202. // to allow other rendering contexts to co-exist.
  203. the3dEngine.EnableRC(NULL, NULL, FALSE);
  204. }
  206. /////////////////////////////////////////////////////////////////////////////
  207. // CMyglView printing
  209. BOOL CMyglView::OnPreparePrinting(CPrintInfo* pInfo) 
  210. {
  211. // default preparation
  212. return DoPreparePrinting(pInfo);
  213. }
  215. void CMyglView::OnPrepareDC(CDC* pDC, CPrintInfo* pInfo) 
  216. {
  217. // TODO: Add your specialized code here and/or call the base class
  219. CView::OnPrepareDC(pDC, pInfo);
  220. }
  222. void CMyglView::OnFilePrintPreview() 
  223. {
  224. // Since the default initialization of CView::OnFilePrintPreview() modifies
  225. // the window viewport and sends a WM_SIZE command, we capture the screen
  226. // DIB information BEFORE it is modified..
  228. // Make this view the current OpenGL rendering context...
  229. if(!the3dEngine.EnableRC(m_pDC->GetSafeHdc(), m_hRC, TRUE))
  230. return;
  232. // Read the window bits
  233. g_pBitmapBits = (GLubyte*)g_DibImage.ReadDIBitmap(&g_pBitmapInfo);
  235. // Releases the device context that is used by the rendering context
  236. // to allow other rendering contexts to co-exist.
  237. the3dEngine.EnableRC(NULL, NULL, FALSE);
  240. // Now that we have the screen information, do the default initialization
  241. CView::OnFilePrintPreview();
  242. }
  244. void CMyglView::OnBeginPrinting(CDC* pDC, CPrintInfo* pInfo)
  245. {
  246.     // Gather some general information about the printer the
  247. // user selected..
  249. // Lock the handle to the structure to get a pointer
  250. LPDEVMODE pMode = (LPDEVMODE)::GlobalLock(pInfo->m_pPD->m_pd.hDevMode);
  252. // Get the printer name
  253. CString szPtrName;
  254. szPtrName.Format("%s", pMode->dmDeviceName);
  256. // Unlock the handles
  257. ::GlobalUnlock(pInfo->m_pPD->m_pd.hDevMode);
  259. int nBitsPerPixel = pDC->GetDeviceCaps(BITSPIXEL);
  260. int nColors = pDC->GetDeviceCaps(NUMCOLORS);
  261. int nBitPlanes = pDC->GetDeviceCaps(PLANES);
  262. int nColorRes = pDC->GetDeviceCaps(COLORRES);
  263. int nRasterCaps = pDC->GetDeviceCaps(RASTERCAPS);
  265. // Does the device support raster operations?
  266. if(nRasterCaps & RC_STRETCHBLT)
  267. g_bStretchBlt = TRUE;
  268. if(nRasterCaps & RC_STRETCHDIB)
  269. g_bStretchDIBits = TRUE;
  271. // Display in the debug window the information gathered
  272. TRACE("You selected printer '%s'n", szPtrName);
  273. TRACE("BitsPerPixel = %dn", nBitsPerPixel);
  274. TRACE("NumColors    = %dn", nColors);
  275. TRACE("NumBitPlanes = %dn", nBitPlanes);
  276. TRACE("ColorResolution        = %dn", nColorRes);
  277. TRACE("Supports StretchBlt    = %dn", g_bStretchBlt);
  278. TRACE("Supports StretchDIBits = %dn", g_bStretchDIBits);
  280. if(!g_bStretchBlt && !g_bStretchDIBits)
  281. {
  282. char szError[100];
  283. sprintf(szError, "Printer '%s' does not support required functions!", szPtrName);
  284. AfxMessageBox( szError, MB_OK);
  285. }
  286. }
  288. void CMyglView::OnPrint(CDC* pDC, CPrintInfo* pInfo) 
  289. {
  290. HBRUSH brush; // Background brush for page
  291. POINT ImageSize; // Size of printed image
  292. POINT ImageOffset; // Offset from edges for image
  293. CRect rectPageMax; // Maximum usable Page rectangle
  294. CRect rectMargins; // Page margins, in device units
  295. CRect rectPageAdj; // Adjusted page area, in device units
  298. if(!pInfo->m_bPreview)
  299. {
  300. // Since we are not doing a print preview, go ahead and capture the screen
  301. // DIB information.
  303. // Make this view the current OpenGL rendering context...
  304. if(!the3dEngine.EnableRC(m_pDC->GetSafeHdc(), m_hRC, TRUE))
  305. return;
  307. // Read the window bits
  308. g_pBitmapBits = (GLubyte*)g_DibImage.ReadDIBitmap(&g_pBitmapInfo);
  310. // Releases the device context that is used by the rendering context
  311. // to allow other rendering contexts to co-exist.
  312. the3dEngine.EnableRC(NULL, NULL, FALSE);
  313. }
  315. // Set our device context mapping mode.
  316. // Each logical unit is converted to 1 device pixel. Positive x is to
  317. // the right; positive y is down.
  318. pDC->SetMapMode (MM_TEXT);
  320. // Get our page margin size, in device units
  321. CalculateMargins(pDC, &rectMargins);
  323. // Get the maximum usable size of the page (in printer device points)
  324. rectPageMax.top    = 0;
  325. rectPageMax.left   = 0;
  326. rectPageMax.right  = pDC->GetDeviceCaps(HORZRES);
  327. rectPageMax.bottom = pDC->GetDeviceCaps(VERTRES);
  329. // Create a white brush and clear the page
  330. brush = CreateSolidBrush(0x00ffffff);
  331. FillRect(pDC->GetSafeHdc(), &rectPageMax, brush);
  333. // Calculate the adjusted page area, in device units
  334. rectPageAdj.top    = 0;
  335. rectPageAdj.left   = 0;
  336. rectPageAdj.right  = rectPageMax.right  - (rectMargins.left + rectMargins.right);
  337. rectPageAdj.bottom = rectPageMax.bottom - (rectMargins.top  + rectMargins.bottom);
  340. // Calculate the new image size and the image offset with image
  341. // centered on page
  342. ImageSize.x = rectPageAdj.right;
  343. ImageSize.y = (ImageSize.x * g_pBitmapInfo->bmiHeader.biHeight / g_pBitmapInfo->bmiHeader.biWidth);
  344. if (ImageSize.y > rectPageAdj.bottom)
  345. {
  346. ImageSize.y = rectPageAdj.bottom;
  347. ImageSize.x = ImageSize.y * g_pBitmapInfo->bmiHeader.biWidth / g_pBitmapInfo->bmiHeader.biHeight;
  348. }
  350. // Calculate the image offset
  351. ImageOffset.x = rectMargins.left + ((rectPageAdj.right  - ImageSize.x)/2);
  352. ImageOffset.y = rectMargins.top   + ((rectPageAdj.bottom - ImageSize.y)/2);
  354. // Set the bitmap stretching mode in the device context. 
  355. // Note:  The COLORONCOLOR mode is typically used to preserve
  356. //        color in color bitmaps. 
  357. SetStretchBltMode(pDC->GetSafeHdc(), COLORONCOLOR);
  360. // Does our device context support StretchDIBits?
  361. if(g_bStretchDIBits)
  362. {
  363. BOOL bRet = StretchDIBits(pDC->GetSafeHdc(),
  364.   ImageOffset.x, ImageOffset.y,
  365.   ImageSize.x, ImageSize.y,
  366.   0, 0,
  367.   g_pBitmapInfo->bmiHeader.biWidth,
  368.   g_pBitmapInfo->bmiHeader.biHeight,
  369.   g_pBitmapBits,
  370.   g_pBitmapInfo,
  371.   DIB_RGB_COLORS,
  372.   SRCCOPY);
  373. }
  374. else if(!g_bStretchBlt)
  375. {
  376. HDC hdc;
  377. HBITMAP bitmap;
  379. hdc    = CreateCompatibleDC(pDC->GetSafeHdc());
  380. bitmap = CreateDIBitmap(hdc,
  381. &(g_pBitmapInfo->bmiHeader),
  382. CBM_INIT,
  383. g_pBitmapBits,
  384. g_pBitmapInfo,
  385. DIB_RGB_COLORS);
  387. HGDIOBJ temp = SelectObject(hdc, bitmap);
  388. BOOL bRet = StretchBlt(pDC->GetSafeHdc(),
  389.    ImageOffset.x, ImageOffset.y,
  390.    ImageSize.x, ImageSize.y,
  391.    hdc,
  392.    0, 0,
  393.    g_pBitmapInfo->bmiHeader.biWidth,
  394.    g_pBitmapInfo->bmiHeader.biHeight,
  395.    SRCCOPY);
  397. // Free our bitmap and bitmap device context
  398. DeleteObject(bitmap);
  399. DeleteDC(hdc);
  400. }
  402. // That's it.  End the print job and free anything we allocated...
  404. // Delete our brush
  405. DeleteObject(brush);
  406. }
  408. void CMyglView::CalculateMargins(CDC* pDC, CRect* pRectMargins)
  409. {
  410. POINT pt;
  411. CRect rectUnPrintable;
  414. // Start by getting the dimensions of the unprintable part of the
  415. // page (in device units). GETPRINTINGOFFSET will tell us the left
  416. // and upper unprintable area.
  417. pDC->Escape(GETPRINTINGOFFSET, 0, NULL, &pt);
  418. rectUnPrintable.left = pt.x;
  419. rectUnPrintable.top  = pt.y;
  421. // To get the right and lower unprintable area, we need to take
  422. // the entire width and height of the paper (GETPHYSPAGESIZE) and
  423. // subtract everything else.
  424. pDC->Escape(GETPHYSPAGESIZE, 0, NULL, &pt);
  426. rectUnPrintable.right  = pt.x // total paper width
  427.    - pDC->GetDeviceCaps(HORZRES)// printable width
  428.    - rectUnPrintable.left; // left unprtable margin
  429.  
  430. rectUnPrintable.bottom = pt.y // total paper height
  431.    - pDC->GetDeviceCaps(VERTRES)// printable ht
  432.    - rectUnPrintable.top; // rt unprtable margin
  433.  
  434. // Convert the margin values from the Page Setup dialog
  435. // to device units and subtract the unprintable part we just
  436. // calculated.
  437. pt.x = pDC->GetDeviceCaps(LOGPIXELSX); // dpi in X directPageMaxion
  438. pt.y = pDC->GetDeviceCaps(LOGPIXELSY); // dpi in Y directPageMaxion
  440. pRectMargins->top    = (long)(g_fMarginTop * pt.y)    - rectUnPrintable.top;
  441. pRectMargins->bottom = (long)(g_fMarginBottom * pt.y) - rectUnPrintable.bottom;
  442. pRectMargins->right  = (long)(g_fMarginRight * pt.x)  - rectUnPrintable.right;
  443. pRectMargins->left   = (long)(g_fMarginLeft * pt.x)   - rectUnPrintable.left;
  445. // Ensure that our margins are in the printable range..
  446. if(pRectMargins->left < 0)
  447. pRectMargins->left = 0;
  448. if(pRectMargins->top < 0)
  449. pRectMargins->top = 0;
  450. if(pRectMargins->right < 0)
  451. pRectMargins->right = 0;
  452. if(pRectMargins->bottom < 0)
  453. pRectMargins->bottom = 0;
  455. // pRectMargins now contains the values used to shrink the
  456. // printable area of the page.
  459. // Convert to logical units and we're done!
  460. pDC->DPtoLP(pRectMargins);
  461. }
  463. void CMyglView::OnEndPrinting(CDC* /*pDC*/, CPrintInfo* /*pInfo*/)
  464. {
  465. // Free the DIB bits
  466. if(g_pBitmapBits)
  467. free(g_pBitmapBits);
  469. // Free the DIB header info
  470. if(g_pBitmapInfo)
  471. free(g_pBitmapInfo);
  472. }
  475. /////////////////////////////////////////////////////////////////////////////
  476. // CMyglView page setup
  478. void CMyglView::OnFilePageSetup() 
  479. {
  480. float scale; // Our Page Setup margin scaling factor
  481. CPageSetupDialog psdlg; // Allocate the structure for our Page Setup dialog
  482. PRINTDLG printDlg; // Allocate the structure to store the returned printer info
  485. // Get the printer information
  486. AfxGetApp()->GetPrinterDeviceDefaults(&printDlg);
  488. // Lock the handles to the structures to get pointers
  489. LPDEVNAMES pDevNames = (LPDEVNAMES)::GlobalLock(printDlg.hDevNames);
  490. LPDEVMODE  pDevMode  = (LPDEVMODE)::GlobalLock(printDlg.hDevMode);
  492. // Allocate space for the Page Setup printer info structures
  493. psdlg.m_psd.hDevNames = ::GlobalAlloc(GPTR, ::GlobalSize(printDlg.hDevNames));
  494. psdlg.m_psd.hDevMode = ::GlobalAlloc(GPTR, ::GlobalSize(printDlg.hDevMode));
  496. // Lock the new handles
  497. LPDEVNAMES m_pDevNames = (LPDEVNAMES)::GlobalLock(psdlg.m_psd.hDevNames);
  498. LPDEVMODE  m_pDevMode  = (LPDEVMODE)::GlobalLock(psdlg.m_psd.hDevMode);
  500. // Copy the printer information into page setup dialog
  501. memcpy(m_pDevNames, pDevNames,
  502. (size_t)::GlobalSize(printDlg.hDevNames));
  503. memcpy(m_pDevMode, pDevMode,
  504. (size_t)::GlobalSize(printDlg.hDevMode));
  506. // Unlock the handles
  507. ::GlobalUnlock(printDlg.hDevNames);
  508. ::GlobalUnlock(printDlg.hDevMode);
  510. ::GlobalUnlock(psdlg.m_psd.hDevNames);
  511. ::GlobalUnlock(psdlg.m_psd.hDevMode);
  513. // Done initializing the CPageSetupDialog.  This dialog will now
  514. // display the system default printer info
  517. // Determine the scaling factor of the Page Setup margins
  518. if(psdlg.m_psd.Flags & PSD_INTHOUSANDTHSOFINCHES)
  519. scale = 1000.0f;
  520. else if(psdlg.m_psd.Flags & PSD_INHUNDREDTHSOFMILLIMETERS)
  521. scale = 2540.0f; // 100*25.4mm/inch
  522. else
  523. scale = 1000.0f; // Default setting
  525. // Initialize our Page Setup dialog margin settings with
  526. // our CMyglView global margin settings
  527. psdlg.m_psd.rtMargin.top = (int)(g_fMarginTop*scale);
  528. psdlg.m_psd.rtMargin.bottom = (int)(g_fMarginBottom*scale);
  529. psdlg.m_psd.rtMargin.left = (int)(g_fMarginLeft*scale);
  530. psdlg.m_psd.rtMargin.right = (int)(g_fMarginRight*scale);
  532. // Display the Page Setup dialog..
  533. if(psdlg.DoModal() == IDOK)
  534. {
  535. // Select this printer as our default configuration
  536. AfxGetApp()->SelectPrinter(psdlg.m_psd.hDevNames, psdlg.m_psd.hDevMode);
  538. // Save the Page Setup dialog margin settings
  539. g_fMarginTop = (float)(psdlg.m_psd.rtMargin.top)/scale;
  540. g_fMarginBottom = (float)(psdlg.m_psd.rtMargin.bottom)/scale;
  541. g_fMarginLeft = (float)(psdlg.m_psd.rtMargin.left)/scale;
  542. g_fMarginRight = (float)(psdlg.m_psd.rtMargin.right)/scale;
  543. }
  544. }
  547. /////////////////////////////////////////////////////////////////////////////
  548. // CMyglView diagnostics
  550. #ifdef _DEBUG
  551. void CMyglView::AssertValid() const
  552. {
  553. CView::AssertValid();
  554. }
  556. void CMyglView::Dump(CDumpContext& dc) const
  557. {
  558. CView::Dump(dc);
  559. }
  561. CMyglDoc* CMyglView::GetDocument() // non-debug version is inline
  562. {
  563. ASSERT(m_pDocument->IsKindOf(RUNTIME_CLASS(CMyglDoc)));
  564. return (CMyglDoc*)m_pDocument;
  565. }
  566. #endif //_DEBUG
  568. /////////////////////////////////////////////////////////////////////////////
  569. // CMyglView message handlers
  571. BOOL CMyglView::PreCreateWindow(CREATESTRUCT& cs)
  572. {
  573. // OpenGL requires WS_CLIPCHILDREN and WS_CLIPSIBLINGS and must not
  574.     // include CS_PARENTDC for the class style. Refer to SetPixelFormat
  575.     // documentation in the "Comments" section for further information.
  576. cs.style |= (WS_CLIPCHILDREN | WS_CLIPSIBLINGS);
  578. // Register a class with its own device context and the 'arrow' cursor
  579. cs.lpszClass = AfxRegisterWndClass(CS_OWNDC | CS_DBLCLKS |
  580.    CS_HREDRAW | CS_VREDRAW,
  581.    ::LoadCursor(NULL, IDC_ARROW));
  583. return CView::PreCreateWindow(cs);
  584. }
  586. int CMyglView::OnCreate(LPCREATESTRUCT lpCreateStruct) 
  587. {
  588. if (CView::OnCreate(lpCreateStruct) == -1)
  589. return -1;
  591. // Get the Device context to our window
  592. m_pDC = new CClientDC (this);
  593. if (m_pDC == NULL)
  594. return (-1);
  596. // Set our window pixel format for openGL rendering
  597. if(!the3dEngine.SetWindowPixelFormat(m_pDC->GetSafeHdc(),
  598.  PFD_DRAW_TO_WINDOW | // Draw to Window (not bitmap)
  599.  PFD_SUPPORT_OPENGL | // Support OpenGL calls in window
  600.  PFD_DOUBLEBUFFER)) // Double buffered mode
  601. return -1;
  603. // Create the rendering context
  604. m_hRC = wglCreateContext(m_pDC->GetSafeHdc());
  605. if (!m_hRC)
  606. return -1;
  608. return 0;
  609. }
  611. BOOL CMyglView::OnEraseBkgnd(CDC* pDC) 
  612. {
  613. // Override to keep the background from being erased everytime
  614. // the window is repainted
  616. return TRUE;
  618. // return CView::OnEraseBkgnd(pDC);
  619. }
  621. void CMyglView::OnSize(UINT nType, int cx, int cy) 
  622. {
  623. CView::OnSize(nType, cx, cy);
  625. if(!m_pDocument)
  626. return;
  628. // Make this view the current OpenGL rendering context...
  629. if(!the3dEngine.EnableRC(m_pDC->GetSafeHdc(), m_hRC, TRUE))
  630. return;
  632. // Reset our camera view
  633. m_Camera.ResetView(cx, cy);
  635. // Releases the device context that is used by the rendering context
  636. // to allow other rendering contexts to co-exist.
  637. the3dEngine.EnableRC(NULL, NULL, FALSE);
  639. // Force a window repaint
  640. InvalidateRect(NULL, FALSE);
  641. }
  643. void CMyglView::OnPaletteChanged(CWnd* pFocusWnd) 
  644. {
  645. if((the3dEngine.GetPalette() != NULL) && (pFocusWnd != this))
  646. {
  647. // Select the palette into the device context
  648. SelectPalette(m_pDC->GetSafeHdc(), the3dEngine.GetPalette(), FALSE);
  650. // Map entries to system palette
  651. RealizePalette(m_pDC->GetSafeHdc());
  653. // Remap the current colors to the newly realized palette
  654. UpdateColors(m_pDC->GetSafeHdc());
  655. return;
  656. }
  658. CView::OnPaletteChanged(pFocusWnd);
  659. }
  661. BOOL CMyglView::OnQueryNewPalette() 
  662. {
  663. int iNumEntries; // Number of entries in the logical palette were
  664. // mapped to different entries in the system palette.
  666. // If the palette was created.
  667. if(the3dEngine.GetPalette())
  668. {
  669. // Selects the palette into the current device context
  670. SelectPalette(m_pDC->GetSafeHdc(), the3dEngine.GetPalette(), FALSE);
  672. // Map entries from the currently selected palette to
  673. // the system palette.  The return value is the number 
  674. // of palette entries modified.
  675. iNumEntries = RealizePalette(m_pDC->GetSafeHdc());
  677. // Repaint, forces remap of palette in current window
  678. InvalidateRect(NULL, FALSE);
  680. return iNumEntries;
  681. }
  683. return CView::OnQueryNewPalette();
  684. }
  686. void CMyglView::OnDestroy() 
  687. {
  688. CView::OnDestroy();
  690. if(m_pDC)
  691. // Clean up rendering context stuff
  692. delete m_pDC;
  694. if(m_hRC)
  695. // Clean up rendering context stuff
  696. wglDeleteContext(m_hRC);
  697. }
  699. void CMyglView::OnActivateView(BOOL bActivate, CView* pActivateView, CView* pDeactiveView) 
  700. {
  701. // Get a pointer to our Main Frame
  702. CMainFrame* pFrame = (CMainFrame*) AfxGetApp()->m_pMainWnd;
  703. ASSERT_VALID(pFrame);
  705. // Let the MainFrame know that we have changed views..
  706. pFrame->SendMessage(WM_REFRESH_DLG_BAR, RDB_NEW_USER_VIEW, 0L);
  708. CView::OnActivateView(bActivate, pActivateView, pDeactiveView);
  709. }
  711. void CMyglView::OnLButtonDown(UINT nFlags, CPoint point) 
  712. {
  713. // Get a pointer to our Main Frame
  714. CMainFrame* pFrame = (CMainFrame*) AfxGetApp()->m_pMainWnd;
  715. ASSERT_VALID(pFrame);
  717. // Get a pointer to our view's document
  718. CMyglDoc* pDoc = GetDocument();
  719. ASSERT_VALID(pDoc);
  721. // Get a pointer to our document's 3dWorld
  722. C3dWorld* pWorld = pDoc->m_pWorld;
  723. ASSERT_VALID(pWorld);
  725. // Get a pointer to our worlds' selected object
  726. C3dObject* pObj =  pWorld->m_pSelectedObj;
  728. // Get a pointer to our worlds' selected point
  729. C3dPoint* pPoint =  pWorld->m_pSelectedPnt;
  732. // Calculate a new Mouse 'Z' value.  Mouse 'Z' is mapped to 
  733. // the mouse y position if the Right Mouse button is down
  735. // Save the mouse left button down screen position
  736. m_CPointLeftButtonDown = point;
  738. // Scale the mouse 'z' screen position to simulate a 'Z' world
  739. // coordinate.
  740. m_fMouseZCoord = (float)m_nMouseZ * g_fMouseZMult;
  742. // Convert the mouse left button down position to world
  743. m_Camera.GetWorldCoord(point.x, point.y, m_fMouseZCoord, m_fLeftButtonDownCoord);
  746. // Are we creating points?
  747. if(pDoc->m_bCreatePoints)
  748. {
  749. // Create a new C3dPoint and append to list
  750. C3dPoint* pPoint = new C3dPoint;
  751. ASSERT(pPoint);
  753. if(pDoc->m_bSnapToGrid)
  754. pWorld->m_pGrid->PointToGrid(&m_fLeftButtonDownCoord[X],
  755.  &m_fLeftButtonDownCoord[Y],
  756.  &m_fLeftButtonDownCoord[Z]); 
  758. pPoint->SetOrigin(m_fLeftButtonDownCoord[X],
  759.   m_fLeftButtonDownCoord[Y],
  760.   m_fLeftButtonDownCoord[Z]);
  762. pWorld->m_PointList.Append(pPoint);
  764. // Save the pointer
  765. pWorld->m_pSelectedPnt = pPoint;
  767. // Update the Coordinate Dialog Toolbar
  768. pFrame->m_wndCoordDlgBar.UpdateDialogData();
  769. }
  771. // Selecting World Points?
  772. else if(pDoc->m_bSelectPoint)
  773. {
  774. GLfloat fMouseCoordinate[4];
  775. C3dPoint* pPoint;
  777. // Convert our point to 3D coordinates
  778. m_Camera.GetWorldCoord(point.x, point.y, m_fMouseZCoord, fMouseCoordinate);
  780. // Find the point from the point list.
  781. pPoint = pWorld->m_PointList.Find(m_fLeftButtonDownCoord[X],
  782.   m_fLeftButtonDownCoord[Y],
  783.   m_fLeftButtonDownCoord[Z],
  784.   0.1f);
  785. if(pPoint)
  786. // Save the point pointer
  787. pWorld->m_pSelectedPnt = pPoint;
  789. if(pWorld->m_pSelectedPnt)
  790. {
  791. // Set the selected coordinates
  792. m_fSelectedCoord[X] = pWorld->m_pSelectedPnt->m_fOrigin[X];
  793. m_fSelectedCoord[Y] = pWorld->m_pSelectedPnt->m_fOrigin[Y];
  794. m_fSelectedCoord[Z] = pWorld->m_pSelectedPnt->m_fOrigin[Z];
  795. }
  797. // Update the Coordinate Dialog Toolbar
  798. pFrame->m_wndCoordDlgBar.UpdateDialogData();
  799. }
  801. // Selecting Object Points?
  802. else if(pWorld->m_pSelectedObj && pDoc->m_bSelectObjPoints)
  803. {
  804. GLfloat fMouseCoordinate[4];
  805. C3dPoint* pPoint;
  807. // Convert our point to 3D coordinates
  808. m_Camera.GetWorldCoord(point.x, point.y, m_fMouseZCoord, fMouseCoordinate);
  810. // Find a point from the selected object
  811. pPoint = pWorld->m_pSelectedObj->FindPoint(&m_Camera,
  812. m_fLeftButtonDownCoord[X],
  813. m_fLeftButtonDownCoord[Y],
  814. m_fLeftButtonDownCoord[Z]);
  815. if(pPoint)
  816. {
  817. // Save the selected point and set the selected coordinates
  818. pWorld->m_pSelectedPnt = pPoint;
  819. pWorld->m_pSelectedObj->GetObjPointOrigin(pPoint,
  820.   &m_fSelectedCoord[X],
  821.   &m_fSelectedCoord[Y],
  822.   &m_fSelectedCoord[Z]);
  824. // Save the inverse rotation transformation matrix of the
  825. // object.  We will use this value in the OnMouseMove() function.
  827. // (We saved this matrix because an object, ie. light objects,
  828. // may modify their rotation values.  Its also saves more
  829. // processing time, as we need this matrix to calcualte the 
  830. // object coordinates.)
  831. pWorld->m_pSelectedObj->GetInvRotationMatrix(g_SelctedObjMatrix);
  832. }
  833. else if(pWorld->m_pSelectedPnt)
  834. {
  835. // Set the selected coordinates
  836. m_fSelectedCoord[X] = pWorld->m_pSelectedPnt->m_fOrigin[X];
  837. m_fSelectedCoord[Y] = pWorld->m_pSelectedPnt->m_fOrigin[Y];
  838. m_fSelectedCoord[Z] = pWorld->m_pSelectedPnt->m_fOrigin[Z];
  839. }
  842. // Update the Coordinate Dialog Toolbar
  843. pFrame->m_wndCoordDlgBar.UpdateDialogData();
  844. }
  846. // Selecting an Object?
  847. else if((pDoc->m_bSelectParentObj && pDoc->m_bSelect) ||
  848. (pDoc->m_bSelectChildObj  && pDoc->m_bSelect))
  849. {
  850. // Make this view the current OpenGL rendering context...
  851. if(!the3dEngine.EnableRC(m_pDC->GetSafeHdc(), m_hRC, TRUE))
  852. return;
  854. // Did we select and object?
  855. C3dObject* pObject = pWorld->ProcessSelection(&m_Camera, point.x, point.y, pDoc->m_bSelectParentObj);
  856. if(pObject)
  857. {
  858. // Find the object in the tree view.
  859. HTREEITEM hItem = pFrame->m_wndTreeDlgBar.FindObject(pObject);
  860. if(hItem)
  861.  pFrame->m_wndTreeDlgBar.SelectItem(hItem);
  863. // Save the pointer 
  864. pWorld->m_pSelectedObj = pObject;
  865. pWorld->m_pSelectedPnt = NULL;
  867. // Update the Coordinate Dialog Toolbar
  868. pFrame->m_wndCoordDlgBar.UpdateDialogData();
  869. }
  870. else
  871. {
  872. pFrame->m_wndTreeDlgBar.SelectItem(NULL);
  874. pWorld->m_pSelectedObj = NULL;
  875. }
  877. // Releases the device context that is used by the rendering context
  878. // to allow other rendering contexts to co-exist.
  879. the3dEngine.EnableRC(NULL, NULL, FALSE);
  880. }
  882. // Save the appropriate selected Object's origin or translation value,
  883. // or the selected Points origin.  This value will be used in the CMyglView::
  884. // OnMouseMove() function for later modification.
  885. if(pObj)
  886. {
  887. if(pDoc->m_bSelectParentObj || pDoc->m_bSelectChildObj)
  888. // Save the object's original origin
  889. pObj->GetOrigin(&m_fSelectedCoord[X],
  890. &m_fSelectedCoord[Y],
  891. &m_fSelectedCoord[Z]);
  892. if(pDoc->m_bSelectObjAxis)
  893. {
  894. // Save the object's original axis origin (Translation)
  895. pObj->GetTranslation(&m_fSelectedCoord[X],
  896.  &m_fSelectedCoord[Y],
  897.  &m_fSelectedCoord[Z]);
  898. // Save the object's original origin
  899. pObj->GetOrigin(&m_fSelectedCoord2[X],
  900. &m_fSelectedCoord2[Y],
  901. &m_fSelectedCoord2[Z]);
  902. }
  903. if(pDoc->m_bSelectObjTextureAxis)
  904. {
  905. if(pObj->m_pTexture)
  906. // Save the object's original texture axis origin
  907. pObj->m_pTexture->GetTextureOrigin3f(&m_fSelectedCoord[X],
  908.  &m_fSelectedCoord[Y],
  909.  &m_fSelectedCoord[Z]);
  910. }
  911. }
  913. // Save the camera origin coordinates.  This value will be used in the CMyglView::
  914. // OnMouseMove() function for later modification.
  915. if(pDoc->m_bSelectCamera)
  916. // Save the object's original origin
  917. m_Camera.GetOrigin(&m_fSelectedCoord[X],
  918.    &m_fSelectedCoord[Y],
  919.    &m_fSelectedCoord[Z]);
  921. // Are we painting?
  922. if(pDoc->m_bPaint)
  923. {
  924. if(pDoc->m_bSelectParentObj || pDoc->m_bSelectChildObj)
  925. {
  926. // Paint the object
  927. if(pWorld->m_pSelectedObj)
  928. {
  929. pWorld->m_pSelectedObj->SetColor4fv(&pFrame->m_wndColorDlgBar.m_Color);
  930. pWorld->m_pSelectedObj->m_bBuildLists = TRUE;
  931. pWorld->m_pSelectedObj->m_bSolidColor = TRUE;
  932. }
  933. }
  934. if(pDoc->m_bSelectObjPoints)
  935. {
  936. if(pWorld->m_pSelectedPnt)
  937. {
  938. // Paint the point
  939. pWorld->m_pSelectedPnt->m_Color.SetColor4fv(&pFrame->m_wndColorDlgBar.m_Color);
  941. // If the point belongs to an object, force a rebuild of its
  942. // display list.
  943. if(pWorld->m_pSelectedObj)
  944. {
  945. pWorld->m_pSelectedObj->m_bBuildLists = TRUE;
  946. pWorld->m_pSelectedObj->m_bSolidColor = FALSE;
  947. }
  948. }
  949. }
  950. }
  952. // Force a repaint of the window
  953. pDoc->UpdateAllViews(NULL);
  955. CView::OnLButtonDown(nFlags, point);
  956. }
  958. void CMyglView::OnLButtonUp(UINT nFlags, CPoint point) 
  959. {
  960. // Reset the last Left button down mouse screen position an its
  961. // 3d coordinate.
  962. m_CPointLeftButtonDown.x = 0;
  963. m_CPointLeftButtonDown.y = 0;
  964. VecClear3f(&m_fLeftButtonDownCoord[0]);
  967. CView::OnLButtonUp(nFlags, point);
  968. }
  970. void CMyglView::OnLButtonDblClk(UINT nFlags, CPoint point) 
  971. {
  972. // Get a pointer to our main window frame
  973. CMainFrame* pFrame = (CMainFrame*) AfxGetApp()->m_pMainWnd;
  974. ASSERT_VALID(pFrame);
  976. // Get a pointer to our view's document
  977. CMyglDoc* pDoc = GetDocument();
  978. ASSERT_VALID(pDoc);
  980. // Get a pointer to our document's 3dWorld
  981. C3dWorld* pWorld = pDoc->m_pWorld;
  982. ASSERT_VALID(pWorld);
  984. // Make the rendering context current
  985. if(!the3dEngine.EnableRC(m_pDC->GetSafeHdc(), m_hRC, TRUE))
  986. return;
  988. // Did we select and object?
  989. C3dObject* pObject = pWorld->ProcessSelection(&m_Camera, point.x, point.y, pDoc->m_bSelectParentObj);
  991. // Releases the device context that is used by the rendering context
  992. // to allow other rendering contexts to co-exist.
  993. the3dEngine.EnableRC(NULL, NULL, FALSE);
  995. if(pObject)
  996. {
  997. // Save the object pointer
  998. pWorld->m_pSelectedObj = pObject;
  1000. // Update the Coordinate Dialog Toolbar
  1001. pFrame->m_wndCoordDlgBar.UpdateDialogData();
  1003. // Update the TreeView Dialog Toolbar
  1004. pFrame->m_wndTreeDlgBar.DisplaySelected(pObject);
  1006. // Display the Object's attributes dialog box
  1007. pWorld->m_pSelectedObj->EditAttributes(this, pWorld);
  1009. // Force selection of parent objects
  1010. pDoc->UserSelectedAnObject();
  1012. // Force a repaint of the window
  1013. pDoc->UpdateAllViews(NULL);
  1014. }
  1015. else
  1016. pWorld->m_pSelectedObj = NULL;
  1019. CView::OnLButtonDblClk(nFlags, point);
  1020. }
  1022. void CMyglView::OnRButtonDown(UINT nFlags, CPoint point) 
  1023. {
  1024. m_nInitMouseZ = point.y;
  1026. CView::OnRButtonDown(nFlags, point);
  1027. }
  1029. void CMyglView::OnMouseMove(UINT nFlags, CPoint point) 
  1030. {
  1031. VECTORF fMouseCoordinate;
  1033. CMainFrame* pFrame = (CMainFrame*) AfxGetApp()->m_pMainWnd;
  1034. ASSERT_VALID(pFrame);
  1036. // Get a pointer to our view's document
  1037. CMyglDoc* pDoc = GetDocument();
  1038. ASSERT_VALID(pDoc);
  1040. // Get a pointer to our document's 3dWorld
  1041. C3dWorld* pWorld = pDoc->m_pWorld;
  1042. ASSERT_VALID(pWorld);
  1044. // Get a pointer to our worlds' selected object and
  1045. // selected light
  1046. C3dObject* pObj =  pWorld->m_pSelectedObj;
  1048. // Calculate a new Mouse Z value.  Mouse 'Z' is mapped to 
  1049. // the mouse y position if the Right Mouse button is down
  1050. if(nFlags & MK_RBUTTON) {
  1051. int deltaY = m_nInitMouseZ - point.y;
  1052. m_nInitMouseZ = point.y;
  1053. m_nMouseZ += deltaY;
  1054. }
  1056. // Convert the mouse point into world coordinates
  1057. m_Camera.GetWorldCoord(point.x,
  1058.    point.y,
  1059.    m_fMouseZCoord,
  1060.    fMouseCoordinate);
  1062. // Now that we have the mouse coordinate, subtract the Left button down
  1063. // coordinate.
  1064. if(nFlags & MK_LBUTTON)
  1065. VecSubf(fMouseCoordinate, m_fLeftButtonDownCoord, fMouseCoordinate);
  1067. // Lock the mouse coordinates?
  1068. fMouseCoordinate[X] *= (float)pDoc->m_bUnLockXAxis;
  1069. fMouseCoordinate[Y] *= (float)pDoc->m_bUnLockYAxis;
  1070. fMouseCoordinate[Z] *= (float)pDoc->m_bUnLockZAxis;
  1072. if(pDoc->m_bSnapToGrid)
  1073. {
  1074. // Round the 3d point to the nearest grid point
  1075. pWorld->m_pGrid->PointToGrid(&fMouseCoordinate[X],
  1076.  &fMouseCoordinate[Y],
  1077.  &fMouseCoordinate[Z]); 
  1078. }
  1082. // Object selected & left button down?
  1083. if(pObj && (nFlags & MK_LBUTTON) )
  1084. {
  1085. // Modify Object?
  1086. if(pDoc->m_bSelectParentObj || pDoc->m_bSelectChildObj)
  1087. {
  1088. // Move the selected object?
  1089. if(pDoc->m_bMove)
  1090. {
  1091. GLfloat x, y, z;
  1093. // Does this object have a parent?
  1094. if(pObj->m_pParent)
  1095. {
  1096. Matx4x4 ObjRotationMatrix;
  1098. // Get the inverse transformation matrix of the parent 
  1099. // object and multiply the mouse coordinate so that we
  1100. // move the object in World coordinate space.
  1101. pObj->m_pParent->GetInvRotationMatrix(ObjRotationMatrix);
  1102. VecTransformf(fMouseCoordinate,
  1103.   fMouseCoordinate,
  1104.   ObjRotationMatrix);
  1105. }
  1107. // Note:  We saved the Selected coordinate in the 
  1108. //   WM_LBUTTONDOWN message handler.
  1109. x = fMouseCoordinate[X]+m_fSelectedCoord[X];
  1110. y = fMouseCoordinate[Y]+m_fSelectedCoord[Y];
  1111. z = fMouseCoordinate[Z]+m_fSelectedCoord[Z];
  1112. pObj->SetOrigin(x, y, z);
  1113. }
  1115. // Rotate the selected object?
  1116. else if(pDoc->m_bRotate)
  1117. {
  1118. CSize rotate = m_CPointLeftButtonDown - point;
  1119. m_CPointLeftButtonDown = point;
  1121. if(m_Camera.m_iViewType == VIEW_ISO) {
  1122. pObj->m_fRotation[Z] -= rotate.cx*g_fMouseRotateMult*pDoc->m_bUnLockZAxis;
  1123. pObj->m_fRotation[X] -= rotate.cy*g_fMouseRotateMult*pDoc->m_bUnLockXAxis;
  1124. }
  1125. else if(m_Camera.m_iViewType == VIEW_SIDE) {
  1126. pObj->m_fRotation[Z] -= rotate.cx*g_fMouseRotateMult*pDoc->m_bUnLockZAxis;
  1127. pObj->m_fRotation[Y] -= rotate.cy*g_fMouseRotateMult*pDoc->m_bUnLockYAxis;
  1128. }
  1129. else if(m_Camera.m_iViewType == VIEW_TOP) {
  1130. pObj->m_fRotation[Y] -= rotate.cx*g_fMouseRotateMult*pDoc->m_bUnLockYAxis;
  1131. pObj->m_fRotation[X] -= rotate.cy*g_fMouseRotateMult*pDoc->m_bUnLockXAxis;
  1132. }
  1133. else if(m_Camera.m_iViewType == VIEW_FRONT) {
  1134. pObj->m_fRotation[Z] -= rotate.cx*g_fMouseRotateMult*pDoc->m_bUnLockZAxis;
  1135. pObj->m_fRotation[X] -= rotate.cy*g_fMouseRotateMult*pDoc->m_bUnLockXAxis;
  1136. }
  1137.     }
  1139. // Scale the selected object?
  1140. else if(pDoc->m_bScale)
  1141. {
  1142. CSize scale = m_CPointLeftButtonDown - point;
  1143. m_CPointLeftButtonDown = point;
  1145. if(m_Camera.m_iViewType == VIEW_ISO) {
  1146. pObj->m_fScale[X] -= (float)scale.cx*g_fMouseScaleMult*pDoc->m_bUnLockXAxis;
  1147. pObj->m_fScale[Y] -= (float)scale.cx*g_fMouseScaleMult*pDoc->m_bUnLockYAxis;
  1148. pObj->m_fScale[Z] -= (float)scale.cy*g_fMouseScaleMult*pDoc->m_bUnLockZAxis;
  1149. }
  1150. else if(m_Camera.m_iViewType == VIEW_SIDE) {
  1151. pObj->m_fScale[Y] -= (float)scale.cx*g_fMouseScaleMult*pDoc->m_bUnLockYAxis;
  1152. pObj->m_fScale[Z] -= (float)scale.cy*g_fMouseScaleMult*pDoc->m_bUnLockZAxis;
  1153. }
  1154. else if(m_Camera.m_iViewType == VIEW_TOP) {
  1155. pObj->m_fScale[X] -= (float)scale.cx*g_fMouseScaleMult*pDoc->m_bUnLockXAxis;
  1156. pObj->m_fScale[Y] -= (float)scale.cy*g_fMouseScaleMult*pDoc->m_bUnLockYAxis;
  1157. }
  1158. else if(m_Camera.m_iViewType == VIEW_FRONT) {
  1159. pObj->m_fScale[X] -= (float)scale.cx*g_fMouseScaleMult*pDoc->m_bUnLockXAxis;
  1160. pObj->m_fScale[Z] -= (float)scale.cy*g_fMouseScaleMult*pDoc->m_bUnLockZAxis;
  1161. }
  1162.     }
  1163. }
  1165. // Modify Object point?
  1166. if(pDoc->m_bSelectObjPoints)
  1167. {
  1168. // The object point was 'Selected' OnLButtonDown()
  1169. C3dPoint* pPnt = pWorld->m_pSelectedPnt;
  1171. // Do we have an object and point selected?
  1172. if(pPnt && pObj)
  1173. {
  1174. // Move the Selected Point?
  1175. if(pDoc->m_bMove)
  1176. {
  1177. // Matx4x4 ObjInvRotationMatrix;
  1178. GLfloat x, y, z;
  1180. // We saved the object inverse rotation matrix in the 
  1181. // OnLButtonDown() function.  (We saved this matrix because
  1182. // an object, ie. light objects, may modify their rotation
  1183. // values.  Its also saves more processing time..)
  1185. // Use the inverse rotation transformation matrix of the
  1186. // object and multiply it by the mouse coordinate so that
  1187. // we move the point in the World coordinate space
  1189. // pObj->GetInvRotationMatrix(ObjInvRotationMatrix);
  1190. VecTransformf(fMouseCoordinate,
  1191.   fMouseCoordinate,
  1192.   g_SelctedObjMatrix);
  1193. //   ObjInvRotationMatrix);
  1195. // Note:  We saved the Selected coordinate in the 
  1196. //   WM_LBUTTONDOWN message handler.
  1197. x = fMouseCoordinate[X]+m_fSelectedCoord[X];
  1198. y = fMouseCoordinate[Y]+m_fSelectedCoord[Y];
  1199. z = fMouseCoordinate[Z]+m_fSelectedCoord[Z];
  1200. pObj->SetObjPointOrigin(pPnt, x, y, z);
  1202. // Rebuild the object
  1203. pObj->m_bBuildLists = TRUE;
  1204. }
  1205. }
  1207. // Update the Coordinate Dialog Toolbar
  1208. pFrame->m_wndCoordDlgBar.UpdateDialogData();
  1210. // Force a repaint of the window
  1211. pDoc->UpdateAllViews(NULL);
  1212. }
  1214. // Translate the selected objects' axis?
  1215. if(pDoc->m_bSelectObjAxis)
  1216. {
  1217. // Move the selected object?
  1218. if(pDoc->m_bMove)
  1219. {
  1220. GLfloat x, y, z;
  1221. Matx4x4 ObjRotationMatrix;
  1223. // Does this object have a parent?
  1224. if(pObj->m_pParent)
  1225. {
  1226. VECTORF fMousePosn;
  1228. // Get the inverse rotation matrix of the parent object
  1229. // and multiply the mouse coordinate so that we move the
  1230. // object's origin in World coordinate space.
  1231. pObj->m_pParent->GetInvRotationMatrix(ObjRotationMatrix);
  1232. VecTransformf(fMouseCoordinate,
  1233.   fMousePosn,
  1234.   ObjRotationMatrix);
  1235. // Note:  We saved the Selected coordinate in the 
  1236. //   WM_LBUTTONDOWN message handler.
  1237. pObj->m_fOrigin[X] = m_fSelectedCoord2[X]+fMousePosn[X];
  1238. pObj->m_fOrigin[Y] = m_fSelectedCoord2[Y]+fMousePosn[Y];
  1239. pObj->m_fOrigin[Z] = m_fSelectedCoord2[Z]+fMousePosn[Z];
  1240. }
  1241. else
  1242. {
  1243. // Object does not have a parent, mouse coordinates are already
  1244. // in world coordinate space
  1245. pObj->m_fOrigin[X] = m_fSelectedCoord2[X]+fMouseCoordinate[X];
  1246. pObj->m_fOrigin[Y] = m_fSelectedCoord2[Y]+fMouseCoordinate[Y];
  1247. pObj->m_fOrigin[Z] = m_fSelectedCoord2[Z]+fMouseCoordinate[Z];
  1248. }
  1250. // Get the inverse rotation matrix of this object, (with new origin)
  1251. // and multiply the mouse coordinate so that we move the object 
  1252. // origin offset in World coordinate space.
  1253. pObj->GetInvRotationMatrix(ObjRotationMatrix);
  1254. VecTransformf(fMouseCoordinate,
  1255.   fMouseCoordinate,
  1256.   ObjRotationMatrix);
  1258. // Note:  We saved the Selected coordinate in the 
  1259. //   WM_LBUTTONDOWN message handler.
  1260. x = m_fSelectedCoord[X]-fMouseCoordinate[X];
  1261. y = m_fSelectedCoord[Y]-fMouseCoordinate[Y];
  1262. z = m_fSelectedCoord[Z]-fMouseCoordinate[Z];
  1264. pObj->SetTranslation(x, y, z);
  1265. }
  1266. }
  1268. // Translate the selected objects' texture axis?
  1269. else if(pDoc->m_bSelectObjTextureAxis)
  1270. {
  1271. if(pObj->m_pTexture)
  1272. {
  1273. // Move the selected object?
  1274. if(pDoc->m_bMove)
  1275. {
  1276. GLfloat x, y, z;
  1277. Matx4x4 ObjRotationMatrix;
  1278. /*
  1279. // Does this object have a parent?
  1280. if(pObj->m_pParent)
  1281. {
  1282. VECTORF fMousePosn;
  1284. // Get the inverse rotation matrix of the parent object
  1285. // and multiply the mouse coordinate so that we move the
  1286. // object's origin in World coordinate space.
  1287. pObj->m_pParent->GetInvRotationMatrix(ObjRotationMatrix);
  1288. VecTransformf(fMouseCoordinate,
  1289.   fMousePosn,
  1290.   ObjRotationMatrix);
  1291. // Note:  We saved the Selected coordinate in the 
  1292. //   WM_LBUTTONDOWN message handler.
  1293. pObj->m_fOrigin[X] = m_fSelectedCoord2[X]+fMousePosn[X];
  1294. pObj->m_fOrigin[Y] = m_fSelectedCoord2[Y]+fMousePosn[Y];
  1295. pObj->m_fOrigin[Z] = m_fSelectedCoord2[Z]+fMousePosn[Z];
  1296. }
  1297. else
  1298. {
  1299. // Object does not have a parent, mouse coordinates are already
  1300. // in world coordinate space
  1301. pObj->m_fOrigin[X] = m_fSelectedCoord2[X]+fMouseCoordinate[X];
  1302. pObj->m_fOrigin[Y] = m_fSelectedCoord2[Y]+fMouseCoordinate[Y];
  1303. pObj->m_fOrigin[Z] = m_fSelectedCoord2[Z]+fMouseCoordinate[Z];
  1304. }
  1305. */
  1306. // Get the inverse rotation matrix of this object, (with new origin)
  1307. // and multiply the mouse coordinate so that we move the object 
  1308. // origin offset in World coordinate space.
  1309. pObj->GetInvRotationMatrix(ObjRotationMatrix);
  1310. VecTransformf(fMouseCoordinate,
  1311.   fMouseCoordinate,
  1312.   ObjRotationMatrix);
  1314. // Note:  We saved the Selected coordinate in the 
  1315. //   WM_LBUTTONDOWN message handler.
  1316. x = m_fSelectedCoord[X]-fMouseCoordinate[X];
  1317. y = m_fSelectedCoord[Y]-fMouseCoordinate[Y];
  1318. z = m_fSelectedCoord[Z]-fMouseCoordinate[Z];
  1320. pObj->m_pTexture->SetTextureOrigin3f(x, y, z);
  1321. pObj->m_bBuildLists = TRUE;
  1322. }
  1323. }
  1324. }
  1326. // Update the Coordinate Dialog Toolbar
  1327. pFrame->m_wndCoordDlgBar.UpdateDialogData();
  1329. // Force a repaint of the window
  1330. pDoc->UpdateAllViews(NULL);
  1331. }
  1333. // World point selected & left button down?
  1334. C3dPoint* pPnt = pWorld->m_pSelectedPnt;
  1335. if(pPnt && (nFlags & MK_LBUTTON) )
  1336. {
  1337. if(pDoc->m_bSelectPoint)
  1338. {
  1339. // Move the Selected Point?
  1340. if(pDoc->m_bMove)
  1341. {
  1342. GLfloat x, y, z;
  1343. // Note:  We saved the Selected coordinate in the 
  1344. //   WM_LBUTTONDOWN message handler.
  1345. x = fMouseCoordinate[X]+m_fSelectedCoord[X];
  1346. y = fMouseCoordinate[Y]+m_fSelectedCoord[Y];
  1347. z = fMouseCoordinate[Z]+m_fSelectedCoord[Z];
  1348. pPnt->SetOrigin(x, y, z);
  1349. }
  1350. }
  1352. // Update the Coordinate Dialog Toolbar
  1353. pFrame->m_wndCoordDlgBar.UpdateDialogData();
  1355. // Force a repaint of the window
  1356. pDoc->UpdateAllViews(NULL);
  1357. }
  1359. if(pDoc->m_bSelectCamera && (nFlags & MK_LBUTTON))
  1360. {
  1361. // Move the camera?
  1362. if(pDoc->m_bMove)
  1363. {
  1364. GLfloat x, y, z;
  1365. VECTORF temp, mousePosn;
  1366. Matx4x4 RotationMatrix;
  1368. // Transform the mouse coordinates to camera coordinates
  1369. Vec4f(fMouseCoordinate[X],
  1370.   fMouseCoordinate[Y],
  1371.   fMouseCoordinate[Z],
  1372.   1.0f,
  1373.   temp);
  1374. m_Camera.GetRotationMatrix(RotationMatrix);
  1375. VecTransformf(temp, mousePosn, RotationMatrix);
  1377. // Subtract the transformed mouse move coordinates from
  1378. // the user selected OnLButtonDown coordinate and set
  1379. // the camera origin accordinly.
  1380. //
  1381. // Note:  We saved the initial camera coordinates
  1382. //   m_fSelectedCoord values in the
  1383. //   WM_LBUTTONDOWN message handler.
  1384. VecSubf(m_fSelectedCoord, mousePosn, m_fSelectedCoord);
  1385. UnVec3f(m_fSelectedCoord, &x, &y, &z);
  1386. m_Camera.SetOrigin(x, y, z);
  1387. }
  1389. // Rotate the camera?
  1390. if(pDoc->m_bRotate)
  1391. {
  1392. CSize rotate = m_CPointLeftButtonDown - point;
  1393. m_CPointLeftButtonDown = point;
  1395. if(m_Camera.m_iViewType == VIEW_ISO) {
  1396. m_Camera.m_fRotation[Z] -= rotate.cx*g_fMouseRotateMult*pDoc->m_bUnLockZAxis;
  1397. m_Camera.m_fRotation[X] -= rotate.cy*g_fMouseRotateMult*pDoc->m_bUnLockXAxis;
  1398. }
  1399. else if(m_Camera.m_iViewType == VIEW_SIDE) {
  1400. m_Camera.m_fRotation[Y] -= rotate.cx*g_fMouseRotateMult*pDoc->m_bUnLockZAxis;
  1401. m_Camera.m_fRotation[X] -= rotate.cy*g_fMouseRotateMult*pDoc->m_bUnLockYAxis;
  1402. }
  1403. else if(m_Camera.m_iViewType == VIEW_TOP) {
  1404. m_Camera.m_fRotation[Z] -= rotate.cx*g_fMouseRotateMult*pDoc->m_bUnLockYAxis;
  1405. m_Camera.m_fRotation[X] -= rotate.cy*g_fMouseRotateMult*pDoc->m_bUnLockXAxis;
  1406. }
  1407. else if(m_Camera.m_iViewType == VIEW_FRONT) {
  1408. m_Camera.m_fRotation[Y] -= rotate.cx*g_fMouseRotateMult*pDoc->m_bUnLockZAxis;
  1409. m_Camera.m_fRotation[X] -= rotate.cy*g_fMouseRotateMult*pDoc->m_bUnLockXAxis;
  1410. }
  1411.     }
  1412. // Update the Coordinate Dialog Toolbar
  1413. pFrame->m_wndCoordDlgBar.UpdateDialogData();
  1415. // Force a repaint of the window
  1416. pDoc->UpdateAllViews(NULL);
  1417. }
  1419. // Display the world coordinates on the status bar if we
  1420. // are not animating the world..
  1421. if(!pWorld->m_bAnimate)
  1422. DisplayWorldCoord(fMouseCoordinate);
  1424. CView::OnMouseMove(nFlags, point);
  1425. }
  1427. void CMyglView::OnViewPerspective() 
  1428. {
  1429. if(m_Camera.m_bPerspective)
  1430. m_Camera.m_bPerspective = FALSE;
  1431. else
  1432. m_Camera.m_bPerspective = TRUE;
  1434. // Make this view the current OpenGL rendering context...
  1435. if(!the3dEngine.EnableRC(GetDC()->m_hDC, m_hRC, TRUE))
  1436. return;
  1438. // Reset our camera view
  1439. m_Camera.ResetView(NULL, NULL);
  1441. // Releases the device context that is used by the rendering context
  1442. // to allow other rendering contexts to co-exist.
  1443. the3dEngine.EnableRC(NULL, NULL, FALSE);
  1445. // Force a repaint of the window
  1446. InvalidateRect(NULL, FALSE);
  1447. }
  1449. void CMyglView::OnUpdateViewPerspective(CCmdUI* pCmdUI) 
  1450. {
  1451. pCmdUI->SetCheck(m_Camera.m_bPerspective);
  1452. }
  1454. void CMyglView::OnViewZoomIn() 
  1455. {
  1456. m_Camera.m_fOrigin[Z] = m_Camera.m_fOrigin[Z]/2;
  1458. // Make this view the current OpenGL rendering context...
  1459. if(!the3dEngine.EnableRC(GetDC()->m_hDC, m_hRC, TRUE))
  1460. return;
  1462. // Reset our camera view
  1463. m_Camera.ResetView(NULL, NULL);
  1465. // Releases the device context that is used by the rendering context
  1466. // to allow other rendering contexts to co-exist.
  1467. the3dEngine.EnableRC(NULL, NULL, FALSE);
  1469. // Force a repaint of the window
  1470. InvalidateRect(NULL, FALSE);
  1471. }
  1473. void CMyglView::OnViewZoomOut() 
  1474. {
  1475. m_Camera.m_fOrigin[Z] = m_Camera.m_fOrigin[Z]*2;
  1477. // Make this view the current OpenGL rendering context...
  1478. if(!the3dEngine.EnableRC(GetDC()->m_hDC, m_hRC, TRUE))
  1479. return;
  1481. // Reset our camera view
  1482. m_Camera.ResetView(NULL, NULL);
  1484. // Releases the device context that is used by the rendering context
  1485. // to allow other rendering contexts to co-exist.
  1486. the3dEngine.EnableRC(NULL, NULL, FALSE);
  1488. // Force a repaint of the window
  1489. InvalidateRect(NULL, FALSE);
  1490. }
  1492. void CMyglView::OnAnimateSceen() 
  1493. {
  1494. // Get a pointer to our view's document
  1495. CMyglDoc* pDoc = GetDocument();
  1496. ASSERT_VALID(pDoc);
  1498. // Get a pointer to our document's 3dWorld
  1499. C3dWorld* pWorld = pDoc->m_pWorld;
  1500. ASSERT_VALID(pWorld);
  1502. // Toggle the animation flag
  1503. pWorld->m_bAnimate = !pWorld->m_bAnimate;
  1505. if(!pWorld->m_bAnimate)
  1506. pDoc->m_dTime = 0.0; // Reset the time index
  1507. }
  1509. void CMyglView::OnUpdateAnimateSceen(CCmdUI* pCmdUI) 
  1510. {
  1511. // Get a pointer to our view's document
  1512. CMyglDoc* pDoc = GetDocument();
  1513. ASSERT_VALID(pDoc);
  1515. // Get a pointer to our document's 3dWorld
  1516. C3dWorld* pWorld = pDoc->m_pWorld;
  1517. ASSERT_VALID(pWorld);
  1519. pCmdUI->SetCheck(pWorld->m_bAnimate);
  1520. }
  1522. void CMyglView::OnViewWireFrame() 
  1523. {
  1524. // Get a pointer to our view's document
  1525. CMyglDoc* pDoc = GetDocument();
  1526. ASSERT_VALID(pDoc);
  1528. // Get a pointer to our document's 3dWorld
  1529. C3dWorld* pWorld = pDoc->m_pWorld;
  1530. ASSERT_VALID(pWorld);
  1532. // Set the rendering mode flag and force a 
  1533. // rebuild of all object display lists
  1534. pWorld->m_iRenderMode = RENDER_WIREFRAME;
  1535. pWorld->RebuildAllObjects();
  1537. // Force a repaint of the window
  1538. pDoc->UpdateAllViews(NULL);
  1539. }
  1541. void CMyglView::OnUpdateViewWireFrame(CCmdUI* pCmdUI) 
  1542. {
  1543. // Get a pointer to our view's document
  1544. CMyglDoc* pDoc = GetDocument();
  1545. ASSERT_VALID(pDoc);
  1547. // Get a pointer to our document's 3dWorld
  1548. C3dWorld* pWorld = pDoc->m_pWorld;
  1549. ASSERT_VALID(pWorld);
  1551. pCmdUI->SetCheck(pWorld->m_iRenderMode == RENDER_WIREFRAME);
  1552. }
  1554. void CMyglView::OnViewFlatShade() 
  1555. {
  1556. // Get a pointer to our view's document
  1557. CMyglDoc* pDoc = GetDocument();
  1558. ASSERT_VALID(pDoc);
  1560. // Get a pointer to our document's 3dWorld
  1561. C3dWorld* pWorld = pDoc->m_pWorld;
  1562. ASSERT_VALID(pWorld);
  1564. // Set the rendering mode flag and force a 
  1565. // rebuild of all object display lists
  1566. pWorld->m_iRenderMode = RENDER_FLAT;
  1567. pWorld->RebuildAllObjects();
  1569. // Force a repaint of the window
  1570. pDoc->UpdateAllViews(NULL);
  1571. }
  1573. void CMyglView::OnUpdateViewFlatShade(CCmdUI* pCmdUI) 
  1574. {
  1575. // Get a pointer to our view's document
  1576. CMyglDoc* pDoc = GetDocument();
  1577. ASSERT_VALID(pDoc);
  1579. // Get a pointer to our document's 3dWorld
  1580. C3dWorld* pWorld = pDoc->m_pWorld;
  1581. ASSERT_VALID(pWorld);
  1583. pCmdUI->SetCheck(pWorld->m_iRenderMode == RENDER_FLAT);
  1584. }
  1586. void CMyglView::OnViewSmoothShade() 
  1587. {
  1588. // Get a pointer to our view's document
  1589. CMyglDoc* pDoc = GetDocument();
  1590. ASSERT_VALID(pDoc);
  1592. // Get a pointer to our document's 3dWorld
  1593. C3dWorld* pWorld = pDoc->m_pWorld;
  1594. ASSERT_VALID(pWorld);
  1596. // Set the rendering mode flag and force a 
  1597. // rebuild of all object display lists
  1598. pWorld->m_iRenderMode = RENDER_SMOOTH;
  1599. pWorld->RebuildAllObjects();
  1601. // Force a repaint of the window
  1602. pDoc->UpdateAllViews(NULL);
  1603. }
  1605. void CMyglView::OnUpdateViewSmoothShade(CCmdUI* pCmdUI) 
  1606. {
  1607. // Get a pointer to our view's document
  1608. CMyglDoc* pDoc = GetDocument();
  1609. ASSERT_VALID(pDoc);
  1611. // Get a pointer to our document's 3dWorld
  1612. C3dWorld* pWorld = pDoc->m_pWorld;
  1613. ASSERT_VALID(pWorld);
  1615. pCmdUI->SetCheck(pWorld->m_iRenderMode == RENDER_SMOOTH);
  1616. }
  1618. void CMyglView::OnViewOutline() 
  1619. {
  1620. // Get a pointer to our view's document
  1621. CMyglDoc* pDoc = GetDocument();
  1622. ASSERT_VALID(pDoc);
  1624. // Get a pointer to our document's 3dWorld
  1625. C3dWorld* pWorld = pDoc->m_pWorld;
  1626. ASSERT_VALID(pWorld);
  1628. // Set the rendering mode flag and force a 
  1629. // rebuild of all object display lists
  1630. pWorld->m_iRenderMode = RENDER_OUTLINE;
  1631. pWorld->RebuildAllObjects();
  1633. // Force a repaint of the window
  1634. pDoc->UpdateAllViews(NULL);
  1635. }
  1637. void CMyglView::OnUpdateViewOutline(CCmdUI* pCmdUI) 
  1638. {
  1639. // Get a pointer to our view's document
  1640. CMyglDoc* pDoc = GetDocument();
  1641. ASSERT_VALID(pDoc);
  1643. // Get a pointer to our document's 3dWorld
  1644. C3dWorld* pWorld = pDoc->m_pWorld;
  1645. ASSERT_VALID(pWorld);
  1647. pCmdUI->SetCheck(pWorld->m_iRenderMode == RENDER_OUTLINE);
  1648. }
  1650. void CMyglView::OnViewDisplayAxis() 
  1651. {
  1652. // Get a pointer to our view's document
  1653. CMyglDoc* pDoc = GetDocument();
  1654. ASSERT_VALID(pDoc);
  1656. // Get a pointer to our document's 3dWorld
  1657. C3dWorld* pWorld = pDoc->m_pWorld;
  1658. ASSERT_VALID(pWorld);
  1660. if(pWorld->m_bDisplayAxis)
  1661. pWorld->m_bDisplayAxis = FALSE;
  1662. else
  1663. pWorld->m_bDisplayAxis = TRUE;
  1665. // Force a repaint of the window
  1666. pDoc->UpdateAllViews(NULL);
  1667. }
  1669. void CMyglView::OnUpdateViewDisplayAxis(CCmdUI* pCmdUI) 
  1670. {
  1671. // Get a pointer to our view's document
  1672. CMyglDoc* pDoc = GetDocument();
  1673. ASSERT_VALID(pDoc);
  1675. // Get a pointer to our document's 3dWorld
  1676. C3dWorld* pWorld = pDoc->m_pWorld;
  1677. ASSERT_VALID(pWorld);
  1679. pCmdUI->SetCheck(pWorld->m_bDisplayAxis);
  1680. }
  1682. void CMyglView::OnViewDisplayGrid() 
  1683. {
  1684. // Get a pointer to our view's document
  1685. CMyglDoc* pDoc = GetDocument();
  1686. ASSERT_VALID(pDoc);
  1688. // Get a pointer to our document's 3dWorld
  1689. C3dWorld* pWorld = pDoc->m_pWorld;
  1690. ASSERT_VALID(pWorld);
  1692. if(pWorld->m_bDisplayGrid)
  1693. pWorld->m_bDisplayGrid = FALSE;
  1694. else
  1695. pWorld->m_bDisplayGrid = TRUE;
  1697. // Force a repaint of the window
  1698. pDoc->UpdateAllViews(NULL);
  1699. }
  1701. void CMyglView::OnUpdateViewDisplayGrid(CCmdUI* pCmdUI) 
  1702. {
  1703. // Get a pointer to our view's document
  1704. CMyglDoc* pDoc = GetDocument();
  1705. ASSERT_VALID(pDoc);
  1707. // Get a pointer to our document's 3dWorld
  1708. C3dWorld* pWorld = pDoc->m_pWorld;
  1709. ASSERT_VALID(pWorld);
  1711. pCmdUI->SetCheck(pWorld->m_bDisplayGrid);
  1712. }
  1715. void CMyglView::OnViewIso() 
  1716. {
  1717. // Set the camera position
  1718. ViewIso();
  1720. // Force a repaint of the window
  1721. InvalidateRect(NULL, FALSE);
  1722. }
  1724. void CMyglView::OnUpdateViewIso(CCmdUI* pCmdUI) 
  1725. {
  1726. if(m_Camera.m_iViewType == VIEW_ISO)
  1727. pCmdUI->SetCheck(TRUE);
  1728. else
  1729. pCmdUI->SetCheck(FALSE);
  1730. }
  1732. void CMyglView::OnViewFront() 
  1733. {
  1734. // Set the camera position
  1735. ViewFront();
  1737. // Force a repaint of the window
  1738. InvalidateRect(NULL, FALSE);
  1739. }
  1741. void CMyglView::OnUpdateViewFront(CCmdUI* pCmdUI) 
  1742. {
  1743. if(m_Camera.m_iViewType == VIEW_FRONT)
  1744. pCmdUI->SetCheck(TRUE);
  1745. else
  1746. pCmdUI->SetCheck(FALSE);
  1747. }
  1749. void CMyglView::OnViewSide() 
  1750. {
  1751. // Set the camera position
  1752. ViewSide();
  1754. // Force a repaint of the window
  1755. InvalidateRect(NULL, FALSE);
  1756. }
  1758. void CMyglView::OnUpdateViewSide(CCmdUI* pCmdUI) 
  1759. {
  1760. if(m_Camera.m_iViewType == VIEW_SIDE)
  1761. pCmdUI->SetCheck(TRUE);
  1762. else
  1763. pCmdUI->SetCheck(FALSE);
  1764. }
  1766. void CMyglView::OnViewTop() 
  1767. {
  1768. // Set the camera position
  1769. ViewTop();
  1771. // Force a repaint of the window
  1772. InvalidateRect(NULL, FALSE);
  1773. }
  1775. void CMyglView::OnUpdateViewTop(CCmdUI* pCmdUI) 
  1776. {
  1777. if(m_Camera.m_iViewType == VIEW_TOP)
  1778. pCmdUI->SetCheck(TRUE);
  1779. else
  1780. pCmdUI->SetCheck(FALSE);
  1781. }
  1783. void CMyglView::DisplayWorldCoord(VECTORF fMouseCoordinate)
  1784. {
  1785. // Display the world coordinates on the status bar
  1787. char buf[80];
  1788. float x = fMouseCoordinate[X];
  1789. float y = fMouseCoordinate[Y];
  1790. float z = fMouseCoordinate[Z];
  1792. CMainFrame* pFrame = (CMainFrame*) AfxGetApp()->m_pMainWnd;
  1793. ASSERT(pFrame);
  1794. CStatusBar* pStatus = &pFrame->m_wndStatusBar;
  1795. ASSERT(pStatus);
  1796. sprintf(buf, "'X'= %5.2f  'Y'= %5.2f  'Z'= %5.2fn", x, y, z);
  1797. pStatus->SetPaneText(0, buf);
  1798. }
  1800. void CMyglView::OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags) 
  1801. {
  1802. // Get a pointer to our view's document
  1803. CMyglDoc* pDoc = GetDocument();
  1804. ASSERT_VALID(pDoc);
  1806. // Get a pointer to our document's 3dWorld
  1807. C3dWorld* pWorld = pDoc->m_pWorld;
  1808. ASSERT_VALID(pWorld);
  1810. if(pWorld->m_bFly)
  1811. {
  1812. switch (nChar)
  1813. {
  1814. case VK_UP:
  1815. m_Camera.m_fOrigin[Z] -=2.0f;
  1816. break;
  1818. case VK_DOWN:
  1819. m_Camera.m_fOrigin[Z] +=2.0f;
  1820. break;
  1822. case VK_LEFT:
  1823. m_Camera.m_fRotation[Z] -=2.0f;
  1824. break;
  1826. case VK_RIGHT:
  1827. m_Camera.m_fRotation[Z] +=2.0f;
  1828. break;
  1830. default:
  1831. break;
  1832. }
  1833. // Force a repaint of the window
  1834. InvalidateRect(NULL, FALSE);
  1835. }
  1839. if(!pWorld->m_bFly && nChar == VK_DELETE) // DELETE KEY PRESSED
  1840. {
  1841. if(pWorld->m_pSelectedObj)
  1842. {
  1843. // Get a pointer to the MainFrame
  1844. CMyglApp* pApp = (CMyglApp *)AfxGetApp();
  1845. ASSERT(pApp);
  1847. if(pApp->m_bConfirmObjectDeletion)
  1848. {
  1849. char buf[80];
  1850. sprintf(buf, "Do you want to delete object '%s'?n", pWorld->m_pSelectedObj->m_szName);
  1852. if(AfxMessageBox(buf, MB_OKCANCEL) == IDOK)
  1853. pWorld->DeleteObject(pWorld->m_pSelectedObj);
  1854. else
  1855. return;
  1856. }
  1857. else
  1858. pWorld->DeleteObject(pWorld->m_pSelectedObj);
  1860. pWorld->m_pSelectedObj = NULL;
  1862. // Get a pointer to the MainFrame
  1863. CMainFrame* pMainFrame = (CMainFrame*)pApp->m_pMainWnd;
  1864. ASSERT(pMainFrame);
  1866. // Force a refresh of the mainframe's dialog bars (TreeView, ..)
  1867. pMainFrame->SendMessage(WM_REFRESH_DLG_BAR, RDB_FORCE_REFRESH, 0L);
  1869. // Force a repaint of the documents views
  1870. pDoc->UpdateAllViews(NULL);
  1871. }
  1872. }
  1875. CView::OnKeyDown(nChar, nRepCnt, nFlags);
  1876. }
  1878. void CMyglView::OnCameraEdit() 
  1879. {
  1880. // Get a pointer to our view's document
  1881. CMyglDoc* pDoc = GetDocument();
  1882. ASSERT_VALID(pDoc);
  1884. // Get a pointer to our document's 3dWorld
  1885. C3dWorld* pWorld = pDoc->m_pWorld;
  1886. ASSERT_VALID(pWorld);
  1888. // Edit the camera attributes
  1889. if(m_Camera.EditAttributes(this, pWorld) == IDOK)
  1890. {
  1891. // Make this view the current OpenGL rendering context...
  1892. if(!the3dEngine.EnableRC(m_pDC->GetSafeHdc(), m_hRC, TRUE))
  1893. return;
  1895. // Reset our camera view
  1896. m_Camera.ResetView(NULL, NULL);
  1898. // Releases the device context that is used by the rendering context
  1899. // to allow other rendering contexts to co-exist.
  1900. the3dEngine.EnableRC(NULL, NULL, FALSE);
  1902. // Force a repaint of the window
  1903. InvalidateRect(NULL, FALSE);
  1904. }
  1906. return;
  1907. }
  1909. void CMyglView::OnViewCullfaces() 
  1910. {
  1911. // Get a pointer to our view's document
  1912. CMyglDoc* pDoc = GetDocument();
  1913. ASSERT_VALID(pDoc);
  1915. // Get a pointer to our document's 3dWorld
  1916. C3dWorld* pWorld = pDoc->m_pWorld;
  1917. ASSERT_VALID(pWorld);
  1919. if(pWorld->m_bCullFaces)
  1920. pWorld->m_bCullFaces = FALSE;
  1921. else
  1922. pWorld->m_bCullFaces = TRUE;
  1924. // Force a repaint of the window
  1925. pDoc->UpdateAllViews(NULL);
  1926. }
  1928. void CMyglView::OnUpdateViewCullfaces(CCmdUI* pCmdUI) 
  1929. {
  1930. // Get a pointer to our view's document
  1931. CMyglDoc* pDoc = GetDocument();
  1932. ASSERT_VALID(pDoc);
  1934. // Get a pointer to our document's 3dWorld
  1935. C3dWorld* pWorld = pDoc->m_pWorld;
  1936. ASSERT_VALID(pWorld);
  1938. if(pWorld->m_bCullFaces)
  1939. pCmdUI->SetCheck(TRUE);
  1940. else
  1941. pCmdUI->SetCheck(FALSE);
  1942. }
  1944. void CMyglView::OnFileSaveImage() 
  1945. {
  1946. CFileDialog fileDlg(FALSE, NULL, NULL);
  1947. fileDlg.m_ofn.lpstrFilter = "Bitmap Files (*.bmp)*.bmp";
  1948. fileDlg.m_ofn.lpstrTitle = "Save Image As";
  1950. int retn = fileDlg.DoModal();
  1951. if(retn == IDOK) {
  1952. CString szFile = fileDlg.GetFileName();
  1953. CString szPath = fileDlg.GetPathName();
  1954. CString szFileExt = fileDlg.GetFileExt();
  1956. if(szFileExt.Compare("") == 0)
  1957. {
  1958. // Assign the default 'bmp' extension
  1959. szFileExt = _T("bmp");
  1960. szFile += _T(".bmp");
  1961. szPath += _T(".bmp");
  1962. }
  1964. if(szFileExt.Compare("bmp") == 0)
  1965. {
  1966. // Make this view the current OpenGL rendering context...
  1967. if(!the3dEngine.EnableRC(m_pDC->GetSafeHdc(), m_hRC, TRUE))
  1968. return;
  1970. g_pBitmapBits = (GLubyte*)g_DibImage.ReadDIBitmap(&g_pBitmapInfo);
  1972. g_DibImage.SaveDIBFile(szPath.GetBuffer(128), g_pBitmapInfo, g_pBitmapBits);
  1974. // Releases the device context that is used by the rendering context
  1975. // to allow other rendering contexts to co-exist.
  1976. the3dEngine.EnableRC(NULL, NULL, FALSE);
  1977. }
  1978. else
  1979. AfxMessageBox("Invalid File Extension!  Select files with 'bmp' extension.", MB_OK, NULL);
  1980. }
  1981. }
  1983. BOOL CMyglView::OnSetCursor(CWnd* pWnd, UINT nHitTest, UINT message) 
  1984. {
  1985. // Get a pointer to our view's document
  1986. CMyglDoc* pDoc = GetDocument();
  1987. ASSERT_VALID(pDoc);
  1989. if(pDoc->m_bPaint)
  1990. {
  1991. // Set our cursor and save the previous 
  1992. pDoc->m_hCursorPrev = ::SetCursor(pDoc->m_hPaintCursor);
  1993. ::ShowCursor(TRUE);
  1994. return TRUE;
  1995. }
  1997. return CView::OnSetCursor(pWnd, nHitTest, message);
  1998. }