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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 界面编程 > 对话框与窗口 > 查看源码
MF3DHelper.cpp
资源名称：3DHelperDemo.zip　[点击查看]
上传用户：qzpk666
上传日期：2022-08-04
资源大小：59k
文件大小：16k
源码类别：

对话框与窗口

开发平台：

Visual C++

MF3DHelper.cpp：源码内容
  1. // MF3DHelper.cpp: implementation of the CMF3DHelper class.
  2. //
  3. //////////////////////////////////////////////////////////////////////
  5. #include "stdafx.h"
  6. #include <LIMITS.H>
  7. #include <FLOAT.H>
  8. #include "MF3DHelper.h"
  11. #ifdef _DEBUG
  12. #undef THIS_FILE
  13. static char THIS_FILE[]=__FILE__;
  14. #define new DEBUG_NEW
  15. #endif
  17. //using namespace NeHe;
  19. #ifndef PI
  20. const float PI = 3.1415927f;
  21. #define RAD(x) (x*PI/180.0f)
  22. #define DEG(x) (x*180.0f/PI)
  24. #define RAD2DEG(x)  (x*180.f/PI);
  25. #define DEG2RAD(x)  (x*PI / 180.0f);
  26. #endif
  29. //////////////////////////////////////////////////////////////////////
  30. // Construction/Destruction
  31. //////////////////////////////////////////////////////////////////////
  33. CMF3DHelper::CMF3DHelper()
  34. {
  35. m_mProjection.Id();
  37. m_fViewport_x = 0.0f;
  38. m_fViewport_y = 0.0f;
  39. m_fViewport_widht = 640.0f;
  40. m_fViewport_height = 480.0f;
  41. m_bShadowUpdateRequired = TRUE;
  42. }
  44. CMF3DHelper::~CMF3DHelper()
  45. {
  46. }
  50. float CMF3DHelper::cotangens(float x) {
  51. float s = (float)sin(RAD(x));
  52. float c = (float)cos(RAD(x));
  53. if(s!=0.0f) {
  54. return c/s;
  55. }
  56. return 0.0f;
  57. }
  59. void CMF3DHelper::emul_glLoadIdentity()
  60. {
  61. m_mProjection.Id();
  62. m_mModel.Id();
  63. }
  65. void CMF3DHelper::emul_glViewport(int x, int y, int widht, int height)
  66. {
  67. m_fViewport_x = (float)x;
  68. m_fViewport_y = (float)y;
  69. m_fViewport_widht = (float)widht;
  70. m_fViewport_height = (float)height;
  71. }
  74. void CMF3DHelper::Scale(float xFactor,float yFactor,float zFactor)
  75. {
  76. m_bShadowUpdateRequired = TRUE;
  77. emul_glScalef(xFactor, yFactor, zFactor);
  78. }
  81. void CMF3DHelper::emul_glScalef(float x, float y, float z)
  82. {
  83. #define M(x,y) m_mProjection.m[Idx(x,y)]
  84. M(0,0) *= x;   M(0,1) *= y;   M(0,2)  *= z;
  85. M(1,0) *= x;   M(1,1) *= y;   M(1,2)  *= z;
  86. M(2,0) *= x;   M(2,1) *= y;   M(2,2)  *= z;
  87. M(3,0) *= x;   M(3,1) *= y;   M(3,2)  *= z;
  88. #undef M
  89. }
  92. void CMF3DHelper::Translate(float x,float y,float z)
  93. {
  94. emul_glTranslatef(x,y,z);
  95. }
  99. void CMF3DHelper::emul_glTranslatef(float x, float y, float z)
  100. {
  101. #define M(x,y) m_mModel.m[Idx(x,y)]
  102. M(0,3) = M(0,0) * x + M(0,1) * y + M(0,2) * z + M(0,3);
  103. M(1,3) = M(1,0) * x + M(1,1) * y + M(1,2) * z + M(1,3);
  104. M(2,3) = M(2,0) * x + M(2,1) * y + M(2,2) * z + M(2,3);
  105. M(3,3) = M(3,0) * x + M(3,1) * y + M(3,2) * z + M(3,3);
  106. #undef M
  107. } 
  109. void CMF3DHelper::emul_glRotatef(float angle, float x, float y, float z)
  110. {
  111. NeHe::Matrix mR;
  112. float s, c;
  113. float xx, yy, zz, xy, yz, zx, xs, ys, zs, one_c;
  114. s = (float)sin(RAD(angle));
  115. c = (float)cos(RAD(angle));
  116. mR.Id();
  118. float mag = sqrtf(x*x + y*y + z*z);
  119. if (mag <= 1.0e-4) {
  120. /* no rotation, leave mat as-is */
  121. return;
  122. }
  124. x /= mag;
  125. y /= mag;
  126.     z /= mag; 
  128. xx = x * x;
  129. yy = y * y;
  130. zz = z * z;
  131. xy = x * y;
  132. yz = y * z;
  133. zx = z * x;
  134. xs = x * s;
  135. ys = y * s;
  136.     zs = z * s; 
  137. one_c = 1.0F - c; 
  138. #define M(x,y)  mR.m[Idx(x,y)]
  139. M(0,0) = (one_c * xx) + c;
  140. M(0,1) = (one_c * xy) - zs;
  141. M(0,2) = (one_c * zx) + ys;
  142. M(0,3) = 0.0f; 
  144. M(1,0) = (one_c * xy) + zs;
  145. M(1,1) = (one_c * yy) + c;
  146. M(1,2) = (one_c * yz) - xs;
  147. M(1,3) = 0.0f;
  149. M(2,0) = (one_c * zx) - ys;
  150. M(2,1) = (one_c * yz) + xs;
  151. M(2,2) = (one_c * zz) + c;
  152. M(2,3) = 0.0F;
  154. M(3,0) = 0.0F;
  155. M(3,1) = 0.0F;
  156. M(3,2) = 0.0F;
  157. M(3,3) = 1.0F;
  158. #undef M
  160. // IMPORTANT!!!
  161. // We need to perform multiplication in form R(otation)xP(erspective)(and not otherwise!!!)
  162. m_mRotation = mR;
  163. NeHe::Matrix mRotTemp = m_mModel;
  164. m_mModel  = mR * mRotTemp;
  166. }
  168. void CMF3DHelper::RotateVector(float fAngle,float fVectorX,float fVectorY, float fVectorZ, BOOL bAbsolute)
  169. {
  170. m_bShadowUpdateRequired = TRUE;
  172. if(bAbsolute==TRUE) {
  173. m_mModel.Id();
  174. }
  176. emul_glRotatef(fAngle, fVectorX, fVectorY, fVectorZ);
  178. return;
  179. }
  181. void CMF3DHelper::Rotate(float angleX,float angleY,float angleZ, BOOL bAbsolute)
  182. {
  183. m_bShadowUpdateRequired = TRUE;
  185. if(bAbsolute==TRUE) {
  186. m_mModel.Id();
  187. }
  189. emul_glRotatef(angleX, 1.0f,0.0f,0.0f);
  190. emul_glRotatef(angleY, 0.0f,1.0f,0.0f);
  191. emul_glRotatef(angleZ, 0.0f,0.0f,1.0f);
  192. m_cTrackBall.SetRotation(angleX, angleY, angleZ);
  194. return;
  195. }
  197. double calculateFov(double size, double distance)
  198. {
  199. const double PI = 3.1415926535;
  201.     double radtheta, degtheta; 
  203.     radtheta = 2.0 * atan2 (size/2.0, distance);
  204.     degtheta = (180.0 * radtheta) / PI;
  205.     return (degtheta);
  206. }
  208. double calculateZNear(double fov, double top, double bottom) 
  209. {
  210. double zNear = (top - bottom) /(2.0f*tan(RAD(fov) / 2.0f));
  211. return zNear;
  212. }
  215. BOOL CMF3DHelper::emul_gluPerspective(float fovy, float aspect, float zNear, float zFar)
  216. {
  217. const float PI = 3.1415f;
  218. if(aspect == 0.0f) {
  219. return FALSE;
  220. }
  221. if((zFar-zNear)==0.0f) {
  222. return FALSE;
  223. }
  225. NeHe::Matrix mT1, mT2;
  226. mT1.Zero();
  228. float f = cotangens(fovy / 2.0f);
  230. #define M(x,y) mT1.m[Idx(x,y)]
  231. M(0,0) = f / aspect;
  232. M(1,1) = f;
  233. M(2,2)= (zFar+zNear) / (zNear-zFar);
  234. M(2,3)= (2*zFar*zNear) / (zNear-zFar);
  235. M(3,2)= -1.0f;
  236. #undef M
  238. m_mProjection =mT1;
  240. return TRUE;
  241. }
  244. BOOL CMF3DHelper::setupPerspective(float fovy, float aspect, float zNear, float zFar)
  245. {
  246. // New should always be less than zFar
  247. if(zNear > zFar) {
  248. float t = zNear;
  249. zNear = zFar;
  250. zFar = zNear;
  251. }
  253. // Calculate bounding sphere
  254. float fDX, fDY, fDZ;
  255. fDX = m_vCubeMax.x - m_vCubeMin.x;
  256. fDY = m_vCubeMax.y - m_vCubeMin.y;
  257. fDZ = m_vCubeMax.z - m_vCubeMin.z;
  258. // Calculate maximal bounding sphere diameter
  259. float fDM = max(fDX, max(fDY, fDZ)) / 2.0f;
  261. float fOffset = 1.0f-zNear; // How much do we have to offset the position of zNear to start at position +1.0
  262. float zNearMod= 1.0f;
  263. float zFarMod = 0.0f;
  265. float zNearX= (float)calculateZNear((double)fovy, (double)m_vCubeMax.x, (double)m_vCubeMin.x);// Optimal zNear for cube (0,0,0/1,1,,1);
  266. float zNearY= (float)calculateZNear((double)fovy, (double)m_vCubeMax.y, (double)m_vCubeMin.y);
  267. zNearMod = max(zNearX, zNearY);
  268. zFarMod  = zNearMod + fDM;
  269. m_mModel.Id();
  271. if(FALSE == emul_gluPerspective(fovy, aspect, zNearMod, zFarMod)) {
  272. return FALSE;
  273. }
  274. // Force visibility of cube (e.g. -1,-1,-1/+1,+1,+1);
  275. float xCenter = (m_vCubeMin.x + m_vCubeMax.x) / 2.0f;
  276. float yCenter = (m_vCubeMin.y + m_vCubeMax.y) / 2.0f;
  277. float zCenter = (m_vCubeMin.z + m_vCubeMax.z) / 2.0f;
  278. float fTranslate = (float)zNearMod + fDM;//+ 1.0f; // cube is -1..1 so shift by e.g 1 unit
  280. NeHe::Matrix mTmp = m_mModel;
  281. m_mModel = m_mProjection;
  282. emul_glTranslatef(-xCenter, -yCenter, fTranslate);; // m_mProjection now holds translation also
  283. m_mProjection = m_mModel;
  284. m_mModel = mTmp;
  286. return TRUE;
  287. }
  290. BOOL CMF3DHelper::Initialize(CDC *pTargetDC, NeHe::Vector vMin, NeHe::Vector vMax, BOOL bSupportTrackBall)
  291. {
  292. try {
  293. if(pTargetDC==NULL) {
  294. return FALSE;
  295. }
  297. CRect rcDraw;
  298. pTargetDC->GetWindow()->GetClientRect(&rcDraw);
  299. if(rcDraw.IsRectEmpty() == TRUE) {
  300. return FALSE;
  301. }
  303. // Mark shadow matrix as "dirty"
  304. m_bShadowUpdateRequired = TRUE;
  307. m_fViewport_x = 0.0f;
  308. m_fViewport_y = 0.0f;
  309. m_fViewport_widht = (float)rcDraw.Width();
  310. m_fViewport_height = (float)rcDraw.Height();
  312. // Set up arc ball also!
  313. m_cTrackBall.Initialize(rcDraw.Width(), rcDraw.Height());
  315. emul_glViewport((int)m_fViewport_x, (int)m_fViewport_y, (int)m_fViewport_widht, (int)m_fViewport_height);
  317. NeHe::Vector vDelta = vMax - vMin;
  318. m_vCubeMin = vMin;
  319. m_vCubeMax = vMax;
  322. float fovy, aspect, zNear, zFar;
  323. fovy = 45.0f;
  324. aspect = (float)rcDraw.Width() / (float)rcDraw.Height();
  325. zNear = vMin.z;
  326. zFar  = vMax.z;
  327. setupPerspective(fovy, aspect, zNear, zFar);
  329. return TRUE;
  330. } catch(...) {
  331. return FALSE;
  332. }
  334. }
  336. BOOL CMF3DHelper::Reset(CDC *pTargetDC, NeHe::Vector vMin, NeHe::Vector vMax, BOOL bSupportTrackBall)
  337. {
  338. m_bShadowUpdateRequired = TRUE; // Matrix needs recalculation!
  339. return Initialize(pTargetDC, vMin, vMax, bSupportTrackBall);
  340. }
  342. void CMF3DHelper::UpdateTrackBall(CDC *pDC) {
  343. NeHe::Vector cRotDelta, cRot;
  344. if(TRUE == m_cTrackBall.Update(pDC, cRotDelta, cRot)) {
  345. Rotate(cRot.x, cRot.y, cRot.z, TRUE);
  346. }
  348. }
  351. NeHe::Vector CMF3DHelper::RenderPoint(NeHe::Vector v3DPoint) 
  352. {
  353. NeHe::Vector vR;
  355. v3DPoint.w = 1.0f; // Need to be homogeneous
  357. NeHe::Vector vR5;
  358. if(m_bShadowUpdateRequired == TRUE) {
  359. m_mShadow = m_mModel*m_mProjection;
  360. m_bShadowUpdateRequired = FALSE;
  361. }
  363. vR = m_mShadow*v3DPoint;
  364. float xk,yk;
  365. xk = (vR.x*0.5f / vR.w + 0.5f)*(float)m_fViewport_widht;
  366. yk = (vR.y*0.5f / vR.w + 0.5f)*(float)m_fViewport_height;
  367. vR.x = xk;
  368. vR.y = yk;
  369. return vR;
  370. }
  372. CString v3DString(float x, float y, float z) {
  373. CString szV;
  374. szV.Format(_T("(%.1f, %.1f, %.1f)"), x,y,z);
  375. return szV;
  376. }
  378. // Draw the cube given as min/max pair of data-range
  379. void CMF3DHelper::DrawVisibilityCube(CDC* pDC, BOOL bDrawAxes, BOOL bDrawBoundingCoordinates)
  380. {
  381. CPen cPen(PS_SOLID, 1, RGB(255,255,255));
  382. CPen cPenR(PS_DASH, 1, RGB(255,64,64));
  383. CPen cPenG(PS_DASH, 1, RGB(64,255,64));
  384. CPen cPenB(PS_DASH, 1, RGB(64,64,255));
  385. CPen *pOld = pDC->SelectObject(&cPen);
  387. float lx,ly,lz,rx,ry,rz,cx,cy,cz;
  388. #define L m_vCubeMin
  389. #define R m_vCubeMax
  391. lx = L.x;
  392. ly = L.y;
  393. lz = L.z;
  394. rx = R.x;
  395. ry = R.y;
  396. rz = R.z;
  397. cx = (lx+rx)/2.0f;
  398. cy = (ly+ry)/2.0f;
  399. cz = (lz+rz)/2.0f;
  401. NeHe::Vector v1(lx,ly,lz);//n,n,n);
  402. NeHe::Vector v2(rx,ly,lz);//p,n,n);
  403. NeHe::Vector v3(rx,ry,lz);//p,p,n);
  404. NeHe::Vector v4(lx,ry,lz);//n,p,n);
  405. NeHe::Vector v5(lx,ly,rz);//n,n,p);
  406. NeHe::Vector v6(rx,ly,rz);//p,n,p);
  407. NeHe::Vector v7(rx,ry,rz);//p,p,p);
  408. NeHe::Vector v8(lx,ry,rz);//n,p,p);
  410. NeHe::Vector vc1(cx,cy,cz);//c,c,c);
  411. NeHe::Vector vc2(rx,cy,cz);//p,c,c);
  412. NeHe::Vector vc3(cx,ry,cz);//c,p,c);
  413. NeHe::Vector vc4(cx,cy,rz);//c,c,p);
  415. CString szV1= v3DString(lx,ly,lz);
  416. CString szV2= v3DString(rx,ly,lz);
  417. CString szV3= v3DString(rx,ry,lz);
  418. CString szV4= v3DString(lx,ry,lz);
  419. CString szV5= v3DString(lx,ly,rz);
  420. CString szV6= v3DString(rx,ly,rz);
  421. CString szV7= v3DString(rx,ry,rz);
  422. CString szV8= v3DString(lx,ry,rz);
  426. NeHe::Vector o1, o2, o3, o4, o5, o6, o7, o8, c1,c2,c3, c4;
  427. o1 = RenderPoint(v1);
  428. o2 = RenderPoint(v2);
  429. o3 = RenderPoint(v3);
  430. o4 = RenderPoint(v4);
  431. o5 = RenderPoint(v5);
  432. o6 = RenderPoint(v6);
  433. o7 = RenderPoint(v7);
  434. o8 = RenderPoint(v8);
  435. c1 =RenderPoint(vc1);
  436. c2 =RenderPoint(vc2);
  437. c3 =RenderPoint(vc3);
  438. c4 =RenderPoint(vc4);
  440. // Draw front rectangle
  441. pDC->MoveTo((int)o1.x, (int)o1.y);
  442. pDC->LineTo((int)o2.x, (int)o2.y);
  443. pDC->LineTo((int)o3.x, (int)o3.y);
  444. pDC->LineTo((int)o4.x, (int)o4.y);
  445. pDC->LineTo((int)o1.x, (int)o1.y);
  447. // Draw connecing lines
  448. pDC->MoveTo((int)o1.x, (int)o1.y);
  449. pDC->LineTo((int)o5.x, (int)o5.y);
  450. pDC->MoveTo((int)o2.x, (int)o2.y);
  451. pDC->LineTo((int)o6.x, (int)o6.y);
  452. pDC->MoveTo((int)o3.x, (int)o3.y);
  453. pDC->LineTo((int)o7.x, (int)o7.y);
  454. pDC->MoveTo((int)o4.x, (int)o4.y);
  455. pDC->LineTo((int)o8.x, (int)o8.y);
  457. // Draw rear rectangle
  458. pDC->MoveTo((int)o5.x, (int)o5.y);
  459. pDC->LineTo((int)o6.x, (int)o6.y);
  460. pDC->LineTo((int)o7.x, (int)o7.y);
  461. pDC->LineTo((int)o8.x, (int)o8.y);
  462. pDC->LineTo((int)o5.x, (int)o5.y);
  465. int iBKModeOld = pDC->GetBkMode();
  466. COLORREF rgbTextOld = pDC->GetTextColor();
  467. pDC->SetBkMode(TRANSPARENT);
  469. // Draw the coordinate axes
  470. // x-axis
  471. if(bDrawAxes==TRUE) {
  472. pDC->SetTextColor(RGB(255,25,255));
  473. pDC->MoveTo((int)c1.x, (int)c1.y);
  474. pDC->SelectObject(&cPenR);
  475. pDC->LineTo((int)c2.x, (int)c2.y);
  476. pDC->TextOut((int)c2.x, (int)c2.y, _T("+X"));
  478. // y-Axis
  479. pDC->MoveTo((int)c1.x, (int)c1.y);
  480. pDC->SelectObject(&cPenG);
  481. pDC->LineTo((int)c3.x, (int)c3.y);
  482. pDC->TextOut((int)c3.x, (int)c3.y, _T("+Y"));
  484. // z-Axis
  485. pDC->MoveTo((int)c1.x, (int)c1.y);
  486. pDC->SelectObject(&cPenB);
  487. pDC->LineTo((int)c4.x, (int)c4.y);
  488. pDC->TextOut((int)c4.x, (int)c4.y, _T("+Z"));
  489. }
  491. if(bDrawBoundingCoordinates==TRUE) {
  492. pDC->SetTextColor(RGB(255,25,255));
  493. pDC->TextOut((int)o1.x, (int)o1.y, szV1);
  494. pDC->TextOut((int)o2.x, (int)o2.y, szV2);
  495. pDC->TextOut((int)o3.x, (int)o3.y, szV3);
  496. pDC->TextOut((int)o4.x, (int)o4.y, szV4);
  497. pDC->TextOut((int)o5.x, (int)o5.y, szV5);
  498. pDC->TextOut((int)o6.x, (int)o6.y, szV6);
  499. pDC->TextOut((int)o7.x, (int)o7.y, szV7);
  500. pDC->TextOut((int)o8.x, (int)o8.y, szV8);
  501. }
  503. pDC->SetBkMode(iBKModeOld);
  504. pDC->SetTextColor(rgbTextOld);
  505. // Finish!
  507. pDC->SelectObject(pOld);
  509. }
  512. NeHe::CMFArcBall::CMFArcBall()
  513. {
  514. m_cMousePoint = CPoint(0,0);
  515. m_bLButtonDown = FALSE;
  516. m_fXRotation = 0.0f;
  517. m_fYRotation = 0.0f;
  518. m_fZRotation = 0.0f;
  519. m_iWidth = 0;
  520. m_iHeight = 0;
  521. }
  523. NeHe::CMFArcBall::~CMFArcBall()
  524. {
  525. }
  527. BOOL NeHe::CMFArcBall::getMousePosition(BOOL &bLDown, BOOL &bLToggled, BOOL &bRDown, BOOL &bRToggled, int &xPos, int &yPos, CDC* pDC)
  528. {
  529. if(pDC==NULL) {
  530. return FALSE;
  531. }
  533. bLDown = bRDown = FALSE;
  534. xPos = yPos = 0;
  536. CPoint ptMouse;
  537. GetCursorPos(&ptMouse);
  539. pDC->GetWindow()->ScreenToClient(&ptMouse);
  541. xPos = ptMouse.x;
  542. yPos = ptMouse.y;
  544. SHORT lButton ,rButton;
  545. lButton = GetAsyncKeyState(VK_LBUTTON);
  546. rButton = GetAsyncKeyState(VK_RBUTTON);
  548. // BOOL bLToggled, bRToggled, bLDown, bRDown;
  549. bLDown = ((lButton & 0x8000) != 0);
  550. bLToggled = ((lButton & 0x0001) != 0);
  551. bRDown = ((rButton & 0x8000) != 0);
  552. bRToggled = ((rButton & 0x0001) != 0);
  554. return TRUE;
  555. }
  558. void NeHe::CMFArcBall::mouseToArc(CPoint cPt, float &fx, float &fy) 
  559. {
  560. #ifndef EPSILON
  561. #define EPSILON (1.0e-9)
  562. #endif
  564. int xPos = (cPt.x-m_iWidth/2);  // Position from center
  565. int yPos = (cPt.y-m_iHeight/2);
  567. float xb = (float)xPos / (float)(m_iWidth/2);
  568. float yh = (float)yPos / (float)(m_iHeight/2);
  570. if(xb<(-1.0f-EPSILON)) {
  571. fx = -180;
  572. } else  {
  573. if(xb > (1.0f-EPSILON)) {
  574. fx = 0;
  575. }else {
  576. fy = -DEG(acosf(xb));
  577. }
  578. }
  580. if(yh<(-1.0f-EPSILON)) {
  581. fy = 90.0f;
  582. } else  {
  583. if(yh > (1.0f-EPSILON)) {
  584. fy = -90.0f;
  585. }else {
  586. fx = -DEG(asinf(yh));
  587. }
  588. }
  590. }
  592. // Returns TRUE only if a rotation is needed
  593. BOOL NeHe::CMFArcBall::Update(CDC* pDC, NeHe::Vector &cRotationDelta, NeHe::Vector &cRotationCumulative)
  594. {
  595. if(pDC == NULL) {
  596. return FALSE;
  597. }
  599. int x, y;
  600. BOOL bLToggled, bRToggled, bLDown, bRDown;
  601.     getMousePosition(bLDown, bLToggled, bRDown, bRToggled, x, y, pDC);
  602. CRect rcScreen(0,0,m_iWidth, m_iHeight);
  603. CPoint point(x,y);
  605. // Mouse is outside the *usable* window
  606. if(FALSE == rcScreen.PtInRect(point)) {
  607. return FALSE;
  608. }
  610. if(bRDown==TRUE) {
  611. m_fXRotation = m_fYRotation = m_fZRotation = 0.0f;
  612. m_bLButtonDown = FALSE;
  613. m_cMousePoint = CPoint(0,0);
  614. cRotationDelta.Null();
  615. cRotationCumulative = NeHe::Vector(m_fXRotation, m_fYRotation, m_fZRotation, 0.0f);
  616. return TRUE;
  617. }
  618. if(bLDown==FALSE) { // Button up..
  619. m_bLButtonDown = FALSE;
  620. cRotationDelta.Null();
  621. // Remember global rotation
  622. cRotationCumulative = NeHe::Vector(m_fXRotation, m_fYRotation, m_fZRotation, 0.0f);
  623. m_cMousePoint = CPoint(0,0);
  624. return FALSE;
  625. } else { // Button down
  626. if(m_bLButtonDown==FALSE) { // Click
  627. // Button state has toggled
  628. // *Fresh* mouse down, start trackball
  629. m_bLButtonDown = TRUE;
  630. m_cMousePoint = point;
  631. // Stay at current rotation
  632. cRotationDelta.Null();
  633. cRotationCumulative = NeHe::Vector(m_fXRotation, m_fYRotation, m_fZRotation, 0.0f);
  634. return FALSE;
  635. } else {
  636. // Perform actions below
  637. // ** dragging **
  638. }
  639. }
  641. // Drag
  642. if(m_cMousePoint == point) {
  643. return FALSE;
  644. }
  646. SHORT sCTRL = ::GetAsyncKeyState(VK_CONTROL);
  647. BOOL bCTRLDown = ((sCTRL & 0x8000) != 0);
  648. bCTRLDown = FALSE;
  649. // Dragging state
  650. cRotationDelta.Null();
  651. float xRot, yRot, zRot;
  652. xRot = yRot = zRot = 0.0f;
  653. xRot = (float)(point.y-m_cMousePoint.y)/m_fYDiv;
  654. if(bCTRLDown==FALSE) {
  655. yRot = (float)(point.x-m_cMousePoint.x)/m_fXDiv;
  656. } else {
  657. zRot = (float)(point.x-m_cMousePoint.x)/m_fXDiv;
  658. }
  659. m_fXRotation -= xRot; 
  660. m_fYRotation += yRot; 
  661. m_fZRotation -= zRot; 
  664. // Limit result to 360 degree
  665. m_fXRotation = fmodf(m_fXRotation, 360.0f);
  666. m_fYRotation = fmodf(m_fYRotation, 360.0f);
  667. m_fZRotation = fmodf(m_fZRotation, 360.0f);
  669. cRotationCumulative = NeHe::Vector(m_fXRotation, m_fYRotation, m_fZRotation, 0.0f);
  670. cRotationDelta = NeHe::Vector(xRot, yRot, zRot, 0.0f);
  672. m_cMousePoint = point;
  674. return TRUE;
  676. }