Kam3D.cpp 9.9 KB

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