Kam3D.cpp 10 KB

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