Open Source Tomb Raider Engine
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

World.cpp 17KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754
  1. /*!
  2. * \file src/World.cpp
  3. * \brief The game world (model)
  4. *
  5. * \author Mongoose
  6. */
  7. #include <math.h>
  8. #include <assert.h>
  9. #include "World.h"
  10. ////////////////////////////////////////////////////////////
  11. // Constructors
  12. ////////////////////////////////////////////////////////////
  13. World::World()
  14. {
  15. mClearLock = false;
  16. mFlags = 0;
  17. }
  18. World::~World()
  19. {
  20. destroy();
  21. }
  22. ////////////////////////////////////////////////////////////
  23. // Public Accessors
  24. ////////////////////////////////////////////////////////////
  25. int World::getRoomByLocation(int index, float x, float y, float z)
  26. {
  27. room_mesh_t *room = mRooms[index];
  28. if (room)
  29. {
  30. if (x > room->bbox_min[0] && x < room->bbox_max[0] &&
  31. z > room->bbox_min[2] && z < room->bbox_max[2])
  32. {
  33. if (y > room->bbox_min[1] && y < room->bbox_max[1])
  34. return index;
  35. }
  36. }
  37. return getRoomByLocation(x, y, z);
  38. }
  39. int World::getRoomByLocation(float x, float y, float z)
  40. {
  41. room_mesh_t *room;
  42. int hop = -1;
  43. for(std::vector<int>::size_type i = 0; i < mRooms.size(); i++)
  44. {
  45. room = mRooms[i];
  46. if (!room)
  47. continue;
  48. if ((x > room->bbox_min[0]) && (x < room->bbox_max[0]) &&
  49. (z > room->bbox_min[2]) && (z < room->bbox_max[2]))
  50. {
  51. // This room contains current position
  52. if ((y > room->bbox_min[1]) && (y < room->bbox_max[1]))
  53. return i;
  54. // This room is above or below current position
  55. hop = i;
  56. }
  57. }
  58. // Room is -1? Must be in void, try to hop to room with same X,Z
  59. if (mFlags & fEnableHopping)
  60. return hop;
  61. return -1;
  62. }
  63. int World::getAdjoiningRoom(int index,
  64. float x, float y, float z,
  65. float x2, float y2, float z2)
  66. {
  67. room_mesh_t *room = mRooms[index];
  68. portal_t * portal;
  69. vec3_t intersect, p1, p2;
  70. p1[0] = x; p1[1] = y; p1[2] = z;
  71. p2[0] = x2; p2[1] = y2; p2[2] = z2;
  72. if (room)
  73. {
  74. for(std::vector<int>::size_type i = 0; i != room->portals.size(); i++)
  75. {
  76. portal = room->portals[i];
  77. if (!portal)
  78. continue;
  79. if (intersectionLinePolygon(intersect, p1, p2, // 4,
  80. portal->vertices))
  81. {
  82. return portal->adjoining_room;
  83. }
  84. }
  85. }
  86. return -1;
  87. }
  88. int World::getSector(int room, float x, float z, float *floor, float *ceiling)
  89. {
  90. room_mesh_t *r;
  91. sector_t * s;
  92. int sector;
  93. assert(room >= 0);
  94. assert(floor != NULL);
  95. assert(ceiling != NULL);
  96. r = mRooms[room];
  97. if (!r)
  98. return -1;
  99. sector = (((((int)x - (int)r->pos[0]) / 1024) * r->numZSectors) +
  100. (((int)z - (int)r->pos[2]) / 1024));
  101. if (sector > -1)
  102. {
  103. s = r->sectors[sector];
  104. if (!s)
  105. return -1;
  106. *floor = s->floor;
  107. *ceiling = s->ceiling;
  108. }
  109. return sector;
  110. }
  111. int World::getSector(int room, float x, float z) {
  112. int sector;
  113. room_mesh_t *r;
  114. if ((room < 0) || (room >= (int)mRooms.size()))
  115. return -1;
  116. r = mRooms[room];
  117. if (!r)
  118. return -1;
  119. sector = (((((int)x - (int)r->pos[0]) / 1024) * r->numZSectors) +
  120. (((int)z - (int)r->pos[2]) / 1024));
  121. if (sector < 0)
  122. return -1;
  123. return sector;
  124. }
  125. unsigned int World::getRoomInfo(int room) {
  126. room_mesh_t *r;
  127. if ((room >= (int)mRooms.size()) || (room < 0))
  128. return 0;
  129. r = mRooms[room];
  130. if (!r)
  131. return 0;
  132. return r->flags;
  133. }
  134. bool World::isWall(int room, int sector) {
  135. room_mesh_t *r;
  136. sector_t *sect;
  137. if ((room >= (int)mRooms.size()) || (room < 0))
  138. return true;
  139. r = mRooms[room];
  140. if ((!r) || (sector >= (int)r->sectors.size()) || (sector < 0))
  141. return true;
  142. sect = r->sectors[sector];
  143. if (!sect)
  144. return true;
  145. return ((sector > 0) && sect->wall); //! \fixme is (sector > 0) correct??
  146. }
  147. bool World::getHeightAtPosition(int index, float x, float *y, float z)
  148. {
  149. room_mesh_t *room = mRooms[index];
  150. #ifdef OBSOLETE_USING_BOXES
  151. unsigned int i;
  152. float zmax, xmax, zmin, xmin;
  153. if (!room)
  154. {
  155. return false;
  156. }
  157. // Mongoose 2002.08.14, It's 0302 - give me a fucking break --
  158. // this works albeit poorly =)
  159. for (i = 0; (int)i < room->num_boxes; ++i)
  160. {
  161. xmax = room->boxes[i].c.pos[0];
  162. xmin = room->boxes[i].a.pos[0];
  163. zmax = room->boxes[i].c.pos[2];
  164. zmin = room->boxes[i].a.pos[2];
  165. if (x < xmax && x > xmin && z < zmax && z > zmin)
  166. {
  167. //printf("%f %f %f %f\n", xmax, xmin, zmax, zmin);
  168. *y = room->boxes[i].a.pos[1]; // hhmm...room->pos[1] +
  169. return true;
  170. }
  171. }
  172. return false;
  173. #else
  174. int sector;
  175. sector_t *sect;
  176. if (!room)
  177. {
  178. return false;
  179. }
  180. // Mongoose 2002.08.14, Remember sector_z is width of sector array
  181. sector = getSector(index, x, z);
  182. sect = room->sectors[sector];
  183. if (!sect)
  184. {
  185. return true;
  186. }
  187. *y = sect->floor;
  188. return true;
  189. #endif
  190. }
  191. // Temp methods for rendering use until more refactoring is done
  192. #ifdef BAD_BLOOD
  193. model_mesh_t *World::getMesh(int index)
  194. {
  195. return mMeshes[index];
  196. }
  197. skeletal_model_t *World::getModel(int index)
  198. {
  199. return mModels[index];
  200. }
  201. room_mesh_t *World::getRoom(int index)
  202. {
  203. return mRooms[index];
  204. }
  205. std::vector<entity_t *> *World::getEntities()
  206. {
  207. return &mEntities;
  208. }
  209. std::vector<sprite_seq_t *> *World::getSprites()
  210. {
  211. return &mSprites;
  212. }
  213. std::vector<room_mesh_t *> *World::getRooms()
  214. {
  215. return &mRooms;
  216. }
  217. #endif
  218. ////////////////////////////////////////////////////////////
  219. // Public Mutators
  220. ////////////////////////////////////////////////////////////
  221. void World::setFlag(WorldFlag flag)
  222. {
  223. mFlags |= flag;
  224. }
  225. void World::clearFlag(WorldFlag flag)
  226. {
  227. mFlags &= ~flag;
  228. }
  229. void World::destroy()
  230. {
  231. // Add some locking to check use state first
  232. if (!mClearLock)
  233. {
  234. clear();
  235. }
  236. }
  237. void World::addRoom(room_mesh_t *room)
  238. {
  239. mClearLock = false;
  240. mRooms.push_back(room);
  241. }
  242. void World::addMesh(model_mesh_t *mesh)
  243. {
  244. if (mesh)
  245. {
  246. mClearLock = false;
  247. mMeshes.push_back(mesh);
  248. }
  249. }
  250. void World::addEntity(entity_t *e)
  251. {
  252. if (e)
  253. {
  254. mClearLock = false;
  255. e->master = 0x0;
  256. e->moveType = worldMoveType_walk; // Walk
  257. e->room = getRoomByLocation(e->pos[0], e->pos[1], e->pos[2]);
  258. mEntities.push_back(e);
  259. }
  260. }
  261. int World::addModel(skeletal_model_t *model)
  262. {
  263. if (model)
  264. {
  265. mClearLock = false;
  266. mModels.push_back(model);
  267. return mModels.size() - 1;
  268. }
  269. return -1;
  270. }
  271. void World::addSprite(sprite_seq_t *sprite)
  272. {
  273. if (sprite)
  274. {
  275. mClearLock = false;
  276. mSprites.push_back(sprite);
  277. }
  278. }
  279. void World::moveEntity(entity_t *e, char movement)
  280. {
  281. const float moved = 180.0f;
  282. const float testd = 220.0f;
  283. const float camHeight = 8.0f;
  284. float x, y, z, pitch, h, floor, ceiling;
  285. int room, sector;
  286. bool wall;
  287. unsigned int roomFlags;
  288. if (!e)
  289. {
  290. return;
  291. }
  292. switch (e->moveType)
  293. {
  294. case worldMoveType_walkNoSwim:
  295. case worldMoveType_walk:
  296. pitch = 0.0f; // in the future pitch could control jump up blocks here
  297. break;
  298. case worldMoveType_noClipping:
  299. case worldMoveType_fly:
  300. case worldMoveType_swim:
  301. pitch = e->angles[2];
  302. break;
  303. }
  304. switch (movement)
  305. {
  306. case 'f':
  307. x = e->pos[0] + (testd * sinf(e->angles[1]));
  308. y = e->pos[1] + (testd * sinf(pitch));
  309. z = e->pos[2] + (testd * cosf(e->angles[1]));
  310. break;
  311. case 'b':
  312. x = e->pos[0] - (testd * sinf(e->angles[1]));
  313. y = e->pos[1] - (testd * sinf(pitch));
  314. z = e->pos[2] - (testd * cosf(e->angles[1]));
  315. break;
  316. case 'l':
  317. x = e->pos[0] - (testd * sinf(e->angles[1] + 90.0f));
  318. y = e->pos[1];
  319. z = e->pos[2] - (testd * cosf(e->angles[1] + 90.0f));
  320. break;
  321. case 'r':
  322. x = e->pos[0] + (testd * sinf(e->angles[1] + 90.0f));
  323. y = e->pos[1];
  324. z = e->pos[2] + (testd * cosf(e->angles[1] + 90.0f));
  325. break;
  326. default:
  327. return;
  328. }
  329. //room = getRoomByLocation(x, y, z);
  330. room = getRoomByLocation(e->room, x, y, z);
  331. if (room == -1) // Will we hit a portal?
  332. {
  333. #define ADJ_ROOM_CHECK
  334. #ifdef ADJ_ROOM_CHECK
  335. room = getAdjoiningRoom(e->room,
  336. e->pos[0], e->pos[1], e->pos[2],
  337. x, y, z);
  338. #else
  339. if (!(mFlags & fEnableHopping))
  340. {
  341. mFlags |= fEnableHopping;
  342. room = getRoomByLocation(e->room, x, y, z);
  343. printf("Hopped\n");
  344. mFlags ^= fEnableHopping;
  345. }
  346. //room = getRoomByLocation(x, y, z);
  347. #endif
  348. if (room > -1)
  349. {
  350. printf("Crossing from room %i to %i\n", e->room, room);
  351. } else {
  352. //! \fixme mRooms, sectors, ... are now std::vector, but often upper bound checks are missing
  353. return;
  354. }
  355. }
  356. roomFlags = getRoomInfo(room);
  357. sector = getSector(room, x, z, &floor, &ceiling);
  358. wall = isWall(room, sector);
  359. // If you're underwater you may want to swim =)
  360. // ...if you're worldMoveType_walkNoSwim, you better hope it's shallow
  361. if (roomFlags & roomFlag_underWater && e->moveType == worldMoveType_walk)
  362. {
  363. e->moveType = worldMoveType_swim;
  364. }
  365. // Don't swim on land
  366. if (!(roomFlags & roomFlag_underWater) && e->moveType == worldMoveType_swim)
  367. {
  368. e->moveType = worldMoveType_walk;
  369. }
  370. // Mongoose 2002.09.02, Add check for room -> room transition
  371. // ( Only allow by movement between rooms by using portals )
  372. if (((e->moveType == worldMoveType_noClipping) ||
  373. (e->moveType == worldMoveType_fly) ||
  374. (e->moveType == worldMoveType_swim)) ||
  375. ((room > -1) && (!wall)))
  376. {
  377. e->room = room;
  378. switch (movement)
  379. {
  380. case 'f':
  381. x = e->pos[0] + (moved * sinf(e->angles[1]));
  382. y = e->pos[1] + (moved * sinf(pitch));
  383. z = e->pos[2] + (moved * cosf(e->angles[1]));
  384. break;
  385. case 'b':
  386. x = e->pos[0] - (moved * sinf(e->angles[1]));
  387. y = e->pos[1] - (moved * sinf(pitch));
  388. z = e->pos[2] - (moved * cosf(e->angles[1]));
  389. break;
  390. case 'l':
  391. x = e->pos[0] - (moved * sinf(e->angles[1] + 90.0f));
  392. z = e->pos[2] - (moved * cosf(e->angles[1] + 90.0f));
  393. break;
  394. case 'r':
  395. x = e->pos[0] + (moved * sinf(e->angles[1] + 90.0f));
  396. z = e->pos[2] + (moved * cosf(e->angles[1] + 90.0f));
  397. break;
  398. }
  399. /*! \fixme Test for vector (move vector) / plane (portal) collision here
  400. * to see if we need to switch rooms... man...
  401. */
  402. h = y;
  403. getHeightAtPosition(room, x, &h, z);
  404. switch (e->moveType)
  405. {
  406. case worldMoveType_fly:
  407. case worldMoveType_swim:
  408. #ifdef DIVE_GAP
  409. // Clips to top of water, waiting for DIVE event
  410. if (h < floor)
  411. e->pos[1] = floor;
  412. else if (h > ceiling)
  413. e->pos[1] = ceiling;
  414. else
  415. e->pos[1] = y;
  416. #endif
  417. // Don't fall out of world, avoid a movement that does
  418. if (h > y - camHeight)
  419. {
  420. e->pos[0] = x;
  421. e->pos[1] = y;
  422. e->pos[2] = z;
  423. }
  424. break;
  425. case worldMoveType_walk:
  426. case worldMoveType_walkNoSwim:
  427. y = e->pos[1]; // Override vector movement walking ( er, not pretty )
  428. // Now fake gravity
  429. // Mongoose 2002.08.14, Remember TR is upside down ( you fall 'up' )
  430. //ddist = h - e->pos[1];
  431. // This is to force false gravity, by making camera stay on ground
  432. e->pos[1] = h; //roomFloor->bbox_min[1];
  433. // Check for camera below terrian and correct
  434. if (e->pos[1] < h - camHeight)
  435. {
  436. e->pos[1] = h - camHeight;
  437. }
  438. e->pos[0] = x;
  439. e->pos[2] = z;
  440. break;
  441. case worldMoveType_noClipping:
  442. e->pos[0] = x;
  443. e->pos[1] = y;
  444. e->pos[2] = z;
  445. }
  446. #ifdef OBSOLETE
  447. m_text->SetString(1,"Room %2i Sector %2i %sPos %.0f %.0f %.0f Yaw %.0f",
  448. room, sector,
  449. wall ? " Wall " : " ",
  450. e->pos[0], e->pos[1], e->pos[2], e->angles[1]);
  451. #endif
  452. }
  453. else
  454. {
  455. e->moving = false;
  456. return;
  457. }
  458. e->room = room;
  459. e->moving = true;
  460. }
  461. ////////////////////////////////////////////////////////////
  462. // Private Accessors
  463. ////////////////////////////////////////////////////////////
  464. ////////////////////////////////////////////////////////////
  465. // Private Mutators
  466. ////////////////////////////////////////////////////////////
  467. void World::clear() {
  468. room_mesh_t *room;
  469. model_mesh_t *mesh;
  470. sprite_seq_t *sprite;
  471. skeletal_model_t *model;
  472. bone_frame_t *boneframe;
  473. bone_tag_t *tag;
  474. animation_frame_t *animation;
  475. std::list<skeletal_model_t *> cache;
  476. mClearLock = true;
  477. for (std::vector<int>::size_type i = 0; i != mEntities.size(); i++)
  478. delete mEntities[i];
  479. mEntities.clear();
  480. for (std::vector<int>::size_type i = 0; i != mRooms.size(); i++) {
  481. room = mRooms[i];
  482. if (room) {
  483. //! \fixme Causes "freeing already freed pointer" exceptions or EXEC_BAD_ACCESS
  484. //for (std::vector<int>::size_type j = 0; j != room->portals.size(); j++)
  485. // delete room->portals[i];
  486. room->portals.clear();
  487. //for (std::vector<int>::size_type j = 0; j != room->models.size(); j++)
  488. // delete room->models[i];
  489. room->models.clear();
  490. //for (std::vector<int>::size_type j = 0; j != room->sprites.size(); j++)
  491. // delete room->sprites[i];
  492. room->sprites.clear();
  493. //for (std::vector<int>::size_type j = 0; j != room->sectors.size(); j++)
  494. // delete room->sectors[i];
  495. room->sectors.clear();
  496. //for (std::vector<int>::size_type j = 0; j != room->boxes.size(); j++)
  497. // delete room->boxes[i];
  498. room->boxes.clear();
  499. delete room;
  500. }
  501. }
  502. for (std::vector<int>::size_type i = 0; i != mMeshes.size(); i++) {
  503. mesh = mMeshes[i];
  504. if (!mesh)
  505. continue;
  506. for (std::vector<int>::size_type j = 0; j != mesh->texturedTriangles.size(); j++) {
  507. if (mesh->texturedTriangles[j])
  508. delete mesh->texturedTriangles[j];
  509. }
  510. for (std::vector<int>::size_type j = 0; j != mesh->coloredTriangles.size(); j++) {
  511. if (mesh->coloredTriangles[j])
  512. delete mesh->coloredTriangles[j];
  513. }
  514. for (std::vector<int>::size_type j = 0; j != mesh->texturedRectangles.size(); j++) {
  515. if (mesh->texturedRectangles[j])
  516. delete mesh->texturedRectangles[j];
  517. }
  518. for (std::vector<int>::size_type j = 0; j != mesh->coloredRectangles.size(); j++) {
  519. if (mesh->coloredRectangles[j])
  520. delete mesh->coloredRectangles[j];
  521. }
  522. if (mesh->vertices)
  523. delete [] mesh->vertices;
  524. if (mesh->colors)
  525. delete [] mesh->colors;
  526. if (mesh->normals)
  527. delete [] mesh->normals;
  528. delete mesh;
  529. }
  530. mMeshes.clear();
  531. for (std::vector<int>::size_type i = 0; i != mSprites.size(); i++) {
  532. sprite = mSprites[i];
  533. if (!sprite)
  534. continue;
  535. if (sprite->sprite)
  536. delete [] sprite->sprite;
  537. delete sprite;
  538. }
  539. mSprites.clear();
  540. for (std::vector<int>::size_type i = 0; i != mModels.size(); i++) {
  541. model = mModels[i];
  542. if (!model)
  543. continue;
  544. // No smart pointers, so skip if deleted once =)
  545. bool found = false;
  546. for (std::list<skeletal_model_t *>::const_iterator iterator = cache.begin(), end = cache.end(); iterator != end; ++iterator) {
  547. if (model == *iterator) {
  548. found = true;
  549. break;
  550. }
  551. }
  552. if (!found)
  553. cache.push_back(model);
  554. else
  555. continue;
  556. for (std::vector<int>::size_type j = 0; j != model->animation.size(); j++) {
  557. animation = model->animation[j];
  558. if (!animation)
  559. continue;
  560. for (std::vector<int>::size_type k = 0; k != animation->frame.size(); k++) {
  561. boneframe = animation->frame[k];
  562. if (!boneframe)
  563. continue;
  564. for (std::vector<int>::size_type l = 0; l != boneframe->tag.size(); l++) {
  565. tag = boneframe->tag[l];
  566. if (!tag)
  567. continue;
  568. delete tag;
  569. }
  570. delete boneframe;
  571. }
  572. delete animation;
  573. }
  574. delete model;
  575. }
  576. mModels.clear();
  577. }