API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Nov 22nd, 2013
105
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 25.36 KB | None | 0 0
raw download clone embed print report
  1. #include "stdafx.h"
  2.  
  3.  
  4. void CVertexHandle::AddVertex( int g, int e, int f, int v )
  5. {
  6. for( int i = 0; i < ( int )m_iGroupsArray.size(); i++ )
  7. {
  8. int gi = m_iGroupsArray[i];
  9. int ei = m_iElementsArray[i];
  10. int fi = m_iFacesArray[i];
  11. int vi = m_iVertexesArray[i];
  12.  
  13. if( gi == g && ei == e && fi == f && vi == v )
  14. return;
  15. }
  16.  
  17. m_iGroupsArray.push_back( g );
  18. m_iElementsArray.push_back( e );
  19. m_iFacesArray.push_back( f );
  20. m_iVertexesArray.push_back( v );
  21. }
  22.  
  23. void CVertexHandle::ReCalcHandle()
  24. {
  25. if( m_bEdgeHandle )
  26. {
  27. for( int i = 0; i < ( int )m_iGroupsArray.size(); i++ )
  28. {
  29. int g = m_iGroupsArray[i];
  30. int e = m_iElementsArray[i];
  31. int f = m_iFacesArray[i];
  32. int v = m_iVertexesArray[i];
  33.  
  34. CMesh mesh;
  35.  
  36. CBrush *brush = dynamic_cast < CBrush * > ( gGroups[g]->elements[e] );
  37. CTriger *triger = dynamic_cast < CTriger * > ( gGroups[g]->elements[e] );
  38.  
  39. if( brush )
  40. mesh = brush->mesh;
  41. else if( triger )
  42. mesh = triger->mesh;
  43.  
  44. Vector vec = mesh.faces[f].vertexes[v];
  45.  
  46. if( i == 0 )
  47. {
  48. v1 = vec;
  49. v2 = vec;
  50. }
  51. else
  52. {
  53. if( ( vec - v1 ).Length() > EPS )
  54. v2 = vec;
  55. }
  56.  
  57. origin = ( v1 + v2 ) / 2;
  58. }
  59. }
  60. else
  61. {
  62. int g = m_iGroupsArray[0];
  63. int e = m_iElementsArray[0];
  64. int f = m_iFacesArray[0];
  65. int v = m_iVertexesArray[0];
  66.  
  67. CMesh mesh;
  68.  
  69. CBrush *brush = dynamic_cast < CBrush * > ( gGroups[g]->elements[e] );
  70. CTriger *triger = dynamic_cast < CTriger * > ( gGroups[g]->elements[e] );
  71.  
  72. if( brush )
  73. mesh = brush->mesh;
  74. else if( triger )
  75. mesh = triger->mesh;
  76.  
  77. origin = v1 = v2 = mesh.faces[f].vertexes[v];
  78. }
  79. }
  80.  
  81. void CVertexHandle::Draw( int viewportIndex )
  82. {
  83. glColor4f( 0.0f, 0.0f, 0.0f, 1.0f );
  84.  
  85. if( viewportIndex )
  86. {
  87. glBegin( GL_QUADS );
  88. glVertex3fv( &Vector( gViewports[ viewportIndex ]->WorldToScreen( origin ) + Vector( -4, 4, 0 ) )[0] );
  89. glVertex3fv( &Vector( gViewports[ viewportIndex ]->WorldToScreen( origin ) + Vector( -4, -4, 0 ) )[0] );
  90. glVertex3fv( &Vector( gViewports[ viewportIndex ]->WorldToScreen( origin ) + Vector( 4, -4, 0 ) )[0] );
  91. glVertex3fv( &Vector( gViewports[ viewportIndex ]->WorldToScreen( origin ) + Vector( 4, 4, 0 ) )[0] );
  92. glEnd();
  93. }
  94. else
  95. {
  96. glPointSize( 8.0f );
  97. glBegin( GL_POINTS );
  98. glVertex3fv( &origin[0] );
  99. glEnd();
  100. }
  101.  
  102. if( selected )
  103. glColor4f( 1.0f, 0.0f, 0.0f, 1.0f );
  104. else if( m_bEdgeHandle )
  105. glColor4f( 1.0f, 0.5f, 0.0f, 1.0f );
  106. else
  107. glColor4f( 1.0f, 1.0f, 1.0f, 1.0f );
  108.  
  109. if( viewportIndex )
  110. {
  111. glBegin( GL_QUADS );
  112. glVertex3fv( &Vector( gViewports[ viewportIndex ]->WorldToScreen( origin ) + Vector( -2.5f, 2.5f, 0 ) )[0] );
  113. glVertex3fv( &Vector( gViewports[ viewportIndex ]->WorldToScreen( origin ) + Vector( -2.5f, -2.5f, 0 ) )[0] );
  114. glVertex3fv( &Vector( gViewports[ viewportIndex ]->WorldToScreen( origin ) + Vector( 2.5f, -2.5f, 0 ) )[0] );
  115. glVertex3fv( &Vector( gViewports[ viewportIndex ]->WorldToScreen( origin ) + Vector( 2.5f, 2.5f, 0 ) )[0] );
  116. glEnd();
  117. }
  118. else
  119. {
  120. glPointSize( 5.0f );
  121. glBegin( GL_POINTS );
  122. glVertex3fv( &origin[0] );
  123. glEnd();
  124. }
  125. }
  126.  
  127. void CVertexHandle::Shift( Vector shift )
  128. {
  129. for( int i = 0; i < ( int )m_iGroupsArray.size(); i++ )
  130. {
  131. int g = m_iGroupsArray[i];
  132. int e = m_iElementsArray[i];
  133. int f = m_iFacesArray[i];
  134. int v = m_iVertexesArray[i];
  135.  
  136. handleVertex hv;
  137. hv.g = g;
  138. hv.e = e;
  139. hv.f = f;
  140. hv.v = v;
  141. hv.shift = shift;
  142.  
  143. bool found = false;
  144. for( int j = 0; j < ( int )( ( CVertexTool * )gToolManager.m_pCurrentTool )->ShiftVerts.size(); j++ )
  145. {
  146. if( ( ( CVertexTool * )gToolManager.m_pCurrentTool )->ShiftVerts[j].g == hv.g &&
  147. ( ( CVertexTool * )gToolManager.m_pCurrentTool )->ShiftVerts[j].e == hv.e &&
  148. ( ( CVertexTool * )gToolManager.m_pCurrentTool )->ShiftVerts[j].f == hv.f &&
  149. ( ( CVertexTool * )gToolManager.m_pCurrentTool )->ShiftVerts[j].v == hv.v )
  150. {
  151. found = true;
  152. break;
  153. }
  154. }
  155.  
  156. if( !found )
  157. ( ( CVertexTool * )gToolManager.m_pCurrentTool )->ShiftVerts.push_back( hv );
  158. }
  159. }
  160.  
  161. bool CVertexHandle::IsHaveVertex( int g, int e, int f, int v )
  162. {
  163. for( int i = 0; i < ( int )m_iGroupsArray.size(); i++ )
  164. {
  165. int gi = m_iGroupsArray[i];
  166. int ei = m_iElementsArray[i];
  167. int fi = m_iFacesArray[i];
  168. int vi = m_iVertexesArray[i];
  169.  
  170. if( gi == g && ei == e && fi == f && vi == v )
  171. return true;
  172. }
  173.  
  174. return false;
  175. }
  176.  
  177.  
  178.  
  179. class CHotKeyVertexToolCtrlF : public CHotKeyAction
  180. {
  181. public:
  182. virtual void Action()
  183. {
  184. ( ( CVertexTool * )gToolManager.m_pCurrentTool )->CreateEdge();
  185. }
  186. };
  187.  
  188.  
  189. CVertexTool::CVertexTool()
  190. {
  191. state = VTS_NONE;
  192. }
  193.  
  194. void CVertexTool::Activated()
  195. {
  196. state = VTS_NONE;
  197.  
  198. BuildHandles();
  199.  
  200. gActionTracker.StartTransaction();
  201. for( vector < CGroup * >::iterator i = gGroups.begin(); i != gGroups.end(); i++ )
  202. {
  203. if( ( *i )->IsSelected() )
  204. {
  205. gActionTracker.RegisterStartChanges( *i );
  206. ( *i )->DrawBackFaces( true );
  207. }
  208. }
  209.  
  210. ShiftVerts.clear();
  211.  
  212. CtrlF = gHotKeysManager.RegisterHotKey( "Ctrl+F", new CHotKeyVertexToolCtrlF() );
  213. }
  214.  
  215. void CVertexTool::Deactivated()
  216. {
  217. for( vector < CGroup * >::reverse_iterator i = gGroups.rbegin(); i != gGroups.rend(); i++ )
  218. {
  219. if( ( *i )->IsSelected() )
  220. {
  221. int color = RandomLong( 0, 9 );
  222. ( *i )->SetColor( wireframeColors[ color ][ 0 ], wireframeColors[ color ][ 1 ], wireframeColors[ color ][ 2 ] );
  223. ( *i )->DrawBackFaces( false );
  224. gActionTracker.RegisterEndChanges( *i );
  225. }
  226. }
  227. gActionTracker.EndTransaction();
  228.  
  229. UnSelectAll();
  230.  
  231. handles.clear();
  232.  
  233. gHotKeysManager.UnRegisterHotKey( CtrlF );
  234. }
  235.  
  236. bool CVertexTool::OnMouseDown( int key )
  237. {
  238. if( g_iActiveViewport == -1 )
  239. return false;
  240.  
  241. int v = g_iActiveViewport;
  242. m_iViewportIndex = g_iActiveViewport;
  243.  
  244. int x = gViewports[ m_iViewportIndex ]->m_iAxisX;
  245. int y = gViewports[ m_iViewportIndex ]->m_iAxisY;
  246. int z = gViewports[ m_iViewportIndex ]->m_iAxisZ;
  247.  
  248. if( key == VK_LBUTTON )
  249. {
  250. if( g_iActiveViewport == 0 )
  251. {
  252. if( !gInput.IsKeyPressed( VK_CONTROL ) )
  253. UnSelectHandles();
  254.  
  255. for( int i = 0; i < ( int )handles.size(); i++ )
  256. {
  257. if( DotProduct( gViewports[v]->camMatrix.GetForwardVector(), handles[i].origin - gViewports[v]->origin ) > 0.0f )
  258. continue;
  259.  
  260. double ox;
  261. double oy;
  262. double oz;
  263.  
  264. gluProject( handles[i].origin.x,
  265. handles[i].origin.y,
  266. handles[i].origin.z,
  267. gViewports[v]->modelview,
  268. gViewports[v]->projection,
  269. gViewports[v]->viewport,
  270. &ox, &oy, &oz );
  271.  
  272. Vector point1( ( float )ox, ( float )oy, 0 );
  273. Vector point2( ( float )gViewports[v]->m_iMousePosX, ( float )gViewports[v]->m_iMousePosY, 0.0f );
  274.  
  275. if( ( point1 - point2 ).Length() < 3 )
  276. handles[i].selected = !handles[i].selected;
  277.  
  278. }
  279. }
  280. else
  281. {
  282. bool s = false;
  283.  
  284. for( int i = 0; i < ( int )handles.size(); i++ )
  285. {
  286. Vector point1 = gViewports[v]->WorldToScreen( handles[i].origin );
  287. Vector point2( ( float )( gViewports[v]->m_iMousePosX - gViewports[v]->m_iCenterX ),
  288. ( float )( gViewports[v]->m_iMousePosY - gViewports[v]->m_iCenterY ), 0.0f );
  289.  
  290. if( ( point1 - point2 ).Length() < 3 && handles[i].selected )
  291. s = true;
  292.  
  293. }
  294.  
  295. if( !s )
  296. {
  297. if( !gInput.IsKeyPressed( VK_CONTROL ) )
  298. UnSelectHandles();
  299.  
  300. vector < handleVertex > tShiftVerts = ShiftVerts;
  301.  
  302. ShiftVerts.clear();
  303.  
  304. for( int i = 0; i < ( int )handles.size(); i++ )
  305. {
  306. Vector point1 = gViewports[v]->WorldToScreen( handles[i].origin );
  307. Vector point2( ( float )( gViewports[v]->m_iMousePosX - gViewports[v]->m_iCenterX ),
  308. ( float )( gViewports[v]->m_iMousePosY - gViewports[v]->m_iCenterY ), 0.0f );
  309.  
  310. if( ( point1 - point2 ).Length() < 3 )
  311. {
  312. handles[i].selected = !handles[i].selected;
  313.  
  314. state = VTS_DRAGED;
  315. draged = false;
  316. m_vStartPos = m_vLastPos =
  317. gViewports[v]->ScreenToWorld( Vector( ( float )gViewports[v]->m_iMousePosX - gViewports[v]->m_iCenterX,
  318. ( float )gViewports[v]->m_iMousePosY - gViewports[v]->m_iCenterY, 0.0f ) );
  319.  
  320.  
  321. m_vStartPos[z] = 0;
  322. m_vLastPos[z] = 0;
  323. m_vLastPos = gViewports[v]->SnapToGrid( m_vLastPos );
  324. m_vStartPos = gViewports[v]->SnapToGrid( m_vStartPos );
  325.  
  326.  
  327. Vector shift = m_vStartPos - handles[i].origin;
  328. shift[z] = 0;
  329. handles[i].Shift( shift );
  330.  
  331.  
  332. }
  333.  
  334.  
  335. }
  336.  
  337. ShiftAll();
  338. ShiftVerts = tShiftVerts;
  339. for( int i = 0; i < ( int )handles.size(); i++ )
  340. handles[i].ReCalcHandle();
  341. }
  342. else
  343. {
  344. vector < handleVertex > tShiftVerts = ShiftVerts;
  345.  
  346. ShiftVerts.clear();
  347.  
  348. for( int i = 0; i < ( int )handles.size(); i++ )
  349. {
  350. Vector point1 = gViewports[v]->WorldToScreen( handles[i].origin );
  351. Vector point2( ( float )( gViewports[v]->m_iMousePosX - gViewports[v]->m_iCenterX ),
  352. ( float )( gViewports[v]->m_iMousePosY - gViewports[v]->m_iCenterY ), 0.0f );
  353.  
  354. if( ( point1 - point2 ).Length() < 3 )
  355. {
  356.  
  357. state = VTS_DRAGED;
  358. draged = false;
  359. m_vStartPos = m_vLastPos =
  360. gViewports[v]->ScreenToWorld( Vector( ( float )gViewports[v]->m_iMousePosX - gViewports[v]->m_iCenterX,
  361. ( float )gViewports[v]->m_iMousePosY - gViewports[v]->m_iCenterY, 0.0f ) );
  362.  
  363.  
  364. m_vStartPos[z] = 0;
  365. m_vLastPos[z] = 0;
  366. m_vLastPos = gViewports[v]->SnapToGrid( m_vLastPos );
  367. m_vStartPos = gViewports[v]->SnapToGrid( m_vStartPos );
  368.  
  369.  
  370. Vector shift = m_vStartPos - handles[i].origin;
  371. shift[z] = 0;
  372. handles[i].Shift( shift );
  373.  
  374.  
  375. }
  376.  
  377.  
  378. }
  379.  
  380. ShiftAll();
  381. ShiftVerts = tShiftVerts;
  382. for( int i = 0; i < ( int )handles.size(); i++ )
  383. handles[i].ReCalcHandle();
  384. }
  385. }
  386. }
  387. else
  388. {
  389. return false;
  390. }
  391.  
  392. return false;
  393. }
  394.  
  395. bool CVertexTool::OnMouseUp( int key )
  396. {
  397. if( state != VTS_DRAGED )
  398. return false;
  399.  
  400. if( key == VK_LBUTTON )
  401. {
  402. state = VTS_NONE;
  403.  
  404. int v = m_iViewportIndex;
  405.  
  406. Vector vCurrentPos;
  407. vCurrentPos = gViewports[v]->ScreenToWorld( Vector( ( float )gViewports[v]->m_iMousePosX - gViewports[v]->m_iCenterX,
  408. ( float )gViewports[v]->m_iMousePosY - gViewports[v]->m_iCenterY, 0.0f ) );
  409. vCurrentPos = gViewports[v]->SnapToGrid( vCurrentPos );
  410.  
  411. if( !draged )
  412. {
  413. if( !gInput.IsKeyPressed( VK_CONTROL ) )
  414. UnSelectHandles();
  415.  
  416. for( int i = 0; i < ( int )handles.size(); i++ )
  417. {
  418. Vector point1 = gViewports[v]->WorldToScreen( handles[i].origin );
  419. Vector point2( ( float )( gViewports[v]->m_iMousePosX - gViewports[v]->m_iCenterX ),
  420. ( float )( gViewports[v]->m_iMousePosY - gViewports[v]->m_iCenterY ), 0.0f );
  421.  
  422. if( ( point1 - point2 ).Length() < 3 )
  423. handles[i].selected = true;
  424. }
  425. }
  426.  
  427. if( NeedMerge() )
  428. {
  429. if( MessageBox::Show( L"Совместить вершины?", "", MessageBoxButtons::YesNo ) == ::DialogResult::Yes )
  430. {
  431. MergeVerts();
  432. BuildHandles();
  433. }
  434. }
  435. }
  436. else
  437. {
  438. return false;
  439. }
  440. return false;
  441. }
  442.  
  443. bool CVertexTool::OnKeyDown( int key )
  444. {
  445. return false;
  446. }
  447.  
  448. bool CVertexTool::OnKeyUp( int key )
  449. {
  450. return false;
  451. }
  452.  
  453. void CVertexTool::Think()
  454. {
  455. if( state != VTS_DRAGED )
  456. return;
  457.  
  458. int v = m_iViewportIndex;
  459.  
  460. int x = gViewports[ m_iViewportIndex ]->m_iAxisX;
  461. int y = gViewports[ m_iViewportIndex ]->m_iAxisY;
  462. int z = gViewports[ m_iViewportIndex ]->m_iAxisZ;
  463.  
  464. Vector vCurrentPos;
  465. vCurrentPos = gViewports[v]->ScreenToWorld( Vector( ( float )gViewports[v]->m_iMousePosX - gViewports[v]->m_iCenterX,
  466. ( float )gViewports[v]->m_iMousePosY - gViewports[v]->m_iCenterY, 0.0f ) );
  467. vCurrentPos[z] = 0;
  468. vCurrentPos = gViewports[v]->SnapToGrid( vCurrentPos );
  469.  
  470. if( ( vCurrentPos - m_vLastPos ).Length() < EPS )
  471. /*return*/;
  472. else
  473. draged = true;
  474.  
  475. ShiftVerts.clear();
  476.  
  477. for( int i = 0; i < ( int )handles.size(); i++ )
  478. if( handles[i].selected )
  479. handles[i].Shift( vCurrentPos - m_vLastPos );
  480.  
  481. m_vLastPos = vCurrentPos;
  482.  
  483. ShiftAll();
  484.  
  485. for( int i = 0; i < ( int )handles.size(); i++ )
  486. handles[i].ReCalcHandle();
  487.  
  488. for( int i = 0; i < ( int )gGroups.size(); i++ )
  489. if( gGroups[ i ]->IsSelected() )
  490. gGroups[i]->ReCalcInfo();
  491. }
  492.  
  493. void CVertexTool::Draw( int viewportIndex )
  494. {
  495. glDisable( GL_DEPTH_TEST );
  496.  
  497. for( int i = 0; i < ( int )handles.size(); i++ )
  498. if( !handles[i].selected )
  499. handles[i].Draw( viewportIndex );
  500.  
  501. for( int i = 0; i < ( int )handles.size(); i++ )
  502. if( handles[i].selected )
  503. handles[i].Draw( viewportIndex );
  504.  
  505. glEnable( GL_DEPTH_TEST );
  506. }
  507.  
  508. void CVertexTool::AddVertex( int g, int e, int f, int v )
  509. {
  510. Vector vec;
  511.  
  512. CBrush *brush = dynamic_cast < CBrush * > ( gGroups[g]->elements[e] );
  513. CTriger *triger = dynamic_cast < CTriger * > ( gGroups[g]->elements[e] );
  514.  
  515. if( brush )
  516. vec = brush->mesh.faces[f].vertexes[v];
  517. else if( triger )
  518. vec = triger->mesh.faces[f].vertexes[v];
  519. else
  520. return;
  521.  
  522. for( int i = 0; i < ( int )handles.size(); i++ )
  523. {
  524. if( handles[i].m_bEdgeHandle )
  525. {
  526. if( ( vec - handles[i].v1 ).Length() < EPS || ( vec - handles[i].v2 ).Length() < EPS )
  527. {
  528. handles[i].AddVertex( g, e, f, v );
  529. }
  530. }
  531. }
  532.  
  533. for( int i = 0; i < ( int )handles.size(); i++ )
  534. {
  535. if( !handles[i].m_bEdgeHandle )
  536. {
  537. if( ( vec - handles[i].v1 ).Length() < EPS || ( vec - handles[i].v2 ).Length() < EPS )
  538. {
  539. handles[i].AddVertex( g, e, f, v );
  540. return;
  541. }
  542. }
  543. }
  544.  
  545. CVertexHandle handle;
  546. handle.selected = false;
  547. handle.m_bEdgeHandle = false;
  548. handle.v1 = handle.v2 = handle.origin = vec;
  549. handle.AddVertex( g, e, f, v );
  550. handles.push_back( handle );
  551. }
  552.  
  553. void CVertexTool::AddEdge( int g1, int e1, int f1, int v1, int g2, int e2, int f2, int v2 )
  554. {
  555. Vector vec1, vec2;
  556.  
  557. CBrush *brush1 = dynamic_cast < CBrush * > ( gGroups[g1]->elements[e1] );
  558. CTriger *triger1 = dynamic_cast < CTriger * > ( gGroups[g1]->elements[e1] );
  559.  
  560. CBrush *brush2 = dynamic_cast < CBrush * > ( gGroups[g2]->elements[e2] );
  561. CTriger *triger2 = dynamic_cast < CTriger * > ( gGroups[g2]->elements[e2] );
  562.  
  563. if( brush1 )
  564. vec1 = brush1->mesh.faces[f1].vertexes[v1];
  565. else if( triger1 )
  566. vec1 = triger1->mesh.faces[f1].vertexes[v1];
  567. else
  568. return;
  569.  
  570. if( brush2 )
  571. vec2 = brush2->mesh.faces[f2].vertexes[v2];
  572. else if( triger2 )
  573. vec2 = triger2->mesh.faces[f2].vertexes[v2];
  574. else
  575. return;
  576.  
  577. Vector vec = ( vec1 + vec2 ) / 2;
  578.  
  579. for( int i = 0; i < ( int )handles.size(); i++ )
  580. {
  581. if( handles[i].m_bEdgeHandle )
  582. {
  583. if( ( vec - handles[i].origin ).Length() < EPS )
  584. {
  585. handles[i].AddVertex( g1, e1, f1, v1 );
  586. handles[i].AddVertex( g2, e2, f2, v2 );
  587. return;
  588. }
  589. }
  590. }
  591.  
  592. CVertexHandle handle;
  593. handle.selected = false;
  594. handle.m_bEdgeHandle = true;
  595. handle.v1 = vec1;
  596. handle.v2 = vec2;
  597. handle.origin = vec;
  598. handle.AddVertex( g1, e1, f1, v1 );
  599. handle.AddVertex( g2, e2, f2, v2 );
  600. handles.push_back( handle );
  601. }
  602.  
  603. void CVertexTool::UnSelectHandles()
  604. {
  605. for( int i = 0; i < ( int )handles.size(); i++ )
  606. handles[i].selected = false;
  607. }
  608.  
  609. void CVertexTool::BuildHandles()
  610. {
  611. handles.clear();
  612.  
  613. for( int g = 0; g < ( int )gGroups.size(); g++ )
  614. {
  615. if( !gGroups[g]->IsSelected() )
  616. continue;
  617.  
  618. for( int e = 0; e < ( int )gGroups[g]->elements.size(); e++ )
  619. {
  620. CMesh mesh;
  621.  
  622. CBrush *brush = dynamic_cast < CBrush * > ( gGroups[g]->elements[e] );
  623. CTriger *triger = dynamic_cast < CTriger * > ( gGroups[g]->elements[e] );
  624.  
  625. if( brush )
  626. mesh = brush->mesh;
  627. else if( triger )
  628. mesh = triger->mesh;
  629. else
  630. continue;
  631.  
  632. for( int f = 0; f < mesh.numFaces; f++ )
  633. {
  634. for( int v = 0; v < mesh.faces[f].numVerts; v++ )
  635. {
  636. if( v == mesh.faces[f].numVerts - 1 )
  637. AddEdge( g, e, f, v, g, e, f, 0 );
  638. else
  639. AddEdge( g, e, f, v, g, e, f, v + 1 );
  640. }
  641. }
  642. }
  643. }
  644.  
  645. for( int g = 0; g < ( int )gGroups.size(); g++ )
  646. {
  647. if( !gGroups[g]->IsSelected() )
  648. continue;
  649.  
  650. for( int e = 0; e < ( int )gGroups[g]->elements.size(); e++ )
  651. {
  652. CMesh mesh;
  653.  
  654. CBrush *brush = dynamic_cast < CBrush * > ( gGroups[g]->elements[e] );
  655. CTriger *triger = dynamic_cast < CTriger * > ( gGroups[g]->elements[e] );
  656.  
  657. if( brush )
  658. mesh = brush->mesh;
  659. else if( triger )
  660. mesh = triger->mesh;
  661. else
  662. continue;
  663.  
  664. for( int f = 0; f < mesh.numFaces; f++ )
  665. {
  666. for( int v = 0; v < mesh.faces[f].numVerts; v++ )
  667. {
  668. AddVertex( g, e, f, v );
  669. }
  670. }
  671. }
  672. }
  673. }
  674.  
  675. void CVertexTool::MergeVerts()
  676. {
  677. for( int i = 0; i < ( int )gGroups.size(); i++ )
  678. {
  679. if( !gGroups[i]->IsSelected() )
  680. continue;
  681.  
  682. for( int j = 0; j < ( int )gGroups[i]->elements.size(); j++ )
  683. {
  684. CMesh mesh;
  685.  
  686. CBrush *brush = dynamic_cast < CBrush * > ( gGroups[i]->elements[j] );
  687. CTriger *triger = dynamic_cast < CTriger * > ( gGroups[i]->elements[j] );
  688.  
  689. if( brush )
  690. {
  691. mesh = brush->mesh;
  692. mesh = MergeVertsInMesh( mesh );
  693. brush->mesh = mesh;
  694. }
  695. else if( triger )
  696. {
  697. mesh = triger->mesh;
  698. mesh = MergeVertsInMesh( mesh );
  699. triger->mesh = mesh;
  700. }
  701. }
  702.  
  703. gGroups[i]->ReCalcInfo();
  704. gGroups[i]->Select();
  705. }
  706. }
  707.  
  708. CMesh CVertexTool::MergeVertsInMesh( CMesh mesh )
  709. {
  710. CMesh res;
  711.  
  712. vector < CFace > faces;
  713.  
  714. for( int i = 0; i < mesh.numFaces; i++ )
  715. {
  716. CFace face = MergeVertsInFace( mesh.faces[i] );
  717. if( face.numVerts >= 3 )
  718. faces.push_back( face );
  719. }
  720.  
  721.  
  722. res.numFaces = ( int )faces.size();
  723. res.faces = new CFace[ ( int )faces.size() ];
  724.  
  725. for( int i = 0; i < ( int )faces.size(); i++ )
  726. res.faces[i] = faces[i];
  727.  
  728. return res;
  729. }
  730.  
  731. CFace CVertexTool::MergeVertsInFace( CFace face )
  732. {
  733. CFace res;
  734.  
  735. vector < Vector > verts;
  736.  
  737. for( int i = 0; i < face.numVerts; i++ )
  738. {
  739. bool push = true;
  740. for( int j = 0; j < ( int )verts.size(); j++ )
  741. {
  742. if( ( verts[j] - face.vertexes[i] ).Length() < EPS )
  743. {
  744. push = false;
  745. break;
  746. }
  747. }
  748. if( push )
  749. verts.push_back( face.vertexes[i] );
  750. }
  751.  
  752.  
  753. res = face;
  754.  
  755. Vector *vertexes = new Vector[ ( int )verts.size() ];
  756.  
  757. for( int j = 0; j < ( int )verts.size(); j++ )
  758. vertexes[j] = verts[j];
  759.  
  760. res.MakeFace( vertexes, ( int )verts.size() );
  761.  
  762. return res;
  763. }
  764.  
  765. bool CVertexTool::NeedMerge()
  766. {
  767. for( int i = 0; i < ( int )handles.size(); i++ )
  768. for( int j = i + 1; j < ( int )handles.size(); j++ )
  769. if( !handles[i].m_bEdgeHandle && !handles[j].m_bEdgeHandle &&
  770. ( handles[i].origin - handles[j].origin ).Length() < EPS )
  771. return true;
  772. return false;
  773. }
  774.  
  775. void CVertexTool::ShiftAll()
  776. {
  777. for( vector < handleVertex >::iterator i = ShiftVerts.begin(); i != ShiftVerts.end(); i++ )
  778. {
  779. int g = ( *i ).g;
  780. int e = ( *i ).e;
  781. int f = ( *i ).f;
  782. int v = ( *i ).v;
  783.  
  784. CMesh *mesh;
  785.  
  786. CBrush *brush = dynamic_cast < CBrush * > ( gGroups[g]->elements[e] );
  787. CTriger *triger = dynamic_cast < CTriger * > ( gGroups[g]->elements[e] );
  788.  
  789. if( brush )
  790. mesh = &brush->mesh;
  791. else
  792. mesh = &triger->mesh;
  793.  
  794. mesh->faces[f].vertexes[v] += ( *i ).shift;
  795. }
  796.  
  797. ShiftVerts.clear();
  798. }
  799.  
  800. void CVertexTool::CreateEdge()
  801. {
  802. CVertexHandle hnd1, hnd2;
  803. int n = 0;
  804.  
  805. for( int i = 0; i < ( int )handles.size(); i++ )
  806. {
  807. if( handles[i].selected )
  808. {
  809. n++;
  810. if( n == 1 )
  811. hnd1 = handles[i];
  812. else if( n == 2 )
  813. hnd2 = handles[i];
  814. else
  815. return;
  816. }
  817. }
  818.  
  819. if( n != 2 )
  820. return;
  821.  
  822. bool bFindCommon = false;
  823.  
  824. Vector v1 = hnd1.origin, v2 = hnd2.origin;
  825.  
  826. for( int i = 0; i < ( int )hnd1.m_iGroupsArray.size(); i++ )
  827. {
  828. for( int j = 0; j < ( int )hnd2.m_iGroupsArray.size(); j++ )
  829. {
  830. if( hnd1.m_iGroupsArray[i] == hnd2.m_iGroupsArray[j] &&
  831. hnd1.m_iElementsArray[i] == hnd2.m_iElementsArray[j] &&
  832. hnd1.m_iFacesArray[i] == hnd2.m_iFacesArray[j] )
  833. {
  834. int g, e, f;
  835. g = hnd1.m_iGroupsArray[i];
  836. e = hnd1.m_iElementsArray[i];
  837. f = hnd1.m_iFacesArray[i];
  838.  
  839. CMesh *mesh;
  840.  
  841. CBrush *brush = dynamic_cast < CBrush * > ( gGroups[g]->elements[e] );
  842. CTriger *triger = dynamic_cast < CTriger * > ( gGroups[g]->elements[e] );
  843.  
  844. if( brush )
  845. mesh = &brush->mesh;
  846. else
  847. mesh = &triger->mesh;
  848.  
  849. CFace face = mesh->faces[f];
  850.  
  851. Vector vec = v1;
  852.  
  853. bool bAdd = false;
  854. for( int i = 0; i < face.numVerts; i++ )
  855. {
  856. int a = i;
  857. int b = i + 1;
  858. if( b == face.numVerts )
  859. b = 0;
  860.  
  861. if( fabs( ( vec - face.vertexes[a] ).Length() + ( face.vertexes[b] - vec ).Length() - ( face.vertexes[a] - face.vertexes[b] ).Length() ) < EPS )
  862. {
  863. bAdd = true;
  864. break;
  865. }
  866. }
  867.  
  868. if( !bAdd )
  869. continue;
  870.  
  871. vec = v2;
  872.  
  873. bAdd = false;
  874. for( int i = 0; i < face.numVerts; i++ )
  875. {
  876. int a = i;
  877. int b = i + 1;
  878. if( b == face.numVerts )
  879. b = 0;
  880.  
  881. if( fabs( ( vec - face.vertexes[a] ).Length() + ( face.vertexes[b] - vec ).Length() - ( face.vertexes[a] - face.vertexes[b] ).Length() ) < EPS )
  882. {
  883. bAdd = true;
  884. break;
  885. }
  886. }
  887.  
  888. if( !bAdd )
  889. continue;
  890.  
  891. bFindCommon = true;
  892. break;
  893. }
  894. }
  895. if( bFindCommon )
  896. break;
  897. }
  898.  
  899. if( !bFindCommon )
  900. return;
  901.  
  902.  
  903.  
  904.  
  905. if( hnd1.m_bEdgeHandle )
  906. {
  907. for( int i = 0; i < ( int )hnd1.m_iGroupsArray.size(); i++ )
  908. {
  909. bool bAdd = true;
  910. for( int j = i + 1; j < ( int )hnd1.m_iGroupsArray.size(); j++ )
  911. {
  912. if( hnd1.m_iGroupsArray[i] == hnd1.m_iGroupsArray[j] &&
  913. hnd1.m_iElementsArray[i] == hnd1.m_iElementsArray[j] &&
  914. hnd1.m_iFacesArray[i] == hnd1.m_iFacesArray[j] )
  915. {
  916. bAdd = false;
  917. break;
  918. }
  919. }
  920.  
  921. if( bAdd )
  922. AddVertexToFace( hnd1.m_iGroupsArray[i], hnd1.m_iElementsArray[i], hnd1.m_iFacesArray[i], v1 );
  923. }
  924. }
  925.  
  926. if( hnd2.m_bEdgeHandle )
  927. {
  928. for( int i = 0; i < ( int )hnd2.m_iGroupsArray.size(); i++ )
  929. {
  930. bool bAdd = true;
  931. for( int j = i + 1; j < ( int )hnd2.m_iGroupsArray.size(); j++ )
  932. {
  933. if( hnd2.m_iGroupsArray[i] == hnd2.m_iGroupsArray[j] &&
  934. hnd2.m_iElementsArray[i] == hnd2.m_iElementsArray[j] &&
  935. hnd2.m_iFacesArray[i] == hnd2.m_iFacesArray[j] )
  936. {
  937. bAdd = false;
  938. break;
  939. }
  940. }
  941.  
  942. if( bAdd )
  943. AddVertexToFace( hnd2.m_iGroupsArray[i], hnd2.m_iElementsArray[i], hnd2.m_iFacesArray[i], v2 );
  944. }
  945. }
  946.  
  947.  
  948.  
  949.  
  950.  
  951. for( int i = 0; i < ( int )hnd1.m_iGroupsArray.size(); i++ )
  952. {
  953. bool bAdd = true;
  954. for( int j = i + 1; j < ( int )hnd1.m_iGroupsArray.size(); j++ )
  955. {
  956. if( hnd1.m_iGroupsArray[i] == hnd1.m_iGroupsArray[j] &&
  957. hnd1.m_iElementsArray[i] == hnd1.m_iElementsArray[j] &&
  958. hnd1.m_iFacesArray[i] == hnd1.m_iFacesArray[j] )
  959. {
  960. bAdd = false;
  961. break;
  962. }
  963. }
  964.  
  965. if( bAdd )
  966. {
  967. bool bCanAdd = false;
  968. for( int j = 0; j < ( int )hnd2.m_iGroupsArray.size(); j++ )
  969. {
  970. if( hnd1.m_iGroupsArray[i] == hnd2.m_iGroupsArray[j] &&
  971. hnd1.m_iElementsArray[i] == hnd2.m_iElementsArray[j] &&
  972. hnd1.m_iFacesArray[i] == hnd2.m_iFacesArray[j] )
  973. {
  974. bCanAdd = true;
  975. break;
  976. }
  977. }
  978.  
  979. if( bCanAdd )
  980. if( AddEdgeToFace( hnd1.m_iGroupsArray[i], hnd1.m_iElementsArray[i], hnd1.m_iFacesArray[i], v1, v2 ) )
  981. break;
  982. }
  983. }
  984.  
  985. BuildHandles();
  986. }
  987.  
  988. void CVertexTool::AddVertexToFace( int g, int e, int f, Vector vec )
  989. {
  990. CMesh *mesh;
  991.  
  992. CBrush *brush = dynamic_cast < CBrush * > ( gGroups[g]->elements[e] );
  993. CTriger *triger = dynamic_cast < CTriger * > ( gGroups[g]->elements[e] );
  994.  
  995. if( brush )
  996. mesh = &brush->mesh;
  997. else
  998. mesh = &triger->mesh;
  999.  
  1000. CFace face = mesh->faces[f];
  1001.  
  1002. if( fabs( DotProduct( vec - face.vertexes[0], face.normal ) ) > EPS )
  1003. return;
  1004.  
  1005. bool bAdd = false;
  1006. for( int i = 0; i < face.numVerts; i++ )
  1007. {
  1008. int a = i;
  1009. int b = i + 1;
  1010. if( b == face.numVerts )
  1011. b = 0;
  1012.  
  1013. if( fabs( ( vec - face.vertexes[a] ).Length() + ( face.vertexes[b] - vec ).Length() - ( face.vertexes[b] - face.vertexes[a] ).Length() ) < EPS )
  1014. {
  1015. bAdd = true;
  1016. break;
  1017. }
  1018. }
  1019.  
  1020. if( !bAdd )
  1021. return;
  1022.  
  1023. Vector *vertexes = new Vector[ face.numVerts + 1 ];
  1024. memcpy( vertexes, face.vertexes, face.numVerts * sizeof( Vector ) );
  1025. vertexes[ face.numVerts ] = vec;
  1026.  
  1027. sort_by_polar_angle( vertexes, face.numVerts + 1, face.normal );
  1028.  
  1029. mesh->faces[f].MakeFace( vertexes, face.numVerts + 1 );
  1030.  
  1031. delete [] vertexes;
  1032. }
  1033.  
  1034. bool CVertexTool::AddEdgeToFace( int g, int e, int f, Vector vec1, Vector vec2 )
  1035. {
  1036. CMesh *mesh;
  1037.  
  1038. CBrush *brush = dynamic_cast < CBrush * > ( gGroups[g]->elements[e] );
  1039. CTriger *triger = dynamic_cast < CTriger * > ( gGroups[g]->elements[e] );
  1040.  
  1041. if( brush )
  1042. mesh = &brush->mesh;
  1043. else
  1044. mesh = &triger->mesh;
  1045.  
  1046. CFace face = mesh->faces[f];
  1047.  
  1048.  
  1049. bool find1 = false;
  1050. bool find2 = false;
  1051. for( int i = 0; i < face.numVerts; i++ )
  1052. {
  1053. if( ( face.vertexes[i] - vec1 ).Length() < EPS )
  1054. find1 = true;
  1055. if( ( face.vertexes[i] - vec2 ).Length() < EPS )
  1056. find2 = true;
  1057. }
  1058.  
  1059. if( !find1 || !find2 )
  1060. return false;
  1061.  
  1062. Vector planeNormal = CrossProduct( vec2 - vec1, face.normal );
  1063. planeNormal.Normalize();
  1064. CPlane clipPlane( planeNormal, vec1 );
  1065.  
  1066. CFace *frontFace;
  1067. CFace *backFace;
  1068.  
  1069. cliper::ClipFace( clipPlane, face, &frontFace, &backFace );
  1070.  
  1071. if( !frontFace || !backFace )
  1072. return true;
  1073.  
  1074.  
  1075.  
  1076.  
  1077. CFace f1 = CFace( *frontFace );
  1078. CFace f2 = CFace( *backFace );
  1079.  
  1080.  
  1081. delete frontFace;
  1082. delete backFace;
  1083.  
  1084. CFace *faces = new CFace[ mesh->numFaces + 1 ];
  1085. for( int i = 0; i < mesh->numFaces; i++ )
  1086. faces[i] = mesh->faces[i];
  1087. faces[ f ] = f1;
  1088. faces[ mesh->numFaces ] = f2;
  1089.  
  1090. delete [] mesh->faces;
  1091.  
  1092. mesh->numFaces++;
  1093. mesh->faces = new CFace[ mesh->numFaces ];
  1094. for( int i = 0; i < mesh->numFaces; i++ )
  1095. mesh->faces[i] = faces[i];
  1096.  
  1097. delete [] faces;
  1098.  
  1099. return true;
  1100. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!