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

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

游戏引擎

开发平台：

Visual C++

skinnedmesh.cpp：源码内容
  1. /* SkinnedMesh
  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 <stdio.h>
  21. #include <string.h>
  22. #ifdef _WIN32
  23. #include <windows.h>
  24. #endif
  25. #include <GL/gl.h>
  26. #include <GL/glext.h>
  28. #include "engine.h"
  29. #include "skinnedmesh.h"
  31. SkinnedMesh::SkinnedMesh(const char *name) : num_bones(0), bones(NULL), num_frames(0), frames(NULL), num_surfaces(0) {
  32. min = vec3(0,0,0);
  33. max = vec3(0,0,0);
  34. center = vec3(0,0,0);
  35. radius = 0;
  36. load(name);
  37. }
  39. SkinnedMesh::~SkinnedMesh() {
  40. if(bones) delete bones;
  41. if(frames) {
  42. for(int i = 0; i < num_frames; i++) delete frames[i];
  43. delete frames;
  44. }
  45. for(int i = 0; i < num_surfaces; i++) {
  46. Surface *s = surfaces[i];
  47. for(int j = 0; j < s->num_vertex; j++) delete s->vertex[j].weights;
  48. if(s->vertex) delete s->vertex;
  49. if(s->edges) delete s->edges;
  50. if(s->triangles) delete s->triangles;
  51. if(s->shadow_volume_vertex) delete s->shadow_volume_vertex;
  52. delete s;
  53. }
  54. num_surfaces = 0;
  55. }
  57. /*****************************************************************************/
  58. /*                                                                           */
  59. /* animation                                                                 */
  60. /*                                                                           */
  61. /*****************************************************************************/
  63. void SkinnedMesh::setFrame(float frame,int from,int to) {
  65. if(num_frames == 0) return;
  67. if(from < 0) from = 0;
  68. if(to < 0) to = num_frames;
  69. int frame0 = (int)frame;
  70. frame -= frame0;
  71. frame0 += from;
  72. if(frame0 >= to) frame0 = (frame0 - from) % (to - from) + from;
  73. int frame1 = frame0 + 1;
  74. if(frame1 >= to) frame1 = from;
  76. for(int i = 0; i < num_bones; i++) { // calculate matrixes
  77. mat4 translate;
  78. translate.translate(frames[frame0][i].xyz * (1.0f - frame) + frames[frame1][i].xyz * frame);
  79. quat rot;
  80. rot.slerp(frames[frame0][i].rot,frames[frame1][i].rot,frame);
  81. bones[i].rotation = rot.to_matrix();
  82. bones[i].transform = translate * bones[i].rotation;
  83. }
  84. }
  86. /*
  87.  */
  88. void SkinnedMesh::calculateSkin() {
  90. min = vec3(1000000,1000000,1000000); // bound box
  91. max = vec3(-1000000,-1000000,-1000000);
  93. for(int i = 0; i < num_surfaces; i++) { // calculate vertexes
  94. Surface *s = surfaces[i];
  96. s->min = vec3(1000000,1000000,1000000);
  97. s->max = vec3(-1000000,-1000000,-1000000);
  99. for(int j = 0; j < s->num_vertex; j++) {
  100. Vertex *v = &s->vertex[j];
  101. v->xyz = vec3(0,0,0);
  102. v->normal = vec3(0,0,0);
  103. v->tangent = vec3(0,0,0);
  104. v->binormal = vec3(0,0,0);
  105. for(int k = 0; k < v->num_weights; k++) {
  106. Weight *w = &v->weights[k];
  107. v->xyz += bones[w->bone].transform * w->xyz * w->weight;
  108. v->normal += bones[w->bone].rotation * w->normal * w->weight;
  109. v->tangent += bones[w->bone].rotation * w->tangent * w->weight;
  110. v->binormal += bones[w->bone].rotation * w->binormal * w->weight;
  111. }
  112. if(s->max.x < v->xyz.x) s->max.x = v->xyz.x;
  113. if(s->min.x > v->xyz.x) s->min.x = v->xyz.x;
  114. if(s->max.y < v->xyz.y) s->max.y = v->xyz.y;
  115. if(s->min.y > v->xyz.y) s->min.y = v->xyz.y;
  116. if(s->max.z < v->xyz.z) s->max.z = v->xyz.z;
  117. if(s->min.z > v->xyz.z) s->min.z = v->xyz.z;
  118. }
  120. for(int j = 0; j < s->num_triangles; j++) {
  121. Triangle *t = &s->triangles[j];
  122. vec3 normal;
  123. normal.cross(s->vertex[t->v[1]].xyz - s->vertex[t->v[0]].xyz,s->vertex[t->v[2]].xyz - s->vertex[t->v[0]].xyz);
  124. normal.normalize();
  125. t->plane = vec4(normal,-s->vertex[t->v[0]].xyz * normal);
  126. normal.cross(t->plane,s->vertex[t->v[0]].xyz - s->vertex[t->v[2]].xyz); // fast point in triangle
  127. normal.normalize();
  128. t->c[0] = vec4(normal,-s->vertex[t->v[0]].xyz * normal);
  129. normal.cross(t->plane,s->vertex[t->v[1]].xyz - s->vertex[t->v[0]].xyz);
  130. normal.normalize();
  131. t->c[1] = vec4(normal,-s->vertex[t->v[1]].xyz * normal);
  132. normal.cross(t->plane,s->vertex[t->v[2]].xyz - s->vertex[t->v[1]].xyz);
  133. normal.normalize();
  134. t->c[2] = vec4(normal,-s->vertex[t->v[2]].xyz * normal);
  135. t->flag = 0;
  136. }
  138. s->center = (s->min + s->max) / 2.0f;
  139. s->radius = (s->max - s->center).length();
  140. if(max.x < s->max.x) max.x = s->max.x;
  141. if(min.x > s->min.x) min.x = s->min.x;
  142. if(max.y < s->max.y) max.y = s->max.y;
  143. if(min.y > s->min.y) min.y = s->min.y;
  144. if(max.z < s->max.z) max.z = s->max.z;
  145. if(min.z > s->min.z) min.z = s->min.z;
  146. }
  148. center = (min + max) / 2.0f;
  149. radius = (max - center).length();
  150. }
  152. /*****************************************************************************/
  153. /*                                                                           */
  154. /* render                                                                    */
  155. /*                                                                           */
  156. /*****************************************************************************/
  158. int SkinnedMesh::render(int ppl,int s) {
  159. int num_triangles = 0;
  160. if(ppl) {
  161. glEnableVertexAttribArrayARB(0);
  162. glEnableVertexAttribArrayARB(1);
  163. glEnableVertexAttribArrayARB(2);
  164. glEnableVertexAttribArrayARB(3);
  165. glEnableVertexAttribArrayARB(4);
  166. if(s < 0) {
  167. for(int i = 0; i < num_surfaces; i++) {
  168. Surface *s = surfaces[i];
  169. glVertexAttribPointerARB(0,3,GL_FLOAT,0,sizeof(Vertex),s->vertex->xyz);
  170. glVertexAttribPointerARB(1,3,GL_FLOAT,0,sizeof(Vertex),s->vertex->normal);
  171. glVertexAttribPointerARB(2,3,GL_FLOAT,0,sizeof(Vertex),s->vertex->tangent);
  172. glVertexAttribPointerARB(3,3,GL_FLOAT,0,sizeof(Vertex),s->vertex->binormal);
  173. glVertexAttribPointerARB(4,2,GL_FLOAT,0,sizeof(Vertex),s->vertex->texcoord);
  174. glDrawElements(GL_TRIANGLES,s->num_indices,GL_UNSIGNED_INT,s->indeices);
  175. num_triangles += s->num_triangles;
  176. }
  177. } else {
  178. Surface *surface = surfaces[s];
  179. Surface *s = surface;
  180. glVertexAttribPointerARB(0,3,GL_FLOAT,0,sizeof(Vertex),s->vertex->xyz);
  181. glVertexAttribPointerARB(1,3,GL_FLOAT,0,sizeof(Vertex),s->vertex->normal);
  182. glVertexAttribPointerARB(2,3,GL_FLOAT,0,sizeof(Vertex),s->vertex->tangent);
  183. glVertexAttribPointerARB(3,3,GL_FLOAT,0,sizeof(Vertex),s->vertex->binormal);
  184. glVertexAttribPointerARB(4,2,GL_FLOAT,0,sizeof(Vertex),s->vertex->texcoord);
  185. glDrawElements(GL_TRIANGLES,s->num_indices,GL_UNSIGNED_INT,s->indeices);
  186. num_triangles += s->num_triangles;
  187. }
  188. glDisableVertexAttribArrayARB(4);
  189. glDisableVertexAttribArrayARB(3);
  190. glDisableVertexAttribArrayARB(2);
  191. glDisableVertexAttribArrayARB(1);
  192. glDisableVertexAttribArrayARB(0);
  193. } else {
  194. glEnableClientState(GL_VERTEX_ARRAY);
  195. glEnableClientState(GL_NORMAL_ARRAY);
  196. glEnableClientState(GL_TEXTURE_COORD_ARRAY);
  197. if(s < 0) {
  198. for(int i = 0; i < num_surfaces; i++) {
  199. Surface *s = surfaces[i];
  200. glVertexPointer(3,GL_FLOAT,sizeof(Vertex),s->vertex->xyz);
  201. glNormalPointer(GL_FLOAT,sizeof(Vertex),s->vertex->normal);
  202. glTexCoordPointer(2,GL_FLOAT,sizeof(Vertex),s->vertex->texcoord);
  203. glDrawElements(GL_TRIANGLES,s->num_indices,GL_UNSIGNED_INT,s->indeices);
  204. num_triangles += s->num_triangles;
  205. }
  206. } else {
  207. Surface *surface = surfaces[s];
  208. Surface *s = surface;
  209. glVertexPointer(3,GL_FLOAT,sizeof(Vertex),s->vertex->xyz);
  210. glNormalPointer(GL_FLOAT,sizeof(Vertex),s->vertex->normal);
  211. glTexCoordPointer(2,GL_FLOAT,sizeof(Vertex),s->vertex->texcoord);
  212. glDrawElements(GL_TRIANGLES,s->num_indices,GL_UNSIGNED_INT,s->indeices);
  213. num_triangles += s->num_triangles;
  214. }
  215. glDisableClientState(GL_TEXTURE_COORD_ARRAY);
  216. glDisableClientState(GL_NORMAL_ARRAY);
  217. glDisableClientState(GL_VERTEX_ARRAY);
  218. }
  219. return num_triangles;
  220. }
  222. /*****************************************************************************/
  223. /*                                                                           */
  224. /* stencil shadows                                                           */
  225. /*                                                                           */
  226. /*****************************************************************************/
  228. void SkinnedMesh::findSilhouette(const vec4 &light,int s) {
  229. if(s < 0) {
  230. for(int i = 0; i < num_surfaces; i++) {
  231. Surface *s = surfaces[i];
  232. for(int j = 0; j < s->num_edges; j++) s->edges[j].flag = -1;
  233. for(int j = 0; j < s->num_triangles; j++) {
  234. Triangle *t = &s->triangles[j];
  235. if(t->plane * light > 0.0) {
  236. t->flag = 1;
  237. s->edges[t->e[0]].reverse = t->reverse[0];
  238. s->edges[t->e[1]].reverse = t->reverse[1];
  239. s->edges[t->e[2]].reverse = t->reverse[2];
  240. s->edges[t->e[0]].flag++;
  241. s->edges[t->e[1]].flag++;
  242. s->edges[t->e[2]].flag++;
  243. } else t->flag = 0;
  244. }
  245. s->num_shadow_volume_vertex = 0;
  246. vec4 *shadow_volume_vertex = s->shadow_volume_vertex;
  247. for(int j = 0; j < s->num_edges; j++) {
  248. if(s->edges[j].flag != 0) continue;
  249. Edge *e = &s->edges[j];
  250. if(e->reverse) {
  251. *shadow_volume_vertex++ = vec4(s->vertex[e->v[0]].xyz,1);
  252. *shadow_volume_vertex++ = vec4(s->vertex[e->v[1]].xyz,1);
  253. *shadow_volume_vertex++ = vec4(s->vertex[e->v[1]].xyz,0);
  254. *shadow_volume_vertex++ = vec4(s->vertex[e->v[0]].xyz,0);
  255. } else {
  256. *shadow_volume_vertex++ = vec4(s->vertex[e->v[1]].xyz,1);
  257. *shadow_volume_vertex++ = vec4(s->vertex[e->v[0]].xyz,1);
  258. *shadow_volume_vertex++ = vec4(s->vertex[e->v[0]].xyz,0);
  259. *shadow_volume_vertex++ = vec4(s->vertex[e->v[1]].xyz,0);
  260. }
  261. s->num_shadow_volume_vertex += 4;
  262. }
  263. }
  264. } else {
  265. Surface *surface = surfaces[s];
  266. Surface *s = surface; // :)
  267. for(int i = 0; i < s->num_edges; i++) s->edges[i].flag = -1;
  268. for(int i = 0; i < s->num_triangles; i++) {
  269. Triangle *t = &s->triangles[i];
  270. if(t->plane * light > 0.0) {
  271. t->flag = 1;
  272. s->edges[t->e[0]].reverse = t->reverse[0];
  273. s->edges[t->e[1]].reverse = t->reverse[1];
  274. s->edges[t->e[2]].reverse = t->reverse[2];
  275. s->edges[t->e[0]].flag++;
  276. s->edges[t->e[1]].flag++;
  277. s->edges[t->e[2]].flag++;
  278. } else t->flag = 0;
  279. }
  280. s->num_shadow_volume_vertex = 0;
  281. vec4 *shadow_volume_vertex = s->shadow_volume_vertex;
  282. for(int i = 0; i < s->num_edges; i++) {
  283. if(s->edges[i].flag != 0) continue;
  284. Edge *e = &s->edges[i];
  285. if(e->reverse) {
  286. *shadow_volume_vertex++ = vec4(s->vertex[e->v[0]].xyz,1);
  287. *shadow_volume_vertex++ = vec4(s->vertex[e->v[1]].xyz,1);
  288. *shadow_volume_vertex++ = vec4(s->vertex[e->v[1]].xyz,0);
  289. *shadow_volume_vertex++ = vec4(s->vertex[e->v[0]].xyz,0);
  290. } else {
  291. *shadow_volume_vertex++ = vec4(s->vertex[e->v[1]].xyz,1);
  292. *shadow_volume_vertex++ = vec4(s->vertex[e->v[0]].xyz,1);
  293. *shadow_volume_vertex++ = vec4(s->vertex[e->v[0]].xyz,0);
  294. *shadow_volume_vertex++ = vec4(s->vertex[e->v[1]].xyz,0);
  295. }
  296. s->num_shadow_volume_vertex += 4;
  297. }
  298. }
  299. }
  301. /*
  302.  */
  303. int SkinnedMesh::getNumIntersections(const vec3 &line0,const vec3 &line1,int s) {
  304. int num_intersections = 0;
  305. if(s < 0) {
  306. vec3 dir = line1 - line0;
  307. float dot = (dir * center - dir * line0) / (dir * dir);
  308. if(dot < 0.0 && (line0 - center).length() > radius) return 0;
  309. else if(dot > 1.0 && (line1 - center).length() > radius) return 0;
  310. else if((line0 + dir * dot - center).length() > radius) return 0;
  311. for(int i = 0; i < num_surfaces; i++) {
  312. Surface *s = surfaces[i];
  313. float dot = (dir * s->center - dir * line0) / (dir * dir);
  314. if(dot < 0.0 && (line0 - s->center).length() > s->radius) continue;
  315. else if(dot > 1.0 && (line1 - s->center).length() > s->radius) continue;
  316. else if((line0 + dir * dot - s->center).length() > s->radius) continue;
  317. for(int j = 0; j < s->num_triangles; j++) {
  318. Triangle *t = &s->triangles[j];
  319. if(t->flag == 0) continue;
  320. float dot = -(t->plane * vec4(line0,1)) / (vec3(t->plane) * dir);
  321. if(dot < 0.0 || dot > 1.0) continue;
  322. vec3 p = line0 + dir * dot;
  323. if(p * t->c[0] > 0.0 && p * t->c[1] > 0.0 && p * t->c[2] > 0.0) num_intersections++;
  324. }
  325. }
  326. return num_intersections;
  327. } else {
  328. Surface *surface = surfaces[s];
  329. Surface *s = surface;
  330. vec3 dir = line1 - line0;
  331. float dot = (dir * s->center - dir * line0) / (dir * dir);
  332. if(dot < 0.0 && (line0 - s->center).length() > s->radius) return 0;
  333. else if(dot > 1.0 && (line1 - s->center).length() > s->radius) return 0;
  334. else if((line0 + dir * dot - s->center).length() > s->radius) return 0;
  335. for(int i = 0; i < s->num_triangles; i++) {
  336. Triangle *t = &s->triangles[i];
  337. if(t->flag == 0) continue;
  338. float dot = -(t->plane * vec4(line0,1)) / (vec3(t->plane) * dir);
  339. if(dot < 0.0 || dot > 1.0) continue;
  340. vec3 p = line0 + dir * dot;
  341. if(p * t->c[0] > 0.0 && p * t->c[1] > 0.0 && p * t->c[2] > 0.0) num_intersections++;
  342. }
  343. return num_intersections;
  344. }
  345. }
  347. /*
  348.  */
  349. int SkinnedMesh::renderShadowVolume(int s) {
  350. int num_triangles = 0;
  351. glEnableVertexAttribArrayARB(0);
  352. if(s < 0) {
  353. for(int i = 0; i < num_surfaces; i++) {
  354. Surface *s = surfaces[i];
  355. glVertexAttribPointerARB(0,4,GL_FLOAT,0,sizeof(vec4),s->shadow_volume_vertex);
  356. glDrawArrays(GL_QUADS,0,s->num_shadow_volume_vertex);
  357. num_triangles += s->num_shadow_volume_vertex / 2;
  358. }
  359. } else {
  360. Surface *surface = surfaces[s];
  361. Surface *s = surface;
  362. glVertexAttribPointerARB(0,4,GL_FLOAT,0,sizeof(vec4),s->shadow_volume_vertex);
  363. glDrawArrays(GL_QUADS,0,s->num_shadow_volume_vertex);
  364. num_triangles += s->num_shadow_volume_vertex / 2;
  365. }
  366. glDisableVertexAttribArrayARB(0);
  367. return num_triangles;
  368. }
  370. /*****************************************************************************/
  371. /*                                                                           */
  372. /* line inersection                                                          */
  373. /*                                                                           */
  374. /*****************************************************************************/
  376. int SkinnedMesh::intersection(const vec3 &line0,const vec3 &line1,vec3 &point,vec3 &normal,int s) {
  377. float nearest = 2.0;
  378. if(s < 0) {
  379. vec3 dir = line1 - line0;
  380. float dot = (dir * center - dir * line0) / (dir * dir);
  381. if(dot < 0.0 && (line0 - center).length() > radius) return 0;
  382. else if(dot > 1.0 && (line1 - center).length() > radius) return 0;
  383. else if((line0 + dir * dot - center).length() > radius) return 0;
  384. for(int i = 0; i < num_surfaces; i++) {
  385. Surface *s = surfaces[i];
  386. float dot = (dir * s->center - dir * line0) / (dir * dir);
  387. if(dot < 0.0 && (line0 - s->center).length() > s->radius) continue;
  388. else if(dot > 1.0 && (line1 - s->center).length() > s->radius) continue;
  389. else if((line0 + dir * dot - s->center).length() > s->radius) continue;
  390. for(int j = 0; j < s->num_triangles; j++) {
  391. Triangle *t = &s->triangles[j];
  392. float dot = -(t->plane * vec4(line0,1)) / (vec3(t->plane) * dir);
  393. if(dot < 0.0 || dot > 1.0) continue;
  394. vec3 p = line0 + dir * dot;
  395. if(nearest > dot && p * t->c[0] > 0.0 && p * t->c[1] > 0.0 && p * t->c[2] > 0.0) {
  396. nearest = dot;
  397. point = p;
  398. normal = t->plane;
  399. }
  400. }
  401. }
  402. return nearest < 2.0 ? 1 : 0;
  403. } else {
  404. Surface *surface = surfaces[s];
  405. Surface *s = surface;
  406. vec3 dir = line1 - line0;
  407. float dot = (dir * s->center - dir * line0) / (dir * dir);
  408. if(dot < 0.0 && (line0 - s->center).length() > s->radius) return 0;
  409. else if(dot > 1.0 && (line1 - s->center).length() > s->radius) return 0;
  410. else if((line0 + dir * dot - s->center).length() > s->radius) return 0;
  411. for(int i = 0; i < s->num_triangles; i++) {
  412. Triangle *t = &s->triangles[i];
  413. float dot = -(t->plane * vec4(line0,1)) / (vec3(t->plane) * dir);
  414. if(dot < 0.0 || dot > 1.0) continue;
  415. vec3 p = line0 + dir * dot;
  416. if(nearest > dot && p * t->c[0] > 0.0 && p * t->c[1] > 0.0 && p * t->c[2] > 0.0) {
  417. nearest = dot;
  418. point = p;
  419. normal = t->plane;
  420. }
  421. }
  422. return nearest < 2.0 ? 1 : 0;
  423. }
  424. }
  426. /*****************************************************************************/
  427. /*                                                                           */
  428. /* transform                                                                 */
  429. /*                                                                           */
  430. /*****************************************************************************/
  432. void SkinnedMesh::transform(const mat4 &m) {
  433. mat4 r = m.rotation();
  434. for(int i = 0; i < num_surfaces; i++) {
  435. Surface *s = surfaces[i];
  436. for(int j = 0; j < s->num_vertex; j++) {
  437. Vertex *v = &s->vertex[j];
  438. for(int k = 0; k < v->num_weights; k++) {
  439. Weight *w = &v->weights[k];
  440. w->xyz = m * w->xyz;
  441. w->normal = r * w->normal;
  442. w->normal.normalize();
  443. }
  444. }
  445. }
  446. for(int i = 0; i < num_frames; i++) {
  447. for(int j = 0; j < num_bones; j++) {
  448. frames[i][j].xyz = m * frames[i][j].xyz;
  449. }
  450. }
  451. calculate_tangent();
  452. setFrame(0);
  453. calculateSkin();
  454. }
  456. /*****************************************************************************/
  457. /*                                                                           */
  458. /* IO functions                                                              */
  459. /*                                                                           */
  460. /*****************************************************************************/
  462. /*
  463.  */
  464. int SkinnedMesh::getNumSurfaces() {
  465. return num_surfaces;
  466. }
  468. const char *SkinnedMesh::getSurfaceName(int s) {
  469. return surfaces[s]->name;
  470. }
  472. int SkinnedMesh::getSurface(const char *name) {
  473. for(int i = 0; i < num_surfaces; i++) if(!strcmp(name,surfaces[i]->name)) return i;
  474. fprintf(stderr,"SkinnedMesh::getSurface(): can`t find "%s" surfacen",name);
  475. return -1;
  476. }
  478. /*
  479.  */
  480. int SkinnedMesh::getNumBones() {
  481. return num_bones;
  482. }
  484. SkinnedMesh::Bone *SkinnedMesh::getBones() {
  485. return bones;
  486. }
  488. const char *SkinnedMesh::getBoneName(int b) {
  489. return bones[b].name;
  490. }
  492. int SkinnedMesh::getBone(const char *name) {
  493. for(int i = 0; i < num_bones; i++) if(!strcmp(name,bones[i].name)) return i;
  494. fprintf(stderr,"SkinnedMesh::getBone(): can`t find "%s" bonen",name);
  495. return -1;
  496. }
  498. const mat4 &SkinnedMesh::getBoneTransform(int b) {
  499. if(b < 0) {
  500. static mat4 dummy;
  501. return dummy;
  502. }
  503. return bones[b].transform;
  504. }
  506. /*
  507.  */
  508. int SkinnedMesh::getNumVertex(int s) {
  509. return surfaces[s]->num_vertex;
  510. }
  512. SkinnedMesh::Vertex *SkinnedMesh::getVertex(int s) {
  513. return surfaces[s]->vertex;
  514. }
  516. int SkinnedMesh::getNumEdges(int s) {
  517. return surfaces[s]->num_edges;
  518. }
  520. SkinnedMesh::Edge *SkinnedMesh::getEdges(int s) {
  521. return surfaces[s]->edges;
  522. }
  524. int SkinnedMesh::getNumTriangles(int s) {
  525. return surfaces[s]->num_triangles;
  526. }
  528. SkinnedMesh::Triangle *SkinnedMesh::getTriangles(int s) {
  529. return surfaces[s]->triangles;
  530. }
  532. /*
  533.  */
  534. const vec3 &SkinnedMesh::getMin(int s) {
  535. if(s < 0) return min;
  536. return surfaces[s]->min;
  537. }
  539. const vec3 &SkinnedMesh::getMax(int s) {
  540. if(s < 0) return max;
  541. return surfaces[s]->max;
  542. }
  544. const vec3 &SkinnedMesh::getCenter(int s) {
  545. if(s < 0) return center;
  546. return surfaces[s]->center;
  547. }
  549. float SkinnedMesh::getRadius(int s) {
  550. if(s < 0) return radius;
  551. return surfaces[s]->radius;
  552. }
  554. /* load
  555.  */
  556. int SkinnedMesh::load(const char *name) {
  557. FILE *file = fopen(name,"rb");
  558. if(!file) {
  559. fprintf(stderr,"SkinnedMesh::load(): error open "%s" filen",name);
  560. return 0;
  561. }
  562. int magic = 0;
  563. fread(&magic,sizeof(int),1,file);
  564. fclose(file);
  565. int ret = 0;
  566. if(magic == SKINNED_MESH_MAGIC) ret = load_binary(name);
  567. else ret = load_ascii(name);
  568. calculate_tangent();
  569. create_shadow_volumes();
  570. setFrame(0);
  571. calculateSkin();
  572. return ret;
  573. }
  575. /* save
  576.  */
  577. int SkinnedMesh::save(const char *name) {
  578. FILE *file = fopen(name,"wb");
  579. if(!file) {
  580. fprintf(stderr,"SkinnedMesh::save(): error create "%s" filen",name);
  581. return 0;
  582. }
  583. int magic = SKINNED_MESH_MAGIC;
  584. fwrite(&magic,sizeof(int),1,file);
  586. fwrite(&num_bones,sizeof(int),1,file); // bones
  587. for(int i = 0; i < num_bones; i++) {
  588. fwrite(bones[i].name,sizeof(bones[i].name),1,file);
  589. fwrite(&bones[i].parent,sizeof(int),1,file);
  590. }
  592. fwrite(&num_surfaces,sizeof(int),1,file); // surfaces
  593. for(int i = 0; i < num_surfaces; i++) {
  594. Surface *s = surfaces[i];
  595. fwrite(s->name,sizeof(s->name),1,file); // name
  597. fwrite(&s->num_vertex,sizeof(int),1,file); // vertexes
  598. for(int j = 0; j < s->num_vertex; j++) {
  599. Vertex *v = &s->vertex[j];
  600. fwrite(&v->texcoord,sizeof(vec2),1,file);
  601. fwrite(&v->num_weights,sizeof(int),1,file); // weights
  602. for(int k = 0; k < v->num_weights; k++) {
  603. Weight *w = &v->weights[k];
  604. fwrite(&w->bone,sizeof(int),1,file);
  605. fwrite(&w->weight,sizeof(float),1,file);
  606. fwrite(&w->xyz,sizeof(vec3),1,file);
  607. fwrite(&w->normal,sizeof(vec3),1,file);
  608. }
  609. }
  611. fwrite(&s->num_triangles,sizeof(int),1,file); // triangles
  612. for(int j = 0; j < s->num_triangles; j++) fwrite(s->triangles[j].v,sizeof(int),3,file);
  613. }
  615. fwrite(&num_frames,sizeof(int),1,file); // frames
  616. for(int i = 0; i < num_frames; i++) fwrite(frames[i],sizeof(Frame),num_bones,file);
  618. fclose(file);
  619. return 1;
  620. }
  622. /*****************************************************************************/
  623. /*                                                                           */
  624. /* binary skinned mesh loader                                                */
  625. /*                                                                           */
  626. /*****************************************************************************/
  628. int SkinnedMesh::load_binary(const char *name) {
  629. FILE *file = fopen(name,"rb");
  630. if(!file) {
  631. fprintf(stderr,"SkinnedMesh::load_binary(): error open "%s" filen",name);
  632. return 0;
  633. }
  635. int magic; // magic
  636. fread(&magic,sizeof(int),1,file);
  637. if(magic != SKINNED_MESH_MAGIC) {
  638. fprintf(stderr,"SkinnedMesh::load_binary(): wrong magic 0x%04x in "%s" file",magic,name);
  639. fclose(file);
  640. return 0;
  641. }
  643. fread(&num_bones,sizeof(int),1,file); // bones
  644. bones = new Bone[num_bones];
  645. for(int i = 0; i < num_bones; i++) {
  646. fread(bones[i].name,sizeof(bones[i].name),1,file);
  647. fread(&bones[i].parent,sizeof(int),1,file);
  648. }
  650. int num_surfaces; // surfaces
  651. fread(&num_surfaces,sizeof(int),1,file);
  652. for(int i = 0; i < num_surfaces; i++) {
  653. Surface *s = new Surface;
  654. memset(s,0,sizeof(Surface));
  655. fread(s->name,sizeof(s->name),1,file); // name
  657. fread(&s->num_vertex,sizeof(int),1,file); // vertexes
  658. s->vertex = new Vertex[s->num_vertex];
  659. for(int j = 0; j < s->num_vertex; j++) {
  660. Vertex *v = &s->vertex[j];
  661. fread(&v->texcoord,sizeof(vec2),1,file);
  662. fread(&v->num_weights,sizeof(int),1,file); // weights
  663. v->weights = new Weight[v->num_weights];
  664. for(int k = 0; k < v->num_weights; k++) {
  665. Weight *w = &v->weights[k];
  666. fread(&w->bone,sizeof(int),1,file);
  667. fread(&w->weight,sizeof(float),1,file);
  668. fread(&w->xyz,sizeof(vec3),1,file);
  669. fread(&w->normal,sizeof(vec3),1,file);
  670. }
  671. }
  673. fread(&s->num_triangles,sizeof(int),1,file); // triangles
  674. s->triangles = new Triangle[s->num_triangles];
  675. s->num_indices = s->num_triangles * 3;
  676. s->indeices = new int[s->num_indices];
  677. for(int j = 0; j < s->num_triangles; j++) {
  678. Triangle *t = &s->triangles[j];
  679. fread(t->v,sizeof(int),3,file);
  680. s->indeices[j * 3 + 0] = t->v[0];
  681. s->indeices[j * 3 + 1] = t->v[1];
  682. s->indeices[j * 3 + 2] = t->v[2];
  683. }
  684. if(this->num_surfaces == NUM_SURFACES) {
  685. fprintf(stderr,"SkinnedMesh::load_binary(): many surfacesn");
  686. this->num_surfaces--;
  687. }
  688. surfaces[this->num_surfaces++] = s;
  689. }
  691. fread(&num_frames,sizeof(int),1,file); // frames
  692. frames = new Frame*[num_frames];
  693. for(int i = 0; i < num_frames; i++) {
  694. frames[i] = new Frame[num_bones];
  695. fread(frames[i],sizeof(Frame),num_bones,file);
  696. }
  698. fclose(file);
  699. return 1;
  700. }
  702. /*****************************************************************************/
  703. /*                                                                           */
  704. /* ascii skinned mesh loader                                                 */
  705. /*                                                                           */
  706. /*****************************************************************************/
  708. void SkinnedMesh::read_string(FILE *file,char *string) {
  709. char c;
  710. char *s = string;
  711. int quoted = -1;
  712. while(fread(&c,sizeof(char),1,file) == 1) {
  713. if(quoted == -1) {
  714. if(c == '"') quoted = 1;
  715. else if(!strchr(" tnr",c)) {
  716. *s++ = c;
  717. quoted = 0;
  718. }
  719. continue;
  720. }
  721. if(quoted == 1 && c == '"') break;
  722. if(quoted == 0 && strchr(" tnr",c)) break;
  723. *s++ = c;
  724. }
  725. *s = '';
  726. }
  728. /*
  729.  */
  730. int SkinnedMesh::load_ascii(const char *name) {
  731. FILE *file = fopen(name,"r");
  732. if(!file) {
  733. fprintf(stderr,"SkinnedMesh::load_ascii(): error open "%s" filen",name);
  734. return 0;
  735. }
  736. char buf[1024];
  737. while(fscanf(file,"%s",buf) != EOF) {
  738. if(!strcmp(buf,"bones")) {
  739. fscanf(file,"%d %s",&num_bones,buf);
  740. bones = new Bone[num_bones];
  741. for(int i = 0; i < num_bones; i++) {
  742. memset(bones[i].name,0,sizeof(bones[i].name));
  743. read_string(file,bones[i].name);
  744. fscanf(file,"%d",&bones[i].parent);
  745. }
  746. fscanf(file,"%s",buf);
  747. }
  748. else if(!strcmp(buf,"surface")) {
  749. Surface *s = new Surface;
  750. memset(s,0,sizeof(Surface));
  751. memset(s->name,0,sizeof(s->name));
  752. read_string(file,s->name);
  753. fscanf(file,"%s",buf);
  754. while(fscanf(file,"%s",buf) != EOF) {
  755. if(!strcmp(buf,"vertex")) {
  756. fscanf(file,"%d %s",&s->num_vertex,buf);
  757. s->vertex = new Vertex[s->num_vertex];
  758. for(int i = 0; i < s->num_vertex; i++) {
  759. Vertex *v = &s->vertex[i];
  760. fscanf(file,"%f %f",&v->texcoord.x,&v->texcoord.y);
  761. fscanf(file,"%s %d",buf,&v->num_weights);
  762. fscanf(file,"%s",buf);
  763. v->weights = new Weight[v->num_weights];
  764. for(int j = 0; j < v->num_weights; j++) {
  765. Weight *w = &v->weights[j];
  766. fscanf(file,"%d %f",&w->bone,&w->weight);
  767. fscanf(file,"%f %f %f",&w->xyz.x,&w->xyz.y,&w->xyz.z);
  768. fscanf(file,"%f %f %f",&w->normal.x,&w->normal.y,&w->normal.z);
  769. }
  770. fscanf(file,"%s",buf);
  771. }
  772. fscanf(file,"%s",buf);
  773. }
  774. else if(!strcmp(buf,"triangles")) {
  775. fscanf(file,"%d %s",&s->num_triangles,buf);
  776. s->triangles = new Triangle[s->num_triangles];
  777. s->num_indices = s->num_triangles * 3;
  778. s->indeices = new int[s->num_indices];
  779. for(int i = 0; i < s->num_triangles; i++) {
  780. Triangle *t = &s->triangles[i];
  781. fscanf(file,"%d %d %d",&t->v[0],&t->v[1],&t->v[2]);
  782. s->indeices[i * 3 + 0] = t->v[0];
  783. s->indeices[i * 3 + 1] = t->v[1];
  784. s->indeices[i * 3 + 2] = t->v[2];
  785. }
  786. fscanf(file,"%s",buf);
  787. }
  788. else if(!strcmp(buf,"}")) {
  789. break;
  790. }
  791. else {
  792. fprintf(stderr,"SkinnedMesh::load_ascii(): unknown token "%s"n",buf);
  793. fclose(file);
  794. return 0;
  795. }
  796. }
  797. if(num_surfaces == NUM_SURFACES) {
  798. fprintf(stderr,"SkinnedMesh::load_ascii(): many surfacesn");
  799. num_surfaces--;
  800. }
  801. surfaces[num_surfaces++] = s;
  802. }
  803. else if(!strcmp(buf,"animation")) {
  804. fscanf(file,"%d %s",&num_frames,buf);
  805. frames = new Frame*[num_frames];
  806. for(int i = 0; i < num_frames; i++) {
  807. frames[i] = new Frame[num_bones];
  808. for(int j = 0; j < num_bones; j++) {
  809. Frame *f = &frames[i][j];
  810. fscanf(file,"%f %f %f",&f->xyz.x,&f->xyz.y,&f->xyz.z);
  811. fscanf(file,"%f %f %f %f",&f->rot.x,&f->rot.y,&f->rot.z,&f->rot.w);
  812. }
  813. }
  814. fscanf(file,"%s",buf);
  815. }
  816. else {
  817. fprintf(stderr,"SkinnedMesh::load_ascii(): unknown token "%s"n",buf);
  818. fclose(file);
  819. return 0;
  820. }
  821. }
  822. fclose(file);
  823. return 1;
  824. }
  826. /*****************************************************************************/
  827. /*                                                                           */
  828. /* calculate tangent                                                         */
  829. /*                                                                           */
  830. /*****************************************************************************/
  832. void SkinnedMesh::calculate_tangent() {
  833. setFrame(0.0);
  834. calculateSkin();
  836. for(int i = 0; i < num_surfaces; i++) {
  837. Surface *s = surfaces[i];
  839. for(int j = 0; j < s->num_vertex; j++) { // set tangents and binormals to zero
  840. Vertex *v = &s->vertex[j];
  841. for(int k = 0; k < v->num_weights; k++) {
  842. Weight *w = &v->weights[k];
  843. w->tangent = vec3(0,0,0);
  844. w->binormal = vec3(0,0,0);
  845. }
  846. }
  848. for(int j = 0; j < s->num_triangles; j++) {
  849. Triangle *t = &s->triangles[j];
  851. Vertex *v0 = &s->vertex[t->v[0]];
  852. Vertex *v1 = &s->vertex[t->v[1]];
  853. Vertex *v2 = &s->vertex[t->v[2]];
  855. vec3 normal,tangent,binormal; // calculate tangent and bonormal for triangle
  856. vec3 e0 = vec3(0,v1->texcoord.x - v0->texcoord.x,v1->texcoord.y - v0->texcoord.y);
  857. vec3 e1 = vec3(0,v2->texcoord.x - v0->texcoord.x,v2->texcoord.y - v0->texcoord.y);
  858. for(int k = 0; k < 3; k++) {
  859. e0.x = v1->xyz[k] - v0->xyz[k];
  860. e1.x = v2->xyz[k] - v0->xyz[k];
  861. vec3 v;
  862. v.cross(e0,e1);
  863. if(fabs(v[0]) > EPSILON) {
  864. tangent[k] = -v[1] / v[0];
  865. binormal[k] = -v[2] / v[0];
  866. } else {
  867. tangent[k] = 0;
  868. binormal[k] = 0;
  869. }
  870. }
  871. tangent.normalize();
  872. binormal.normalize();
  873. normal.cross(tangent,binormal);
  874. normal.normalize();
  876. v0->binormal.cross(v0->normal,tangent);
  877. v0->binormal.normalize();
  878. v0->tangent.cross(v0->binormal,v0->normal);
  879. if(normal * v0->normal < 0) v0->binormal = -v0->binormal;
  881. for(int k = 0; k < v0->num_weights; k++) { // add it in to vertex weights
  882. Weight *w = &v0->weights[k];
  883. mat4 transform = bones[w->bone].rotation.inverse();
  884. w->tangent += transform * v0->tangent;
  885. w->binormal += transform * v0->binormal;
  886. }
  888. v1->binormal.cross(v1->normal,tangent);
  889. v1->binormal.normalize();
  890. v1->tangent.cross(v1->binormal,v1->normal);
  891. if(normal * v1->normal < 0) v1->binormal = -v1->binormal;
  893. for(int k = 0; k < v1->num_weights; k++) {
  894. Weight *w = &v1->weights[k];
  895. mat4 transform = bones[w->bone].rotation.inverse();
  896. w->tangent += transform * v1->tangent;
  897. w->binormal += transform * v1->binormal;
  898. }
  900. v2->binormal.cross(v2->normal,tangent);
  901. v2->binormal.normalize();
  902. v2->tangent.cross(v2->binormal,v2->normal);
  903. if(normal * v2->normal < 0) v2->binormal = -v2->binormal;
  905. for(int k = 0; k < v2->num_weights; k++) {
  906. Weight *w = &v2->weights[k];
  907. mat4 transform = bones[w->bone].rotation.inverse();
  908. w->tangent += transform * v2->tangent;
  909. w->binormal += transform * v2->binormal;
  910. }
  911. }
  913. for(int j = 0; j < s->num_vertex; j++) { // normalize tangents and binormals
  914. Vertex *v = &s->vertex[j];
  915. for(int k = 0; k < v->num_weights; k++) {
  916. Weight *w = &v->weights[k];
  917. w->tangent.normalize();
  918. w->binormal.normalize();
  919. }
  920. }
  921. }
  922. }
  924. /*****************************************************************************/
  925. /*                                                                           */
  926. /* create shadow volume                                                      */
  927. /*                                                                           */
  928. /*****************************************************************************/
  930. struct csv_Edge {
  931. int v[2];
  932. int id;
  933. };
  935. static int csv_edge_cmp(const void *a,const void *b) {
  936. csv_Edge *e0 = (csv_Edge*)a;
  937. csv_Edge *e1 = (csv_Edge*)b;
  938. int v[2][2];
  939. if(e0->v[0] < e0->v[1]) { v[0][0] = e0->v[0]; v[0][1] = e0->v[1]; }
  940. else { v[0][0] = e0->v[1]; v[0][1] = e0->v[0]; }
  941. if(e1->v[0] < e1->v[1]) { v[1][0] = e1->v[0]; v[1][1] = e1->v[1]; }
  942. else { v[1][0] = e1->v[1]; v[1][1] = e1->v[0]; }
  943. if(v[0][0] > v[1][0]) return 1;
  944. if(v[0][0] < v[1][0]) return -1;
  945. if(v[0][1] > v[1][1]) return 1;
  946. if(v[0][1] < v[1][1]) return -1;
  947. return 0;
  948. }
  950. void SkinnedMesh::create_shadow_volumes() {
  951. for(int i = 0; i < num_surfaces; i++) {
  952. Surface *s = surfaces[i];
  953. s->num_edges = s->num_triangles * 3;
  955. csv_Edge *e = new csv_Edge[s->num_edges]; // create temporary edges
  956. for(int j = 0, k = 0; j < s->num_edges; j += 3, k++) {
  957. e[j + 0].v[0] = s->triangles[k].v[0];
  958. e[j + 0].v[1] = s->triangles[k].v[1];
  959. e[j + 1].v[0] = s->triangles[k].v[1];
  960. e[j + 1].v[1] = s->triangles[k].v[2];
  961. e[j + 2].v[0] = s->triangles[k].v[2];
  962. e[j + 2].v[1] = s->triangles[k].v[0];
  963. e[j + 0].id = j + 0;
  964. e[j + 1].id = j + 1;
  965. e[j + 2].id = j + 2;
  966. }
  967. qsort(e,s->num_edges,sizeof(csv_Edge),csv_edge_cmp); // optimize it
  968. int num_optimized_edges = 0;
  969. int *ebuf = new int[s->num_edges];
  970. int *rbuf = new int[s->num_edges];
  971. for(int j = 0; j < s->num_edges; j++) {
  972. if(j == 0 || csv_edge_cmp(&e[num_optimized_edges - 1],&e[j])) e[num_optimized_edges++] = e[j];
  973. ebuf[e[j].id] = num_optimized_edges - 1;
  974. rbuf[e[j].id] = e[num_optimized_edges - 1].v[0] != e[j].v[0];
  975. }
  977. s->num_edges = num_optimized_edges;
  978. s->edges = new Edge[s->num_edges];
  979. for(int j = 0; j < s->num_edges; j++) {
  980. s->edges[j].v[0] = e[j].v[0];
  981. s->edges[j].v[1] = e[j].v[1];
  982. s->edges[j].reverse = 0;
  983. s->edges[j].flag = 0;
  984. }
  985. for(int j = 0, k = 0; j < s->num_triangles; j++, k += 3) {
  986. Triangle *t = &s->triangles[j];
  987. t->e[0] = ebuf[k + 0];
  988. t->e[1] = ebuf[k + 1];
  989. t->e[2] = ebuf[k + 2];
  990. t->reverse[0] = rbuf[k + 0];
  991. t->reverse[1] = rbuf[k + 1];
  992. t->reverse[2] = rbuf[k + 2];
  993. }
  994. s->shadow_volume_vertex = new vec4[s->num_edges * 4];
  995. delete rbuf;
  996. delete ebuf;
  997. delete e;
  998. }
  999. }