/trunk/sources/utils/GraphViewer/Graph.cpp

# · C++ · 1038 lines · 823 code · 146 blank · 69 comment · 190 complexity · 4824be34091546e9906eec0112d796cd MD5 · raw file 

    

  1. //-------------------------------------------------------------------------------------------------

    2. 

  2. //

    3. 

  3. //-------------------------------------------------------------------------------------------------

    4. 

  4. 

    5. 

  5. //-------------------------------------------------------------------------------------------------

    6. 

  6. #include "stdafx.h"

    7. 

  7. #include "Graph.h"

    8. 

  8. 

    9. 

  9. 

    10. 

  10. 

    11. 

  11. ///////////////////////////////////////////////////////////////////////////////////////////////////

    12. 

  12. // game.graph

    13. 

  13. ///////////////////////////////////////////////////////////////////////////////////////////////////

    14. 

  14. 

    15. 

  15. //-------------------------------------------------------------------------------------------------

    16. 

  16. CGraph::CGraph()

    17. 

  17. {

    18. 

  18.     m_chFilename[0] = 0;

    19. 

  19.     m_pLevels = NULL;

    20. 

  20.     m_pVertexs = NULL;

    21. 

  21.     m_pEdges = NULL;

    22. 

  22.     m_pLevelPoints = NULL;

    23. 

  23.     m_pGrid = NULL;

    24. 

  24. }

    25. 

  25. 

    26. 

  26. //-------------------------------------------------------------------------------------------------

    27. 

  27. CGraph::~CGraph()

    28. 

  28. {

    29. 

  29.     Clean();

    30. 

  30. }

    31. 

  31. 

    32. 

  32. //-------------------------------------------------------------------------------------------------

    33. 

  33. void CGraph::Clean()

    34. 

  34. {

    35. 

  35.     m_chFilename[0] = 0;

    36. 

  36. 

    37. 

  37.     if (m_pLevels)

    38. 

  38.     {

    39. 

  39.         delete[] m_pLevels;

    40. 

  40.         m_pLevels = NULL;

    41. 

  41.     }

    42. 

  42. 

    43. 

  43.     if (m_pVertexs)

    44. 

  44.     {

    45. 

  45.         delete[] m_pVertexs;

    46. 

  46.         m_pVertexs = NULL;

    47. 

  47.     }

    48. 

  48. 

    49. 

  49.     if (m_pEdges)

    50. 

  50.     {

    51. 

  51.         delete[] m_pEdges;

    52. 

  52.         m_pEdges = NULL;

    53. 

  53.     }

    54. 

  54. 

    55. 

  55.     if (m_pLevelPoints)

    56. 

  56.     {

    57. 

  57.         delete[] m_pLevelPoints;

    58. 

  58.         m_pLevelPoints = NULL;

    59. 

  59.     }

    60. 

  60. 

    61. 

  61.     if (m_pGrid)

    62. 

  62.     {

    63. 

  63.         delete[] m_pGrid;

    64. 

  64.         m_pGrid = NULL;

    65. 

  65.     }

    66. 

  66. }

    67. 

  67. 

    68. 

  68. //-------------------------------------------------------------------------------------------------

    69. 

  69. bool CGraph::Load(LPCSTR pFilename)

    70. 

  70. {

    71. 

  71.     DWORD dwReaded;

    72. 

  72.     CString str;

    73. 

  73.     unsigned u;

    74. 

  74. 

    75. 

  75.     Clean();

    76. 

  76. 

    77. 

  77.     HANDLE hFile = CreateFile(pFilename, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL);

    78. 

  78.     if (hFile == INVALID_HANDLE_VALUE)

    79. 

  79.     {

    80. 

  80.         AfxMessageBox("ќшибка открыти€ файла!");

    81. 

  81.         Clean();

    82. 

  82.         return false;

    83. 

  83.     }

    84. 

  84. 

    85. 

  85.     // заголовок

    86. 

  86.     if (!ReadFile(hFile, &m_sHeader, sizeof(GG_HEADER), &dwReaded, NULL) || (dwReaded!=sizeof(GG_HEADER)))

    87. 

  87.     {

    88. 

  88.         AfxMessageBox("ќшибка чтени€ заголовка!");

    89. 

  89.         CloseHandle(hFile);

    90. 

  90.         Clean();

    91. 

  91.         return false;

    92. 

  92.     }

    93. 

  93. 

    94. 

  94.     // уровни

    95. 

  95.     if (m_sHeader.level_count <= 0)

    96. 

  96.     {

    97. 

  97.         AfxMessageBox("ќшибка: level_count <= 0");

    98. 

  98.         CloseHandle(hFile);

    99. 

  99.         Clean();

    100. 

  100.         return false;

    101. 

  101.     }

    102. 

  102. 

    103. 

  103.     m_pLevels = new GG_LEVEL[m_sHeader.level_count];

    104. 

  104.     if (!m_pLevels)

    105. 

  105.     {

    106. 

  106.         AfxMessageBox("ќшибка выделени€ пам€ти!");

    107. 

  107.         CloseHandle(hFile);

    108. 

  108.         Clean();

    109. 

  109.         return false;

    110. 

  110.     }

    111. 

  111. 

    112. 

  112.     for (u=0; u<m_sHeader.level_count; u++)

    113. 

  113.     {

    114. 

  114.         if (!LoadLevel(hFile, &m_pLevels[u]))

    115. 

  115.         {

    116. 

  116.             str.Format("ќшибка чтени€ уровн€ є%d", u);

    117. 

  117.             AfxMessageBox(str);

    118. 

  118.             CloseHandle(hFile);

    119. 

  119.             Clean();

    120. 

  120.             return false;

    121. 

  121.         }

    122. 

  122.     }

    123. 

  123. 

    124. 

  124.     // game vertex

    125. 

  125.     if (m_sHeader.vertex_count <= 0)

    126. 

  126.     {

    127. 

  127.         AfxMessageBox("ќшибка: vertex_count <= 0");

    128. 

  128.         CloseHandle(hFile);

    129. 

  129.         Clean();

    130. 

  130.         return false;

    131. 

  131.     }

    132. 

  132. 

    133. 

  133.     m_pVertexs = new GG_VERTEX[m_sHeader.vertex_count];

    134. 

  134.     if (!m_pVertexs)

    135. 

  135.     {

    136. 

  136.         AfxMessageBox("ќшибка выделени€ пам€ти!");

    137. 

  137.         CloseHandle(hFile);

    138. 

  138.         Clean();

    139. 

  139.         return false;

    140. 

  140.     }

    141. 

  141.     if (!ReadFile(hFile, m_pVertexs, m_sHeader.vertex_count*sizeof(GG_VERTEX), &dwReaded, NULL) || (dwReaded!=m_sHeader.vertex_count*sizeof(GG_VERTEX)))

    142. 

  142.     {

    143. 

  143.         AfxMessageBox("ќшибка чтени€ GG_VERTEX!");

    144. 

  144.         CloseHandle(hFile);

    145. 

  145.         Clean();

    146. 

  146.         return false;

    147. 

  147.     }

    148. 

  148. 

    149. 

  149.     // пересчитываем смещени€ в индексы

    150. 

  150.     unsigned edges_offset = m_sHeader.vertex_count * 0x2a;

    151. 

  151.     unsigned level_points_offset = edges_offset + m_sHeader.edge_count * 0x06;

    152. 

  152.     for (u=0; u<m_sHeader.vertex_count; u++)

    153. 

  153.     {

    154. 

  154.         if (m_pVertexs[u].edge_count > 0)

    155. 

  155.             m_pVertexs[u].edge_offset = (m_pVertexs[u].edge_offset - edges_offset) / 0x06;

    156. 

  156. 

    157. 

  157.         if (m_pVertexs[u].level_point_count > 0)

    158. 

  158.             m_pVertexs[u].level_point_offset = (m_pVertexs[u].level_point_offset - level_points_offset) / 0x14;

    159. 

  159.     }

    160. 

  160. 

    161. 

  161.     // edge

    162. 

  162.     if (m_sHeader.edge_count <= 0)

    163. 

  163.     {

    164. 

  164.         AfxMessageBox("ќшибка: edge_count <= 0");

    165. 

  165.         CloseHandle(hFile);

    166. 

  166.         Clean();

    167. 

  167.         return false;

    168. 

  168.     }

    169. 

  169. 

    170. 

  170.     m_pEdges = new GG_EDGE[m_sHeader.edge_count];

    171. 

  171.     if (!m_pEdges)

    172. 

  172.     {

    173. 

  173.         AfxMessageBox("ќшибка выделени€ пам€ти!");

    174. 

  174.         CloseHandle(hFile);

    175. 

  175.         Clean();

    176. 

  176.         return false;

    177. 

  177.     }

    178. 

  178.     if (!ReadFile(hFile, m_pEdges, m_sHeader.edge_count*sizeof(GG_EDGE), &dwReaded, NULL) || (dwReaded!=m_sHeader.edge_count*sizeof(GG_EDGE)))

    179. 

  179.     {

    180. 

  180.         AfxMessageBox("ќшибка чтени€ GG_EDGE!");

    181. 

  181.         CloseHandle(hFile);

    182. 

  182.         Clean();

    183. 

  183.         return false;

    184. 

  184.     }

    185. 

  185. 

    186. 

  186.     // level vertex

    187. 

  187.     if (m_sHeader.level_point_count > 0)

    188. 

  188.     {

    189. 

  189.         m_pLevelPoints = new GG_LEVEL_POINT[m_sHeader.level_point_count];

    190. 

  190.         if (!m_pLevelPoints)

    191. 

  191.         {

    192. 

  192.             AfxMessageBox("ќшибка выделени€ пам€ти!");

    193. 

  193.             CloseHandle(hFile);

    194. 

  194.             Clean();

    195. 

  195.             return false;

    196. 

  196.         }

    197. 

  197.         if (!ReadFile(hFile, m_pLevelPoints, m_sHeader.level_point_count*sizeof(GG_LEVEL_POINT), &dwReaded, NULL) || (dwReaded!=m_sHeader.level_point_count*sizeof(GG_LEVEL_POINT)))

    198. 

  198.         {

    199. 

  199.             AfxMessageBox("ќшибка чтени€ GG_LEVEL_POINT!");

    200. 

  200.             CloseHandle(hFile);

    201. 

  201.             Clean();

    202. 

  202.             return false;

    203. 

  203.         }

    204. 

  204.     }

    205. 

  205.     else

    206. 

  206.     {

    207. 

  207.         //AfxMessageBox("ќшибка: level_point_count <= 0");

    208. 

  208.         //CloseHandle(hFile);

    209. 

  209.         //Clean();

    210. 

  210.         //return false;

    211. 

  211.     }

    212. 

  212. 

    213. 

  213.     CloseHandle(hFile);

    214. 

  214.     strcpy(m_chFilename, pFilename);

    215. 

  215.     return true;

    216. 

  216. }

    217. 

  217. 

    218. 

  218. //-------------------------------------------------------------------------------------------------

    219. 

  219. bool CGraph::LoadLevel(HANDLE hFile, GG_LEVEL* pLevel)

    220. 

  220. {

    221. 

  221.     DWORD dwReaded;

    222. 

  222. 

    223. 

  223.     DWORD u=0;

    224. 

  224.     if (!ReadFile(hFile, &pLevel->level_name[u], 1, &dwReaded, NULL) || (dwReaded != 1))

    225. 

  225.     {

    226. 

  226.         AfxMessageBox("ќшибка при чтении имени уровн€!");

    227. 

  227.         return false;

    228. 

  228.     }

    229. 

  229.     while (pLevel->level_name[u++] != 0)

    230. 

  230.     {

    231. 

  231.         if (!ReadFile(hFile, &pLevel->level_name[u], 1, &dwReaded, NULL) || (dwReaded != 1))

    232. 

  232.         {

    233. 

  233.             AfxMessageBox("ќшибка при чтении имени уровн€!");

    234. 

  234.             return false;

    235. 

  235.         }

    236. 

  236.     }

    237. 

  237. 

    238. 

  238.     if (!ReadFile(hFile, &pLevel->offset, sizeof(POINT_3D), &dwReaded, NULL) || (dwReaded != sizeof(POINT_3D)))

    239. 

  239.     {

    240. 

  240.         AfxMessageBox("ќшибка при чтении смещени€ уровн€!");

    241. 

  241.         return false;

    242. 

  242.     }

    243. 

  243. 

    244. 

  244.     if (!ReadFile(hFile, &pLevel->level_id, 1, &dwReaded, NULL) || (dwReaded != 1))

    245. 

  245.     {

    246. 

  246.         AfxMessageBox("ќшибка при чтении id уровн€!");

    247. 

  247.         return false;

    248. 

  248.     }

    249. 

  249. 

    250. 

  250.     u=0;

    251. 

  251.     if (!ReadFile(hFile, &pLevel->section_name[u], 1, &dwReaded, NULL) || (dwReaded != 1))

    252. 

  252.     {

    253. 

  253.         AfxMessageBox("ќшибка при чтении секции уровн€!");

    254. 

  254.         return false;

    255. 

  255.     }

    256. 

  256.     while (pLevel->section_name[u++] != 0)

    257. 

  257.     {

    258. 

  258.         if (!ReadFile(hFile, &pLevel->section_name[u], 1, &dwReaded, NULL) || (dwReaded != 1))

    259. 

  259.         {

    260. 

  260.             AfxMessageBox("ќшибка при чтении секции уровн€!");

    261. 

  261.             return false;

    262. 

  262.         }

    263. 

  263.     }

    264. 

  264. 

    265. 

  265.     if (!ReadFile(hFile, &pLevel->guid, 16, &dwReaded, NULL) || (dwReaded != 16))

    266. 

  266.     {

    267. 

  267.         AfxMessageBox("ќшибка при чтении guid уровн€!");

    268. 

  268.         return false;

    269. 

  269.     }

    270. 

  270. 

    271. 

  271.     return true;

    272. 

  272. }

    273. 

  273. 

    274. 

  274. //-------------------------------------------------------------------------------------------------

    275. 

  275. void CGraph::GridClean()

    276. 

  276. {

    277. 

  277.     m_uGridCX = m_uGridCY = m_uGridCZ = 0;

    278. 

  278. 

    279. 

  279.     if (m_pGrid)

    280. 

  280.     {

    281. 

  281.         delete[] m_pGrid;

    282. 

  282.         m_pGrid = NULL;

    283. 

  283.     }

    284. 

  284. }

    285. 

  285. 

    286. 

  286. //-------------------------------------------------------------------------------------------------

    287. 

  287. bool CGraph::GridInit(unsigned uLevel)

    288. 

  288. {

    289. 

  289.     unsigned u, i, index, size, x, z, k;

    290. 

  290.     POINT_3D* ptr;

    291. 

  291. 

    292. 

  292.     unsigned level_id = m_pLevels[uLevel].level_id;

    293. 

  293. 

    294. 

  294.     // размерность матрицы по X и Z

    295. 

  295.     m_sGridBox.p1.x = m_sGridBox.p1.y = m_sGridBox.p1.z =  10000;

    296. 

  296.     m_sGridBox.p2.x = m_sGridBox.p2.y = m_sGridBox.p2.z = -10000;

    297. 

  297. 

    298. 

  298.     for (u=0; u<m_sHeader.vertex_count; u++)

    299. 

  299.     {

    300. 

  300.         if (m_pVertexs[u].level_id == level_id)

    301. 

  301.         {

    302. 

  302.             ptr = &m_pVertexs[u].level_point;

    303. 

  303. 

    304. 

  304.             if (m_sGridBox.p1.x > ptr->x)

    305. 

  305.                 m_sGridBox.p1.x = ptr->x;

    306. 

  306.             if (m_sGridBox.p1.y > ptr->y)

    307. 

  307.                 m_sGridBox.p1.y = ptr->y;

    308. 

  308.             if (m_sGridBox.p1.z > ptr->z)

    309. 

  309.                 m_sGridBox.p1.z = ptr->z;

    310. 

  310. 

    311. 

  311.             if (m_sGridBox.p2.x < ptr->x)

    312. 

  312.                 m_sGridBox.p2.x = ptr->x;

    313. 

  313.             if (m_sGridBox.p2.y < ptr->y)

    314. 

  314.                 m_sGridBox.p2.y = ptr->y;

    315. 

  315.             if (m_sGridBox.p2.z < ptr->z)

    316. 

  316.                 m_sGridBox.p2.z = ptr->z;

    317. 

  317. 

    318. 

  318.             index = m_pVertexs[u].level_point_offset;

    319. 

  319.             for (i=0; i<m_pVertexs[u].level_point_count; i++)

    320. 

  320.             {

    321. 

  321.                 ptr = &m_pLevelPoints[index+i].point;

    322. 

  322. 

    323. 

  323.                 if (m_sGridBox.p1.x > ptr->x)

    324. 

  324.                     m_sGridBox.p1.x = ptr->x;

    325. 

  325.                 if (m_sGridBox.p1.y > ptr->y)

    326. 

  326.                     m_sGridBox.p1.y = ptr->y;

    327. 

  327.                 if (m_sGridBox.p1.z > ptr->z)

    328. 

  328.                     m_sGridBox.p1.z = ptr->z;

    329. 

  329. 

    330. 

  330.                 if (m_sGridBox.p2.x < ptr->x)

    331. 

  331.                     m_sGridBox.p2.x = ptr->x;

    332. 

  332.                 if (m_sGridBox.p2.y < ptr->y)

    333. 

  333.                     m_sGridBox.p2.y = ptr->y;

    334. 

  334.                 if (m_sGridBox.p2.z < ptr->z)

    335. 

  335.                     m_sGridBox.p2.z = ptr->z;

    336. 

  336.             }

    337. 

  337.         }

    338. 

  338.     }

    339. 

  339. 

    340. 

  340.     m_uGridCX = (unsigned) ((m_sGridBox.p2.x - m_sGridBox.p1.x) / 0.7 + 1.501);

    341. 

  341.     m_uGridCZ = (unsigned) ((m_sGridBox.p2.z - m_sGridBox.p1.z) / 0.7 + 1.501);

    342. 

  342. 

    343. 

  343.     // размерность матрицы по Y

    344. 

  344.     m_uGridCY = 1;

    345. 

  345.     size = m_uGridCX * m_uGridCZ;

    346. 

  346.     m_pGrid = new unsigned[size];

    347. 

  347.     if (!m_pGrid)

    348. 

  348.     {

    349. 

  349.         AfxMessageBox("ќшибка выделени€ пам€ти!");

    350. 

  350.         return false;

    351. 

  351.     }

    352. 

  352.     memset(m_pGrid, 0, size * sizeof(unsigned));

    353. 

  353. 

    354. 

  354.     for (u=0; u<m_sHeader.vertex_count; u++)

    355. 

  355.     {

    356. 

  356.         if (m_pVertexs[u].level_id == level_id)

    357. 

  357.         {

    358. 

  358.             ptr = &m_pVertexs[u].level_point;

    359. 

  359. 

    360. 

  360.             //x = (unsigned) ((ptr->x - m_sGridBox.p1.x) / 0.7 + 0.501);

    361. 

  361.             //z = (unsigned) ((ptr->z - m_sGridBox.p1.z) / 0.7 + 0.501);

    362. 

  362.             x = (unsigned) ((ptr->x - m_sGridBox.p1.x) / 0.7);

    363. 

  363.             z = (unsigned) ((ptr->z - m_sGridBox.p1.z) / 0.7);

    364. 

  364.             k = x * m_uGridCZ + z;

    365. 

  365.             m_pGrid[k]++;

    366. 

  366.             if (m_uGridCY < m_pGrid[k])

    367. 

  367.                 m_uGridCY = m_pGrid[k];

    368. 

  368. 

    369. 

  369.             index = m_pVertexs[u].level_point_offset;

    370. 

  370.             for (i=0; i<m_pVertexs[u].level_point_count; i++)

    371. 

  371.             {

    372. 

  372.                 ptr = &m_pLevelPoints[index+i].point;

    373. 

  373. 

    374. 

  374.                 //x = (unsigned) ((ptr->x - m_sGridBox.p1.x) / 0.7 + 0.501);

    375. 

  375.                 //z = (unsigned) ((ptr->z - m_sGridBox.p1.z) / 0.7 + 0.501);

    376. 

  376.                 x = (unsigned) ((ptr->x - m_sGridBox.p1.x) / 0.7);

    377. 

  377.                 z = (unsigned) ((ptr->z - m_sGridBox.p1.z) / 0.7);

    378. 

  378.                 k = x * m_uGridCZ + z;

    379. 

  379.                 m_pGrid[k]++;

    380. 

  380.                 if (m_uGridCY < m_pGrid[k])

    381. 

  381.                     m_uGridCY = m_pGrid[k];

    382. 

  382.             }

    383. 

  383.         }

    384. 

  384.     }

    385. 

  385. 

    386. 

  386.     delete[] m_pGrid;

    387. 

  387. 

    388. 

  388.     // заполнение матрицы индексами вертексов, дл€ game_vertex-ов ставим 1 в старший бит

    389. 

  389.     size = m_uGridCX * m_uGridCZ * m_uGridCY;

    390. 

  390.     m_pGrid = new unsigned[size];

    391. 

  391.     if (!m_pGrid)

    392. 

  392.     {

    393. 

  393.         AfxMessageBox("ќшибка выделени€ пам€ти!");

    394. 

  394.         return false;

    395. 

  395.     }

    396. 

  396.     memset(m_pGrid, -1, size * sizeof(unsigned));

    397. 

  397. 

    398. 

  398.     for (u=0; u<m_sHeader.vertex_count; u++)

    399. 

  399.     {

    400. 

  400.         if (m_pVertexs[u].level_id == level_id)

    401. 

  401.         {

    402. 

  402.             ptr = &m_pVertexs[u].level_point;

    403. 

  403. 

    404. 

  404.             //x = (unsigned) ((ptr->x - m_sGridBox.p1.x) / 0.7 + 0.501);

    405. 

  405.             //z = (unsigned) ((ptr->z - m_sGridBox.p1.z) / 0.7 + 0.501);

    406. 

  406.             x = (unsigned) ((ptr->x - m_sGridBox.p1.x) / 0.7);

    407. 

  407.             z = (unsigned) ((ptr->z - m_sGridBox.p1.z) / 0.7);

    408. 

  408.             k = (x * m_uGridCZ + z) * m_uGridCY;

    409. 

  409.             while (m_pGrid[k] != -1)

    410. 

  410.                 k++;

    411. 

  411.             m_pGrid[k] = u | 0x80000000;

    412. 

  412. 

    413. 

  413.             index = m_pVertexs[u].level_point_offset;

    414. 

  414.             for (i=0; i<m_pVertexs[u].level_point_count; i++)

    415. 

  415.             {

    416. 

  416.                 ptr = &m_pLevelPoints[index+i].point;

    417. 

  417. 

    418. 

  418.                 //x = (unsigned) ((ptr->x - m_sGridBox.p1.x) / 0.7 + 0.501);

    419. 

  419.                 //z = (unsigned) ((ptr->z - m_sGridBox.p1.z) / 0.7 + 0.501);

    420. 

  420.                 x = (unsigned) ((ptr->x - m_sGridBox.p1.x) / 0.7);

    421. 

  421.                 z = (unsigned) ((ptr->z - m_sGridBox.p1.z) / 0.7);

    422. 

  422.                 k = (x * m_uGridCZ + z) * m_uGridCY;

    423. 

  423.                 while (m_pGrid[k] != -1)

    424. 

  424.                     k++;

    425. 

  425.                 m_pGrid[k] = index+i;

    426. 

  426.             }

    427. 

  427.         }

    428. 

  428.     }

    429. 

  429. 

    430. 

  430.     return true;

    431. 

  431. }

    432. 

  432. 

    433. 

  433. //-------------------------------------------------------------------------------------------------

    434. 

  434. void CGraph::DrawVertexs(DRAW_DATA* pDD)

    435. 

  435. {

    436. 

  436.     if (!m_pVertexs || !m_pGrid)

    437. 

  437.         return;

    438. 

  438. 

    439. 

  439.     GG_VERTEX* ptr;

    440. 

  440.     int pt = ((pDD->iZoom < 3) ? 1 : pDD->iZoom / 2)+1; // размер точки

    441. 

  441.     COLORREF cr = RGB(0,192,0);                         // цвет точки

    442. 

  442. 

    443. 

  443.     unsigned i, v, gx, gy;

    444. 

  444.     for (unsigned x=0; x<(unsigned)pDD->cx; x++)

    445. 

  445.     {

    446. 

  446.         for (unsigned y=0; y<(unsigned)pDD->cy; y++)

    447. 

  447.         {

    448. 

  448.             gx = x + pDD->x;

    449. 

  449.             gy = (m_uGridCZ-1) - pDD->y - y;

    450. 

  450. 

    451. 

  451.             if ((gx < m_uGridCX) && (gy < m_uGridCZ))

    452. 

  452.             {

    453. 

  453.                 i = (gx * m_uGridCZ + gy) * m_uGridCY;

    454. 

  454. 

    455. 

  455.                 for (unsigned k=0; k<m_uGridCY; k++)

    456. 

  456.                 {

    457. 

  457.                     v = m_pGrid[i + k];

    458. 

  458. 

    459. 

  459.                     if (v != -1)

    460. 

  460.                     {

    461. 

  461.                         if (v & 0x80000000)

    462. 

  462.                         {

    463. 

  463.                             ptr = &m_pVertexs[v & 0x7fffffff];

    464. 

  464.                             if ((ptr->level_point.y >= pDD->fMinY) && (ptr->level_point.y <= pDD->fMaxY))

    465. 

  465.                             {

    466. 

  466.                                 pDD->pDC->FillSolidRect(x*pDD->iZoom-1, y*pDD->iZoom-1, pt, pt, cr);

    467. 

  467.                                 break;

    468. 

  468.                             }

    469. 

  469.                         }

    470. 

  470.                     }

    471. 

  471.                     else

    472. 

  472.                     {

    473. 

  473.                         break;

    474. 

  474.                     }

    475. 

  475.                 }

    476. 

  476.             }

    477. 

  477.         }

    478. 

  478.     }

    479. 

  479. }

    480. 

  480. 

    481. 

  481. //-------------------------------------------------------------------------------------------------

    482. 

  482. void CGraph::DrawEdges(DRAW_DATA* pDD)

    483. 

  483. {

    484. 

  484.     if (!m_pEdges || !m_pGrid)

    485. 

  485.         return;

    486. 

  486. 

    487. 

  487.     GG_VERTEX* ptr;

    488. 

  488.     int pt = ((pDD->iZoom < 3) ? 1 : pDD->iZoom / 2)+3; // размер точки

    489. 

  489.     COLORREF cr = RGB(0,192,0);                         // цвет точки

    490. 

  490. 

    491. 

  491.     CPen pen(PS_SOLID, 1, cr);

    492. 

  492.     CPen* pOldPen = pDD->pDC->SelectObject(&pen);

    493. 

  493.     pDD->pDC->SetBkMode(OPAQUE);

    494. 

  494.     pDD->pDC->SetROP2(R2_COPYPEN);

    495. 

  495. 

    496. 

  496.     unsigned i, v, gx, gy;

    497. 

  497.     for (unsigned x=0; x<(unsigned)pDD->cx; x++)

    498. 

  498.     {

    499. 

  499.         for (unsigned y=0; y<(unsigned)pDD->cy; y++)

    500. 

  500.         {

    501. 

  501.             gx = x + pDD->x;

    502. 

  502.             gy = (m_uGridCZ-1) - pDD->y - y;

    503. 

  503. 

    504. 

  504.             if ((gx < m_uGridCX) && (gy < m_uGridCZ))

    505. 

  505.             {

    506. 

  506.                 i = (gx * m_uGridCZ + gy) * m_uGridCY;

    507. 

  507. 

    508. 

  508.                 for (unsigned k=0; k<m_uGridCY; k++)

    509. 

  509.                 {

    510. 

  510.                     v = m_pGrid[i + k];

    511. 

  511. 

    512. 

  512.                     if (v != -1)

    513. 

  513.                     {

    514. 

  514.                         if (v & 0x80000000)

    515. 

  515.                         {

    516. 

  516.                             ptr = &m_pVertexs[v & 0x7fffffff];

    517. 

  517.                             if ((ptr->level_point.y >= pDD->fMinY) && (ptr->level_point.y <= pDD->fMaxY))

    518. 

  518.                             {

    519. 

  519.                                 for (unsigned l=0; l<m_pVertexs[v].edge_count; l++)

    520. 

  520.                                 {

    521. 

  521.                                     unsigned  gvid = m_pEdges[m_pVertexs[v].edge_offset+l].game_vertex_id;

    522. 

  522. 

    523. 

  523.                                     if (m_pVertexs[v].level_id == m_pVertexs[gvid].level_id)

    524. 

  524.                                     {

    525. 

  525.                                         POINT_3D* pDst = &m_pVertexs[gvid].level_point;

    526. 

  526.                                         unsigned  x2 = (unsigned) (abs((pDst->x - m_sGridBox.p1.x) / 0.7) - pDD->x);

    527. 

  527.                                         unsigned  y2 = (unsigned) ((m_uGridCZ-1) - abs((pDst->z - m_sGridBox.p1.z) / 0.7) - pDD->y);

    528. 

  528. 

    529. 

  529.                                         pDD->pDC->MoveTo(x*pDD->iZoom, y*pDD->iZoom);

    530. 

  530.                                         pDD->pDC->LineTo(x2*pDD->iZoom, y2*pDD->iZoom);

    531. 

  531.                                     }

    532. 

  532.                                     else

    533. 

  533.                                     {

    534. 

  534.                                         pDD->pDC->FillSolidRect(x*pDD->iZoom-1, y*pDD->iZoom-1, pt, pt, cr);

    535. 

  535.                                     }

    536. 

  536.                                 }

    537. 

  537.                             }

    538. 

  538.                         }

    539. 

  539.                     }

    540. 

  540.                     else

    541. 

  541.                     {

    542. 

  542.                         break;

    543. 

  543.                     }

    544. 

  544.                 }

    545. 

  545.             }

    546. 

  546.         }

    547. 

  547.     }

    548. 

  548. 

    549. 

  549.     pDD->pDC->SelectObject(pOldPen);

    550. 

  550. }

    551. 

  551. 

    552. 

  552. //-------------------------------------------------------------------------------------------------

    553. 

  553. void CGraph::DrawLevelPoints(DRAW_DATA* pDD)

    554. 

  554. {

    555. 

  555.     if (!m_pLevelPoints || !m_pGrid)

    556. 

  556.         return;

    557. 

  557. 

    558. 

  558.     GG_LEVEL_POINT* ptr;

    559. 

  559.     int pt = 1;//(pDD->iZoom < 3) ? 1 : pDD->iZoom / 2; // размер точки

    560. 

  560.     COLORREF cr = RGB(0,0,92);                      // цвет точки

    561. 

  561. 

    562. 

  562.     unsigned i, v, gx, gy;

    563. 

  563.     for (unsigned x=0; x<(unsigned)pDD->cx; x++)

    564. 

  564.     {

    565. 

  565.         for (unsigned y=0; y<(unsigned)pDD->cy; y++)

    566. 

  566.         {

    567. 

  567.             gx = x + pDD->x;

    568. 

  568.             gy = (m_uGridCZ-1) - pDD->y - y;

    569. 

  569. 

    570. 

  570.             if ((gx < m_uGridCX) && (gy < m_uGridCZ))

    571. 

  571.             {

    572. 

  572.                 i = (gx * m_uGridCZ + gy) * m_uGridCY;

    573. 

  573. 

    574. 

  574.                 for (unsigned k=0; k<m_uGridCY; k++)

    575. 

  575.                 {

    576. 

  576.                     v = m_pGrid[i + k];

    577. 

  577. 

    578. 

  578.                     if (v != -1)

    579. 

  579.                     {

    580. 

  580.                         if (!(v & 0x80000000))

    581. 

  581.                         {

    582. 

  582.                             ptr = &m_pLevelPoints[v];

    583. 

  583.                             if ((ptr->point.y >= pDD->fMinY) && (ptr->point.y <= pDD->fMaxY))

    584. 

  584.                             {

    585. 

  585.                                 pDD->pDC->FillSolidRect(x*pDD->iZoom, y*pDD->iZoom, pt, pt, cr);

    586. 

  586.                                 break;

    587. 

  587.                             }

    588. 

  588.                         }

    589. 

  589.                     }

    590. 

  590.                     else

    591. 

  591.                     {

    592. 

  592.                         break;

    593. 

  593.                     }

    594. 

  594.                 }

    595. 

  595.             }

    596. 

  596.         }

    597. 

  597.     }

    598. 

  598. }

    599. 

  599. 

    600. 

  600. //-------------------------------------------------------------------------------------------------

    601. 

  601. void CGraph::DrawSelVertexs(DRAW_DATA* pDD, unsigned uVertex)

    602. 

  602. {

    603. 

  603.     if (!m_pVertexs || !m_pGrid)

    604. 

  604.         return;

    605. 

  605. 

    606. 

  606.     GG_VERTEX* ptr = &m_pVertexs[uVertex & 0x7fffffff];

    607. 

  607.     int pt = ((pDD->iZoom < 3) ? 1 : pDD->iZoom / 2)+1; // размер точки

    608. 

  608.     COLORREF cr = RGB(192,0,0);                         // цвет точки

    609. 

  609. 

    610. 

  610.     unsigned x = (unsigned) (abs((ptr->level_point.x - m_sGridBox.p1.x) / 0.7) - pDD->x);

    611. 

  611.     unsigned y = (unsigned) ((m_uGridCZ-1) - abs((ptr->level_point.z - m_sGridBox.p1.z) / 0.7) - pDD->y);

    612. 

  612. 

    613. 

  613.     if ((ptr->level_point.y >= pDD->fMinY) && (ptr->level_point.y <= pDD->fMaxY))

    614. 

  614.     {

    615. 

  615.         pDD->pDC->FillSolidRect(x*pDD->iZoom-1, y*pDD->iZoom-1, pt, pt, cr);

    616. 

  616.     }

    617. 

  617. }

    618. 

  618. 

    619. 

  619. //-------------------------------------------------------------------------------------------------

    620. 

  620. void CGraph::DrawSelEdges(DRAW_DATA* pDD, unsigned uVertex)

    621. 

  621. {

    622. 

  622.     if (!m_pEdges || !m_pGrid)

    623. 

  623.         return;

    624. 

  624. 

    625. 

  625.     GG_VERTEX* ptr = &m_pVertexs[uVertex & 0x7fffffff];

    626. 

  626.     int pt = ((pDD->iZoom < 3) ? 1 : pDD->iZoom / 2)+3; // размер точки

    627. 

  627.     COLORREF cr = RGB(192,0,0);                         // цвет точки

    628. 

  628. 

    629. 

  629.     CPen pen(PS_SOLID, 1, cr);

    630. 

  630.     CPen* pOldPen = pDD->pDC->SelectObject(&pen);

    631. 

  631.     pDD->pDC->SetBkMode(OPAQUE);

    632. 

  632.     pDD->pDC->SetROP2(R2_COPYPEN);

    633. 

  633. 

    634. 

  634.     unsigned x = (unsigned) (abs((ptr->level_point.x - m_sGridBox.p1.x) / 0.7) - pDD->x);

    635. 

  635.     unsigned y = (unsigned) ((m_uGridCZ-1) - abs((ptr->level_point.z - m_sGridBox.p1.z) / 0.7) - pDD->y);

    636. 

  636. 

    637. 

  637.     if ((ptr->level_point.y >= pDD->fMinY) && (ptr->level_point.y <= pDD->fMaxY))

    638. 

  638.     {

    639. 

  639.         for (unsigned l=0; l<m_pVertexs[uVertex].edge_count; l++)

    640. 

  640.         {

    641. 

  641.             unsigned gvid = m_pEdges[m_pVertexs[uVertex].edge_offset+l].game_vertex_id;

    642. 

  642. 

    643. 

  643.             if (m_pVertexs[uVertex].level_id == m_pVertexs[gvid].level_id)

    644. 

  644.             {

    645. 

  645.                 POINT_3D* pDst = &m_pVertexs[gvid].level_point;

    646. 

  646.                 unsigned  x2 = (unsigned) (abs((pDst->x - m_sGridBox.p1.x) / 0.7) - pDD->x);

    647. 

  647.                 unsigned  y2 = (unsigned) ((m_uGridCZ-1) - abs((pDst->z - m_sGridBox.p1.z) / 0.7) - pDD->y);

    648. 

  648. 

    649. 

  649.                 pDD->pDC->MoveTo(x*pDD->iZoom, y*pDD->iZoom);

    650. 

  650.                 pDD->pDC->LineTo(x2*pDD->iZoom, y2*pDD->iZoom);

    651. 

  651.             }

    652. 

  652.             else

    653. 

  653.             {

    654. 

  654.                 pDD->pDC->FillSolidRect(x*pDD->iZoom-1, y*pDD->iZoom-1, pt, pt, cr);

    655. 

  655.             }

    656. 

  656.         }

    657. 

  657.     }

    658. 

  658. 

    659. 

  659.     pDD->pDC->SelectObject(pOldPen);

    660. 

  660. }

    661. 

  661. 

    662. 

  662. //-------------------------------------------------------------------------------------------------

    663. 

  663. void CGraph::DrawSelLevelPoints(DRAW_DATA* pDD, unsigned uVertex)

    664. 

  664. {

    665. 

  665.     if (!m_pLevelPoints || !m_pGrid)

    666. 

  666.         return;

    667. 

  667. 

    668. 

  668.     POINT_3D* ptr;

    669. 

  669.     int pt = 2;//(pDD->iZoom < 3) ? 2 : pDD->iZoom / 2 + 1; // размер точки

    670. 

  670.     COLORREF cr = RGB(192,0,0);                         // цвет точки

    671. 

  671. 

    672. 

  672.     if (uVertex & 0x80000000)

    673. 

  673.     {

    674. 

  674.         uVertex &= 0x7fffffff;

    675. 

  675. 

    676. 

  676.         unsigned index = m_pVertexs[uVertex].level_point_offset;

    677. 

  677.         for (unsigned i=0; i<m_pVertexs[uVertex].level_point_count; i++)

    678. 

  678.         {

    679. 

  679.             ptr = &m_pLevelPoints[index+i].point;

    680. 

  680. 

    681. 

  681.             unsigned x = (unsigned) (abs((ptr->x  - m_sGridBox.p1.x) / 0.7) - pDD->x);

    682. 

  682.             unsigned y = (unsigned) ((m_uGridCZ-1) - abs((ptr->z - m_sGridBox.p1.z) / 0.7) - pDD->y);

    683. 

  683. 

    684. 

  684.             if ((ptr->y >= pDD->fMinY) && (ptr->y <= pDD->fMaxY))

    685. 

  685.             {

    686. 

  686.                 pDD->pDC->FillSolidRect(x*pDD->iZoom, y*pDD->iZoom, pt, pt, cr);

    687. 

  687.             }

    688. 

  688.         }

    689. 

  689.     }

    690. 

  690.     else

    691. 

  691.     {

    692. 

  692.         ptr = &m_pLevelPoints[uVertex].point;

    693. 

  693. 

    694. 

  694.         unsigned x = (unsigned) (abs((ptr->x  - m_sGridBox.p1.x) / 0.7) - pDD->x);

    695. 

  695.         unsigned y = (unsigned) ((m_uGridCZ-1) - abs((ptr->z - m_sGridBox.p1.z) / 0.7) - pDD->y);

    696. 

  696. 

    697. 

  697.         if ((ptr->y >= pDD->fMinY) && (ptr->y <= pDD->fMaxY))

    698. 

  698.         {

    699. 

  699.             pDD->pDC->FillSolidRect(x*pDD->iZoom, y*pDD->iZoom, pt, pt, cr);

    700. 

  700.         }

    701. 

  701.     }

    702. 

  702. }

    703. 

  703. 

    704. 

  704. 

    705. 

  705. 

    706. 

  706. ///////////////////////////////////////////////////////////////////////////////////////////////////

    707. 

  707. // level.ai

    708. 

  708. ///////////////////////////////////////////////////////////////////////////////////////////////////

    709. 

  709. 

    710. 

  710. //-------------------------------------------------------------------------------------------------

    711. 

  711. CLevel::CLevel()

    712. 

  712. {

    713. 

  713.     m_chFilename[0] = 0;

    714. 

  714.     memset(&m_sHeader, 0, sizeof(AI_HEADER));

    715. 

  715.     m_pPoints = NULL;

    716. 

  716. 

    717. 

  717.     m_pGrid = NULL;

    718. 

  718. }

    719. 

  719. 

    720. 

  720. //-------------------------------------------------------------------------------------------------

    721. 

  721. CLevel::~CLevel()

    722. 

  722. {

    723. 

  723.     Clean();

    724. 

  724. }

    725. 

  725. 

    726. 

  726. //-------------------------------------------------------------------------------------------------

    727. 

  727. void CLevel::Clean()

    728. 

  728. {

    729. 

  729.     m_chFilename[0] = 0;

    730. 

  730.     memset(&m_sHeader, 0, sizeof(AI_HEADER));

    731. 

  731. 

    732. 

  732.     if (m_pPoints)

    733. 

  733.     {

    734. 

  734.         delete[] m_pPoints;

    735. 

  735.         m_pPoints = NULL;

    736. 

  736.     }

    737. 

  737. 

    738. 

  738.     if (m_pGrid)

    739. 

  739.     {

    740. 

  740.         delete[] m_pGrid;

    741. 

  741.         m_pGrid = NULL;

    742. 

  742.     }

    743. 

  743. }

    744. 

  744. 

    745. 

  745. //-------------------------------------------------------------------------------------------------

    746. 

  746. bool CLevel::Load(LPCSTR pFilename)

    747. 

  747. {

    748. 

  748.     DWORD dwReaded;

    749. 

  749. 

    750. 

  750.     Clean();

    751. 

  751. 

    752. 

  752.     HANDLE hFile = CreateFile(pFilename, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL);

    753. 

  753.     if (hFile == INVALID_HANDLE_VALUE)

    754. 

  754.     {

    755. 

  755.         AfxMessageBox("ќшибка открыти€ файла!");

    756. 

  756.         Clean();

    757. 

  757.         return false;

    758. 

  758.     }

    759. 

  759. 

    760. 

  760.     // заголовок

    761. 

  761.     if (!ReadFile(hFile, &m_sHeader, sizeof(AI_HEADER), &dwReaded, NULL) || (dwReaded!=sizeof(AI_HEADER)))

    762. 

  762.     {

    763. 

  763.         AfxMessageBox("ќшибка чтени€ заголовка!");

    764. 

  764.         CloseHandle(hFile);

    765. 

  765.         Clean();

    766. 

  766.         return false;

    767. 

  767.     }

    768. 

  768. 

    769. 

  769.     // вертексы

    770. 

  770.     if (m_sHeader.vertex_count <= 0)

    771. 

  771.     {

    772. 

  772.         AfxMessageBox("ќшибка: vertex_count <= 0");

    773. 

  773.         CloseHandle(hFile);

    774. 

  774.         Clean();

    775. 

  775.         return false;

    776. 

  776.     }

    777. 

  777. 

    778. 

  778.     m_pPoints = new AI_POINT[m_sHeader.vertex_count];

    779. 

  779.     if (!m_pPoints)

    780. 

  780.     {

    781. 

  781.         AfxMessageBox("ќшибка выделени€ пам€ти!");

    782. 

  782.         CloseHandle(hFile);

    783. 

  783.         Clean();

    784. 

  784.         return false;

    785. 

  785.     }

    786. 

  786.     if (!ReadFile(hFile, m_pPoints, m_sHeader.vertex_count*sizeof(AI_POINT), &dwReaded, NULL) || (dwReaded!=m_sHeader.vertex_count*sizeof(AI_POINT)))

    787. 

  787.     {

    788. 

  788.         AfxMessageBox("ќшибка чтени€ AI_POINT!");

    789. 

  789.         CloseHandle(hFile);

    790. 

  790.         Clean();

    791. 

  791.         return false;

    792. 

  792.     }

    793. 

  793. 

    794. 

  794.     CloseHandle(hFile);

    795. 

  795.     strcpy(m_chFilename, pFilename);

    796. 

  796.     return true;

    797. 

  797. }

    798. 

  798. 

    799. 

  799. //-------------------------------------------------------------------------------------------------

    800. 

  800. void CLevel::GridClean()

    801. 

  801. {

    802. 

  802.     m_uGridCX = m_uGridCY = m_uGridCZ = 0;

    803. 

  803. 

    804. 

  804.     if (m_pGrid)

    805. 

  805.     {

    806. 

  806.         delete[] m_pGrid;

    807. 

  807.         m_pGrid = NULL;

    808. 

  808.     }

    809. 

  809. }

    810. 

  810. 

    811. 

  811. //-------------------------------------------------------------------------------------------------

    812. 

  812. bool CLevel::GridInit()

    813. 

  813. {

    814. 

  814.     unsigned u, size, i;

    815. 

  815. 

    816. 

  816.     // размерность матрицы по X и Z

    817. 

  817.     m_uGridCX = (unsigned) ((m_sHeader.box.p2.x - m_sHeader.box.p1.x) / m_sHeader.cell_size + 1.501);

    818. 

  818.     m_uGridCZ = (unsigned) ((m_sHeader.box.p2.z - m_sHeader.box.p1.z) / m_sHeader.cell_size + 1.501);

    819. 

  819. 

    820. 

  820.     // размерность матрицы по Y

    821. 

  821.     m_uGridCY = 1;

    822. 

  822.     size = m_uGridCX * m_uGridCZ;

    823. 

  823.     m_pGrid = new unsigned[size];

    824. 

  824.     if (!m_pGrid)

    825. 

  825.     {

    826. 

  826.         AfxMessageBox("ќшибка выделени€ пам€ти!");

    827. 

  827.         return false;

    828. 

  828.     }

    829. 

  829.     memset(m_pGrid, 0, size * sizeof(unsigned));

    830. 

  830. 

    831. 

  831.     for (u=0; u<m_sHeader.vertex_count; u++)

    832. 

  832.     {

    833. 

  833.         i = m_pPoints[u].packed_xz;

    834. 

  834.         m_pGrid[i]++;

    835. 

  835.         if (m_pGrid[i] > (unsigned) m_uGridCY)

    836. 

  836.             m_uGridCY = m_pGrid[i];

    837. 

  837.     }

    838. 

  838. 

    839. 

  839.     delete[] m_pGrid;

    840. 

  840. 

    841. 

  841.     // заполнение матрицы индексами вертексов

    842. 

  842.     size = m_uGridCX * m_uGridCZ * m_uGridCY;

    843. 

  843.     m_pGrid = new unsigned[size];

    844. 

  844.     if (!m_pGrid)

    845. 

  845.     {

    846. 

  846.         AfxMessageBox("ќшибка выделени€ пам€ти!");

    847. 

  847.         return false;

    848. 

  848.     }

    849. 

  849.     memset(m_pGrid, -1, size * sizeof(unsigned));

    850. 

  850. 

    851. 

  851.     for (u=0; u<m_sHeader.vertex_count; u++)

    852. 

  852.     {

    853. 

  853.         i = m_pPoints[u].packed_xz * m_uGridCY;

    854. 

  854.         while (m_pGrid[i] != -1)

    855. 

  855.             i++;

    856. 

  856.         m_pGrid[i] = u;

    857. 

  857.     }

    858. 

  858. 

    859. 

  859.     return true;

    860. 

  860. }

    861. 

  861. 

    862. 

  862. //-------------------------------------------------------------------------------------------------

    863. 

  863. void CLevel::DrawVertexs(DRAW_DATA* pDD)

    864. 

  864. {

    865. 

  865.     if (!m_pPoints || !m_pGrid)

    866. 

  866.         return;

    867. 

  867. 

    868. 

  868.     float f;

    869. 

  869.     int pt = 1;//(pDD->iZoom < 3) ? 1 : pDD->iZoom / 2; // размер точки

    870. 

  870.     COLORREF cr = RGB(0,0,92);                      // цвет точки

    871. 

  871. 

    872. 

  872.     if (pDD->iCoverMode == 0)

    873. 

  873.     {

    874. 

  874.         unsigned i, v, gx, gy;

    875. 

  875.         for (unsigned x=0; x<(unsigned)pDD->cx; x++)

    876. 

  876.         {

    877. 

  877.             for (unsigned y=0; y<(unsigned)pDD->cy; y++)

    878. 

  878.             {

    879. 

  879.                 gx = x + pDD->x;

    880. 

  880.                 gy = (m_uGridCZ-1) - pDD->y - y;

    881. 

  881. 

    882. 

  882.                 if ((gx < m_uGridCX) && (gy < m_uGridCZ))

    883. 

  883.                 {

    884. 

  884.                     i = (gx * m_uGridCZ + gy) * m_uGridCY;

    885. 

  885. 

    886. 

  886.                     for (unsigned k=0; k<m_uGridCY; k++)

    887. 

  887.                     {

    888. 

  888.                         v = m_pGrid[i + k];

    889. 

  889.                         if (v != -1)

    890. 

  890.                         {

    891. 

  891.                             f = m_sHeader.box.p1.y + (float) m_pPoints[v].packed_y * m_sHeader.factor_y / 65535;

    892. 

  892.                             if ((f >= pDD->fMinY) && (f <= pDD->fMaxY))

    893. 

  893.                             {

    894. 

  894.                                 pDD->pDC->FillSolidRect(x*pDD->iZoom, y*pDD->iZoom, pt, pt, cr);

    895. 

  895.                                 break;

    896. 

  896.                             }

    897. 

  897.                         }

    898. 

  898.                         else

    899. 

  899.                         {

    900. 

  900.                             break;

    901. 

  901.                         }

    902. 

  902.                     }

    903. 

  903.                 }

    904. 

  904.             }

    905. 

  905.         }

    906. 

  906.     }

    907. 

  907.     else

    908. 

  908.     {

    909. 

  909.         unsigned _cr[] = {

    910. 

  910.             RGB(0,  0,128),

    911. 

  911.             RGB(0, 32,128),

    912. 

  912.             RGB(0, 64,128),

    913. 

  913.             RGB(0,128,128),

    914. 

  914. 

    915. 

  915.             RGB( 0,128,64),

    916. 

  916.             RGB( 0,128,32),

    917. 

  917.             RGB( 0,128,0),

    918. 

  918.             RGB(32,128,0),

    919. 

  919. 

    920. 

  920.             RGB( 64,128,0),

    921. 

  921.             RGB(128,128,0),

    922. 

  922.             RGB(128, 64,0),

    923. 

  923.             RGB(128, 32,0),

    924. 

  924. 

    925. 

  925.             RGB(128,0,0),

    926. 

  926.             RGB(128,0,0),

    927. 

  927.             RGB(128,0,0),

    928. 

  928.             RGB(128,0,0)

    929. 

  929.         };

    930. 

  930. 

    931. 

  931.         unsigned _cr2[] = {

    932. 

  932.             RGB(0,  0,128),

    933. 

  933.             RGB(0, 16,128),

    934. 

  934.             RGB(0, 32,128),

    935. 

  935.             RGB(0, 64,128),

    936. 

  936. 

    937. 

  937.             RGB(0,128,128),

    938. 

  938.             RGB(0,128,64),

    939. 

  939.             RGB(0,128,32),

    940. 

  940.             RGB(0,128,16),

    941. 

  941. 

    942. 

  942.             RGB( 16,128,0),

    943. 

  943.             RGB( 32,128,0),

    944. 

  944.             RGB( 64,128,0),

    945. 

  945.             RGB(128,128,0),

    946. 

  946. 

    947. 

  947.             RGB(128,64,0),

    948. 

  948.             RGB(128,32,0),

    949. 

  949.             RGB(128,16,0),

    950. 

  950.             RGB(128, 0,0)

    951. 

  951.         };

    952. 

  952. 

    953. 

  953.         unsigned i, v, gx, gy, ugol;

    954. 

  954.         for (unsigned x=0; x<(unsigned)pDD->cx; x++)

    955. 

  955.         {

    956. 

  956.             for (unsigned y=0; y<(unsigned)pDD->cy; y++)

    957. 

  957.             {

    958. 

  958.                 gx = x + pDD->x;

    959. 

  959.                 gy = (m_uGridCZ-1) - pDD->y - y;

    960. 

  960. 

    961. 

  961.                 if ((gx < m_uGridCX) && (gy < m_uGridCZ))

    962. 

  962.                 {

    963. 

  963.                     i = (gx * m_uGridCZ + gy) * m_uGridCY;

    964. 

  964. 

    965. 

  965.                     for (unsigned k=0; k<m_uGridCY; k++)

    966. 

  966.                     {

    967. 

  967.                         v = m_pGrid[i + k];

    968. 

  968.                         if (v != -1)

    969. 

  969.                         {

    970. 

  970.                             f = m_sHeader.box.p1.y + (float) m_pPoints[v].packed_y * m_sHeader.factor_y / 65535;

    971. 

  971.                             if ((f >= pDD->fMinY) && (f <= pDD->fMaxY))

    972. 

  972.                             {

    973. 

  973.                                 switch (pDD->iCoverMode)

    974. 

  974.                                 {

    975. 

  975.                                     case 1:

    976. 

  976.                                         pDD->pDC->FillSolidRect(x*pDD->iZoom, y*pDD->iZoom, pt, pt, _cr[m_pPoints[v].cover1]);

    977. 

  977.                                         break;

    978. 

  978.                                     case 2:

    979. 

  979.                                         pDD->pDC->FillSolidRect(x*pDD->iZoom, y*pDD->iZoom, pt, pt, _cr[m_pPoints[v].cover2]);

    980. 

  980.                                         break;

    981. 

  981.                                     case 3:

    982. 

  982.                                         pDD->pDC->FillSolidRect(x*pDD->iZoom, y*pDD->iZoom, pt, pt, _cr[m_pPoints[v].cover3]);

    983. 

  983.                                         break;

    984. 

  984.                                     case 4:

    985. 

  985.                                         pDD->pDC->FillSolidRect(x*pDD->iZoom, y*pDD->iZoom, pt, pt, _cr[m_pPoints[v].cover4]);

    986. 

  986.                                         break;

    987. 

  987.                                     //case 5:

    988. 

  988.                                     default:

    989. 

  989.                                         //перевод сферических координат в декартовы:

    990. 

  990.                                         // x = R*sin(Fi)*cos(Teta)

    991. 

  991.                                         // y = R*sin(Fi)*sin(Teta)

    992. 

  992.                                         // z = R*cos(Fi)

    993. 

  993.                                         //double pi = 3.1415926535;

    994. 

  994.                                         //double v = ((int)((pPoint->plane >> 7) & 0x03f)) * 0.5*pi / 64;

    995. 

  995.                                         //double u = ((int)((pPoint->plane >> 0) & 0x07f)) * 0.5*pi / 128;

    996. 

  996.                                         //double nx = sin(v)*cos(u);

    997. 

  997.                                         //double nz = sin(v)*sin(u);

    998. 

  998.                                         //double ny = cos(v);

    999. 

  999.                                         ugol = ((m_pPoints[v].plane >> 7) & 0x03f);

    1000. 

  1000.                                         if (ugol > 31)

    1001. 

  1001.                                             ugol = 31;

    1002. 

  1002.                                         pDD->pDC->FillSolidRect(x*pDD->iZoom, y*pDD->iZoom, pt, pt, _cr2[ugol/2]);

    1003. 

  1003.                                         break;

    1004. 

  1004.                                 };

    1005. 

  1005.                                 break;

    1006. 

  1006.                             }

    1007. 

  1007.                         }

    1008. 

  1008.                         else

    1009. 

  1009.                         {

    1010. 

  1010.                             break;

    1011. 

  1011.                         }

    1012. 

  1012.                     }

    1013. 

  1013.                 }

    1014. 

  1014.             }

    1015. 

  1015.         }

    1016. 

  1016.     }

    1017. 

  1017. }

    1018. 

  1018. 

    1019. 

  1019. //-------------------------------------------------------------------------------------------------

    1020. 

  1020. void CLevel::DrawSelVertexs(DRAW_DATA* pDD, unsigned uVertex)

    1021. 

  1021. {

    1022. 

  1022.     if (!m_pPoints || !m_pGrid)

    1023. 

  1023.         return;

    1024. 

  1024. 

    1025. 

  1025.     int pt = 2;//(pDD->iZoom < 3) ? 2 : pDD->iZoom / 2 + 1; // размер точки

    1026. 

  1026.     COLORREF cr = RGB(192,0,0);                         // цвет точки

    1027. 

  1027. 

    1028. 

  1028.     unsigned x = (m_pPoints[uVertex].packed_xz / m_uGridCZ) - pDD->x;

    1029. 

  1029.     unsigned y = (m_uGridCZ-1) - (m_pPoints[uVertex].packed_xz % m_uGridCZ) - pDD->y;

    1030. 

  1030. 

    1031. 

  1031.     float f = m_sHeader.box.p1.y + (float) m_pPoints[uVertex].packed_y * m_sHeader.factor_y / 65535;

    1032. 

  1032.     if ((f >= pDD->fMinY) && (f <= pDD->fMaxY))

    1033. 

  1033.     {

    1034. 

  1034.         pDD->pDC->FillSolidRect(x*pDD->iZoom, y*pDD->iZoom, pt, pt, cr);

    1035. 

  1035.     }

    1036. 

  1036. }

    1037. 

  1037. 

    1038. 

  1038. //-------------------------------------------------------------------------------------------------
    1039.