Open Source Tomb Raider Engine
Vous ne pouvez pas sélectionner plus de 25 sujets Les noms de sujets doivent commencer par une lettre ou un nombre, peuvent contenir des tirets ('-') et peuvent comporter jusqu'à 35 caractères.

Camera.cpp 7.1KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352
  1. /*!
  2. * \file src/Camera.cpp
  3. * \brief OpenGL camera class
  4. *
  5. * \author Mongoose
  6. */
  7. #include <stdio.h>
  8. #include <math.h>
  9. #include "utils/math.h"
  10. #include "Camera.h"
  11. unsigned int Camera::mCounter = 0;
  12. ////////////////////////////////////////////////////////////
  13. // Constructors
  14. ////////////////////////////////////////////////////////////
  15. Camera::Camera()
  16. {
  17. mId = ++mCounter;
  18. mFlags = 0;
  19. mViewDistance = 14.0f;
  20. mTranslateDelta = 256.0f;
  21. mRotateDelta = HEL_DEG_TO_RAD(15.0f);
  22. mRotateDelta2 = HEL_DEG_TO_RAD(5.0f);
  23. mFlags &= Camera_FlyMode;
  24. reset();
  25. }
  26. Camera::~Camera()
  27. {
  28. }
  29. ////////////////////////////////////////////////////////////
  30. // Public Accessors
  31. ////////////////////////////////////////////////////////////
  32. unsigned int Camera::getId()
  33. {
  34. return mId;
  35. }
  36. void Camera::getPosition(vec3_t pos)
  37. {
  38. pos[0] = mPos[0];
  39. pos[1] = mPos[1];
  40. pos[2] = mPos[2];
  41. }
  42. void Camera::getUp(vec3_t up)
  43. {
  44. up[0] = mUp[0];
  45. up[1] = mUp[1];
  46. up[2] = mUp[2];
  47. }
  48. void Camera::getTarget(vec3_t target)
  49. {
  50. target[0] = mTarget[0];
  51. target[1] = mTarget[1];
  52. target[2] = mTarget[2];
  53. }
  54. float Camera::getYaw()
  55. {
  56. return HEL_RAD_TO_DEG(mTheta);
  57. }
  58. vec_t Camera::getRadianYaw()
  59. {
  60. return mTheta;
  61. }
  62. vec_t Camera::getRadianPitch()
  63. {
  64. return mTheta2;
  65. }
  66. ////////////////////////////////////////////////////////////
  67. // Public Mutators
  68. ////////////////////////////////////////////////////////////
  69. void Camera::rotate(float angle, float x, float y, float z)
  70. {
  71. Quaternion t, n;
  72. Matrix matrix;
  73. vec_t side[4] = { 1.0f, 0.0f, 0.0f, 1.0f };
  74. vec_t up[4] = { 0.0f, 1.0f, 0.0f, 1.0f };
  75. vec_t look[4] = { 0.0f, 0.0f, -1.0f, 1.0f };
  76. unsigned int i;
  77. matrix_t m;
  78. t.set(angle, x, y, z);
  79. n = mQ * t;
  80. n.normalize();
  81. n.getMatrix(m);
  82. matrix.setMatrix(m);
  83. matrix.multiply4v(side, mSide);
  84. matrix.multiply4v(look, mTarget);
  85. matrix.multiply4v(up, mUp);
  86. for (i = 0; i < 3; ++i)
  87. {
  88. mSide[i] += mPos[i];
  89. mTarget[i] += mPos[i];
  90. mUp[i] += mPos[i];
  91. }
  92. mQ = n;
  93. }
  94. void Camera::translate(float x, float y, float z)
  95. {
  96. int i;
  97. vec_t result[4];
  98. vec_t v[4];
  99. matrix_t m;
  100. Matrix matrix;
  101. v[0] = x;
  102. v[1] = y;
  103. v[2] = -z;
  104. v[3] = 1;
  105. m[0] = mSide[0] - mPos[0];
  106. m[1] = mUp[0] - mPos[0];
  107. m[2] = mTarget[0] - mPos[0];
  108. m[3] = 0;
  109. m[4] = mSide[1] - mPos[1];
  110. m[5] = mUp[1] - mPos[1];
  111. m[6] = mTarget[1] - mPos[1];
  112. m[7] = 0;
  113. m[8] = mSide[2] - mPos[2];
  114. m[9] = mUp[2] - mPos[2];
  115. m[10] = mTarget[2] - mPos[2];
  116. m[11] = 0;
  117. m[12] = 0;
  118. m[13] = 0;
  119. m[14] = 0;
  120. m[15] = 1;
  121. matrix.setMatrix(m);
  122. matrix.multiply4v(v, result);
  123. for (i = 0; i < 3; ++i)
  124. {
  125. mSide[i] += result[i];
  126. mUp[i] += result[i];
  127. mTarget[i] += result[i];
  128. mPos[i] += result[i];
  129. }
  130. mPos[0] = x;
  131. mPos[1] = y;
  132. mPos[2] = z;
  133. }
  134. void Camera::reset()
  135. {
  136. mTheta = 0.0f;
  137. mTheta2 = 0.0f;
  138. mPos[0] = 0.0f;
  139. mPos[1] = 0.0f;
  140. mPos[2] = 0.0f;
  141. mTarget[0] = 0.0f;
  142. mTarget[1] = 0.0f;
  143. mTarget[2] = mViewDistance;
  144. mSide[0] = 1.0f;
  145. mSide[1] = 0.0f;
  146. mSide[2] = 0.0f;
  147. mUp[0] = 0.0f;
  148. mUp[1] = 1.0f;
  149. mUp[2] = 0.0f;
  150. mQ.setIdentity();
  151. translate(0.0f, 0.0f, 0.0f);
  152. }
  153. void Camera::setSensitivityY(float angle)
  154. {
  155. mRotateDelta2 = HEL_DEG_TO_RAD(angle);
  156. }
  157. void Camera::setSensitivityX(float angle)
  158. {
  159. mRotateDelta = HEL_DEG_TO_RAD(angle);
  160. }
  161. ////////
  162. void Camera::command(enum camera_command cmd)
  163. {
  164. switch (cmd)
  165. {
  166. case CAMERA_MOVE_FORWARD:
  167. if (mFlags & Camera_FlyMode)
  168. {
  169. mPos[2] += (mTranslateDelta * cosf(mTheta));
  170. }
  171. mPos[0] += (mTranslateDelta * sinf(mTheta));
  172. mPos[1] += (mTranslateDelta * sinf(mTheta2));
  173. break;
  174. case CAMERA_MOVE_BACKWARD:
  175. if (mFlags & Camera_FlyMode)
  176. {
  177. mPos[2] -= (mTranslateDelta * cosf(mTheta));
  178. }
  179. mPos[0] -= (mTranslateDelta * sinf(mTheta));
  180. mPos[1] -= (mTranslateDelta * sinf(mTheta2));
  181. break;
  182. case CAMERA_MOVE_LEFT:
  183. mPos[0] -= (mTranslateDelta * sinf(mTheta - 90.0f));
  184. mPos[2] -= (mTranslateDelta * cosf(mTheta - 90.0f));
  185. break;
  186. case CAMERA_MOVE_RIGHT:
  187. mPos[0] -= (mTranslateDelta * sinf(mTheta + 90.0f));
  188. mPos[2] -= (mTranslateDelta * cosf(mTheta + 90.0f));
  189. break;
  190. case CAMERA_ROTATE_UP:
  191. if (mTheta2 < (M_PI / 2)) {
  192. mTheta2 += mRotateDelta2;
  193. rotate(mTheta2, 1.0f, 0.0f, 0.0f);
  194. }
  195. break;
  196. case CAMERA_ROTATE_DOWN:
  197. if (mTheta2 > -(M_PI / 2)) {
  198. mTheta2 -= mRotateDelta2;
  199. rotate(mTheta2, 1.0f, 0.0f, 0.0f);
  200. }
  201. break;
  202. case CAMERA_ROTATE_RIGHT:
  203. mTheta += mRotateDelta;
  204. rotate(mTheta, 0.0f, 1.0f, 0.0f);
  205. break;
  206. case CAMERA_ROTATE_LEFT:
  207. mTheta -= mRotateDelta;
  208. rotate(mTheta, 0.0f, 1.0f, 0.0f);
  209. break;
  210. case CAMERA_MOVE_UP:
  211. mPos[1] -= mTranslateDelta / 2.0f;
  212. mTarget[1] -= mTranslateDelta / 2.0f;
  213. break;
  214. case CAMERA_MOVE_DOWN:
  215. mPos[1] += mTranslateDelta / 2.0f;
  216. mTarget[1] += mTranslateDelta / 2.0f;
  217. break;
  218. case CAMERA_SPEED_UP:
  219. ++mTranslateDelta;
  220. break;
  221. case CAMERA_SPEED_DOWN:
  222. if (--mTranslateDelta < 0.0f)
  223. mTranslateDelta = 1.0f;
  224. break;
  225. }
  226. }
  227. //! \fixme Mostly invalid for QUAT_CAM (can rotate on XYZ)
  228. bool Camera::isBehind(int x, int z)
  229. {
  230. vec_t bTheta, bCameraX, bCameraZ, Distance;
  231. // Set up a "virtual camera" a huge distance behind us
  232. bTheta = mTheta + HEL_PI;
  233. if (bTheta > HEL_PI)
  234. bTheta -= HEL_2_PI;
  235. // 64k is a fair distance away...
  236. bCameraX = (65536.0f * sinf(bTheta)) + mPos[0];
  237. bCameraZ = (65536.0f * cosf(bTheta)) + mPos[2];
  238. bCameraX -= x;
  239. bCameraZ -= z;
  240. Distance = sqrtf((bCameraX * bCameraX) + (bCameraZ * bCameraZ));
  241. return (Distance < 65536.0f);
  242. }
  243. void Camera::setSpeed(float s)
  244. {
  245. mTranslateDelta = s;
  246. }
  247. void Camera::update()
  248. {
  249. mTarget[2] = (mViewDistance * cosf(mTheta)) + mPos[2];
  250. mTarget[0] = (mViewDistance * sinf(mTheta)) + mPos[0];
  251. mTarget[1] = (mViewDistance * sinf(mTheta2)) + mPos[1]; // + height_offset;
  252. }
  253. void Camera::setPosition(vec3_t pos)
  254. {
  255. mPos[0] = pos[0];
  256. mPos[1] = pos[1];
  257. mPos[2] = pos[2];
  258. }
  259. void Camera::setUp(vec3_t up)
  260. {
  261. mUp[0] = up[0];
  262. mUp[1] = up[1];
  263. mUp[2] = up[2];
  264. }
  265. void Camera::setTarget(vec3_t target)
  266. {
  267. mTarget[0] = target[0];
  268. mTarget[1] = target[1];
  269. mTarget[2] = target[2];
  270. }
  271. ////////////////////////////////////////////////////////////
  272. // Private Accessors
  273. ////////////////////////////////////////////////////////////
  274. ////////////////////////////////////////////////////////////
  275. // Private Mutators
  276. ////////////////////////////////////////////////////////////