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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 游戏引擎 > 查看源码
mesh.cpp
资源名称：Engine_v0.2.tar.gz　[点击查看]
上传用户：qccn516
上传日期：2013-05-02
资源大小：3382k
文件大小：46k
源码类别：

游戏引擎

开发平台：

Visual C++

mesh.cpp：源码内容
  1. /* Mesh
  2.  *
  3.  * Copyright (C) 2003-2004, Alexander Zaprjagaev <frustum@frustum.org>
  4.  *
  5.  * This program is free software; you can redistribute it and/or modify
  6.  * it under the terms of the GNU General Public License as published by
  7.  * the Free Software Foundation; either version 2 of the License, or
  8.  * (at your option) any later version.
  9.  *
  10.  * This program is distributed in the hope that it will be useful,
  11.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13.  * GNU General Public License for more details.
  14.  *
  15.  * You should have received a copy of the GNU General Public License
  16.  * along with this program; if not, write to the Free Software
  17.  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  18.  */
  20. #include "mesh.h"
  22. Mesh::Mesh() : num_surfaces(0) {
  23. min = vec3(1000000,1000000,1000000);
  24. max = vec3(-1000000,-1000000,-1000000);
  25. center = vec3(0,0,0);
  26. radius = 1000000;
  27. }
  29. Mesh::Mesh(const char *name) : num_surfaces(0) {
  30. load(name);
  31. }
  33. Mesh::Mesh(const Mesh *mesh) : num_surfaces(0) {
  34. min = mesh->min;
  35. max = mesh->max;
  36. center = mesh->center;
  37. radius = mesh->radius;
  38. for(int i = 0; i < mesh->num_surfaces; i++) {
  39. Surface *s = new Surface;
  40. memcpy(s,mesh->surfaces[i],sizeof(Surface));
  41. s->vertex = new Vertex[s->num_vertex];
  42. memcpy(s->vertex,mesh->surfaces[i]->vertex,sizeof(Vertex) * s->num_vertex);
  43. if(mesh->surfaces[i]->edges) {
  44. s->edges = new Edge[s->num_edges];
  45. memcpy(s->edges,mesh->surfaces[i]->edges,sizeof(Edge) * s->num_edges);
  46. }
  47. if(mesh->surfaces[i]->triangles) {
  48. s->triangles = new Triangle[s->num_triangles];
  49. memcpy(s->triangles,mesh->surfaces[i]->triangles,sizeof(Triangle) * s->num_triangles);
  50. }
  51. if(mesh->surfaces[i]->indices) {
  52. s->indices = new int[s->num_indices];
  53. memcpy(s->indices,mesh->surfaces[i]->indices,sizeof(int) * s->num_indices);
  54. }
  55. if(mesh->surfaces[i]->silhouettes[0].vertex) {
  56. for(int j = 0; j < NUM_SILHOUETTES; j++) {
  57. s->silhouettes[j].vertex = new vec4[s->num_edges * 4];
  58. s->silhouettes[j].flags = new char[s->num_triangles];
  59. }
  60. }
  61. if(num_surfaces == NUM_SURFACES) {
  62. fprintf(stderr,"Mesh::Mesh(): many surfacesn");
  63. num_surfaces--;
  64. }
  65. surfaces[num_surfaces++] = s;
  66. }
  67. }
  69. Mesh::~Mesh() {
  70. for(int i = 0; i < num_surfaces; i++) {
  71. Surface *s = surfaces[i];
  72. if(s->vertex) delete s->vertex;
  73. if(s->indices) delete s->indices;
  74. if(s->edges) delete s->edges;
  75. if(s->triangles) delete s->triangles;
  76. if(s->silhouettes[0].vertex) {
  77. for(int j = 0; j < NUM_SILHOUETTES; j++) {
  78. delete s->silhouettes[j].vertex;
  79. delete s->silhouettes[j].flags;
  80. }
  81. }
  82. delete s;
  83. }
  84. num_surfaces = 0;
  85. }
  87. /*****************************************************************************/
  88. /*                                                                           */
  89. /* render                                                                    */
  90. /*                                                                           */
  91. /*****************************************************************************/
  93. /*
  94.  */
  95. int Mesh::render(int,int) {
  96. fprintf(stderr,"Mesh::render()n");
  97. return 0;
  98. }
  100. /*****************************************************************************/
  101. /*                                                                           */
  102. /* stencil shadows                                                           */
  103. /*                                                                           */
  104. /*****************************************************************************/
  106. /*
  107.  */
  108. void Mesh::findSilhouette(const vec4 &light,int s) {
  109. if(s < 0) {
  110. for(int i = 0; i < num_surfaces; i++) {
  111. Surface *s = surfaces[i];
  112. for(int j = 0; j < NUM_SILHOUETTES; j++) {
  113. if(s->silhouettes[j].light == light) {
  114. s->silhouette = &s->silhouettes[j];
  115. continue;
  116. }
  117. }
  118. s->silhouette = &s->silhouettes[s->last_silhouette++];
  119. if(s->last_silhouette == NUM_SILHOUETTES) s->last_silhouette = 0;
  120. for(int j = 0; j < s->num_edges; j++) s->edges[j].flag = -1;
  121. for(int j = 0; j < s->num_triangles; j++) {
  122. if(s->triangles[j].plane * light > 0.0) {
  123. s->silhouette->flags[j] = 1;
  124. Triangle *t = &s->triangles[j];
  125. s->edges[t->e[0]].reverse = t->reverse[0];
  126. s->edges[t->e[1]].reverse = t->reverse[1];
  127. s->edges[t->e[2]].reverse = t->reverse[2];
  128. s->edges[t->e[0]].flag++;
  129. s->edges[t->e[1]].flag++;
  130. s->edges[t->e[2]].flag++;
  131. } else s->silhouette->flags[j] = 0;
  132. }
  133. s->silhouette->light = light;
  134. s->silhouette->num_vertex = 0;
  135. vec4 *vertex = s->silhouette->vertex;
  136. for(int j = 0; j < s->num_edges; j++) {
  137. if(s->edges[j].flag != 0) continue;
  138. Edge *e = &s->edges[j];
  139. if(e->reverse) {
  140. *vertex++ = vec4(e->v[0],1);
  141. *vertex++ = vec4(e->v[1],1);
  142. *vertex++ = vec4(e->v[1],0);
  143. *vertex++ = vec4(e->v[0],0);
  144. } else {
  145. *vertex++ = vec4(e->v[1],1);
  146. *vertex++ = vec4(e->v[0],1);
  147. *vertex++ = vec4(e->v[0],0);
  148. *vertex++ = vec4(e->v[1],0);
  149. }
  150. s->silhouette->num_vertex += 4;
  151. }
  152. }
  153. } else {
  154. Surface *surface = surfaces[s];
  155. Surface *s = surface; // :)
  156. for(int i = 0; i < NUM_SILHOUETTES; i++) {
  157. if(s->silhouettes[i].light == light) {
  158. s->silhouette = &s->silhouettes[i];
  159. return;
  160. }
  161. }
  162. s->silhouette = &s->silhouettes[s->last_silhouette++];
  163. if(s->last_silhouette == NUM_SILHOUETTES) s->last_silhouette = 0;
  164. for(int i = 0; i < s->num_edges; i++) s->edges[i].flag = -1;
  165. for(int i = 0; i < s->num_triangles; i++) {
  166. if(s->triangles[i].plane * light > 0.0) {
  167. s->silhouette->flags[i] = 1;
  168. Triangle *t = &s->triangles[i];
  169. s->edges[t->e[0]].reverse = t->reverse[0];
  170. s->edges[t->e[1]].reverse = t->reverse[1];
  171. s->edges[t->e[2]].reverse = t->reverse[2];
  172. s->edges[t->e[0]].flag++;
  173. s->edges[t->e[1]].flag++;
  174. s->edges[t->e[2]].flag++;
  175. } else s->silhouette->flags[i] = 0;;
  176. }
  177. s->silhouette->light = light;
  178. s->silhouette->num_vertex = 0;
  179. vec4 *vertex = s->silhouette->vertex;
  180. for(int i = 0; i < s->num_edges; i++) {
  181. if(s->edges[i].flag != 0) continue;
  182. Edge *e = &s->edges[i];
  183. if(e->reverse) {
  184. *vertex++ = vec4(e->v[0],1);
  185. *vertex++ = vec4(e->v[1],1);
  186. *vertex++ = vec4(e->v[1],0);
  187. *vertex++ = vec4(e->v[0],0);
  188. } else {
  189. *vertex++ = vec4(e->v[1],1);
  190. *vertex++ = vec4(e->v[0],1);
  191. *vertex++ = vec4(e->v[0],0);
  192. *vertex++ = vec4(e->v[1],0);
  193. }
  194. s->silhouette->num_vertex += 4;
  195. }
  196. }
  197. }
  199. int Mesh::getNumIntersections(const vec3 &line0,const vec3 &line1,int s) {
  200. int num_intersections = 0;
  201. if(s < 0) {
  202. vec3 dir = line1 - line0;
  203. float dot = (dir * center - dir * line0) / (dir * dir);
  204. if(dot < 0.0 && (line0 - center).length() > radius) return 0;
  205. else if(dot > 1.0 && (line1 - center).length() > radius) return 0;
  206. else if((line0 + dir * dot - center).length() > radius) return 0;
  207. for(int i = 0; i < num_surfaces; i++) {
  208. Surface *s = surfaces[i];
  209. float dot = (dir * s->center - dir * line0) / (dir * dir);
  210. if(dot < 0.0 && (line0 - s->center).length() > s->radius) continue;
  211. else if(dot > 1.0 && (line1 - s->center).length() > s->radius) continue;
  212. else if((line0 + dir * dot - s->center).length() > s->radius) continue;
  213. for(int j = 0; j < s->num_triangles; j++) {
  214. if(s->silhouette->flags[j] == 0) continue;
  215. Triangle *t = &s->triangles[j];
  216. float dot = -(t->plane * vec4(line0,1)) / (vec3(t->plane) * dir);
  217. if(dot < 0.0 || dot > 1.0) continue;
  218. vec3 p = line0 + dir * dot;
  219. if(p * t->c[0] > 0.0 && p * t->c[1] > 0.0 && p * t->c[2] > 0.0) num_intersections++;
  220. }
  221. }
  222. return num_intersections;
  223. } else {
  224. Surface *surface = surfaces[s];
  225. Surface *s = surface;
  226. vec3 dir = line1 - line0;
  227. float dot = (dir * s->center - dir * line0) / (dir * dir);
  228. if(dot < 0.0 && (line0 - s->center).length() > s->radius) return 0;
  229. else if(dot > 1.0 && (line1 - s->center).length() > s->radius) return 0;
  230. else if((line0 + dir * dot - s->center).length() > s->radius) return 0;
  231. for(int i = 0; i < s->num_triangles; i++) {
  232. if(s->silhouette->flags[i] == 0) continue;
  233. Triangle *t = &s->triangles[i];
  234. float dot = -(t->plane * vec4(line0,1)) / (vec3(t->plane) * dir);
  235. if(dot < 0.0 || dot > 1.0) continue;
  236. vec3 p = line0 + dir * dot;
  237. if(p * t->c[0] > 0.0 && p * t->c[1] > 0.0 && p * t->c[2] > 0.0) num_intersections++;
  238. }
  239. return num_intersections;
  240. }
  241. }
  243. int Mesh::renderShadowVolume(int) {
  244. fprintf(stderr,"Mesh::renderShadowVolume()n");
  245. return 0;
  246. }
  248. /*****************************************************************************/
  249. /*                                                                           */
  250. /* line inersection                                                          */
  251. /*                                                                           */
  252. /*****************************************************************************/
  254. int Mesh::intersection(const vec3 &line0,const vec3 &line1,vec3 &point,vec3 &normal,int s) {
  255. float nearest = 2.0;
  256. if(s < 0) {
  257. vec3 dir = line1 - line0;
  258. float dot = (dir * center - dir * line0) / (dir * dir);
  259. if(dot < 0.0 && (line0 - center).length() > radius) return 0;
  260. else if(dot > 1.0 && (line1 - center).length() > radius) return 0;
  261. else if((line0 + dir * dot - center).length() > radius) return 0;
  262. for(int i = 0; i < num_surfaces; i++) {
  263. Surface *s = surfaces[i];
  264. float dot = (dir * s->center - dir * line0) / (dir * dir);
  265. if(dot < 0.0 && (line0 - s->center).length() > s->radius) continue;
  266. else if(dot > 1.0 && (line1 - s->center).length() > s->radius) continue;
  267. else if((line0 + dir * dot - s->center).length() > s->radius) continue;
  268. for(int j = 0; j < s->num_triangles; j++) {
  269. Triangle *t = &s->triangles[j];
  270. float dot = -(t->plane * vec4(line0,1)) / (vec3(t->plane) * dir);
  271. if(dot < 0.0 || dot > 1.0) continue;
  272. vec3 p = line0 + dir * dot;
  273. if(nearest > dot && p * t->c[0] > 0.0 && p * t->c[1] > 0.0 && p * t->c[2] > 0.0) {
  274. nearest = dot;
  275. point = p;
  276. normal = t->plane;
  277. }
  278. }
  279. }
  280. return nearest < 2.0 ? 1 : 0;
  281. } else {
  282. Surface *surface = surfaces[s];
  283. Surface *s = surface;
  284. vec3 dir = line1 - line0;
  285. float dot = (dir * s->center - dir * line0) / (dir * dir);
  286. if(dot < 0.0 && (line0 - s->center).length() > s->radius) return 0;
  287. else if(dot > 1.0 && (line1 - s->center).length() > s->radius) return 0;
  288. else if((line0 + dir * dot - s->center).length() > s->radius) return 0;
  289. for(int i = 0; i < s->num_triangles; i++) {
  290. Triangle *t = &s->triangles[i];
  291. float dot = -(t->plane * vec4(line0,1)) / (vec3(t->plane) * dir);
  292. if(dot < 0.0 || dot > 1.0) continue;
  293. vec3 p = line0 + dir * dot;
  294. if(nearest > dot && p * t->c[0] > 0.0 && p * t->c[1] > 0.0 && p * t->c[2] > 0.0) {
  295. nearest = dot;
  296. point = p;
  297. normal = t->plane;
  298. }
  299. }
  300. return nearest < 2.0 ? 1 : 0;
  301. }
  302. }
  304. /*****************************************************************************/
  305. /*                                                                           */
  306. /* transform                                                                 */
  307. /*                                                                           */
  308. /*****************************************************************************/
  310. void Mesh::transform(const mat4 &m,int s) {
  311. mat4 r = m.rotation();
  312. if(s < 0) {
  313. for(int i = 0; i < num_surfaces; i++) {
  314. Surface *s = surfaces[i];
  315. for(int j = 0; j < s->num_vertex; j++) {
  316. Vertex *v = &s->vertex[j];
  317. v->xyz = m * v->xyz;
  318. v->normal = r * v->normal;
  319. v->normal.normalize();
  320. v->tangent = r * v->tangent;
  321. v->tangent.normalize();
  322. v->binormal = r * v->binormal;
  323. v->binormal.normalize();
  324. }
  325. for(int j = 0; j < s->num_edges; j++) {
  326. Edge *e = &s->edges[j];
  327. e->v[0] = m * e->v[0];
  328. e->v[1] = m * e->v[1];
  329. }
  330. for(int j = 0; j < s->num_triangles; j++) {
  331. Triangle *t = &s->triangles[j];
  332. t->v[0] = m * t->v[0];
  333. t->v[1] = m * t->v[1];
  334. t->v[2] = m * t->v[2];
  335. vec3 normal;
  336. normal.cross(t->v[1] - t->v[0],t->v[2] - t->v[0]);
  337. normal.normalize();
  338. t->plane = vec4(normal,-t->v[0] * normal);
  339. normal.cross(t->plane,t->v[0] - t->v[2]); // fast point in traingle
  340. normal.normalize();
  341. t->c[0] = vec4(normal,-t->v[0] * normal);
  342. normal.cross(t->plane,t->v[1] - t->v[0]);
  343. normal.normalize();
  344. t->c[1] = vec4(normal,-t->v[1] * normal);
  345. normal.cross(t->plane,t->v[2] - t->v[1]);
  346. normal.normalize();
  347. t->c[2] = vec4(normal,-t->v[2] * normal);
  348. }
  349. }
  350. } else {
  351. Surface *surface = surfaces[s];
  352. Surface *s = surface;
  353. for(int i = 0; i < s->num_vertex; i++) {
  354. Vertex *v = &s->vertex[i];
  355. v->xyz = m * v->xyz;
  356. v->normal = r * v->normal;
  357. v->normal.normalize();
  358. v->tangent = r * v->tangent;
  359. v->tangent.normalize();
  360. v->binormal = r * v->binormal;
  361. v->binormal.normalize();
  362. }
  363. for(int i = 0; i < s->num_edges; i++) {
  364. Edge *e = &s->edges[i];
  365. e->v[0] = m * e->v[0];
  366. e->v[1] = m * e->v[1];
  367. }
  368. for(int i = 0; i < s->num_triangles; i++) {
  369. Triangle *t = &s->triangles[i];
  370. t->v[0] = m * t->v[0];
  371. t->v[1] = m * t->v[1];
  372. t->v[2] = m * t->v[2];
  373. vec3 normal;
  374. normal.cross(t->v[1] - t->v[0],t->v[2] - t->v[0]);
  375. normal.normalize();
  376. t->plane = vec4(normal,-t->v[0] * normal);
  377. normal.cross(t->plane,t->v[0] - t->v[2]); // fast point in traingle
  378. normal.normalize();
  379. t->c[0] = vec4(normal,-t->v[0] * normal);
  380. normal.cross(t->plane,t->v[1] - t->v[0]);
  381. normal.normalize();
  382. t->c[1] = vec4(normal,-t->v[1] * normal);
  383. normal.cross(t->plane,t->v[2] - t->v[1]);
  384. normal.normalize();
  385. t->c[2] = vec4(normal,-t->v[2] * normal);
  386. }
  387. }
  388. calculate_bounds();
  389. }
  391. /*****************************************************************************/
  392. /*                                                                           */
  393. /* IO functions                                                              */
  394. /*                                                                           */
  395. /*****************************************************************************/
  397. /*
  398.  */
  399. int Mesh::getNumSurfaces() {
  400. return num_surfaces;
  401. }
  403. const char *Mesh::getSurfaceName(int s) {
  404. return surfaces[s]->name;
  405. }
  407. int Mesh::getSurface(const char *name) {
  408. for(int i = 0; i < num_surfaces; i++) if(!strcmp(name,surfaces[i]->name)) return i;
  409. fprintf(stderr,"Mesh::getSurface(): can`t find "%s" surfacen",name);
  410. return -1;
  411. }
  413. /*
  414.  */
  415. int Mesh::getNumVertex(int s) {
  416. return surfaces[s]->num_vertex;
  417. }
  419. Mesh::Vertex *Mesh::getVertex(int s) {
  420. return surfaces[s]->vertex;
  421. }
  423. int Mesh::getNumStrips(int s) {
  424. return surfaces[s]->num_strips;
  425. }
  427. int *Mesh::getIndices(int s) {
  428. return surfaces[s]->indices;
  429. }
  431. int Mesh::getNumEdges(int s) {
  432. return surfaces[s]->num_edges;
  433. }
  435. Mesh::Edge *Mesh::getEdges(int s) {
  436. return surfaces[s]->edges;
  437. }
  439. int Mesh::getNumTriangles(int s) {
  440. return surfaces[s]->num_triangles;
  441. }
  443. Mesh::Triangle *Mesh::getTriangles(int s) {
  444. return surfaces[s]->triangles;
  445. }
  447. /*
  448.  */
  449. const vec3 &Mesh::getMin(int s) {
  450. if(s < 0) return min;
  451. return surfaces[s]->min;
  452. }
  454. const vec3 &Mesh::getMax(int s) {
  455. if(s < 0) return max;
  456. return surfaces[s]->max;
  457. }
  459. const vec3 &Mesh::getCenter(int s) {
  460. if(s < 0) return center;
  461. return surfaces[s]->center;
  462. }
  464. float Mesh::getRadius(int s) {
  465. if(s < 0) return radius;
  466. return surfaces[s]->radius;
  467. }
  469. /* add surface
  470.  */
  471. void Mesh::addSurface(Mesh *mesh,int surface) {
  472. Surface *s = new Surface;
  473. memcpy(s,mesh->surfaces[surface],sizeof(Surface));
  474. s->vertex = new Vertex[s->num_vertex];
  475. memcpy(s->vertex,mesh->surfaces[surface]->vertex,sizeof(Vertex) * s->num_vertex);
  476. if(mesh->surfaces[surface]->edges) {
  477. s->edges = new Edge[s->num_edges];
  478. memcpy(s->edges,mesh->surfaces[surface]->edges,sizeof(Edge) * s->num_edges);
  479. }
  480. if(mesh->surfaces[surface]->triangles) {
  481. s->triangles = new Triangle[s->num_triangles];
  482. memcpy(s->triangles,mesh->surfaces[surface]->triangles,sizeof(Triangle) * s->num_triangles);
  483. }
  484. if(mesh->surfaces[surface]->indices) {
  485. s->indices = new int[s->num_indices];
  486. memcpy(s->indices,mesh->surfaces[surface]->indices,sizeof(int) * s->num_indices);
  487. }
  488. if(mesh->surfaces[surface]->silhouettes[0].vertex) {
  489. for(int j = 0; j < NUM_SILHOUETTES; j++) {
  490. s->silhouettes[j].vertex = new vec4[s->num_edges * 4];
  491. s->silhouettes[j].flags = new char[s->num_triangles];
  492. }
  493. }
  494. if(num_surfaces == NUM_SURFACES) {
  495. fprintf(stderr,"Mesh::addSurface(): many surfacesn");
  496. num_surfaces--;
  497. }
  498. surfaces[num_surfaces++] = s;
  499. calculate_bounds();
  500. }
  502. void Mesh::addSurface(const char *name,Vertex *vertex,int num_vertex) {
  503. Surface *s = new Surface;
  504. memset(s,0,sizeof(Surface));
  505. strcpy(s->name,name);
  506. s->num_vertex = num_vertex;
  507. s->vertex = new Vertex[s->num_vertex];
  508. memcpy(s->vertex,vertex,sizeof(Vertex) * s->num_vertex);
  509. if(num_surfaces == NUM_SURFACES) {
  510. fprintf(stderr,"Mesh::addSurface(): many surfacesn");
  511. num_surfaces--;
  512. }
  513. surfaces[num_surfaces++] = s;
  514. calculate_bounds();
  515. }
  517. /* load
  518.  */
  519. int Mesh::load(const char *name) {
  520. for(int i = 0; i < num_surfaces; i++) {
  521. Surface *s = surfaces[i];
  522. if(s->vertex) delete s->vertex;
  523. if(s->edges) delete s->edges;
  524. if(s->triangles) delete s->triangles;
  525. if(s->indices) delete s->indices;
  526. delete s;
  527. }
  528. if(strstr(name,".mesh")) {
  529. FILE *file = fopen(name,"rb");
  530. if(!file) {
  531. fprintf(stderr,"Mesh::load(): error open "%s" filen",name);
  532. return 0;
  533. }
  534. int magic;
  535. fread(&magic,sizeof(int),1,file);
  536. if(magic == MESH_STRIP_MAGIC) { // load mesh file
  537. load(file);
  538. fclose(file);
  539. return 1;
  540. }
  541. fclose(file);
  542. }
  543. if(strstr(name,".3ds")) load_3ds(name);
  544. else if(strstr(name,".mesh")) load_mesh(name);
  545. if(num_surfaces == 0) {
  546. fprintf(stderr,"Mesh::load(): error open "%s" filen",name);
  547. return 0;
  548. }
  549. calculate_tangent();
  550. create_shadow_volumes();
  551. create_triangle_strips();
  552. calculate_bounds();
  553. return 1;
  554. }
  556. /* save
  557.  */
  558. int Mesh::save(const char *name) {
  559. FILE *file = fopen(name,"wb");
  560. if(!file) {
  561. fprintf(stderr,"Mesh::load(): error create "%s" filen",name);
  562. return 0;
  563. }
  564. int magic = MESH_STRIP_MAGIC;
  565. fwrite(&magic,sizeof(int),1,file);
  566. save(file);
  567. fclose(file);
  568. return 1;
  569. }
  571. /* strip mesh loader
  572.  */
  573. void Mesh::load(FILE *file) {
  574. // number of surfaces
  575. int num_surfaces;
  576. fread(&num_surfaces,sizeof(int),1,file);
  577. for(int i = 0; i < num_surfaces; i++) {
  578. Surface *s = new Surface;
  579. memset(s,0,sizeof(Surface));
  580. // name
  581. fread(s->name,sizeof(s->name),1,file);
  582. // vertexes
  583. fread(&s->num_vertex,sizeof(int),1,file);
  584. s->vertex = new Vertex[s->num_vertex];
  585. fread(s->vertex,sizeof(Vertex),s->num_vertex,file);
  586. // edges
  587. fread(&s->num_edges,sizeof(int),1,file);
  588. s->edges = new Edge[s->num_edges];
  589. for(int j = 0; j < s->num_edges; j++) {
  590. Edge *e = &s->edges[j];
  591. fread(e->v,sizeof(vec3),2,file);
  592. e->reverse = 0;
  593. e->flag = 0;
  594. }
  595. // triangles
  596. fread(&s->num_triangles,sizeof(int),1,file);
  597. s->triangles = new Triangle[s->num_triangles];
  598. for(int j = 0; j < s->num_triangles; j++) {
  599. Triangle *t = &s->triangles[j];
  600. fread(t->v,sizeof(vec3),3,file);
  601. fread(t->e,sizeof(int),3,file);
  602. char reverse;
  603. fread(&reverse,sizeof(char),1,file);
  604. t->reverse[0] = reverse & (1 << 0);
  605. t->reverse[1] = reverse & (1 << 1);
  606. t->reverse[2] = reverse & (1 << 2);
  607. vec3 normal;
  608. normal.cross(t->v[1] - t->v[0],t->v[2] - t->v[0]);
  609. normal.normalize();
  610. t->plane = vec4(normal,-t->v[0] * normal);
  611. normal.cross(t->plane,t->v[0] - t->v[2]);
  612. normal.normalize();
  613. t->c[0] = vec4(normal,-t->v[0] * normal);
  614. normal.cross(t->plane,t->v[1] - t->v[0]);
  615. normal.normalize();
  616. t->c[1] = vec4(normal,-t->v[1] * normal);
  617. normal.cross(t->plane,t->v[2] - t->v[1]);
  618. normal.normalize();
  619. t->c[2] = vec4(normal,-t->v[2] * normal);
  620. }
  621. // indices
  622. fread(&s->num_indices,sizeof(int),1,file);
  623. fread(&s->num_strips,sizeof(int),1,file);
  624. s->indices = new int[s->num_indices];
  625. if(s->num_indices < 65536) {
  626. unsigned short *buf = new unsigned short[s->num_indices];
  627. fread(buf,sizeof(unsigned short),s->num_indices,file);
  628. for(int j = 0; j < s->num_indices; j++) s->indices[j] = buf[j];
  629. delete buf;
  630. } else fread(s->indices,sizeof(int),s->num_indices,file);
  631. // shadow volume vertexes
  632. for(int j = 0; j < NUM_SILHOUETTES; j++) {
  633. s->silhouettes[j].vertex = new vec4[s->num_edges * 4];
  634. s->silhouettes[j].flags = new char[s->num_triangles];
  635. }
  636. if(this->num_surfaces == NUM_SURFACES) {
  637. fprintf(stderr,"Mesh::load(): many surfacesn");
  638. this->num_surfaces--;
  639. }
  640. surfaces[this->num_surfaces++] = s;
  641. }
  642. calculate_bounds();
  643. }
  645. /* strip mesh saver
  646.  */
  647. void Mesh::save(FILE *file) {
  648. fwrite(&num_surfaces,sizeof(int),1,file);
  649. for(int i = 0; i < num_surfaces; i++) {
  650. Surface *s = surfaces[i];
  651. fwrite(s->name,sizeof(s->name),1,file);
  652. // vertexes
  653. fwrite(&s->num_vertex,sizeof(int),1,file);
  654. fwrite(s->vertex,sizeof(Vertex),s->num_vertex,file);
  655. // edges
  656. fwrite(&s->num_edges,sizeof(int),1,file);
  657. for(int j = 0; j < s->num_edges; j++) {
  658. fwrite(s->edges[j].v,sizeof(vec3),2,file);
  659. }
  660. // triangles
  661. fwrite(&s->num_triangles,sizeof(int),1,file);
  662. for(int j = 0; j < s->num_triangles; j++) {
  663. fwrite(s->triangles[j].v,sizeof(vec3),3,file);
  664. fwrite(s->triangles[j].e,sizeof(int),3,file);
  665. char reverse = (s->triangles[j].reverse[2] << 2) | (s->triangles[j].reverse[1] << 1) | (s->triangles[j].reverse[0] << 0);
  666. fwrite(&reverse,sizeof(char),1,file);
  667. }
  668. // indices
  669. fwrite(&s->num_indices,sizeof(int),1,file);
  670. fwrite(&s->num_strips,sizeof(int),1,file);
  671. if(s->num_indices < 65536) {
  672. unsigned short *buf = new unsigned short[s->num_indices];
  673. for(int j = 0; j < s->num_indices; j++) buf[j] = (unsigned int)s->indices[j];
  674. fwrite(buf,sizeof(unsigned short),s->num_indices,file);
  675. delete buf;
  676. } else fwrite(s->indices,sizeof(int),s->num_indices,file);
  677. }
  678. }
  680. /*****************************************************************************/
  681. /*                                                                           */
  682. /* raw mesh loader                                                           */
  683. /*                                                                           */
  684. /*****************************************************************************/
  686. struct load_mesh_Vertex {
  687. vec3 xyz;
  688. vec3 normal;
  689. vec2 texcoord;
  690. };
  692. int Mesh::load_mesh(const char *name) {
  693. FILE *file = fopen(name,"rb");
  694. if(!file) {
  695. fprintf(stderr,"Mesh::load_mesh(): error open "%s" filen",name);
  696. return 0;
  697. }
  698. int magic;
  699. // mesh magic raw
  700. fread(&magic,sizeof(int),1,file);
  701. if(magic != MESH_RAW_MAGIC) {
  702. fprintf(stderr,"Mesh::load_mesh(): wrong magic 0x%04x in "%s" filen",magic,name);
  703. fclose(file);
  704. return 0;
  705. }
  706. // number of surfaces
  707. int num_surfaces;
  708. fread(&num_surfaces,sizeof(int),1,file);
  709. for(int i = 0; i < num_surfaces; i++) {
  710. Surface *s = new Surface;
  711. memset(s,0,sizeof(Surface));
  712. // name
  713. fread(s->name,sizeof(s->name),1,file);
  714. // vertexes
  715. int num_vertex;
  716. fread(&num_vertex,sizeof(int),1,file);
  717. load_mesh_Vertex *vertex = new load_mesh_Vertex[num_vertex];
  718. fread(vertex,sizeof(load_mesh_Vertex),num_vertex,file);
  719. s->vertex = new Vertex[num_vertex];
  720. for(int j = 0; j < num_vertex; j += 3) {
  721. if(vertex[j + 0].xyz == vertex[j + 1].xyz) continue; // skip degenerate triangles
  722. if(vertex[j + 1].xyz == vertex[j + 2].xyz) continue;
  723. if(vertex[j + 2].xyz == vertex[j + 0].xyz) continue;
  724. for(int k = 0; k < 3; k++) {
  725. s->vertex[s->num_vertex + k].xyz = vertex[j + k].xyz;
  726. s->vertex[s->num_vertex + k].normal = vertex[j + k].normal;
  727. s->vertex[s->num_vertex + k].texcoord = vertex[j + k].texcoord;
  728. }
  729. s->num_vertex += 3;
  730. }
  731. delete vertex;
  732. if(this->num_surfaces == NUM_SURFACES) {
  733. fprintf(stderr,"Mesh::load_mesh(): many surfacesn");
  734. this->num_surfaces--;
  735. }
  736. surfaces[this->num_surfaces++] = s;
  737. }
  738. fclose(file);
  739. return 1;
  740. }
  742. /*****************************************************************************/
  743. /*                                                                           */
  744. /* 3ds loader                                                                */
  745. /*                                                                           */
  746. /*****************************************************************************/
  748. enum {
  749. LOAD_3DS_CHUNK_MAIN = 0x4d4d,
  750. LOAD_3DS_CHUNK_OBJMESH = 0x3d3d,
  751. LOAD_3DS_CHUNK_OBJBLOCK = 0x4000,
  752. LOAD_3DS_CHUNK_TRIMESH = 0x4100,
  753. LOAD_3DS_CHUNK_VERTLIST = 0x4110,
  754. LOAD_3DS_CHUNK_FACELIST = 0x4120,
  755. LOAD_3DS_CHUNK_MAPLIST = 0x4140,
  756. LOAD_3DS_CHUNK_SMOOTHLIST = 0x4150
  757. };
  759. struct load_3ds_trimesh {
  760. vec3 *vertex;
  761. int num_vertex;
  762. vec2 *texcoord;
  763. int num_texcoord;
  764. int *face;
  765. int *smoothgroup;
  766. int num_face;
  767. vec3 *normal;
  768. };
  770. struct load_3ds_objblock {
  771. char *name;
  772. load_3ds_trimesh **trimesh;
  773. int num_trimesh;
  774. };
  776. struct load_3ds_mesh {
  777. load_3ds_objblock **objblock;
  778. int num_objblock;
  779. };
  781. typedef int (*load_3ds_process_chunk)(FILE *file,int type,int size,void *data);
  783. static int load_3ds_skeep_bytes(FILE *file,int bytes) {
  784. fseek(file,bytes,SEEK_CUR);
  785. return bytes;
  786. }
  788. static int load_3ds_read_string(FILE *file,char *string) {
  789. int i = 0;
  790. char *s = string;
  791. while((*s++ = fgetc(file)) != '') i++;
  792. return ++i;
  793. }
  795. static int load_3ds_read_ushort(FILE *file) {
  796. unsigned short ret;
  797. fread(&ret,1,sizeof(unsigned short),file);
  798. return ret;
  799. }
  801. static int load_3ds_read_int(FILE *file) {
  802. int ret;
  803. fread(&ret,1,sizeof(int),file);
  804. return ret;
  805. }
  807. static float load_3ds_read_float(FILE *file) {
  808. float ret;
  809. fread(&ret,1,sizeof(float),file);
  810. return ret;
  811. }
  813. static int load_3ds_read_chunk(FILE *file,load_3ds_process_chunk func,void *data) {
  814. int type = load_3ds_read_ushort(file);
  815. int size = load_3ds_read_int(file);
  816. if(func(file,type,size - 6,data) == 0) load_3ds_skeep_bytes(file,size - 6);
  817. return size;
  818. }
  820. static int load_3ds_read_chunks(FILE *file,int bytes,load_3ds_process_chunk func,void *data) {
  821. int bytes_read = 0;
  822. while(bytes_read < bytes) bytes_read += load_3ds_read_chunk(file,func,data);
  823. if(bytes_read != bytes) fprintf(stderr,"Mesh::load_3ds(): expected %d bytes but read %dn",bytes,bytes_read);
  824. return bytes_read;
  825. }
  827. static int load_3ds_process_smoothlist(FILE *file,int type,int size,void *data) {
  828. if(type == LOAD_3DS_CHUNK_SMOOTHLIST) {
  829. load_3ds_trimesh *t = (load_3ds_trimesh*)data;
  830. t->smoothgroup = new int[t->num_face];
  831. for(int i = 0; i < t->num_face; i++) t->smoothgroup[i] = load_3ds_read_int(file);
  832. return 1;
  833. }
  834. return 0;
  835. }
  837. static int load_3ds_process_trimesh(FILE *file,int type,int size,void *data) {
  838. load_3ds_trimesh *t = (load_3ds_trimesh*)data;
  839. if(type == LOAD_3DS_CHUNK_VERTLIST) {
  840. t->num_vertex = load_3ds_read_ushort(file);
  841. t->vertex = new vec3[t->num_vertex];
  842. for(int i = 0; i < t->num_vertex; i++) {
  843. t->vertex[i].x = load_3ds_read_float(file);
  844. t->vertex[i].y = load_3ds_read_float(file);
  845. t->vertex[i].z = load_3ds_read_float(file);
  846. }
  847. return 1;
  848. } else if(type == LOAD_3DS_CHUNK_MAPLIST) {
  849. t->num_texcoord = load_3ds_read_ushort(file);
  850. t->texcoord = new vec2[t->num_texcoord];
  851. for(int i = 0; i < t->num_texcoord; i++) {
  852. t->texcoord[i].x = load_3ds_read_float(file);
  853. t->texcoord[i].y = 1.0f - load_3ds_read_float(file);
  854. }
  855. return 1;
  856. } else if(type == LOAD_3DS_CHUNK_FACELIST) {
  857. int bytes_left;
  858. t->num_face = load_3ds_read_ushort(file);
  859. t->face = new int[t->num_face * 3];
  860. for(int i = 0; i < t->num_face * 3; i += 3) {
  861. t->face[i + 0] = load_3ds_read_ushort(file);
  862. t->face[i + 1] = load_3ds_read_ushort(file);
  863. t->face[i + 2] = load_3ds_read_ushort(file);
  864. load_3ds_read_ushort(file);
  865. }
  866. bytes_left = size - t->num_face * sizeof(unsigned short) * 4 - 2;
  867. if(bytes_left > 0) load_3ds_read_chunks(file,bytes_left,load_3ds_process_smoothlist,t);
  868. return 1;
  869. }
  870. return 0;
  871. }
  873. static int load_3ds_process_objblock(FILE *file,int type,int size,void *data) {
  874. if(type == LOAD_3DS_CHUNK_TRIMESH) {
  875. load_3ds_objblock *o = (load_3ds_objblock*)data;
  876. o->num_trimesh++;
  877. o->trimesh = (load_3ds_trimesh**)realloc(o->trimesh,sizeof(load_3ds_trimesh) * o->num_trimesh);
  878. o->trimesh[o->num_trimesh - 1] = new load_3ds_trimesh;
  879. load_3ds_trimesh *t = o->trimesh[o->num_trimesh - 1];
  880. memset(t,0,sizeof(load_3ds_trimesh));
  881. load_3ds_read_chunks(file,size,load_3ds_process_trimesh,t);
  882. return 1;
  883. }
  884. return 0;
  885. }
  887. static int load_3ds_process_objmesh(FILE *file,int type,int size,void *data) {
  888. if(type == LOAD_3DS_CHUNK_OBJBLOCK) {
  889. char name[256];
  890. size -= load_3ds_read_string(file,name);
  891. load_3ds_mesh *m = (load_3ds_mesh*)data;
  892. m->num_objblock++;
  893. m->objblock = (load_3ds_objblock**)realloc(m->objblock,sizeof(load_3ds_objblock) * m->num_objblock);
  894. m->objblock[m->num_objblock - 1] = new load_3ds_objblock;
  895. load_3ds_objblock *o = m->objblock[m->num_objblock - 1];
  896. memset(o,0,sizeof(load_3ds_objblock));
  897. o->name = strdup(name);
  898. load_3ds_read_chunks(file,size,load_3ds_process_objblock,o);
  899. return 1;
  900. }
  901. return 0;
  902. }
  904. static int load_3ds_process_main(FILE *file,int type,int size,void *data) {
  905. if(type == LOAD_3DS_CHUNK_OBJMESH) {
  906. load_3ds_read_chunks(file,size,load_3ds_process_objmesh,data);
  907. return 1;
  908. }
  909. return 0;
  910. }
  912. static void load_3ds_trimesh_calculate_normals(load_3ds_trimesh *t) {
  913. vec3 *normal_face = new vec3[t->num_face];
  914. int *vertex_count = new int[t->num_vertex];
  915. memset(vertex_count,0,sizeof(int) * t->num_vertex);
  916. int **vertex_face = new int*[t->num_vertex];
  917. t->normal = new vec3[t->num_face * 3];
  918. memset(t->normal,0,sizeof(vec3) * t->num_face * 3);
  919. if(t->texcoord == NULL) {
  920. t->num_texcoord = t->num_vertex;
  921. t->texcoord = new vec2[t->num_vertex];
  922. memset(t->texcoord,0,sizeof(vec2) * t->num_vertex);
  923. }
  924. for(int i = 0, j = 0; i < t->num_face; i++, j += 3) {
  925. int v0 = t->face[j + 0];
  926. int v1 = t->face[j + 1];
  927. int v2 = t->face[j + 2];
  928. vertex_count[v0]++;
  929. vertex_count[v1]++;
  930. vertex_count[v2]++;
  931. normal_face[i].cross(t->vertex[v1] - t->vertex[v0],t->vertex[v2] - t->vertex[v0]);
  932. normal_face[i].normalize();
  933. }
  934. for(int i = 0; i < t->num_vertex; i++) {
  935. vertex_face[i] = new int[vertex_count[i] + 1];
  936. vertex_face[i][0] = vertex_count[i];
  937. }
  938. for(int i = 0, j = 0; i < t->num_face; i++, j += 3) {
  939. int v0 = t->face[j + 0];
  940. int v1 = t->face[j + 1];
  941. int v2 = t->face[j + 2];
  942. vertex_face[v0][vertex_count[v0]--] = i;
  943. vertex_face[v1][vertex_count[v1]--] = i;
  944. vertex_face[v2][vertex_count[v2]--] = i;
  945. }
  946. for(int i = 0, j = 0; i < t->num_face; i++, j += 3) {
  947. int v0 = t->face[j + 0];
  948. int v1 = t->face[j + 1];
  949. int v2 = t->face[j + 2];
  950. for(int k = 1; k <= vertex_face[v0][0]; k++) {
  951. int l = vertex_face[v0][k];
  952. if(l == i || (t->smoothgroup && t->smoothgroup[i] & t->smoothgroup[l])) t->normal[j + 0] += normal_face[l];
  953. }
  954. for(int k = 1; k <= vertex_face[v1][0]; k++) {
  955. int l = vertex_face[v1][k];
  956. if(l == i || (t->smoothgroup && t->smoothgroup[i] & t->smoothgroup[l])) t->normal[j + 1] += normal_face[l];
  957. }
  958. for(int k = 1; k <= vertex_face[v2][0]; k++) {
  959. int l = vertex_face[v2][k];
  960. if(l == i || (t->smoothgroup && t->smoothgroup[i] & t->smoothgroup[l])) t->normal[j + 2] += normal_face[l];
  961. }
  962. }
  963. for(int i = 0; i < t->num_face * 3; i++) t->normal[i].normalize();
  964. for(int i = 0; i < t->num_vertex; i++) delete vertex_face[i];
  965. delete vertex_face;
  966. delete vertex_count;
  967. delete normal_face;
  968. }
  970. /*
  971.  */
  972. int Mesh::load_3ds(const char *name) {
  973. FILE *file;
  974. file = fopen(name,"rb");
  975. if(!file) {
  976. fprintf(stderr,"Mesh::load_3ds(): error open "%s" filen",name);
  977. return 0;
  978. }
  979. int type = load_3ds_read_ushort(file);
  980. int size = load_3ds_read_int(file);
  981. if(type != LOAD_3DS_CHUNK_MAIN) {
  982. fprintf(stderr,"Mesh::load_3ds(): wrong main chunk in "%s" filen",name);
  983. fclose(file);
  984. return 0;
  985. }
  986. load_3ds_mesh *m = new load_3ds_mesh;
  987. memset(m,0,sizeof(load_3ds_mesh));
  988. load_3ds_read_chunks(file,size - 6,load_3ds_process_main,m);
  989. fclose(file);
  990. for(int i = 0; i < m->num_objblock; i++) {
  991. load_3ds_objblock *o = m->objblock[i];
  992. Surface *s = new Surface;
  993. memset(s,0,sizeof(Surface));
  994. // name
  995. strcpy(s->name,m->objblock[i]->name);
  996. free(m->objblock[i]->name);
  997. // calculate number of vertexes
  998. int num_objblock_vertex = 0;
  999. for(int j = 0; j < o->num_trimesh; j++) {
  1000. num_objblock_vertex += o->trimesh[j]->num_face * 3;
  1001. load_3ds_trimesh_calculate_normals(o->trimesh[j]);
  1002. }
  1003. s->num_vertex = num_objblock_vertex;
  1004. s->vertex = new Vertex[s->num_vertex];
  1005. // copy vertexes
  1006. num_objblock_vertex = 0;
  1007. for(int j = 0; j < o->num_trimesh; j++) {
  1008. load_3ds_trimesh *t = o->trimesh[j];
  1009. for(int k = 0, l = 0; k < t->num_face; k++, l += 3) {
  1010. Vertex *v = s->vertex + num_objblock_vertex + l;
  1011. v[0].xyz = t->vertex[t->face[l + 0]];
  1012. v[1].xyz = t->vertex[t->face[l + 1]];
  1013. v[2].xyz = t->vertex[t->face[l + 2]];
  1014. v[0].texcoord = t->texcoord[t->face[l + 0]];
  1015. v[1].texcoord = t->texcoord[t->face[l + 1]];
  1016. v[2].texcoord = t->texcoord[t->face[l + 2]];
  1017. v[0].normal = t->normal[l + 0];
  1018. v[1].normal = t->normal[l + 1];
  1019. v[2].normal = t->normal[l + 2];
  1020. }
  1021. num_objblock_vertex += t->num_face * 3;
  1022. delete t->vertex;
  1023. delete t->texcoord;
  1024. delete t->face;
  1025. if(t->smoothgroup) delete t->smoothgroup;
  1026. delete t->normal;
  1027. delete t;
  1028. }
  1029. free(o->trimesh);
  1030. delete o;
  1031. if(num_surfaces == NUM_SURFACES) {
  1032. fprintf(stderr,"Mesh::load_3ds(): many surfacesn");
  1033. num_surfaces--;
  1034. }
  1035. surfaces[num_surfaces++] = s;
  1036. }
  1037. free(m->objblock);
  1038. delete m;
  1039. return 1;
  1040. }
  1042. /*****************************************************************************/
  1043. /*                                                                           */
  1044. /* calculate tangent                                                         */
  1045. /*                                                                           */
  1046. /*****************************************************************************/
  1048. void Mesh::calculate_tangent() {
  1049. for(int i = 0; i < num_surfaces; i++) {
  1050. Surface *s = surfaces[i];
  1051. for(int j = 0; j < s->num_vertex; j += 3) {
  1052. Vertex *v0 = &s->vertex[j + 0];
  1053. Vertex *v1 = &s->vertex[j + 1];
  1054. Vertex *v2 = &s->vertex[j + 2];
  1055. vec3 normal,tangent,binormal;
  1056. vec3 e0 = vec3(0,v1->texcoord.x - v0->texcoord.x,v1->texcoord.y - v0->texcoord.y);
  1057. vec3 e1 = vec3(0,v2->texcoord.x - v0->texcoord.x,v2->texcoord.y - v0->texcoord.y);
  1058. for(int k = 0; k < 3; k++) {
  1059. e0.x = v1->xyz[k] - v0->xyz[k];
  1060. e1.x = v2->xyz[k] - v0->xyz[k];
  1061. vec3 v;
  1062. v.cross(e0,e1);
  1063. if(fabs(v[0]) > EPSILON) {
  1064. tangent[k] = -v[1] / v[0];
  1065. binormal[k] = -v[2] / v[0];
  1066. } else {
  1067. tangent[k] = 0;
  1068. binormal[k] = 0;
  1069. }
  1070. }
  1071. tangent.normalize();
  1072. binormal.normalize();
  1073. normal.cross(tangent,binormal);
  1074. normal.normalize();
  1076. v0->binormal.cross(v0->normal,tangent);
  1077. v0->binormal.normalize();
  1078. v0->tangent.cross(v0->binormal,v0->normal);
  1079. if(normal * v0->normal < 0) v0->binormal = -v0->binormal;
  1081. v1->binormal.cross(v1->normal,tangent);
  1082. v1->binormal.normalize();
  1083. v1->tangent.cross(v1->binormal,v1->normal);
  1084. if(normal * v1->normal < 0) v1->binormal = -v1->binormal;
  1086. v2->binormal.cross(v2->normal,tangent);
  1087. v2->binormal.normalize();
  1088. v2->tangent.cross(v2->binormal,v2->normal);
  1089. if(normal * v2->normal < 0) v2->binormal = -v2->binormal;
  1090. }
  1091. }
  1092. }
  1094. /*****************************************************************************/
  1095. /*                                                                           */
  1096. /* calculate bounds                                                          */
  1097. /*                                                                           */
  1098. /*****************************************************************************/
  1100. void Mesh::calculate_bounds() {
  1101. min = vec3(1000000,1000000,1000000);
  1102. max = vec3(-1000000,-1000000,-1000000);
  1103. for(int i = 0; i < num_surfaces; i++) {
  1104. Surface *s = surfaces[i];
  1105. s->min = vec3(1000000,1000000,1000000);
  1106. s->max = vec3(-1000000,-1000000,-1000000);
  1107. for(int j = 0; j < s->num_vertex; j++) {
  1108. if(s->max.x < s->vertex[j].xyz.x) s->max.x = s->vertex[j].xyz.x;
  1109. if(s->min.x > s->vertex[j].xyz.x) s->min.x = s->vertex[j].xyz.x;
  1110. if(s->max.y < s->vertex[j].xyz.y) s->max.y = s->vertex[j].xyz.y;
  1111. if(s->min.y > s->vertex[j].xyz.y) s->min.y = s->vertex[j].xyz.y;
  1112. if(s->max.z < s->vertex[j].xyz.z) s->max.z = s->vertex[j].xyz.z;
  1113. if(s->min.z > s->vertex[j].xyz.z) s->min.z = s->vertex[j].xyz.z;
  1114. }
  1115. s->center = (s->min + s->max) / 2.0f;
  1116. s->radius = 0;
  1117. if(max.x < s->max.x) max.x = s->max.x;
  1118. if(min.x > s->min.x) min.x = s->min.x;
  1119. if(max.y < s->max.y) max.y = s->max.y;
  1120. if(min.y > s->min.y) min.y = s->min.y;
  1121. if(max.z < s->max.z) max.z = s->max.z;
  1122. if(min.z > s->min.z) min.z = s->min.z;
  1123. }
  1124. center = (min + max) / 2.0f;
  1125. radius = 0;
  1126. for(int i = 0; i < num_surfaces; i++) {
  1127. Surface *s = surfaces[i];
  1128. for(int j = 0; j < s->num_vertex; j++) {
  1129. float r = (s->center - s->vertex[j].xyz).length();
  1130. if(r > s->radius) s->radius = r;
  1131. r = (center - s->vertex[j].xyz).length();
  1132. if(r > radius) radius = r;
  1133. }
  1134. }
  1135. }
  1138. /*****************************************************************************/
  1139. /*                                                                           */
  1140. /* create shadow volume                                                      */
  1141. /*                                                                           */
  1142. /*****************************************************************************/
  1144. struct csv_Vertex {
  1145. vec3 xyz;
  1146. int id;
  1147. };
  1149. struct csv_Edge {
  1150. int v[2];
  1151. int id;
  1152. };
  1154. static int csv_vertex_cmp(const void *a,const void *b) {
  1155. csv_Vertex *v0 = (csv_Vertex*)a;
  1156. csv_Vertex *v1 = (csv_Vertex*)b;
  1157. float d;
  1158. d = v0->xyz[0] - v1->xyz[0];
  1159. if(d > EPSILON) return 1;
  1160. if(d < -EPSILON) return -1;
  1161. d = v0->xyz[1] - v1->xyz[1];
  1162. if(d > EPSILON) return 1;
  1163. if(d < -EPSILON) return -1;
  1164. d = v0->xyz[2] - v1->xyz[2];
  1165. if(d > EPSILON) return 1;
  1166. if(d < -EPSILON) return -1;
  1167. return 0;
  1168. }
  1170. static int csv_edge_cmp(const void *a,const void *b) {
  1171. csv_Edge *e0 = (csv_Edge*)a;
  1172. csv_Edge *e1 = (csv_Edge*)b;
  1173. int v[2][2];
  1174. if(e0->v[0] < e0->v[1]) { v[0][0] = e0->v[0]; v[0][1] = e0->v[1]; }
  1175. else { v[0][0] = e0->v[1]; v[0][1] = e0->v[0]; }
  1176. if(e1->v[0] < e1->v[1]) { v[1][0] = e1->v[0]; v[1][1] = e1->v[1]; }
  1177. else { v[1][0] = e1->v[1]; v[1][1] = e1->v[0]; }
  1178. if(v[0][0] > v[1][0]) return 1;
  1179. if(v[0][0] < v[1][0]) return -1;
  1180. if(v[0][1] > v[1][1]) return 1;
  1181. if(v[0][1] < v[1][1]) return -1;
  1182. return 0;
  1183. }
  1185. void Mesh::create_shadow_volumes() {
  1186. for(int i = 0; i < num_surfaces; i++) {
  1187. Surface *s = surfaces[i];
  1188. s->num_edges = s->num_vertex;
  1189. s->num_triangles = s->num_vertex / 3;
  1190. // cerate vertexes
  1191. csv_Vertex *v = new csv_Vertex[s->num_vertex];
  1192. for(int j = 0; j < s->num_vertex; j++) {
  1193. v[j].xyz = s->vertex[j].xyz;
  1194. v[j].id = j;
  1195. }
  1196. qsort(v,s->num_vertex,sizeof(csv_Vertex),csv_vertex_cmp);
  1197. int num_optimized_vertex = 0;
  1198. int *vbuf = new int[s->num_vertex];
  1199. for(int j = 0; j < s->num_vertex; j++) {
  1200. if(j == 0 || csv_vertex_cmp(&v[num_optimized_vertex - 1],&v[j])) v[num_optimized_vertex++] = v[j];
  1201. vbuf[v[j].id] = num_optimized_vertex - 1;
  1202. }
  1203. // create edges
  1204. csv_Edge *e = new csv_Edge[s->num_edges];
  1205. for(int j = 0; j < s->num_edges; j += 3) {
  1206. e[j + 0].v[0] = vbuf[j + 0];
  1207. e[j + 0].v[1] = vbuf[j + 1];
  1208. e[j + 1].v[0] = vbuf[j + 1];
  1209. e[j + 1].v[1] = vbuf[j + 2];
  1210. e[j + 2].v[0] = vbuf[j + 2];
  1211. e[j + 2].v[1] = vbuf[j + 0];
  1212. e[j + 0].id = j + 0;
  1213. e[j + 1].id = j + 1;
  1214. e[j + 2].id = j + 2;
  1215. }
  1216. qsort(e,s->num_edges,sizeof(csv_Edge),csv_edge_cmp);
  1217. int num_optimized_edges = 0;
  1218. int *ebuf = new int[s->num_edges];
  1219. int *rbuf = new int[s->num_edges];
  1220. for(int j = 0; j < s->num_edges; j++) {
  1221. if(j == 0 || csv_edge_cmp(&e[num_optimized_edges - 1],&e[j])) e[num_optimized_edges++] = e[j];
  1222. ebuf[e[j].id] = num_optimized_edges - 1;
  1223. rbuf[e[j].id] = e[num_optimized_edges - 1].v[0] != e[j].v[0];
  1224. }
  1225. // final
  1226. s->num_edges = num_optimized_edges;
  1227. s->edges = new Edge[s->num_edges];
  1228. for(int j = 0; j < s->num_edges; j++) {
  1229. s->edges[j].v[0] = v[e[j].v[0]].xyz;
  1230. s->edges[j].v[1] = v[e[j].v[1]].xyz;
  1231. s->edges[j].reverse = 0;
  1232. s->edges[j].flag = 0;
  1233. }
  1234. // triangles
  1235. s->triangles = new Triangle[s->num_triangles];
  1236. for(int j = 0, k = 0; j < s->num_triangles; j++, k += 3) {
  1237. Triangle *t = &s->triangles[j];
  1238. t->v[0] = v[vbuf[k + 0]].xyz;
  1239. t->v[1] = v[vbuf[k + 1]].xyz;
  1240. t->v[2] = v[vbuf[k + 2]].xyz;
  1241. t->e[0] = ebuf[k + 0];
  1242. t->e[1] = ebuf[k + 1];
  1243. t->e[2] = ebuf[k + 2];
  1244. t->reverse[0] = rbuf[k + 0];
  1245. t->reverse[1] = rbuf[k + 1];
  1246. t->reverse[2] = rbuf[k + 2];
  1247. vec3 normal;
  1248. normal.cross(t->v[1] - t->v[0],t->v[2] - t->v[0]);
  1249. normal.normalize();
  1250. t->plane = vec4(normal,-t->v[0] * normal);
  1251. normal.cross(t->plane,t->v[0] - t->v[2]); // fast point in traingle
  1252. normal.normalize();
  1253. t->c[0] = vec4(normal,-t->v[0] * normal);
  1254. normal.cross(t->plane,t->v[1] - t->v[0]);
  1255. normal.normalize();
  1256. t->c[1] = vec4(normal,-t->v[1] * normal);
  1257. normal.cross(t->plane,t->v[2] - t->v[1]);
  1258. normal.normalize();
  1259. t->c[2] = vec4(normal,-t->v[2] * normal);
  1260. }
  1261. // shadow volume vertexes
  1262. for(int j = 0; j < NUM_SILHOUETTES; j++) {
  1263. s->silhouettes[j].vertex = new vec4[s->num_edges * 4];
  1264. s->silhouettes[j].flags = new char[s->num_triangles];
  1265. }
  1266. delete rbuf;
  1267. delete ebuf;
  1268. delete e;
  1269. delete v;
  1270. }
  1271. }
  1273. /*****************************************************************************/
  1274. /*                                                                           */
  1275. /* create triangle strips                                                    */
  1276. /*                                                                           */
  1277. /*****************************************************************************/
  1279. struct cts_Vertex {
  1280. Mesh::Vertex v;
  1281. int face;
  1282. int num;
  1283. int id;
  1284. };
  1286. struct cts_Edge {
  1287. int v[2];
  1288. int face;
  1289. int num;
  1290. };
  1292. struct cts_Triangle {
  1293. int v[3];
  1294. int env[3];
  1295. int flag;
  1296. };
  1298. static int cts_vertex_cmp(const void *a,const void *b) {
  1299. cts_Vertex *ctsv0 = (cts_Vertex*)a;
  1300. cts_Vertex *ctsv1 = (cts_Vertex*)b;
  1301. Mesh::Vertex *v0 = &ctsv0->v;
  1302. Mesh::Vertex *v1 = &ctsv1->v;
  1303. float d;
  1304. #define CMP(a,b,e) { 
  1305. d = (a)[0] - (b)[0]; 
  1306. if(d > e) return 1; 
  1307. if(d < -e) return -1; 
  1308. d = (a)[1] - (b)[1]; 
  1309. if(d > e) return 1; 
  1310. if(d < -e) return -1; 
  1311. d = (a)[2] - (b)[2]; 
  1312. if(d > e) return 1; 
  1313. if(d < -e) return -1; 
  1314. }
  1315. CMP(v0->xyz,v1->xyz,EPSILON)
  1316. CMP(v0->normal,v1->normal,EPSILON)
  1317. //CMP(v0->tangent,v1->tangent,0.1)
  1318. //CMP(v0->binormal,v1->binormal,0.1)
  1319. #undef CMP
  1320. d = v0->texcoord[0] - v1->texcoord[0];
  1321. if(d > EPSILON) return 1;
  1322. if(d < -EPSILON) return -1;
  1323. d = v0->texcoord[1] - v1->texcoord[1];
  1324. if(d > EPSILON) return 1;
  1325. if(d < -EPSILON) return -1;
  1326. return 0;
  1327. }
  1329. static int cts_edge_cmp(const void *a,const void *b) {
  1330. cts_Edge *e0 = (cts_Edge*)a;
  1331. cts_Edge *e1 = (cts_Edge*)b;
  1332. int v[2][2];
  1333. if(e0->v[0] < e0->v[1]) { v[0][0] = e0->v[0]; v[0][1] = e0->v[1]; }
  1334. else { v[0][0] = e0->v[1]; v[0][1] = e0->v[0]; }
  1335. if(e1->v[0] < e1->v[1]) { v[1][0] = e1->v[0]; v[1][1] = e1->v[1]; }
  1336. else { v[1][0] = e1->v[1]; v[1][1] = e1->v[0]; }
  1337. if(v[0][0] > v[1][0]) return 1;
  1338. if(v[0][0] < v[1][0]) return -1;
  1339. if(v[0][1] > v[1][1]) return 1;
  1340. if(v[0][1] < v[1][1]) return -1;
  1341. return 0;
  1342. }
  1344. void Mesh::create_triangle_strips() {
  1345. for(int i = 0; i < num_surfaces; i++) {
  1346. Surface *s = surfaces[i];
  1347. s->num_indices = 0; // already is zero
  1348. s->num_strips = 0;
  1349. s->indices = new int[s->num_vertex * 4 / 3];
  1350. cts_Vertex *v = new cts_Vertex[s->num_vertex];
  1351. cts_Edge *e = new cts_Edge[s->num_vertex];
  1352. cts_Triangle *t = new cts_Triangle[s->num_vertex / 3];
  1353. // create vertexes
  1354. for(int j = 0; j < s->num_vertex; j++) {
  1355. v[j].v = s->vertex[j];
  1356. v[j].face = j / 3;
  1357. v[j].num = j % 3;
  1358. v[j].id = j;
  1359. }
  1360. qsort(v,s->num_vertex,sizeof(cts_Vertex),cts_vertex_cmp);
  1361. int num_optimized_vertex = 0;
  1362. int *vbuf = new int[s->num_vertex];
  1363. for(int j = 0; j < s->num_vertex; j++) {
  1364. if(j == 0 || cts_vertex_cmp(&v[num_optimized_vertex - 1],&v[j])) v[num_optimized_vertex++] = v[j];
  1365. t[v[j].face].v[v[j].num] = num_optimized_vertex - 1;
  1366. vbuf[v[j].id] = num_optimized_vertex - 1;
  1367. }
  1368. // create edges
  1369. for(int j = 0; j < s->num_vertex; j += 3) {
  1370. e[j + 0].v[0] = vbuf[j + 1];
  1371. e[j + 0].v[1] = vbuf[j + 2];
  1372. e[j + 1].v[0] = vbuf[j + 0];
  1373. e[j + 1].v[1] = vbuf[j + 2];
  1374. e[j + 2].v[0] = vbuf[j + 0];
  1375. e[j + 2].v[1] = vbuf[j + 1];
  1376. e[j + 0].face = e[j + 1].face = e[j + 2].face = j / 3;
  1377. e[j + 0].num = 0;
  1378. e[j + 1].num = 1;
  1379. e[j + 2].num = 2;
  1380. }
  1381. delete vbuf;
  1382. qsort(e,s->num_vertex,sizeof(cts_Edge),cts_edge_cmp);
  1383. // create triangles
  1384. for(int j = 0; j < s->num_vertex / 3; j++) {
  1385. t[j].env[0] = t[j].env[1] = t[j].env[2] = -1;
  1386. t[j].flag = 0;
  1387. }
  1388. // find triangle environment
  1389. for(int j = 0, k = 0; j < s->num_vertex; j++) {
  1390. if(j == 0 || cts_edge_cmp(&e[k],&e[j])) k = j;
  1391. if(j != k) {
  1392. t[e[j].face].env[e[j].num] = e[k].face;
  1393. t[e[k].face].env[e[k].num] = e[j].face;
  1394. }
  1395. }
  1396. delete e;
  1397. // create triangle strips
  1398. for(int j = 0; j < s->num_vertex / 3; j++) {
  1399. if(t[j].v[0] == t[j].v[1] || t[j].v[1] == t[j].v[2] || t[j].v[2] == t[j].v[0]) t[j].flag = 1;
  1400. }
  1401. int *indices = s->indices;
  1402. for(int j = 0; j < s->num_vertex / 3; j++) {
  1403. if(!t[j].flag) {
  1404. s->num_strips++;
  1405. int env;
  1406. for(env = 0; env < 3; env++) if(t[j].env[env] != -1 && t[t[j].env[env]].flag == 0) break;
  1407. int *strip_length = indices++;
  1408. *strip_length = 3;
  1409. *indices++ = t[j].v[(0 + env) % 3];
  1410. *indices++ = t[j].v[(1 + env) % 3];
  1411. *indices++ = t[j].v[(2 + env) % 3];
  1412. t[j].flag = 1;
  1413. int k = j;
  1414. while(1) {
  1415. for(env = 0; env < 3; env++) {
  1416. if(t[k].env[env] != -1 && t[t[k].env[env]].flag == 0) {
  1417. int *v = t[t[k].env[env]].v;
  1418. if(*(indices - 3) != v[0] && ((*(indices - 2) == v[2] && *(indices - 1) == v[1]) || (*(indices - 2) == v[1] && *(indices - 1) == v[2]))) {
  1419. *indices++ = v[0];
  1420. break;
  1421. }
  1422. if(*(indices - 3) != v[2] && ((*(indices - 2) == v[1] && *(indices - 1) == v[0]) || (*(indices - 2) == v[0] && *(indices - 1) == v[1]))) {
  1423. *indices++ = v[2];
  1424. break;
  1425. }
  1426. if(*(indices - 3) != v[1] && ((*(indices - 2) == v[0] && *(indices - 1) == v[2]) || (*(indices - 2) == v[2] && *(indices - 1) == v[0]))) {
  1427. *indices++ = v[1];
  1428. break;
  1429. }
  1430. }
  1431. }
  1432. if(env == 3) break;
  1433. vec3 normal;
  1434. normal.cross(v[*(indices - 3)].v.xyz - v[*(indices - 2)].v.xyz,v[*(indices - 4)].v.xyz - v[*(indices - 2)].v.xyz);
  1435. normal.cross(normal,v[*(indices - 3)].v.xyz - v[*(indices - 2)].v.xyz);
  1436. vec4 plane(normal,-(v[*(indices - 2)].v.xyz * normal));
  1437. if((plane * v[*(indices - 4)].v.xyz) * (plane * v[*(indices - 1)].v.xyz) > 0.0) {
  1438. indices--;
  1439. break;
  1440. };
  1441. k = t[k].env[env];
  1442. t[k].flag = 1;
  1443. (*strip_length)++;
  1444. }
  1445. s->num_indices += (*strip_length) + 1;
  1446. }
  1447. }
  1448. delete t;
  1449. delete s->vertex;
  1450. s->num_vertex = num_optimized_vertex;
  1451. s->vertex = new Vertex[s->num_vertex];
  1452. for(int j = 0; j < s->num_vertex; j++) s->vertex[j] = v[j].v;
  1453. delete v;
  1454. indices = new int[s->num_indices];
  1455. for(int j = 0; j < s->num_indices; j++) indices[j] = s->indices[j];
  1456. delete s->indices;
  1457. s->indices = indices;
  1458. }
  1459. }