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

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

游戏引擎

开发平台：

Visual C++

bsp.cpp：源码内容
  1. /* Bsp
  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 "console.h"
  21. #include "engine.h"
  22. #include "frustum.h"
  23. #include "material.h"
  24. #include "mesh.h"
  25. #include "meshvbo.h"
  26. #include "object.h"
  27. #include "objectmesh.h"
  28. #include "bsp.h"
  30. /*****************************************************************************/
  31. /*                                                                           */
  32. /* Node                                                                      */
  33. /*                                                                           */
  34. /*****************************************************************************/
  36. Node::Node() : left(NULL), right(NULL), object(NULL) {
  37. min = vec3(1000000,1000000,1000000);
  38. max = vec3(-1000000,-1000000,-1000000);
  39. center = vec3(0,0,0);
  40. radius = 1000000;
  41. }
  43. Node::~Node() {
  44. if(left) delete left;
  45. if(right) delete right;
  46. if(object) {
  47. delete object->mesh;
  48. delete object;
  49. }
  50. }
  52. /*
  53.  */
  54. void Node::create(Mesh *mesh) {
  55. min = mesh->getMin();
  56. max = mesh->getMax();
  57. center = mesh->getCenter();
  58. radius = mesh->getRadius();
  59. int num_vertex = 0;
  60. for(int i = 0; i < mesh->getNumSurfaces(); i++) num_vertex += mesh->getNumVertex(i);
  61. if(num_vertex / 3 > TRIANGLES_PER_NODE) {
  62. vec4 plane;
  63. vec3 size = max - min;
  64. if(size.x > size.y) { // find clip plane
  65. if(size.x > size.z) plane = vec4(1,0,0,1);
  66. else plane = vec4(0,0,1,1);
  67. } else{
  68. if(size.y > size.z) plane = vec4(0,1,0,1);
  69. else plane = vec4(0,0,1,1);
  70. }
  71. vec3 center(0,0,0);
  72. int num_vertex = 0; // find center of node
  73. for(int i = 0; i < mesh->getNumSurfaces(); i++) {
  74. Mesh::Vertex *vertex = mesh->getVertex(i);
  75. for(int j = 0; j < mesh->getNumVertex(i); j++) {
  76. center += vertex[j].xyz;
  77. num_vertex++;
  78. }
  79. }
  80. center /= (float)num_vertex;
  81. plane.w = -(plane * vec4(center,1));
  82. Mesh *left_mesh = new Mesh();
  83. Mesh *right_mesh = new Mesh();
  84. for(int i = 0; i < mesh->getNumSurfaces(); i++) {
  85. int num_vertex = mesh->getNumVertex(i);
  86. Mesh::Vertex *vertex = mesh->getVertex(i);
  87. int left_mesh_num_vertex = 0;
  88. Mesh::Vertex *left_mesh_vertex = new Mesh::Vertex[num_vertex * 2];
  89. int right_mesh_num_vertex = 0;
  90. Mesh::Vertex *right_mesh_vertex = new Mesh::Vertex[num_vertex * 2];
  91. for(int j = 0; j < num_vertex; j += 3) {
  92. /*int pos = 0;
  93. if(plane * vec4(vertex[j + 0].xyz,1) > 0.0) pos++;
  94. if(plane * vec4(vertex[j + 1].xyz,1) > 0.0) pos++;
  95. if(plane * vec4(vertex[j + 2].xyz,1) > 0.0) pos++;
  96. if(pos > 1) {
  97. left_mesh_vertex[left_mesh_num_vertex++] = vertex[j + 0];
  98. left_mesh_vertex[left_mesh_num_vertex++] = vertex[j + 1];
  99. left_mesh_vertex[left_mesh_num_vertex++] = vertex[j + 2];
  100. } else {
  101. right_mesh_vertex[right_mesh_num_vertex++] = vertex[j + 0];
  102. right_mesh_vertex[right_mesh_num_vertex++] = vertex[j + 1];
  103. right_mesh_vertex[right_mesh_num_vertex++] = vertex[j + 2];
  104. }*/
  105. int num_left = 0;
  106. int num_right = 0;
  107. Mesh::Vertex *left = &left_mesh_vertex[left_mesh_num_vertex];
  108. Mesh::Vertex *right = &right_mesh_vertex[right_mesh_num_vertex];
  109. float cur_dot = plane * vec4(vertex[j + 0].xyz,1);
  110. for(int cur = 0; cur < 3; cur++) {
  111. int next = (cur + 1) % 3;
  112. float next_dot = plane * vec4(vertex[j + next].xyz,1);
  113. if(cur_dot <= 0.0) left[num_left++] = vertex[j + cur];
  114. if(cur_dot > 0.0) right[num_right++] = vertex[j + cur];
  115. if((cur_dot <= 0.0) != (next_dot <= 0.0)) {
  116. float k = -cur_dot / (next_dot - cur_dot);
  117. Mesh::Vertex v;
  118. v.xyz = vertex[j + cur].xyz * (1.0f - k) + vertex[j + next].xyz * k;
  119. v.normal = vertex[j + cur].normal * (1.0f - k) + vertex[j + next].normal * k;
  120. v.tangent = vertex[j + cur].tangent * (1.0f - k) + vertex[j + next].tangent * k;
  121. v.binormal = vertex[j + cur].binormal * (1.0f - k) + vertex[j + next].binormal * k;
  122. v.texcoord = vertex[j + cur].texcoord * (1.0f - k) + vertex[j + next].texcoord * k;
  123. left[num_left++] = v;
  124. right[num_right++] = v;
  125. }
  126. cur_dot = next_dot;
  127. }
  128. if(num_left == 3) left_mesh_num_vertex += 3;
  129. else if(num_left == 4) {
  130. left[4] = left[0];
  131. left[5] = left[2];
  132. left_mesh_num_vertex += 6;
  133. }
  134. if(num_right == 3) right_mesh_num_vertex += 3;
  135. else if(num_right == 4) {
  136. right[4] = right[0];
  137. right[5] = right[2];
  138. right_mesh_num_vertex += 6;
  139. }
  140. }
  141. if(left_mesh_num_vertex > 0) left_mesh->addSurface(mesh->getSurfaceName(i),left_mesh_vertex,left_mesh_num_vertex);
  142. if(right_mesh_num_vertex > 0) right_mesh->addSurface(mesh->getSurfaceName(i),right_mesh_vertex,right_mesh_num_vertex);
  143. delete right_mesh_vertex;
  144. delete left_mesh_vertex;
  145. }
  146. int left_mesh_num_vertex = 0;
  147. for(int i = 0; i < left_mesh->getNumSurfaces(); i++) left_mesh_num_vertex += left_mesh->getNumVertex(i);
  148. int right_mesh_num_vertex = 0;
  149. for(int i = 0; i < right_mesh->getNumSurfaces(); i++) right_mesh_num_vertex += right_mesh->getNumVertex(i);
  150. if(left_mesh_num_vertex > 0 && right_mesh_num_vertex > 0) {
  151. left_mesh->calculate_bounds();
  152. left = new Node();
  153. left->create(left_mesh);
  154. right_mesh->calculate_bounds();
  155. right = new Node();
  156. right->create(right_mesh);
  157. } else {
  158. mesh->create_shadow_volumes();
  159. mesh->create_triangle_strips();
  160. object = new ObjectMesh(new MeshVBO(mesh));
  161. delete right_mesh;
  162. delete left_mesh;
  163. }
  164. } else {
  165. mesh->create_shadow_volumes();
  166. mesh->create_triangle_strips();
  167. object = new ObjectMesh(new MeshVBO(mesh));
  168. }
  169. delete mesh;
  170. }
  172. /*
  173.  */
  174. void Node::load(FILE *file) {
  175. int header;
  176. fread(&header,sizeof(int),1,file);
  177. if(header == 0x7fffffff) {
  178. fread(&min,sizeof(vec3),1,file);
  179. fread(&max,sizeof(vec3),1,file);
  180. fread(&center,sizeof(vec3),1,file);
  181. fread(&radius,sizeof(float),1,file);
  182. left = new Node();
  183. left->load(file);
  184. right = new Node();
  185. right->load(file);
  186. } else {
  187. fseek(file,-sizeof(int),SEEK_CUR);
  188. Mesh *mesh = new Mesh();
  189. mesh->load(file);
  190. min = mesh->getMin();
  191. max = mesh->getMax();
  192. center = mesh->getCenter();
  193. radius = mesh->getRadius();
  194. object = new ObjectMesh(new MeshVBO(mesh));
  195. delete mesh;
  196. }
  197. }
  199. /*
  200.  */
  201. void Node::save(FILE *file) {
  202. if(left && right) {
  203. int header = 0x7fffffff;
  204. fwrite(&header,sizeof(int),1,file);
  205. fwrite(&min,sizeof(vec3),1,file);
  206. fwrite(&max,sizeof(vec3),1,file);
  207. fwrite(&center,sizeof(vec3),1,file);
  208. fwrite(&radius,sizeof(float),1,file);
  209. left->save(file);
  210. right->save(file);
  211. } else {
  212. object->mesh->save(file);
  213. }
  214. }
  216. /*
  217.  */
  218. void Node::bindMaterial(const char *name,Material *material) {
  219. if(left) left->bindMaterial(name,material);
  220. if(right) right->bindMaterial(name,material);
  221. if(object) object->bindMaterial(name,material);
  222. }
  224. /*
  225.  */
  226. void Node::render() {
  227. if(left && right) {
  228. int check_left = Engine::frustum->inside(left->center,left->radius);
  229. int check_right = Engine::frustum->inside(right->center,right->radius);
  230. if(check_left && check_right) {
  231. if((left->center - Engine::camera).length() < (right->center - Engine::camera).length()) {
  232. left->render();
  233. right->render();
  234. } else {
  235. right->render();
  236. left->render();
  237. }
  238. return;
  239. }
  240. if(check_left) left->render();
  241. else if(check_right) right->render();
  242. return;
  243. }
  244. if(object && object->frame != Engine::frame) {
  245. Sector *s = Bsp::visible_sectors[Bsp::num_visible_sectors - 1];
  246. s->visible_objects[s->num_visible_objects++] = object;
  247. Engine::num_triangles += object->render(Object::RENDER_OPACITY);
  248. }
  249. }
  251. /*****************************************************************************/
  252. /*                                                                           */
  253. /* Portal                                                                    */
  254. /*                                                                           */
  255. /*****************************************************************************/
  257. Portal::Portal() : center(0,0,0), radius(1000000.0), num_sectors(0), sectors(NULL), frame(0) {
  259. }
  261. Portal::~Portal() {
  262. if(sectors) delete sectors;
  263. }
  265. /*
  266.  */
  267. void Portal::create(Mesh *mesh,int s) {
  268. center = mesh->getCenter(s);
  269. radius = mesh->getRadius(s);
  270. int num_vertex = mesh->getNumVertex(s);
  271. if(num_vertex != 6) {
  272. fprintf(stderr,"Portal::create(): portal mesh must have only two trianglen");
  273. return;
  274. }
  275. Mesh::Vertex *v = mesh->getVertex(s);
  276. int flag[6]; // create quad from the six vertexes
  277. for(int i = 0; i < 6; i++) {
  278. flag[i] = 0;
  279. for(int j = 0; j < 6; j++) {
  280. if(i == j) continue;
  281. if(v[i].xyz == v[j].xyz) flag[i] = 1;
  282. }
  283. }
  284. for(int i = 0, j = 0; i < 6; i++) {
  285. if(flag[i] == 0) points[j++] = v[i].xyz;
  286. if(i == 5 && j != 2) {
  287. fprintf(stderr,"Portal::create(): can`t find two similar vertexes for create quadn");
  288. return;
  289. }
  290. }
  291. points[2] = points[1];
  292. for(int i = 0, j = 1; i < 3; i++) {
  293. if(flag[i] != 0) {
  294. points[j] = v[i].xyz;
  295. j += 2;
  296. }
  297. }
  298. }
  300. void Portal::getScissor(int *scissor) {
  301. if((center - Engine::camera).length() < radius) {
  302. scissor[0] = Engine::viewport[0];
  303. scissor[1] = Engine::viewport[1];
  304. scissor[2] = Engine::viewport[2];
  305. scissor[3] = Engine::viewport[3];
  306. return;
  307. }
  308. mat4 mvp = Engine::projection * Engine::modelview;
  309. vec4 p[4];
  310. p[0] = mvp * vec4(points[0],1);
  311. p[1] = mvp * vec4(points[1],1);
  312. p[2] = mvp * vec4(points[2],1);
  313. p[3] = mvp * vec4(points[3],1);
  314. p[0] /= p[0].w;
  315. p[1] /= p[1].w;
  316. p[2] /= p[2].w;
  317. p[3] /= p[3].w;
  318. vec3 min = vec3(1000000,1000000,1000000);
  319. vec3 max = vec3(-1000000,-1000000,-1000000);
  320. for(int i = 0; i < 4; i++) {
  321. if(min.x > p[i].x) min.x = p[i].x;
  322. if(max.x < p[i].x) max.x = p[i].x;
  323. if(min.y > p[i].y) min.y = p[i].y;
  324. if(max.y < p[i].y) max.y = p[i].y;
  325. }
  326. scissor[0] = Engine::viewport[0] + (int)((float)Engine::viewport[2] * (min.x + 1.0) / 2.0) - 4; // remove it
  327. scissor[1] = Engine::viewport[1] + (int)((float)Engine::viewport[3] * (min.y + 1.0) / 2.0) - 4;
  328. scissor[2] = Engine::viewport[0] + (int)((float)Engine::viewport[2] * (max.x + 1.0) / 2.0) + 4;
  329. scissor[3] = Engine::viewport[1] + (int)((float)Engine::viewport[3] * (max.y + 1.0) / 2.0) + 4;
  330. if(scissor[0] < Engine::viewport[0]) scissor[0] = Engine::viewport[0];
  331. else if(scissor[0] > Engine::viewport[0] + Engine::viewport[2]) scissor[0] = Engine::viewport[0] + Engine::viewport[2];
  332. if(scissor[1] < Engine::viewport[1]) scissor[1] = Engine::viewport[1];
  333. else if(scissor[1] > Engine::viewport[1] + Engine::viewport[3]) scissor[1] = Engine::viewport[1] + Engine::viewport[3];
  334. if(scissor[2] < Engine::viewport[0]) scissor[2] = Engine::viewport[0];
  335. else if(scissor[2] > Engine::viewport[2] + Engine::viewport[3]) scissor[2] = Engine::viewport[0] + Engine::viewport[2];
  336. if(scissor[3] < Engine::viewport[1]) scissor[3] = Engine::viewport[1];
  337. else if(scissor[3] > Engine::viewport[1] + Engine::viewport[3]) scissor[3] = Engine::viewport[1] + Engine::viewport[3];
  338. scissor[2] -= scissor[0];
  339. scissor[3] -= scissor[1];
  340. }
  342. /*
  343.  */
  344. void Portal::render() {
  345. glBegin(GL_QUADS);
  346. glVertex3fv(points[0]);
  347. glVertex3fv(points[1]);
  348. glVertex3fv(points[2]);
  349. glVertex3fv(points[3]);
  350. glEnd();
  351. }
  353. /*****************************************************************************/
  354. /*                                                                           */
  355. /* Sector                                                                    */
  356. /*                                                                           */
  357. /*****************************************************************************/
  359. Sector::Sector() : center(0,0,0), radius(1000000.0), num_planes(0), planes(NULL), root(NULL),
  360. num_portals(0), portals(NULL), num_objects(0), objects(NULL), num_node_objects(0), node_objects(NULL),
  361. num_visible_objects(0), visible_objects(NULL), portal(NULL), frame(0),
  362. old_num_visible_objects(0), old_visible_objects(NULL), old_portal(NULL), old_frame(0) {
  364. }
  366. Sector::~Sector() {
  367. if(portals) delete portals;
  368. if(planes) delete planes;
  369. if(root) delete root;
  370. if(objects) delete objects;
  371. if(node_objects) delete node_objects;
  372. if(visible_objects) delete visible_objects;
  373. if(old_visible_objects) delete old_visible_objects;
  374. }
  376. /*
  377.  */
  378. void Sector::create(Mesh *mesh,int s) {
  379. center = mesh->getCenter(s);
  380. radius = mesh->getRadius(s);
  381. num_planes = mesh->getNumVertex(s) / 3;
  382. planes = new vec4[num_planes];
  383. Mesh::Vertex *v = mesh->getVertex(s);
  384. for(int i = 0; i < num_planes; i++) {
  385. vec3 normal;
  386. normal.cross(v[i * 3 + 1].xyz - v[i * 3 + 0].xyz,v[i * 3 + 2].xyz - v[i * 3 + 0].xyz);
  387. normal.normalize();
  388. planes[i] = vec4(normal,-normal * v[i * 3 + 0].xyz);
  389. }
  390. }
  392. /* get all objects from the tree
  393.  */
  394. void Sector::getNodeObjects(Node *node) {
  395. if(node->left && node->right) {
  396. getNodeObjects(node->left);
  397. getNodeObjects(node->right);
  398. }
  399. if(node->object) {
  400. if(node_objects) node_objects[num_node_objects] = node->object;
  401. num_node_objects++;
  402. }
  403. }
  405. /*
  406.  */
  407. void Sector::create() {
  409. objects = new Object*[NUM_OBJECTS];
  411. num_node_objects = 0;
  412. getNodeObjects(root);
  414. node_objects = new Object*[num_node_objects];
  415. visible_objects = new Object*[num_node_objects + NUM_OBJECTS];
  416. old_visible_objects = new Object*[num_node_objects + NUM_OBJECTS];
  418. num_node_objects = 0;
  419. getNodeObjects(root);
  420. }
  422. /*
  423.  */
  424. int Sector::inside(const vec3 &point) {
  425. for(int i = 0; i < num_planes; i++) {
  426. if(planes[i] * vec4(point,1) > 0.0) return 0;
  427. }
  428. return 1;
  429. }
  431. int Sector::inside(Portal *portal) {
  432. if(inside(portal->points[0]) == 0) return 0;
  433. if(inside(portal->points[1]) == 0) return 0;
  434. if(inside(portal->points[2]) == 0) return 0;
  435. if(inside(portal->points[3]) == 0) return 0;
  436. return 1;
  437. }
  439. int Sector::inside(const vec3 &center,float radius) {
  440. for(int i = 0; i < num_planes; i++) {
  441. if(planes[i] * vec4(center,1) > radius) return 0;
  442. }
  443. return 1;
  444. }
  446. int Sector::inside(Mesh *mesh,int s) {
  447. Mesh::Vertex *v = mesh->getVertex(s);
  448. for(int i = 0; i < mesh->getNumVertex(s); i++) {
  449. if(inside(v[i].xyz) == 0) return 0;
  450. }
  451. return 1;
  452. }
  454. /*
  455.  */
  456. void Sector::addObject(Object *object) {
  457. if(!objects) return;
  458. int i = 0;
  459. for(; i < num_objects; i++) if(objects[i] == object) return;
  460. objects[num_objects++] = object;
  461. }
  463. /*
  464.  */
  465. void Sector::removeObject(Object *object) {
  466. for(int i = 0; i < num_objects; i++) {
  467. if(objects[i] == object) {
  468. num_objects--;
  469. for(; i < num_objects; i++) objects[i] = objects[i + 1];
  470. return;
  471. }
  472. }
  473. }
  475. /*
  476.  */
  477. void Sector::bindMaterial(const char *name,Material *material) {
  478. root->bindMaterial(name,material);
  479. }
  481. /*
  482.  */
  483. void Sector::render(Portal *portal) {
  485. if(frame == Engine::frame) return;
  486. frame = Engine::frame;
  488. this->portal = portal;
  489. Bsp::visible_sectors[Bsp::num_visible_sectors++] = this;
  491. num_visible_objects = 0;
  493. root->render();
  495. for(int i = 0; i < num_objects; i++) {
  496. Object *o = objects[i];
  497. if(o->frame == Engine::frame) continue;
  498. if(Engine::frustum->inside(o->pos + o->getCenter(),o->getRadius())) {
  499. Engine::num_triangles += o->render(Object::RENDER_OPACITY);
  500. visible_objects[num_visible_objects++] = o;
  501. }
  502. }
  504. for(int i = 0; i < num_portals; i++) {
  505. Portal *p = &Bsp::portals[portals[i]];
  506. if(p->frame == Engine::frame) continue;
  507. p->frame = Engine::frame;
  508. if(Engine::frustum->inside(p->center,p->radius)) {
  509. float dist = (Engine::camera - p->center).length();
  511. if(Engine::have_occlusion && dist > p->radius) {
  513. if(Material::old_material) Material::old_material->disable();
  515. glDisable(GL_CULL_FACE);
  516. glColorMask(GL_FALSE,GL_FALSE,GL_FALSE,GL_FALSE);
  517. glDepthMask(GL_FALSE);
  518. glBeginQueryARB(GL_SAMPLES_PASSED_ARB,Engine::query_id);
  519. p->render();
  520. glEndQueryARB(GL_SAMPLES_PASSED_ARB);
  521. glDepthMask(GL_TRUE);
  522. glColorMask(GL_TRUE,GL_TRUE,GL_TRUE,GL_TRUE);
  523. glEnable(GL_CULL_FACE);
  525. GLuint samples;
  526. glGetQueryObjectuivARB(Engine::query_id,GL_QUERY_RESULT_ARB,&samples);
  527. if(samples == 0) continue;
  528. }
  530. if(dist > p->radius) Engine::frustum->addPortal(Engine::camera,p->points);
  531. for(int j = 0; j < p->num_sectors; j++) {
  532. Bsp::sectors[p->sectors[j]].render(dist > p->radius ? p : NULL);
  533. }
  534. if(dist > p->radius) Engine::frustum->removePortal();
  535. }
  536. }
  537. }
  539. /*
  540.  */
  541. void Sector::saveState() {
  542. old_num_visible_objects = num_visible_objects;
  543. for(int i = 0; i < num_visible_objects; i++) {
  544. old_visible_objects[i] = visible_objects[i];
  545. }
  546. old_portal = portal;
  547. old_frame = frame;
  548. }
  550. void Sector::restoreState(int frame) {
  551. num_visible_objects = old_num_visible_objects;
  552. for(int i = 0; i < num_visible_objects; i++) {
  553. visible_objects[i] = old_visible_objects[i];
  554. }
  555. portal = old_portal;
  556. this->frame = frame;
  557. }
  559. /*****************************************************************************/
  560. /*                                                                           */
  561. /* Bsp                                                                       */
  562. /*                                                                           */
  563. /*****************************************************************************/
  565. int Bsp::num_portals;
  566. Portal *Bsp::portals;
  567. int Bsp::num_sectors;
  568. Sector *Bsp::sectors;
  569. int Bsp::num_visible_sectors;
  570. Sector **Bsp::visible_sectors;
  571. int Bsp::old_num_visible_sectors;
  572. Sector **Bsp::old_visible_sectors;
  574. Bsp::Bsp() {
  575. num_portals = 0;
  576. portals = NULL;
  577. num_sectors = 0;
  578. sectors = NULL;
  579. num_visible_sectors = 0;
  580. visible_sectors = NULL;
  581. old_num_visible_sectors = 0;
  582. old_visible_sectors = NULL;
  583. }
  585. Bsp::~Bsp() {
  586. if(num_portals) delete [] portals;
  587. num_portals = 0;
  588. portals = NULL;
  589. if(num_sectors) delete [] sectors;
  590. num_sectors = 0;
  591. sectors = NULL;
  592. if(visible_sectors) delete visible_sectors;
  593. num_visible_sectors = 0;
  594. visible_sectors = NULL;
  595. if(old_visible_sectors) delete old_visible_sectors;
  596. old_num_visible_sectors = 0;
  597. old_visible_sectors = NULL;
  598. }
  600. /*****************************************************************************/
  601. /*                                                                           */
  602. /* Bsp IO                                                                    */
  603. /*                                                                           */
  604. /*****************************************************************************/
  606. /*
  607.  */
  608. void Bsp::load(const char *name) {
  610. if(strstr(name,".bsp")) { // read own binary bsp format
  612. FILE *file = fopen(name,"rb");
  613. if(!file) {
  614. fprintf(stderr,"Bsp::load(): error open "%s" filen",name);
  615. return;
  616. }
  618. int magic;
  619. fread(&magic,sizeof(int),1,file);
  620. if(magic != BSP_MAGIC) {
  621. fprintf(stderr,"Bsp::load(): wrong magic in "%s" filen",name);
  622. fclose(file);
  623. return;
  624. }
  626. fread(&num_portals,sizeof(int),1,file);
  627. portals = new Portal[num_portals];
  628. for(int i = 0; i < num_portals; i++) {
  629. Portal *p = &portals[i];
  630. fread(&p->center,sizeof(vec3),1,file);
  631. fread(&p->radius,sizeof(float),1,file);
  632. fread(&p->num_sectors,sizeof(int),1,file);
  633. p->sectors = new int[p->num_sectors];
  634. fread(p->sectors,sizeof(int),p->num_sectors,file);
  635. fread(p->points,sizeof(vec3),4,file);
  636. }
  638. fread(&num_sectors,sizeof(int),1,file);
  639. sectors = new Sector[num_sectors];
  640. for(int i = 0; i < num_sectors; i++) {
  641. Sector *s = &sectors[i];
  642. fread(&s->center,sizeof(vec3),1,file);
  643. fread(&s->radius,sizeof(float),1,file);
  644. fread(&s->num_portals,sizeof(int),1,file);
  645. s->portals = new int[s->num_portals];
  646. fread(s->portals,sizeof(int),s->num_portals,file);
  647. fread(&s->num_planes,sizeof(int),1,file);
  648. s->planes = new vec4[s->num_planes];
  649. fread(s->planes,sizeof(vec4),s->num_planes,file);
  650. s->root = new Node();
  651. s->root->load(file);
  652. s->create();
  653. }
  655. fclose(file);
  657. visible_sectors = new Sector*[num_sectors];
  658. old_visible_sectors = new Sector*[num_sectors];
  660. Engine::console->printf("sectors %dnportals %dn",num_sectors,num_portals);
  662. return;
  663. }
  665. // else generate bsp tree with portals and sectors
  666. Mesh *mesh = new Mesh();
  667. if(strstr(name,".3ds")) mesh->load_3ds(name);
  668. else if(strstr(name,".mesh")) mesh->load_mesh(name);
  670. mesh->calculate_bounds();
  671. mesh->calculate_tangent();
  673. for(int i = 0; i < mesh->getNumSurfaces(); i++) {
  674. const char *name = mesh->getSurfaceName(i);
  675. if(!strncmp(name,"portal",6)) num_portals++;
  676. else if(!strncmp(name,"sector",6)) num_sectors++;
  677. }
  679. if(num_portals == 0 || num_sectors == 0) {
  681. num_sectors = 1;
  682. sectors = new Sector[1];
  683. sectors[0].root = new Node();
  684. sectors[0].root->create(mesh);
  685. sectors[0].create();
  687. } else {
  689. portals = new Portal[num_portals];
  690. sectors = new Sector[num_sectors];
  692. int *usage_flag = new int[mesh->getNumSurfaces()];
  694. num_portals = 0;
  695. num_sectors = 0;
  696. for(int i = 0; i < mesh->getNumSurfaces(); i++) {
  697. const char *name = mesh->getSurfaceName(i);
  698. if(!strncmp(name,"portal",6)) {
  699. portals[num_portals++].create(mesh,i);
  700. usage_flag[i] = 1;
  701. } else if(!strncmp(name,"sector",6)) {
  702. sectors[num_sectors++].create(mesh,i);
  703. usage_flag[i] = 1;
  704. } else usage_flag[i] = 0;
  705. }
  707. for(int i = 0; i < num_portals; i++) portals[i].sectors = new int[num_sectors];
  708. for(int i = 0; i < num_sectors; i++) sectors[i].portals = new int[num_portals];
  710. for(int i = 0; i < num_sectors; i++) {
  711. Sector *s = &sectors[i];
  712. for(int j = 0; j < num_portals; j++) {
  713. Portal *p = &portals[j];
  714. if(s->inside(p)) {
  715. p->sectors[p->num_sectors++] = i;
  716. s->portals[s->num_portals++] = j;
  717. }
  718. }
  719. }
  721. for(int i = 0; i < num_sectors; i++) {
  722. Sector *s = &sectors[i];
  723. Mesh *m = new Mesh();
  724. for(int j = 0; j < mesh->getNumSurfaces(); j++) {
  725. if(usage_flag[j]) continue;
  726. if(s->inside(mesh,j)) {
  727. m->addSurface(mesh,j);
  728. usage_flag[j] = 1;
  729. }
  730. }
  731. s->root = new Node();
  732. s->root->create(m);
  733. s->create();
  734. }
  736. delete usage_flag;
  737. delete mesh;
  738. }
  740. visible_sectors = new Sector*[num_sectors];
  741. old_visible_sectors = new Sector*[num_sectors];
  743. Engine::console->printf("sectors %dnportals %dn",num_sectors,num_portals);
  744. }
  746. /*
  747.  */
  748. void Bsp::save(const char *name) {
  749. FILE *file = fopen(name,"wb");
  750. if(!file) {
  751. fprintf(stderr,"Bsp::save(): can`t create "%s" filen",name);
  752. return;
  753. }
  754. int magic = BSP_MAGIC;
  755. fwrite(&magic,sizeof(int),1,file);
  756. fwrite(&num_portals,sizeof(int),1,file);
  757. for(int i = 0; i < num_portals; i++) {
  758. Portal *p = &portals[i];
  759. fwrite(&p->center,sizeof(vec3),1,file);
  760. fwrite(&p->radius,sizeof(float),1,file);
  761. fwrite(&p->num_sectors,sizeof(int),1,file);
  762. fwrite(p->sectors,sizeof(int),p->num_sectors,file);
  763. fwrite(p->points,sizeof(vec3),4,file);
  764. }
  765. fwrite(&num_sectors,sizeof(int),1,file);
  766. for(int i = 0; i < num_sectors; i++) {
  767. Sector *s = &sectors[i];
  768. fwrite(&s->center,sizeof(vec3),1,file);
  769. fwrite(&s->radius,sizeof(float),1,file);
  770. fwrite(&s->num_portals,sizeof(int),1,file);
  771. fwrite(s->portals,sizeof(int),s->num_portals,file);
  772. fwrite(&s->num_planes,sizeof(int),1,file);
  773. fwrite(s->planes,sizeof(vec4),s->num_planes,file);
  774. s->root->save(file);
  775. }
  776. fclose(file);
  777. }
  779. /*****************************************************************************/
  780. /*                                                                           */
  781. /* Bsp Render                                                                */
  782. /*                                                                           */
  783. /*****************************************************************************/
  785. /*
  786.  */
  787. void Bsp::bindMaterial(const char *name,Material *material) {
  788. for(int i = 0; i < num_sectors; i++) sectors[i].bindMaterial(name,material);
  789. }
  791. /*
  792.  */
  793. void Bsp::render() {
  794. num_visible_sectors = 0;
  795. if(Engine::camera.sector != -1) {
  796. sectors[Engine::camera.sector].render();
  797. } else {
  798. int sector = -1;
  799. float dist = 1000000.0;
  800. for(int i = 0; i < num_sectors; i++) {
  801. float d = (sectors[i].center - Engine::camera).length();
  802. if(d < dist) {
  803. dist = d;
  804. sector = i;
  805. }
  806. }
  807. if(sector != -1) sectors[sector].render();
  808. }
  809. }
  811. /*
  812.  */
  813. void Bsp::saveState() {
  814. old_num_visible_sectors = num_visible_sectors;
  815. for(int i = 0; i < num_visible_sectors; i++) {
  816. old_visible_sectors[i] = visible_sectors[i];
  817. old_visible_sectors[i]->saveState();
  818. }
  819. }
  821. void Bsp::restoreState(int frame) {
  822. num_visible_sectors = old_num_visible_sectors;
  823. for(int i = 0; i < num_visible_sectors; i++) {
  824. visible_sectors[i] = old_visible_sectors[i];
  825. visible_sectors[i]->restoreState(frame);
  826. }
  827. }