Category

Development Platform
Home > SourceCode/Document > Graph program > Special Effects > View Code
md2.cpp
Package: VCtracking.rar　[view]
Upload User: xuczgm
Upload Date: 2022-04-25
Package Size: 8601k
Code Size: 24k
Category:

Special Effects

Development Platform:

Visual C++

md2.cpp：Code Content
  1. /*/
  2. //                 MD2 Viewer (c) 1999 by Mete Ciragan
  3. //
  4. // file:           md2.c
  5. // last modified:  Apr 28 1999, Mete Ciragan
  6. // copyright:      The programs and associated files contained in this
  7. //                 distribution were developed by Mete Ciragan. The programs
  8. //                 are not in the public domain, but they are freely
  9. //                 distributable without licensing fees. These programs are
  10. //                 provided without guarantee or warrantee expressed or
  11. //                 implied.
  12. //
  13. // version:        1.4
  14. //
  15. // email:          mete@swissquake.ch
  16. // web:            http://www.swissquake.ch/chumbalum-soft/
  17. /*/
  18. #include "stdafx.h"
  19. #include <stdio.h>
  20. #include <stdlib.h>
  21. #include <string.h> /* memset */
  22. #include <math.h> /* sqrt */
  23. //#include <mx/gl.h>
  24. #include <windows.h>
  25. #include <gl/gl.h>
  26. #include "md2.h"
  28. #define NUMVERTEXNORMALS 162
  30. float avertexnormals[NUMVERTEXNORMALS][3] = {
  31. #include "anorms.h"
  32. };
  34. static int g_glcmds = 1; /* use glcommands */
  35. static int g_interp = 1; /* interpolate frames */
  39. /*
  40.  * load model
  41.  */
  42. md2_model_t*
  43. md2_readModel (const char *filename)
  44. {
  45. FILE *file;
  46. md2_model_t *model;
  47. byte buffer[MD2_MAX_FRAMESIZE];
  48. int i;
  50. model = (md2_model_t *) malloc (sizeof (md2_model_t));
  51. if (!model)
  52. return 0;
  54. file = fopen (filename, "rb");
  55. if (!file)
  56. {
  57. free (model);
  58. return 0;
  59. }
  61. /* initialize model and read header */
  62. memset (model, 0, sizeof (md2_model_t));
  63. fread (&model->header, sizeof (md2_header_t), 1, file);
  64. #if 0
  65. printf ("magic:tt%dn", model->header.magic);
  66. printf ("version:tt%dn", model->header.version);
  67. printf ("skinWidth:tt%dn", model->header.skinWidth);
  68. printf ("skinHeight:tt%dn", model->header.skinHeight);
  69. printf ("frameSize:tt%dn", model->header.frameSize);
  70. printf ("numSkins:tt%dn", model->header.numSkins);
  71. printf ("numVertices:tt%dn", model->header.numVertices);
  72. printf ("numTexCoords:tt%dn", model->header.numTexCoords);
  73. printf ("numTriangles:tt%dn", model->header.numTriangles);
  74. printf ("numGlCommands:tt%dn", model->header.numGlCommands);
  75. printf ("numFrames:tt%dn", model->header.numFrames);
  76. printf ("offsetSkins:tt%dn", model->header.offsetSkins);
  77. printf ("offsetTexCoords:t%dn", model->header.offsetTexCoords);
  78. printf ("offsetTriangles:t%dn", model->header.offsetTriangles);
  79. printf ("offsetFrames:tt%dn", model->header.offsetFrames);
  80. printf ("offsetGlCommands:t%dn", model->header.offsetGlCommands);
  81. printf ("offsetEnd:tt%dn", model->header.offsetEnd);
  82. #endif
  83. if (model->header.magic != (int) (('2' << 24) + ('P' << 16) + ('D' << 8) + 'I'))
  84. {
  85. fclose (file);
  86. free (model);
  87. return 0;
  88. }
  90. /* read skins */
  91. fseek (file, model->header.offsetSkins, SEEK_SET);
  92. if (model->header.numSkins > 0)
  93. {
  94. model->skins = (md2_skin_t *) malloc (sizeof (md2_skin_t) * model->header.numSkins);
  95. if (!model->skins)
  96. {
  97. md2_freeModel (model);
  98. return 0;
  99. }
  101. for (i = 0; i < model->header.numSkins; i++)
  102. fread (&model->skins[i], sizeof (md2_skin_t), 1, file);
  103. }
  105. /* read texture coordinates */
  106. fseek (file, model->header.offsetTexCoords, SEEK_SET);
  107. if (model->header.numTexCoords > 0)
  108. {
  109. model->texCoords = (md2_textureCoordinate_t *) malloc (sizeof (md2_textureCoordinate_t) * model->header.numTexCoords);
  110. if (!model->texCoords)
  111. {
  112. md2_freeModel (model);
  113. return 0;
  114. }
  116. for (i = 0; i < model->header.numTexCoords; i++)
  117. fread (&model->texCoords[i], sizeof (md2_textureCoordinate_t), 1, file);
  118. }
  120. /* read triangles */
  121. fseek (file, model->header.offsetTriangles, SEEK_SET);
  122. if (model->header.numTriangles > 0)
  123. {
  124. model->triangles = (md2_triangle_t *) malloc (sizeof (md2_triangle_t) * model->header.numTriangles);
  125. if (!model->triangles)
  126. {
  127. md2_freeModel (model);
  128. return 0;
  129. }
  131. for (i = 0; i < model->header.numTriangles; i++)
  132. fread (&model->triangles[i], sizeof (md2_triangle_t), 1, file);
  133. }
  135. /* read alias frames */
  136. fseek (file, model->header.offsetFrames, SEEK_SET);
  137. if (model->header.numFrames > 0)
  138. {
  139. model->frames = (md2_frame_t *) malloc (sizeof (md2_frame_t) * model->header.numFrames);
  140. if (!model->frames)
  141. {
  142. md2_freeModel (model);
  143. return 0;
  144. }
  146. for (i = 0; i < model->header.numFrames; i++)
  147. {
  148. md2_alias_frame_t *frame = (md2_alias_frame_t *) buffer;
  149. int j;
  151. model->frames[i].vertices = (md2_triangleVertex_t *) malloc (sizeof (md2_triangleVertex_t) * model->header.numVertices);
  152. if (!model->frames[i].vertices)
  153. {
  154. md2_freeModel (model);
  155. return 0;
  156. }
  158. fread (frame, 1, model->header.frameSize, file);
  159. strcpy (model->frames[i].name, frame->name);
  160. for (j = 0; j < model->header.numVertices; j++)
  161. {
  162. model->frames[i].vertices[j].vertex[0] = (float) ((int) frame->alias_vertices[j].vertex[0]) * frame->scale[0] + frame->translate[0];
  163. model->frames[i].vertices[j].vertex[2] = -1* ((float) ((int) frame->alias_vertices[j].vertex[1]) * frame->scale[1] + frame->translate[1]);
  164. model->frames[i].vertices[j].vertex[1] = (float) ((int) frame->alias_vertices[j].vertex[2]) * frame->scale[2] + frame->translate[2];
  166. model->frames[i].vertices[j].normal[0] = avertexnormals[frame->alias_vertices[j].lightNormalIndex][0];
  167. model->frames[i].vertices[j].normal[1] = avertexnormals[frame->alias_vertices[j].lightNormalIndex][1];
  168. model->frames[i].vertices[j].normal[2] = avertexnormals[frame->alias_vertices[j].lightNormalIndex][2];
  169. //model->frames[i].vertices[j].lightNormalIndex = frame->alias_vertices[j].lightNormalIndex;
  170. }
  171. }
  172. }
  174. /* read gl commands */
  175. fseek (file, model->header.offsetGlCommands, SEEK_SET);
  176. if (model->header.numGlCommands)
  177. {
  178. model->glCommandBuffer = (int *) malloc (sizeof (int) * model->header.numGlCommands);
  179. if (!model->glCommandBuffer)
  180. {
  181. md2_freeModel (model);
  182. return 0;
  183. }
  185. fread (model->glCommandBuffer, sizeof (int), model->header.numGlCommands, file);
  186. }
  188. fclose (file);
  190. return model;
  191. }
  195. /*
  196.  * free model
  197.  */
  198. void
  199. md2_freeModel (md2_model_t *model)
  200. {
  201. if (model)
  202. {
  203. if (model->skins)
  204. free (model->skins);
  206. if (model->texCoords)
  207. free (model->texCoords);
  209. if (model->triangles)
  210. free (model->triangles);
  212. if (model->frames)
  213. {
  214. int i;
  216. for (i = 0; i < model->header.numFrames; i++)
  217. {
  218. if (model->frames[i].vertices)
  219. free (model->frames[i].vertices);
  220. }
  221. free (model->frames);
  222. }
  224. if (model->glCommandBuffer)
  225. free (model->glCommandBuffer);
  227. free (model);
  228. }
  229. }
  233. /*
  234.  * set draw style, either with glcommands, interpolated
  235.  */
  236. void
  237. md2_setStyle (int glcmds, int interp)
  238. {
  239. g_glcmds = glcmds;
  240. g_interp = interp;
  241. }
  245. /*
  246.  * center model
  247.  *
  248.  */
  249. void
  250. md2_getBoundingBox (md2_model_t *model, float *minmax)
  251. {
  252. int i;
  253. float minx, maxx;
  254. float miny, maxy;
  255. float minz, maxz;
  257. minx = miny = minz = 999999.0f;
  258. maxx = maxy = maxz = -999999.0f;
  260. /* get bounding box */
  261. for (i = 0; i < model->header.numVertices; i++)
  262. {
  263. md2_triangleVertex_t *v = &model->frames[0].vertices[i];
  265. if (v->vertex[0] < minx)
  266. minx = v->vertex[0];
  267. else if (v->vertex[0] > maxx)
  268. maxx = v->vertex[0];
  270. if (v->vertex[1] < miny)
  271. miny = v->vertex[1];
  272. else if (v->vertex[1] > maxy)
  273. maxy = v->vertex[1];
  275. if (v->vertex[2] < minz)
  276. minz = v->vertex[2];
  277. else if (v->vertex[2] > maxz)
  278. maxz = v->vertex[2];
  279. }
  281. minmax[0] = minx;
  282. minmax[1] = maxx;
  283. minmax[2] = miny;
  284. minmax[3] = maxy;
  285. minmax[4] = minz;
  286. minmax[5] = maxz;
  287. }
  291. /*
  292.  * draw normal
  293.  *
  294.  */
  295. void
  296. _md2_drawModel (md2_model_t *model, int frame)
  297. {
  298. int i;
  300. md2_frame_t *f = &model->frames[frame];
  302. glBegin (GL_TRIANGLES);
  304. for (i = 0; i < model->header.numTriangles; i++)
  305. {
  306. md2_triangle_t *t = &model->triangles[i];
  307. //int lightNormalIndex;
  308. /*
  309. lightNormalIndex = f->vertices[t->vertexIndices[0]].lightNormalIndex;
  310. glNormal3f (avertexnormals[lightNormalIndex][0],
  311. avertexnormals[lightNormalIndex][2],
  312. -avertexnormals[lightNormalIndex][1]);
  313. */
  314. glNormal3f (f->vertices[t->vertexIndices[0]].normal[0],
  315. f->vertices[t->vertexIndices[0]].normal[2],
  316. -f->vertices[t->vertexIndices[0]].normal[1]);
  317. glTexCoord2f ((float) model->texCoords[t->textureIndices[0]].s / (float) model->header.skinWidth,
  318. (float) model->texCoords[t->textureIndices[0]].t / (float) model->header.skinHeight);
  319. glVertex3f (f->vertices[t->vertexIndices[0]].vertex[0],
  320. f->vertices[t->vertexIndices[0]].vertex[1],
  321. f->vertices[t->vertexIndices[0]].vertex[2]);
  323. /*
  324. lightNormalIndex = f->vertices[t->vertexIndices[1]].lightNormalIndex;
  325. glNormal3f (avertexnormals[lightNormalIndex][0],
  326. avertexnormals[lightNormalIndex][2],
  327. -avertexnormals[lightNormalIndex][1]);
  328. */
  329. glNormal3f (f->vertices[t->vertexIndices[1]].normal[0],
  330. f->vertices[t->vertexIndices[1]].normal[2],
  331. -f->vertices[t->vertexIndices[1]].normal[1]);
  332. glTexCoord2f ((float) model->texCoords[t->textureIndices[1]].s / (float) model->header.skinWidth,
  333. (float) model->texCoords[t->textureIndices[1]].t / (float) model->header.skinHeight);
  334. glVertex3f (f->vertices[t->vertexIndices[1]].vertex[0],
  335. f->vertices[t->vertexIndices[1]].vertex[1],
  336. f->vertices[t->vertexIndices[1]].vertex[2]);
  337. /*
  338. lightNormalIndex = f->vertices[t->vertexIndices[2]].lightNormalIndex;
  339. glNormal3f (avertexnormals[lightNormalIndex][0],
  340. avertexnormals[lightNormalIndex][2],
  341. -avertexnormals[lightNormalIndex][1]);
  342. */
  343. glNormal3f (f->vertices[t->vertexIndices[2]].normal[0],
  344. f->vertices[t->vertexIndices[2]].normal[2],
  345. -f->vertices[t->vertexIndices[2]].normal[1]);
  346. glTexCoord2f ((float) model->texCoords[t->textureIndices[2]].s / (float) model->header.skinWidth,
  347. (float) model->texCoords[t->textureIndices[2]].t / (float) model->header.skinHeight);
  348. glVertex3f (f->vertices[t->vertexIndices[2]].vertex[0],
  349. f->vertices[t->vertexIndices[2]].vertex[1],
  350. f->vertices[t->vertexIndices[2]].vertex[2]);
  351. }
  352. glEnd ();
  353. }
  357. /*
  358.  * draw interpolated
  359.  *
  360.  */
  361. void
  362. _md2_drawModeli (md2_model_t *model, int frame1, int frame2, float pol)
  363. {
  364. int i;
  366. md2_frame_t *f1 = &model->frames[frame1];
  367. md2_frame_t *f2 = &model->frames[frame2];
  369. glBegin (GL_TRIANGLES);
  371. for (i = 0; i < model->header.numTriangles; i++)
  372. {
  373. md2_triangle_t *t = &model->triangles[i];
  374. //int lightNormalIndex1, lightNormalIndex2;
  375. float x1, y1, z1, x2, y2, z2;
  376. float *n1, *n2;
  378. glTexCoord2f ((float) model->texCoords[t->textureIndices[0]].s / (float) model->header.skinWidth,
  379. (float) model->texCoords[t->textureIndices[0]].t / (float) model->header.skinHeight);
  380. /*
  381. lightNormalIndex1 = f1->vertices[t->vertexIndices[0]].lightNormalIndex;
  382. lightNormalIndex2 = f2->vertices[t->vertexIndices[0]].lightNormalIndex;
  383. glNormal3f ((1.0f - pol) * avertexnormals[lightNormalIndex1][0] + pol * avertexnormals[lightNormalIndex2][0],
  384. (1.0f - pol) * avertexnormals[lightNormalIndex1][2] + pol * avertexnormals[lightNormalIndex2][2],
  385. (1.0f - pol) * -avertexnormals[lightNormalIndex1][1] + pol * -avertexnormals[lightNormalIndex2][1]);
  386. */
  387. n1 = f1->vertices[t->vertexIndices[0]].normal;
  388. n2 = f2->vertices[t->vertexIndices[0]].normal;
  389. glNormal3f ((1.0f - pol) * n1[0] + pol * n2[0],
  390. (1.0f - pol) * n1[2] + pol * n2[2],
  391. (1.0f - pol) * -n1[1] + pol * -n2[1]);
  393. x1 = f1->vertices[t->vertexIndices[0]].vertex[0];
  394. y1 = f1->vertices[t->vertexIndices[0]].vertex[1];
  395. z1 = f1->vertices[t->vertexIndices[0]].vertex[2];
  396. x2 = f2->vertices[t->vertexIndices[0]].vertex[0];
  397. y2 = f2->vertices[t->vertexIndices[0]].vertex[1];
  398. z2 = f2->vertices[t->vertexIndices[0]].vertex[2];
  399. glVertex3f (x1 + pol * (x2 - x1),
  400. y1 + pol * (y2 - y1),
  401. z1 + pol * (z2 - z1));
  403. glTexCoord2f ((float) model->texCoords[t->textureIndices[1]].s / (float) model->header.skinWidth,
  404. (float) model->texCoords[t->textureIndices[1]].t / (float) model->header.skinHeight);
  405. /*
  406. lightNormalIndex1 = f1->vertices[t->vertexIndices[1]].lightNormalIndex;
  407. lightNormalIndex2 = f2->vertices[t->vertexIndices[1]].lightNormalIndex;
  408. glNormal3f ((1.0f - pol) * avertexnormals[lightNormalIndex1][0] + pol * avertexnormals[lightNormalIndex2][0],
  409. (1.0f - pol) * avertexnormals[lightNormalIndex1][2] + pol * avertexnormals[lightNormalIndex2][2],
  410. (1.0f - pol) * -avertexnormals[lightNormalIndex1][1] + pol * -avertexnormals[lightNormalIndex2][1]);
  411. */
  412. n1 = f1->vertices[t->vertexIndices[1]].normal;
  413. n2 = f2->vertices[t->vertexIndices[1]].normal;
  414. glNormal3f ((1.0f - pol) * n1[0] + pol * n2[0],
  415. (1.0f - pol) * n1[2] + pol * n2[2],
  416. (1.0f - pol) * -n1[1] + pol * -n2[1]);
  418. x1 = f1->vertices[t->vertexIndices[1]].vertex[0];
  419. y1 = f1->vertices[t->vertexIndices[1]].vertex[1];
  420. z1 = f1->vertices[t->vertexIndices[1]].vertex[2];
  421. x2 = f2->vertices[t->vertexIndices[1]].vertex[0];
  422. y2 = f2->vertices[t->vertexIndices[1]].vertex[1];
  423. z2 = f2->vertices[t->vertexIndices[1]].vertex[2];
  424. glVertex3f (x1 + pol * (x2 - x1),
  425. y1 + pol * (y2 - y1),
  426. z1 + pol * (z2 - z1));
  428. glTexCoord2f ((float) model->texCoords[t->textureIndices[2]].s / (float) model->header.skinWidth,
  429. (float) model->texCoords[t->textureIndices[2]].t / (float) model->header.skinHeight);
  430. /*
  431. lightNormalIndex1 = f1->vertices[t->vertexIndices[2]].lightNormalIndex;
  432. lightNormalIndex2 = f2->vertices[t->vertexIndices[2]].lightNormalIndex;
  433. glNormal3f ((1.0f - pol) * avertexnormals[lightNormalIndex1][0] + pol * avertexnormals[lightNormalIndex2][0],
  434. (1.0f - pol) * avertexnormals[lightNormalIndex1][2] + pol * avertexnormals[lightNormalIndex2][2],
  435. (1.0f - pol) * -avertexnormals[lightNormalIndex1][1] + pol * -avertexnormals[lightNormalIndex2][1]);
  436. */
  437. n1 = f1->vertices[t->vertexIndices[2]].normal;
  438. n2 = f2->vertices[t->vertexIndices[2]].normal;
  439. glNormal3f ((1.0f - pol) * n1[0] + pol * n2[0],
  440. (1.0f - pol) * n1[2] + pol * n2[2],
  441. (1.0f - pol) * -n1[1] + pol * -n2[1]);
  443. x1 = f1->vertices[t->vertexIndices[2]].vertex[0];
  444. y1 = f1->vertices[t->vertexIndices[2]].vertex[1];
  445. z1 = f1->vertices[t->vertexIndices[2]].vertex[2];
  446. x2 = f2->vertices[t->vertexIndices[2]].vertex[0];
  447. y2 = f2->vertices[t->vertexIndices[2]].vertex[1];
  448. z2 = f2->vertices[t->vertexIndices[2]].vertex[2];
  449. glVertex3f (x1 + pol * (x2 - x1),
  450. y1 + pol * (y2 - y1),
  451. z1 + pol * (z2 - z1));
  452. }
  453. glEnd ();
  454. }
  458. /*
  459.  * draw with glcommands
  460.  *
  461.  */
  462. void
  463. _md2_drawModelg (md2_model_t *model, int frame)
  464. {
  465. int i = 0;
  466. int val = model->glCommandBuffer[i++];
  468. while (val != 0)
  469. {
  470. int count;
  472. if (val > 0)
  473. {
  474. glBegin (GL_TRIANGLE_STRIP);
  475. count = val;
  476. }
  477. else
  478. {
  479. glBegin (GL_TRIANGLE_FAN);
  480. count = -val;
  481. }
  483. while (count--)
  484. {
  485. float s = *(float *) &model->glCommandBuffer[i++];
  486. float t = *(float *) &model->glCommandBuffer[i++];
  487. int index = model->glCommandBuffer[i++];
  488. //int lightNormalIndex = model->frames[frame].vertices[index].lightNormalIndex;
  490. glTexCoord2f (s, t);
  491. /*
  492. glNormal3f (avertexnormals[lightNormalIndex][0],
  493. avertexnormals[lightNormalIndex][2],
  494. -avertexnormals[lightNormalIndex][1]);
  495. */
  496. glNormal3f (model->frames[frame].vertices[index].normal[0],
  497. model->frames[frame].vertices[index].normal[2],
  498. -model->frames[frame].vertices[index].normal[1]);
  499. glVertex3f (model->frames[frame].vertices[index].vertex[0],
  500. model->frames[frame].vertices[index].vertex[1],
  501. model->frames[frame].vertices[index].vertex[2]);
  502. }
  504. glEnd ();
  506. val = model->glCommandBuffer[i++];
  507. }
  508. }
  512. /*
  513.  * draw with glcommands, interpolated
  514.  *
  515.  */
  516. void
  517. _md2_drawModelgi (md2_model_t *model, int frame1, int frame2, float pol)
  518. {
  519. int i = 0;
  520. int val = model->glCommandBuffer[i++];
  522. while (val != 0)
  523. {
  524. int count;
  526. if (val > 0)
  527. {
  528. glBegin (GL_TRIANGLE_STRIP);
  529. count = val;
  530. }
  531. else
  532. {
  533. glBegin (GL_TRIANGLE_FAN);
  534. count = -val;
  535. }
  537. while (count--)
  538. {
  539. float s = *(float *) &model->glCommandBuffer[i++];
  540. float t = *(float *) &model->glCommandBuffer[i++];
  541. int index = model->glCommandBuffer[i++];
  542. //int lightNormalIndex1 = model->frames[frame1].vertices[index].lightNormalIndex;
  543. //int lightNormalIndex2 = model->frames[frame2].vertices[index].lightNormalIndex;
  544. float x1, y1, z1, x2, y2, z2;
  545. float *n1 = model->frames[frame1].vertices[index].normal;
  546. float *n2 = model->frames[frame2].vertices[index].normal;
  548. /* texcoords don't need to be interpolated */
  549. glTexCoord2f (s, t);
  551. /* interpolate light normal */
  552. /*
  553. glNormal3f ((1.0f - pol) * avertexnormals[lightNormalIndex1][0] + pol * avertexnormals[lightNormalIndex2][0],
  554. (1.0f - pol) * avertexnormals[lightNormalIndex1][2] + pol * avertexnormals[lightNormalIndex2][2],
  555. (1.0f - pol) * -avertexnormals[lightNormalIndex1][1] + pol * -avertexnormals[lightNormalIndex2][1]);
  556. */
  557. glNormal3f ((1.0f - pol) * n1[0] + pol * n2[0],
  558. (1.0f - pol) * n1[2] + pol * n2[2],
  559. (1.0f - pol) * -n1[1] + pol * -n2[1]);
  561. /* interpolate vertices */
  562. x1 = model->frames[frame1].vertices[index].vertex[0];
  563. y1 = model->frames[frame1].vertices[index].vertex[1];
  564. z1 = model->frames[frame1].vertices[index].vertex[2];
  566. x2 = model->frames[frame2].vertices[index].vertex[0];
  567. y2 = model->frames[frame2].vertices[index].vertex[1];
  568. z2 = model->frames[frame2].vertices[index].vertex[2];
  570. glVertex3f (x1 + pol * (x2 - x1),
  571. y1 + pol * (y2 - y1),
  572. z1 + pol * (z2 - z1));
  573. }
  575. glEnd ();
  577. val = model->glCommandBuffer[i++];
  578. }
  579. }
  583. /*
  584.  * draw model
  585.  */
  586. void
  587. md2_drawModel (md2_model_t *model, int frame1, int frame2, float pol)
  588. {
  589. if (g_glcmds)
  590. {
  591. if (g_interp)
  592. _md2_drawModelgi (model, frame1, frame2, pol);
  593. else
  594. _md2_drawModelg (model, frame1);
  595. }
  596. else
  597. {
  598. if (g_interp)
  599. _md2_drawModeli (model, frame1, frame2, pol);
  600. else
  601. _md2_drawModel (model, frame1);
  602. }
  603. }
  607. void
  608. _makeFacetNormal (md2_model_t *model, md2_triangle_t *t, int frame, float *fn)
  609. {
  610. float v1[3], v2[3];
  611. double angle;
  613. v1[0] = model->frames[frame].vertices[t->vertexIndices[1]].vertex[0] - model->frames[frame].vertices[t->vertexIndices[0]].vertex[0];
  614. v1[1] = model->frames[frame].vertices[t->vertexIndices[1]].vertex[1] - model->frames[frame].vertices[t->vertexIndices[0]].vertex[1];
  615. v1[2] = model->frames[frame].vertices[t->vertexIndices[1]].vertex[2] - model->frames[frame].vertices[t->vertexIndices[0]].vertex[2];
  617. v2[0] = model->frames[frame].vertices[t->vertexIndices[2]].vertex[0] - model->frames[frame].vertices[t->vertexIndices[0]].vertex[0];
  618. v2[1] = model->frames[frame].vertices[t->vertexIndices[2]].vertex[1] - model->frames[frame].vertices[t->vertexIndices[0]].vertex[1];
  619. v2[2] = model->frames[frame].vertices[t->vertexIndices[2]].vertex[2] - model->frames[frame].vertices[t->vertexIndices[0]].vertex[2];
  621. angle = 1;
  623. fn[0] = (v1[1] * v2[2] - v1[2] * v2[1]) * (float) angle;
  624. fn[1] = (v1[2] * v2[0] - v1[0] * v2[2]) * (float) angle;
  625. fn[2] = (v1[0] * v2[1] - v1[1] * v2[0]) * (float) angle;
  626. }
  630. void
  631. _normalize (float *n)
  632. {
  633. float l = (float) sqrt (n[0] * n[0] + n[1] * n[1] + n[2] * n[2]);
  635. if (l != 0.0f)
  636. {
  637. n[0] /= l;
  638. n[1] /= l;
  639. n[2] /= l;
  640. }
  641. }
  645. void
  646. md2_generateLightNormals (md2_model_t *model)
  647. {
  648. int i;
  650. if (!model)
  651. return;
  654. for (i = 0; i < model->header.numFrames; i++)
  655. {
  656. int j;
  658. /* clear all normals */
  659. for (j = 0; j < model->header.numVertices; j++)
  660. {
  661. model->frames[i].vertices[j].normal[0] = 0.0f;
  662. model->frames[i].vertices[j].normal[1] = 0.0f;
  663. model->frames[i].vertices[j].normal[2] = 0.0f;
  664. }
  666. /* calc normals */
  667. for (j = 0; j < model->header.numTriangles; j++)
  668. {
  669. int k;
  670. float facetnormal[3];
  672. _makeFacetNormal (model, &model->triangles[j], i, facetnormal);
  674. for (k = 0; k < 3; k++)
  675. {
  676. model->frames[i].vertices[model->triangles[j].vertexIndices[k]].normal[0] -= facetnormal[0];
  677. model->frames[i].vertices[model->triangles[j].vertexIndices[k]].normal[1] += facetnormal[2];
  678. model->frames[i].vertices[model->triangles[j].vertexIndices[k]].normal[2] -= facetnormal[1];
  679. }
  680. }
  682. /* normalize normals */
  683. for (j = 0; j < model->header.numVertices; j++)
  684. _normalize (model->frames[i].vertices[j].normal);
  685. }
  686. }
  690. int
  691. md2_getAnimationCount (md2_model_t *model)
  692. {
  693. int i, j, pos;
  694. int count;
  695. int lastId;
  696. char name[16], last[16];
  698. strcpy (last, model->frames[0].name);
  699. pos = strlen (last) - 1;
  700. j = 0;
  701. while (last[pos] >= '0' && last[pos] <= '9' && j < 2)
  702. {
  703. pos--;
  704. j++;
  705. }
  706. last[pos + 1] = '';
  708. lastId = 0;
  709. count = 0;
  711. for (i = 0; i <= model->header.numFrames; i++)
  712. {
  713. if (i == model->header.numFrames)
  714. strcpy (name, ""); // some kind of a sentinel
  715. else
  716. strcpy (name, model->frames[i].name);
  717. pos = strlen (name) - 1;
  718. j = 0;
  719. while (name[pos] >= '0' && name[pos] <= '9' && j < 2)
  720. {
  721. pos--;
  722. j++;
  723. }
  724. name[pos + 1] = '';
  726. if (strcmp (last, name))
  727. {
  728. strcpy (last, name);
  729. count++;
  730. }
  731. }
  733. return count;
  734. }
  738. const char *
  739. md2_getAnimationName (md2_model_t *model, int animation)
  740. {
  741. int i, j, pos;
  742. int count;
  743. int lastId;
  744. static char last[32];
  745. char name[32];
  747. strcpy (last, model->frames[0].name);
  748. pos = strlen (last) - 1;
  749. j = 0;
  750. while (last[pos] >= '0' && last[pos] <= '9' && j < 2)
  751. {
  752. pos--;
  753. j++;
  754. }
  755. last[pos + 1] = '';
  757. lastId = 0;
  758. count = 0;
  760. for (i = 0; i <= model->header.numFrames; i++)
  761. {
  762. if (i == model->header.numFrames)
  763. strcpy (name, ""); // some kind of a sentinel
  764. else
  765. strcpy (name, model->frames[i].name);
  766. pos = strlen (name) - 1;
  767. j = 0;
  768. while (name[pos] >= '0' && name[pos] <= '9' && j < 2)
  769. {
  770. pos--;
  771. j++;
  772. }
  773. name[pos + 1] = '';
  775. if (strcmp (last, name))
  776. {
  777. if (count == animation)
  778. return last;
  780. strcpy (last, name);
  781. count++;
  782. }
  783. }
  785. return 0;
  786. }
  790. void
  791. md2_getAnimationFrames (md2_model_t *model, int animation, int *startFrame, int *endFrame)
  792. {
  793. int i, j, pos;
  794. int count, numFrames, frameCount;
  795. int lastId;
  796. char name[16], last[16];
  798. strcpy (last, model->frames[0].name);
  799. pos = strlen (last) - 1;
  800. j = 0;
  801. while (last[pos] >= '0' && last[pos] <= '9' && j < 2)
  802. {
  803. pos--;
  804. j++;
  805. }
  806. last[pos + 1] = '';
  808. lastId = 0;
  809. count = 0;
  810. numFrames = 0;
  811. frameCount = 0;
  813. for (i = 0; i <= model->header.numFrames; i++)
  814. {
  815. if (i == model->header.numFrames)
  816. strcpy (name, ""); // some kind of a sentinel
  817. else
  818. strcpy (name, model->frames[i].name);
  819. pos = strlen (name) - 1;
  820. j = 0;
  821. while (name[pos] >= '0' && name[pos] <= '9' && j < 2)
  822. {
  823. pos--;
  824. j++;
  825. }
  826. name[pos + 1] = '';
  828. if (strcmp (last, name))
  829. {
  830. strcpy (last, name);
  832. if (count == animation)
  833. {
  834. *startFrame = frameCount - numFrames;
  835. *endFrame = frameCount - 1;
  836. return;
  837. }
  839. count++;
  840. numFrames = 0;
  841. }
  842. frameCount++;
  843. numFrames++;
  844. }
  847. *startFrame = *endFrame = 0;
  848. }
  852. #if 0
  853. void
  854. md2_printModelInfo (md2_model_t *model)
  855. {
  856. int i;
  858. printf ("magic:tt%dn", model->header.magic);
  859. printf ("version:tt%dn", model->header.version);
  860. printf ("skinWidth:tt%dn", model->header.skinWidth);
  861. printf ("skinHeight:tt%dn", model->header.skinHeight);
  862. printf ("frameSize:tt%dn", model->header.frameSize);
  863. printf ("numSkins:tt%dn", model->header.numSkins);
  864. printf ("numVertices:tt%dn", model->header.numVertices);
  865. printf ("numTexCoords:tt%dn", model->header.numTexCoords);
  866. printf ("numTriangles:tt%dn", model->header.numTriangles);
  867. printf ("numGlCommands:tt%dn", model->header.numGlCommands);
  868. printf ("numFrames:tt%dn", model->header.numFrames);
  869. printf ("offsetSkins:tt%dn", model->header.offsetSkins);
  870. printf ("offsetTexCoords:t%dn", model->header.offsetTexCoords);
  871. printf ("offsetTriangles:t%dn", model->header.offsetTriangles);
  872. printf ("offsetFrames:tt%dn", model->header.offsetFrames);
  873. printf ("offsetGlCommands:t%dn", model->header.offsetGlCommands);
  874. printf ("offsetEnd:tt%dn", model->header.offsetEnd);
  876. for (i = 0; i < model->header.numFrames; i++)
  877. printf ("%s ", model->frames[i].name);
  879. }
  883. int
  884. main (int argc, char *argv[])
  885. {
  886. md2_model_t *model;
  888. if (argc != 2)
  889. {
  890. printf ("usage: %s <model.md2>n", argv[0]);
  891. return -1;
  892. }
  894. model = md2_readModel (argv[1]);
  895. if (!model)
  896. {
  897. printf ("hoopsn");
  898. return -1;
  899. }
  901. md2_printModelInfo (model);
  902. md2_freeModel (model);
  904. return 0;
  905. }
  906. #endif