Category

Development Platform
Home > SourceCode/Document > Graph program > View Code
Planes.cpp
Package: solidgraph_sources.zip　[view]
Upload User: kairuinn
Upload Date: 2009-02-07
Package Size: 2922k
Code Size: 15k
Category:

Graph program

Development Platform:

Visual C++

Planes.cpp：Code Content
  1. #include "stdafx.h"
  2. #include "..//Solidgraph.h"
  4. #include "Planes.h"
  6. #include "..//Dialogs//WorkPlanesSetupsDlg.h"
  8. CPlanes::CPlanes()
  9. {
  10. m_x_WP.enable = m_y_WP.enable = m_z_WP.enable = FALSE;
  11. m_x_WP.visible = m_y_WP.visible = m_z_WP.visible = TRUE;
  12. m_z_WP.enable = TRUE;
  13. m_x_WP.position = m_y_WP.position = m_z_WP.position = 0.0f;
  14. m_x_WP.r = 1.0f;
  15. m_x_WP.g = 0.0f;
  16. m_x_WP.b = 0.0f;
  17. m_x_WP.a = 0.2f;
  18. m_y_WP.r = 0.0f;
  19. m_y_WP.g = 1.0f;
  20. m_y_WP.b = 0.0f;
  21. m_y_WP.a = 0.2f;
  22. m_z_WP.r = 0.0f;
  23. m_z_WP.g = 0.0f;
  24. m_z_WP.b = 1.0f;
  25. m_z_WP.a = 0.2f;
  26. m_x_WP.step = m_y_WP.step = m_z_WP.step = 1.0f;
  28. m_active_work_plane = NULL;
  29. m_snap_point = NULL;
  31. m_grid_lines_count = 2;
  33. m_use_plane_point = false;
  34. }
  36. CPlanes::~CPlanes()
  37. {
  38. if (m_snap_point)
  39. delete m_snap_point;
  40. }
  42. void  CPlanes::SetupDialog()
  43. {
  44. CWorkPlanesSetupsDlg dlg;
  45. dlg.m_x_pos = m_x_WP.position;
  46. dlg.m_y_pos = m_y_WP.position;
  47. dlg.m_z_pos = m_z_WP.position;
  48. dlg.m_xy_vis = m_z_WP.visible;
  49. dlg.m_xz_vis = m_y_WP.visible;
  50. dlg.m_yz_vis = m_x_WP.visible;
  51. if (m_z_WP.enable)
  52. dlg.m_cur_work_plane = 0;
  53. else
  54. if (m_y_WP.enable)
  55. dlg.m_cur_work_plane = 1;
  56. else
  57. if (m_x_WP.enable)
  58. dlg.m_cur_work_plane = 2;
  59. else
  60. {
  61. ASSERT(0);
  62. }
  63. if (dlg.DoModal()==IDOK)
  64. {
  65. m_x_WP.position = dlg.m_x_pos ;
  66. m_y_WP.position = dlg.m_y_pos ;
  67. m_z_WP.position = dlg.m_z_pos ;
  68. m_x_WP.visible = dlg.m_yz_vis ;
  69. m_y_WP.visible = dlg.m_xz_vis ;
  70. m_z_WP.visible = dlg.m_xy_vis ;
  71. m_x_WP.enable = m_y_WP.enable = m_z_WP.enable = FALSE;
  72. if (dlg.m_cur_work_plane == 0)
  73. m_z_WP.enable = TRUE;
  74. else
  75. if (dlg.m_cur_work_plane == 1)
  76. m_y_WP.enable = TRUE;
  77. else
  78. if (dlg.m_cur_work_plane == 2)
  79. m_x_WP.enable = TRUE;
  80. else
  81. {
  82. ASSERT(0);
  83. }
  84. }
  85. }
  87. //#include "glMath.h"
  88. #include <float.h>
  90. void  CPlanes::DrawAxes(C3dCamera* cam)
  91. {
  92. }
  94. double  EyeToGridStep(double dist)
  95. {
  96. if (dist<=0.001 && dist>=-0.001)
  97. return 0.0001;
  98. if (dist<=0.01 && dist>=-0.01)
  99. return 0.001;
  100. if (dist<=0.1 && dist>=-0.1)
  101. return 0.01;
  102. if (dist<=1.0 && dist>=-1.0)
  103. return 0.1;
  104. if (dist<=10.0 && dist>=-10.0)
  105. return 1.0;
  106. if (dist<=100.0 && dist>=-100.0)
  107. return 10.0;
  108. if (dist<=1000.0 && dist>=-1000.0)
  109. return 100.0;
  110. if (dist<=10000.0 && dist>=-10000.0)
  111. return 1000.0;
  112. if (dist<=100000.0 && dist>=-100000.0)
  113. return 10000.0;
  114. return 100000.0;
  115. }
  117. void  CPlanes::DrawWorkPlanes(C3dCamera* cam,bool isCommanderRegime)
  118. {
  119. glPushAttrib(GL_ENABLE_BIT);
  120. glEnable(GL_BLEND);
  121. glDisable(GL_CULL_FACE);
  122. glDisable(GL_LIGHTING);
  123. glDisable(GL_TEXTURE_2D);
  124. glDisable(GL_LINE_SMOOTH);
  125. glDisable(GL_DEPTH_TEST);
  127. SG_POINT EyePos;
  128. cam->GetEyePos(&EyePos.x,&EyePos.y,&EyePos.z);
  129. SG_POINT LookAtPos;
  130. cam->GetLookAtPos(&LookAtPos.x,&LookAtPos.y,&LookAtPos.z);
  132. if (m_x_WP.enable && m_x_WP.visible)
  133. {
  134. double plD = 0.0;
  135. SG_POINT plP = {m_x_WP.position, 0.0, 0.0};
  136. SG_VECTOR plN = {1.0, 0.0, 0.0};
  137. sgSpaceMath::PlaneFromNormalAndPoint(plP, plN, plD);
  138. SG_POINT resPnt;
  139. if (cam->ProjectCenterOfScreenOnPlane(plD,plN, resPnt))
  140. {
  141. bool  actP = m_active_work_plane==&m_x_WP && m_use_plane_point && isCommanderRegime;
  142. if (actP)
  143. glColor4f(m_x_WP.r, m_x_WP.g, m_x_WP.b, m_x_WP.a+0.4f);
  144. else
  145. glColor4f(m_x_WP.r, m_x_WP.g, m_x_WP.b, m_x_WP.a+0.1f);
  147. double curPos, tmpDbl;
  149. m_x_WP.step = (float)EyeToGridStep(sgSpaceMath::PointsDistance(resPnt,EyePos));
  151. double  begVal1 = FloorGrid(resPnt.z-m_x_WP.step*7.0,(float)m_x_WP.step);
  152. double  endVal1 = FloorGrid(resPnt.z+m_x_WP.step*7.0,(float)m_x_WP.step);
  153. double  begVal2 = FloorGrid(resPnt.y-m_x_WP.step*7.0,(float)m_x_WP.step);
  154. double  endVal2 = FloorGrid(resPnt.y+m_x_WP.step*7.0,(float)m_x_WP.step);
  156. glBegin(GL_LINES);
  157. for (curPos = begVal1; curPos<=endVal1; curPos+=m_x_WP.step)
  158. {
  159. bool isCel = false;
  160. if (fabs(modf(curPos/(double)(m_x_WP.step*10.0),&tmpDbl))<0.00001)
  161. {
  162. if (actP)
  163. glColor4f(0.0f, 0.0f, 0.0f, m_x_WP.a+0.6f);
  164. else
  165. glColor4f(0.0f, 0.0f, 0.0f, m_x_WP.a+0.3f);
  166. isCel = true;
  167. }
  168. glVertex3d(resPnt.x, begVal2, curPos);
  169. glVertex3d(resPnt.x, endVal2, curPos);
  170. if (isCel)
  171. {
  172. if (actP)
  173. glColor4f(m_x_WP.r, m_x_WP.g, m_x_WP.b, m_x_WP.a+0.4f);
  174. else
  175. glColor4f(m_x_WP.r, m_x_WP.g, m_x_WP.b, m_x_WP.a+0.1f);
  176. }
  177. }
  178. for (curPos = begVal2; curPos<=endVal2; curPos+=m_x_WP.step)
  179. {
  180. bool isCel = false;
  181. if (fabs(modf(curPos/(double)(m_x_WP.step*10.0),&tmpDbl))<0.00001)
  182. {
  183. if (actP)
  184. glColor4f(0.0f, 0.0f, 0.0f, m_x_WP.a+0.6f);
  185. else
  186. glColor4f(0.0f, 0.0f, 0.0f, m_x_WP.a+0.3f);
  187. isCel = true;
  188. }
  189. glVertex3d(resPnt.x,curPos,  begVal1 );
  190. glVertex3d(resPnt.x,curPos,  endVal1 );
  191. if (isCel)
  192. {
  193. if (actP)
  194. glColor4f(m_x_WP.r, m_x_WP.g, m_x_WP.b, m_x_WP.a+0.4f);
  195. else
  196. glColor4f(m_x_WP.r, m_x_WP.g, m_x_WP.b, m_x_WP.a+0.1f);
  197. }
  198. }
  199. glEnd();
  201. }
  203. }
  205. if (m_y_WP.enable && m_y_WP.visible)
  206. {
  207. double plD = 0.0;
  208. SG_POINT plP = {0.0, m_y_WP.position, 0.0};
  209. SG_VECTOR plN = {0.0, 1.0, 0.0};
  210. sgSpaceMath::PlaneFromNormalAndPoint(plP, plN, plD);
  211. SG_POINT resPnt;
  212. if (cam->ProjectCenterOfScreenOnPlane(plD,plN, resPnt))
  213. {
  214. bool  actP = m_active_work_plane==&m_y_WP && m_use_plane_point && isCommanderRegime;
  215. if (actP)
  216. glColor4f(m_y_WP.r, m_y_WP.g, m_y_WP.b, m_y_WP.a+0.4f);
  217. else
  218. glColor4f(m_y_WP.r, m_y_WP.g, m_y_WP.b, m_y_WP.a+0.1f);
  220. double curPos, tmpDbl;
  222. m_y_WP.step = (float)EyeToGridStep(sgSpaceMath::PointsDistance(resPnt,EyePos));
  224. double  begVal1 = FloorGrid(resPnt.z-m_y_WP.step*7.0,(float)m_y_WP.step);
  225. double  endVal1 = FloorGrid(resPnt.z+m_y_WP.step*7.0,(float)m_y_WP.step);
  226. double  begVal2 = FloorGrid(resPnt.x-m_y_WP.step*7.0,(float)m_y_WP.step);
  227. double  endVal2 = FloorGrid(resPnt.x+m_y_WP.step*7.0,(float)m_y_WP.step);
  229. glBegin(GL_LINES);
  230. for (curPos = begVal1; curPos<=endVal1; curPos+=m_y_WP.step)
  231. {
  232. bool isCel = false;
  233. if (fabs(modf(curPos/(double)(m_y_WP.step*10.0),&tmpDbl))<0.00001)
  234. {
  235. if (actP)
  236. glColor4f(0.0f, 0.0f, 0.0f, m_y_WP.a+0.6f);
  237. else
  238. glColor4f(0.0f, 0.0f, 0.0f, m_y_WP.a+0.3f);
  239. isCel = true;
  240. }
  241. glVertex3d(begVal2, resPnt.y, curPos);
  242. glVertex3d(endVal2, resPnt.y, curPos);
  243. if (isCel)
  244. {
  245. if (actP)
  246. glColor4f(m_y_WP.r, m_y_WP.g, m_y_WP.b, m_y_WP.a+0.4f);
  247. else
  248. glColor4f(m_y_WP.r, m_y_WP.g, m_y_WP.b, m_y_WP.a+0.1f);
  249. }
  250. }
  251. for (curPos = begVal2; curPos<=endVal2; curPos+=m_y_WP.step)
  252. {
  253. bool isCel = false;
  254. if (fabs(modf(curPos/(double)(m_y_WP.step*10.0),&tmpDbl))<0.00001)
  255. {
  256. if (actP)
  257. glColor4f(0.0f, 0.0f, 0.0f, m_y_WP.a+0.6f);
  258. else
  259. glColor4f(0.0f, 0.0f, 0.0f, m_y_WP.a+0.3f);
  260. isCel = true;
  261. }
  262. glVertex3d(curPos, resPnt.y, begVal1 );
  263. glVertex3d(curPos, resPnt.y, endVal1 );
  264. if (isCel)
  265. {
  266. if (actP)
  267. glColor4f(m_y_WP.r, m_y_WP.g, m_y_WP.b, m_y_WP.a+0.4f);
  268. else
  269. glColor4f(m_y_WP.r, m_y_WP.g, m_y_WP.b, m_y_WP.a+0.1f);
  270. }
  271. }
  272. glEnd();
  275. }
  276. }
  278. if (m_z_WP.enable && m_z_WP.visible)
  279. {
  280. double plD = 0.0;
  281. SG_POINT plP = {0.0,0.0,m_z_WP.position};
  282. SG_VECTOR plN = {0.0, 0.0, 1.0};
  283. sgSpaceMath::PlaneFromNormalAndPoint(plP, plN, plD);
  284. SG_POINT resPnt;
  285. if (cam->ProjectCenterOfScreenOnPlane(plD,plN, resPnt))
  286. {
  287. bool  actP = m_active_work_plane==&m_z_WP && m_use_plane_point && isCommanderRegime;
  288. if (actP)
  289. glColor4f(m_z_WP.r, m_z_WP.g, m_z_WP.b, m_z_WP.a+0.4f);
  290. else
  291. glColor4f(m_z_WP.r, m_z_WP.g, m_z_WP.b, m_z_WP.a+0.1f);
  293. double curPos, tmpDbl;
  295. m_z_WP.step = (float)EyeToGridStep(sgSpaceMath::PointsDistance(resPnt,EyePos));
  297. double  begVal1 = FloorGrid(resPnt.y-m_z_WP.step*7.0,(float)m_z_WP.step);
  298. double  endVal1 = FloorGrid(resPnt.y+m_z_WP.step*7.0,(float)m_z_WP.step);
  299. double  begVal2 = FloorGrid(resPnt.x-m_z_WP.step*7.0,(float)m_z_WP.step);
  300. double  endVal2 = FloorGrid(resPnt.x+m_z_WP.step*7.0,(float)m_z_WP.step);
  302. glBegin(GL_LINES);
  304. for (curPos = begVal1; curPos<=endVal1; curPos+=m_z_WP.step)
  305. {
  306. bool isCel = false;
  307. if (fabs(modf(curPos/(double)(m_z_WP.step*10.0),&tmpDbl))<0.00001)
  308. {
  309. if (actP)
  310. glColor4f(0.0f, 0.0f, 0.0f, m_z_WP.a+0.6f);
  311. else
  312. glColor4f(0.0f, 0.0f, 0.0f, m_z_WP.a+0.3f);
  313. isCel = true;
  314. }
  315. glVertex3d(begVal2, curPos, resPnt.z);
  316. glVertex3d(endVal2, curPos, resPnt.z);
  317. if (isCel)
  318. {
  319. if (actP)
  320. glColor4f(m_z_WP.r, m_z_WP.g, m_z_WP.b, m_z_WP.a+0.4f);
  321. else
  322. glColor4f(m_z_WP.r, m_z_WP.g, m_z_WP.b, m_z_WP.a+0.1f);
  323. }
  324. }
  325. for (curPos = begVal2; curPos<=endVal2; curPos+=m_z_WP.step)
  326. {
  327. bool isCel = false;
  328. if (fabs(modf(curPos/(double)(m_z_WP.step*10.0),&tmpDbl))<0.00001)
  329. {
  330. if (actP)
  331. glColor4f(0.0f, 0.0f,0.0f, m_z_WP.a+0.6f);
  332. else
  333. glColor4f(0.0f, 0.0f, 0.0f, m_z_WP.a+0.3f);
  334. isCel = true;
  335. }
  336. glVertex3d(curPos, begVal1, resPnt.z);
  337. glVertex3d(curPos, endVal1, resPnt.z);
  338. if (isCel)
  339. {
  340. if (actP)
  341. glColor4f(m_z_WP.r, m_z_WP.g, m_z_WP.b, m_z_WP.a+0.4f);
  342. else
  343. glColor4f(m_z_WP.r, m_z_WP.g, m_z_WP.b, m_z_WP.a+0.1f);
  344. }
  345. }
  346. glEnd();
  348. }
  349. }
  351. DrawAxes(cam);
  353. if (isCommanderRegime && m_snap_point && m_active_work_plane->step>FLT_EPSILON && m_grid_lines_count>0
  354.  && m_use_plane_point)
  355. {
  356. glBegin(GL_LINES);
  357. glColor4f(m_active_work_plane->r, m_active_work_plane->g, m_active_work_plane->b, 1.0f);
  358. if (m_active_work_plane==&m_x_WP)
  359. {
  360. glVertex3d(m_snap_point->x,m_snap_point->y-m_active_work_plane->step*0.5,m_snap_point->z);
  361. glVertex3d(m_snap_point->x,m_snap_point->y+m_active_work_plane->step*0.5,m_snap_point->z);
  362. glVertex3d(m_snap_point->x,m_snap_point->y,m_snap_point->z-m_active_work_plane->step*0.5);
  363. glVertex3d(m_snap_point->x,m_snap_point->y,m_snap_point->z+m_active_work_plane->step*0.5);
  364. }
  367. if (m_active_work_plane==&m_y_WP)
  368. {
  369. glVertex3d(m_snap_point->x-m_active_work_plane->step*0.5,m_snap_point->y,m_snap_point->z);
  370. glVertex3d(m_snap_point->x+m_active_work_plane->step*0.5,m_snap_point->y,m_snap_point->z);
  371. glVertex3d(m_snap_point->x,m_snap_point->y,m_snap_point->z-m_active_work_plane->step*0.5);
  372. glVertex3d(m_snap_point->x,m_snap_point->y,m_snap_point->z+m_active_work_plane->step*0.5);
  373. }
  375. if (m_active_work_plane==&m_z_WP)
  376. {
  377. glVertex3d(m_snap_point->x-m_active_work_plane->step*0.5,m_snap_point->y,m_snap_point->z);
  378. glVertex3d(m_snap_point->x+m_active_work_plane->step*0.5,m_snap_point->y,m_snap_point->z);
  379. glVertex3d(m_snap_point->x,m_snap_point->y-m_active_work_plane->step*0.5,m_snap_point->z);
  380. glVertex3d(m_snap_point->x,m_snap_point->y+m_active_work_plane->step*0.5,m_snap_point->z);
  381. }
  382. glEnd();
  385. }
  387. glPopAttrib();
  389. }
  391. #include <float.h>
  393. SG_POINT*  CPlanes::GetPointOnWorkPlanes( SG_POINT* begAxePnt, SG_VECTOR* naprCos)
  394. {
  395. SG_VECTOR planeNorm;
  396. SG_POINT  tmpPnt;
  397. double    dist = DBL_MAX;
  398. SG_POINT  resPnt;
  399. double    tmpDst ;
  401. m_active_work_plane = NULL;
  402. if (m_snap_point)
  403. {
  404. delete m_snap_point;
  405. m_snap_point = NULL;
  406. }
  408. #define   COSINUS_60    0.5
  410. bool   second_prohod = false;
  412. sec_pr:
  413. if (m_x_WP.enable)
  414. {
  415. planeNorm.x = 1.0;
  416. planeNorm.y = 0.0; 
  417. planeNorm.z = 0.0;
  419. if ((second_prohod || fabs(naprCos->x)>COSINUS_60) && sgSpaceMath::IntersectPlaneAndLine(planeNorm, -m_x_WP.position, 
  420. *begAxePnt, *naprCos,
  421. tmpPnt)==1)
  422. {
  423. if (((tmpPnt.x-begAxePnt->x)*naprCos->x+
  424.  (tmpPnt.y-begAxePnt->y)*naprCos->y+
  425.  (tmpPnt.z-begAxePnt->z)*naprCos->z)>0.00001)
  426. {
  427. tmpDst = sgSpaceMath::PointsDistance(tmpPnt,*begAxePnt);
  428. if (tmpDst>0.00001)
  429. if (tmpDst<dist)
  430. {
  431. dist = tmpDst;
  432. m_active_work_plane = &m_x_WP;
  433. resPnt = tmpPnt;
  434. }
  435. }
  436. }
  437. }
  439. if (m_y_WP.enable)
  440. {
  441. planeNorm.x = 0.0;
  442. planeNorm.y = 1.0; 
  443. planeNorm.z = 0.0;
  445. if ((second_prohod || fabs(naprCos->y)>COSINUS_60) && sgSpaceMath::IntersectPlaneAndLine(planeNorm, -m_y_WP.position, 
  446. *begAxePnt, *naprCos,
  447. tmpPnt)==1)
  448. {
  449. if (((tmpPnt.x-begAxePnt->x)*naprCos->x+
  450.  (tmpPnt.y-begAxePnt->y)*naprCos->y+
  451.  (tmpPnt.z-begAxePnt->z)*naprCos->z)>0.00001)
  452. {
  453. tmpDst = sgSpaceMath::PointsDistance(tmpPnt,*begAxePnt);
  454. if (tmpDst>0.00001)
  455. if (tmpDst<dist)
  456. {
  457. dist = tmpDst;
  458. m_active_work_plane = &m_y_WP;
  459. resPnt = tmpPnt;
  460. }
  461. }
  462. }
  463. }
  465. if (m_z_WP.enable)
  466. {
  467. planeNorm.x = 0.0;
  468. planeNorm.y = 0.0; 
  469. planeNorm.z = 1.0;
  471. if ((second_prohod || fabs(naprCos->z)>COSINUS_60) && sgSpaceMath::IntersectPlaneAndLine(planeNorm, -m_z_WP.position, 
  472. *begAxePnt, *naprCos,
  473. tmpPnt)==1)
  474. {
  475. if (((tmpPnt.x-begAxePnt->x)*naprCos->x+
  476. (tmpPnt.y-begAxePnt->y)*naprCos->y+
  477. (tmpPnt.z-begAxePnt->z)*naprCos->z)>0.00001)
  478. {
  479. tmpDst = sgSpaceMath::PointsDistance(tmpPnt,*begAxePnt);
  480. if (tmpDst>0.00001)
  481. if (tmpDst<dist)
  482. {
  483. dist = tmpDst;
  484. m_active_work_plane = &m_z_WP;
  485. resPnt = tmpPnt;
  486. }
  487. }
  488. }
  489. }
  491. if (!second_prohod && m_active_work_plane==NULL)
  492. {
  493. second_prohod = true;
  494. goto sec_pr;
  495. }
  497. if (m_active_work_plane)
  498. {
  499. m_snap_point = new SG_POINT;
  500. *m_snap_point = resPnt;
  501. }
  502. return m_snap_point;
  503. }
  505. void   CPlanes::GetCurrentWorkPlane(double& d, SG_VECTOR& nrml)
  506. {
  507. if (!m_active_work_plane)
  508. {
  509. ASSERT(0);
  510. return;
  511. }
  512. d = m_active_work_plane->position;
  513. if (m_active_work_plane==&m_x_WP)
  514. {
  515. nrml.x = 1.0;
  516. nrml.y = 0.0;
  517. nrml.z = 0.0;
  518. }
  519. else
  520. if (m_active_work_plane==&m_y_WP)
  521. {
  522. nrml.x = 0.0;
  523. nrml.y = 1.0;
  524. nrml.z = 0.0;
  525. }
  526. else
  527. if (m_active_work_plane==&m_z_WP)
  528. {
  529. nrml.x = 0.0;
  530. nrml.y = 0.0;
  531. nrml.z = 1.0;
  532. }
  533. else
  534. {
  535. ASSERT(0);
  536. }
  537. }
  539. float  CPlanes::GetActiveWorkPlaneGridSize()
  540. {
  541. if (m_z_WP.enable)
  542. return m_z_WP.step;
  543. if (m_y_WP.enable)
  544. return m_y_WP.step;
  545. if (m_x_WP.enable)
  546. return m_x_WP.step;
  547. ASSERT(0);
  548. return 0.0f;
  549. }