Kam3D.cpp 11 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425
  1. #include "Kam3D.h"
  2. #include <d3d11.h>
  3. #include <DirectXMath.h>
  4. #include "Globals.h"
  5. #include "MausEreignis.h"
  6. #include "Shader.h"
  7. #include "TastaturEreignis.h"
  8. #include "Welt3D.h"
  9. using namespace Framework;
  10. // Inhalt der Kam3D Klasse
  11. // Konstruktor
  12. Kam3D::Kam3D()
  13. : ReferenceCounter(),
  14. rend(0)
  15. {
  16. openingAngle = (float)PI / 4;
  17. minZ = 0.1f;
  18. maxZ = 5000;
  19. pos = Vec3<float>(0, 0, -1000);
  20. rotX = 0;
  21. rotY = 0;
  22. rotZ = 0;
  23. viewport.x = 0;
  24. viewport.y = 0;
  25. viewport.front = 0.f;
  26. viewport.back = 1.f;
  27. viewport.width = 200;
  28. viewport.height = 200;
  29. welt = 0;
  30. style = 0;
  31. speed = 1;
  32. updateMatrix();
  33. }
  34. // Destruktor
  35. Kam3D::~Kam3D()
  36. {
  37. if (welt) welt->release();
  38. }
  39. // private
  40. // Aktualisiert die view und projektion matrizen
  41. void Kam3D::updateMatrix()
  42. {
  43. view = view.rotationX(-rotX) * view.rotationY(-rotY) * view.rotationZ(-rotZ)
  44. * view.translation(Vec3<float>(-pos.x, -pos.y, -pos.z));
  45. proj = proj.projektion(
  46. openingAngle, viewport.width / viewport.height, minZ, maxZ);
  47. }
  48. // Setzt die Position der Kamera in der 3D Welt
  49. void Kam3D::setPosition(Vec3<float> pos)
  50. {
  51. this->pos = pos;
  52. rend = 1;
  53. updateMatrix();
  54. }
  55. // zoomt heran, indem sich die Kamera etwas auf das Blickziel zubewegt
  56. // val: Die länge der Strecke um die sich die Kamera bewegen soll
  57. void Kam3D::scrollIn(float val)
  58. {
  59. Vec3<float> n(0, 0, 1);
  60. Mat4<float> tmp
  61. = tmp.rotationY(rotY) * tmp.rotationX(rotX) * tmp.rotationZ(rotZ);
  62. n = tmp * n * val;
  63. pos += n;
  64. rend = 1;
  65. updateMatrix();
  66. }
  67. // zppmt heraus, indem sich die Kamera etwas von dem Blockziel entfernt
  68. // val: Die länge der Strecke um die sich die Kamera bewegen soll
  69. void Kam3D::scrollOut(float val)
  70. {
  71. Vec3<float> n(0, 0, 1);
  72. Mat4<float> tmp
  73. = tmp.rotationY(rotY) * tmp.rotationX(rotX) * tmp.rotationZ(rotZ);
  74. n = tmp * n * val;
  75. pos -= n;
  76. rend = 1;
  77. updateMatrix();
  78. }
  79. // Richtet die Kamera so aus, dass sie genau auf einen bestimmten Punkt zeigt
  80. // ziel: Der Punkt, auf den die Kamera zeigen soll
  81. void Kam3D::setAusrichtung(Vec3<float> ziel)
  82. {
  83. Vec3<float> target = (ziel - pos).normalize();
  84. if (Vec3<float>(0, target.y, target.z).getLength() == 0)
  85. rotX = 0;
  86. else
  87. rotX = -lowPrecisionACos(
  88. target.z / Vec3<float>(0, target.y, target.z).getLength());
  89. if (target.y < 0) rotX = -rotX;
  90. if (Vec3<float>(target.x, 0, target.z).getLength() == 0)
  91. rotY = 0;
  92. else
  93. rotY = lowPrecisionACos(
  94. abs(target.z) / Vec3<float>(target.x, 0, target.z).getLength());
  95. if (target.x < 0) rotY = -rotY;
  96. rotZ = 0;
  97. rend = 1;
  98. updateMatrix();
  99. }
  100. //! Legt die Drehung der Kamera um die einzelnen Axen fest
  101. //! \param rotation Die Drehung um die einzelnen Axen
  102. void Kam3D::setRotation(Vec3<float> rotation)
  103. {
  104. rotX = rotation.x;
  105. rotY = rotation.y;
  106. rotZ = rotation.z;
  107. rend = 1;
  108. updateMatrix();
  109. }
  110. // Setzt die Position des Bildes auf dem Bildschirm
  111. // p: Ein Punkt mit x und y Koordinaten in Pixeln
  112. void Kam3D::setBildschirmPosition(Punkt p)
  113. {
  114. viewport.x = (float)p.x;
  115. viewport.y = (float)p.y;
  116. }
  117. // Setzt die Position des Bildes auf dem Bildschirm
  118. // x: Die x Koordinate in Pixeln
  119. // y: Die y Koordinate in Pixeln
  120. void Kam3D::setBildschirmPosition(int x, int y)
  121. {
  122. viewport.x = (float)x;
  123. viewport.y = (float)y;
  124. }
  125. // Setzt die Größe des Bildes auf dem Bildschirm
  126. // p: Ein Punkt, mit x als Breite und y als Höhe in Pixlen
  127. void Kam3D::setBildschirmSize(Punkt p)
  128. {
  129. viewport.width = (float)p.x;
  130. viewport.height = (float)p.y;
  131. updateMatrix();
  132. }
  133. // Setzt die Größe des Bildes auf dem Bildschirm
  134. // br: Die Breite in Pixeln
  135. // hö: Die Höhe in Pixeln
  136. void Kam3D::setBildschirmSize(int br, int hö)
  137. {
  138. viewport.width = (float)br;
  139. viewport.height = (float)hö;
  140. updateMatrix();
  141. }
  142. // Setzt die Welt, die gezeichnet werden soll
  143. // w: Die Welt
  144. void Kam3D::setWelt(Welt3D* w)
  145. {
  146. if (welt) welt->release();
  147. welt = w;
  148. }
  149. // Setzt den Style der Kamera
  150. // style: Der neue Style bestehend aus den Flags aus der zugehörigen Style
  151. // Klasse
  152. void Kam3D::setStyle(__int64 style)
  153. {
  154. this->style = style;
  155. }
  156. // Setzt den Style der Kamera
  157. // style: Alle Style Flags, die verändert werden sollen
  158. // add_remove: 1, falls der Style hinzugefügt werden soll. 0, falls der Style
  159. // entfernt weden soll
  160. void Kam3D::setStyle(__int64 style, bool add_remove)
  161. {
  162. if (add_remove)
  163. this->style |= style;
  164. else if (!add_remove)
  165. this->style &= ~style;
  166. }
  167. // Fügt Style Flags hinzu
  168. // style: Der Style, der hinzugefügt werden soll
  169. void Kam3D::addStyle(__int64 style)
  170. {
  171. this->style |= style;
  172. }
  173. // Entfernt Style Flags
  174. // style: Der Style, der entfernt werden soll
  175. void Kam3D::removeStyle(__int64 style)
  176. {
  177. this->style &= ~style;
  178. }
  179. //! Set the movement speed per second if the camera has style Movable
  180. void Kam3D::setMovementSpeed(float speed)
  181. {
  182. this->speed = speed;
  183. }
  184. // Verarbeitet die vergangene Zeit
  185. // tickval: Die zeit in sekunden, die seit dem letzten Aufruf der Funktion
  186. // vergangen ist return: true, wenn sich das Bild neu gezeichnet werden muss,
  187. // false sonnst.
  188. bool Kam3D::tick(double tv)
  189. {
  190. bool ret = rend;
  191. rend = 0;
  192. if (hatStyle(Style::Rotatable))
  193. {
  194. if (getTastenStand(T_Oben))
  195. {
  196. rotX -= (float)tv;
  197. ret = 1;
  198. }
  199. if (getTastenStand(T_Unten))
  200. {
  201. rotX += (float)tv;
  202. ret = 1;
  203. }
  204. if (getTastenStand(T_Links))
  205. {
  206. rotY -= (float)tv;
  207. ret = 1;
  208. }
  209. if (getTastenStand(T_Rechts))
  210. {
  211. rotY += (float)tv;
  212. ret = 1;
  213. }
  214. }
  215. if (hatStyle(Style::Movable))
  216. {
  217. Vec3<float> n(0, 0, 1);
  218. Vec3<float> n2(1, 0, 0);
  219. Vec3<float> n3(0, 1, 0);
  220. Mat4<float> tmp = tmp.rotationY(rotY) * tmp.rotationX(rotX);
  221. n = tmp * n;
  222. n = n * (float)tv * speed;
  223. n2 = tmp * n2;
  224. n2 = n2 * (float)tv * speed;
  225. n3 = tmp * n3;
  226. n3 = n3 * (float)tv * speed;
  227. if (getTastenStand('W'))
  228. {
  229. pos += n;
  230. ret = 1;
  231. }
  232. if (getTastenStand('S'))
  233. {
  234. pos -= n;
  235. ret = 1;
  236. }
  237. if (getTastenStand('D'))
  238. {
  239. pos += n2;
  240. ret = 1;
  241. }
  242. if (getTastenStand('A'))
  243. {
  244. pos -= n2;
  245. ret = 1;
  246. }
  247. if (getTastenStand(' '))
  248. {
  249. pos += n3;
  250. ret = 1;
  251. }
  252. if (getTastenStand(T_Shift))
  253. {
  254. pos -= n3;
  255. ret = 1;
  256. }
  257. }
  258. updateMatrix();
  259. if (welt && hatStyle(Style::Tick)) return welt->tick(tv) || ret;
  260. return ret;
  261. }
  262. // Verarbeitet ein Mausereignis
  263. // me: Das Mausereignis, das verarbeitet werden soll
  264. void Kam3D::doMausEreignis(MausEreignis& me)
  265. {
  266. if (me.verarbeitet) return;
  267. if (me.mx > viewport.x && me.my > viewport.y
  268. && me.mx < viewport.x + viewport.width
  269. && me.my < viewport.y + viewport.height)
  270. {
  271. MausEreignis3D me3d;
  272. me3d.id = me.id;
  273. me3d.verarbeitet = me.verarbeitet;
  274. Vec3<float> mausP
  275. = Vec3<float>((me.mx - viewport.x) / (0.5f * viewport.width) - 1,
  276. (me.my - viewport.y) / (0.5f * viewport.height) - 1,
  277. 0);
  278. Vec3<float> mausT = Vec3<float>(mausP.x, mausP.y, 1);
  279. Mat4<float> mat = proj * view;
  280. mat = mat.getInverse();
  281. mausP = mat * mausP;
  282. mausT = mat * mausT;
  283. me3d.pos = mausP;
  284. me3d.dir = mausT - mausP;
  285. me.verarbeitet = 1;
  286. }
  287. }
  288. // Verarbeitet ein Tastaturereignis
  289. // te: das Tastaturereignis, das verarbeitet werden soll
  290. void Kam3D::doTastaturEreignis(TastaturEreignis& te) {}
  291. // Gibt zurück, ob bestimmte Styles gesetzt wurden
  292. // style: Die Styles, die überprüft werden sollen
  293. // return: 1, falls alle Styles in style gesetzt wurden
  294. bool Kam3D::hatStyle(__int64 style) const
  295. {
  296. return (this->style | style) == this->style;
  297. }
  298. // Gibt zurück, ob bestimmte Styles nicht gesetzt wurden
  299. // style: Die Styles, die geprüft werden sollen
  300. // return: 1, falls alle Styles in style nicht gesetzt wurden
  301. bool Kam3D::hatStyleNicht(__int64 style) const
  302. {
  303. return (this->style | style) != this->style;
  304. }
  305. // Gibt einen Zeiger auf den Viewport zurück
  306. const ViewPort* Kam3D::zViewPort() const
  307. {
  308. return &viewport;
  309. }
  310. // Gibt die Position der Kamera in der Welt zurück
  311. const Vec3<float>& Kam3D::getWorldPosition() const
  312. {
  313. return pos;
  314. }
  315. // Gibt die Position in der Welt zurück
  316. // screen: die Position auf dem Bildschirm, die übersetzt werden soll
  317. const Vec3<float> Kam3D::getWorldPosition(Punkt screen) const
  318. {
  319. Vec3<float> point = Vec3<float>(
  320. (screen.x - viewport.x) / (0.5f * viewport.width) - 1,
  321. (viewport.height - (screen.y - viewport.y)) / (0.5f * viewport.height)
  322. - 1,
  323. 0.1f);
  324. Mat4<float> mat = getProjectionMatrix();
  325. Mat4<float> inv = getViewMatrix().getInverse();
  326. point.x = (point.x * 0.1f) / mat.elements[0][0];
  327. point.y = (point.y * 0.1f) / mat.elements[1][1];
  328. return inv * point;
  329. }
  330. // Gibt die Richtung der Kamera in der Welt zurück
  331. // screen: die Position auf dem Bildschirm, die übersetzt werden soll
  332. const Vec3<float> Kam3D::getWorldDirection(Punkt screen) const
  333. {
  334. Vec3<float> point = Vec3<float>(
  335. (screen.x - viewport.x) / (0.5f * viewport.width) - 1,
  336. (viewport.height - (screen.y - viewport.y)) / (0.5f * viewport.height)
  337. - 1,
  338. 0.1f);
  339. Vec3<float> pointT = Vec3<float>(point.x, point.y, 1);
  340. Mat4<float> mat = getProjectionMatrix();
  341. Mat4<float> inv = getViewMatrix().getInverse();
  342. point.x = (point.x * 0.1f) / mat.elements[0][0];
  343. point.y = (point.y * 0.1f) / mat.elements[1][1];
  344. pointT.x = (pointT.x) / mat.elements[0][0];
  345. pointT.y = (pointT.y) / mat.elements[1][1];
  346. point = inv * point;
  347. pointT = inv * pointT;
  348. return pointT - point;
  349. }
  350. // Gibt die Projektionsmatrix der Kamera zurück
  351. const Mat4<float>& Kam3D::getProjectionMatrix() const
  352. {
  353. return proj;
  354. }
  355. // Gibt die Ansichtsmatrix der Kamera zurück
  356. const Mat4<float>& Kam3D::getViewMatrix() const
  357. {
  358. return view;
  359. }
  360. //! Gibt die Rotation um die einzelnen axen zurück
  361. const Vec3<float> Kam3D::getRotation() const
  362. {
  363. return {rotX, rotY, rotZ};
  364. }
  365. //! Gibt die Position der Kamera auf dem Bildschirm zurück
  366. const Punkt Kam3D::getScreenPos() const
  367. {
  368. return Punkt((int)viewport.x, (int)viewport.y);
  369. }
  370. //! Gibt die Größe der Kamera auf dem Bildschirm zurück
  371. const Punkt Kam3D::getScreenSize() const
  372. {
  373. return Punkt((int)viewport.width, (int)viewport.height);
  374. }
  375. // Gibt die Welt zurück
  376. Welt3D* Kam3D::getWelt() const
  377. {
  378. return welt ? dynamic_cast<Welt3D*>(welt->getThis()) : 0;
  379. }
  380. // Gibt die Welt zurück
  381. Welt3D* Kam3D::zWelt() const
  382. {
  383. return welt;
  384. }