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.

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