Kam3D.cpp 8.3 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325
  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. {
  14. openingAngle = (float)PI / 4;
  15. minZ = 0.1f;
  16. maxZ = 5000;
  17. pos = Vec3< float >( 0, 0, -1000 );
  18. rotX = 0;
  19. rotY = 0;
  20. rotZ = 0;
  21. viewport.x = 0;
  22. viewport.y = 0;
  23. viewport.front = 0.f;
  24. viewport.back = 1.f;
  25. viewport.width = 200;
  26. viewport.height = 200;
  27. welt = 0;
  28. style = 0;
  29. ref = 1;
  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( abs( 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. if( hatStyle( Style::Rotatable ) )
  163. {
  164. if( getTastenStand( T_Oben ) )
  165. rotX -= (float)tv;
  166. if( getTastenStand( T_Unten ) )
  167. rotX += (float)tv;
  168. if( getTastenStand( T_Links ) )
  169. rotY -= (float)tv;
  170. if( getTastenStand( T_Rechts ) )
  171. rotY += (float)tv;
  172. }
  173. if( hatStyle( Style::Movable ) )
  174. {
  175. Vec3< float > n( 0, 0, 1 );
  176. Vec3< float > n2( 1, 0, 0 );
  177. Vec3< float > n3( 0, 1, 0 );
  178. Mat4< float > tmp = tmp.rotationY( rotY ) * tmp.rotationX( rotX );
  179. n = tmp * n;
  180. n = n * (float)tv * 60;
  181. n2 = tmp * n2;
  182. n2 = n2 * (float)tv * 60;
  183. n3 = tmp * n3;
  184. n3 = n3 * (float)tv * 60;
  185. if( getTastenStand( 'w' ) )
  186. pos += n;
  187. if( getTastenStand( 's' ) )
  188. pos -= n;
  189. if( getTastenStand( 'd' ) )
  190. pos += n2;
  191. if( getTastenStand( 'a' ) )
  192. pos -= n2;
  193. if( getTastenStand( ' ' ) )
  194. pos += n3;
  195. if( getTastenStand( T_Shift ) )
  196. pos -= n3;
  197. }
  198. updateMatrix();
  199. if( welt && hatStyle( Style::Tick ) )
  200. return welt->tick( tv );
  201. return 0;
  202. }
  203. // Verarbeitet ein Mausereignis
  204. // me: Das Mausereignis, das verarbeitet werden soll
  205. void Kam3D::doMausEreignis( MausEreignis &me )
  206. {
  207. if( me.verarbeitet )
  208. return;
  209. if( me.mx > viewport.x && me.my > viewport.y && me.mx < viewport.x + viewport.width && me.my < viewport.y + viewport.height )
  210. {
  211. MausEreignis3D me3d;
  212. me3d.id = me.id;
  213. me3d.verarbeitet = me.verarbeitet;
  214. Vec3< float > mausP = Vec3< float >( ( me.mx - viewport.x ) / ( 0.5f * viewport.width ) - 1, ( me.my - viewport.y ) / ( 0.5f * viewport.height ) - 1, 0 );
  215. Vec3< float > mausT = Vec3< float >( mausP.x, mausP.y, 1 );
  216. Mat4< float > mat = proj * view;
  217. mat = mat.getInverse();
  218. mausP = mat * mausP;
  219. mausT = mat * mausT;
  220. me3d.pos = mausP;
  221. me3d.dir = mausT - mausP;
  222. me.verarbeitet = 1;
  223. }
  224. }
  225. // Verarbeitet ein Tastaturereignis
  226. // te: das Tastaturereignis, das verarbeitet werden soll
  227. void Kam3D::doTastaturEreignis( TastaturEreignis &te )
  228. {
  229. }
  230. // Gibt zurück, ob bestimmte Styles gesetzt wurden
  231. // style: Die Styles, die überprüft werden sollen
  232. // return: 1, falls alle Styles in style gesetzt wurden
  233. bool Kam3D::hatStyle( __int64 style ) const
  234. {
  235. return ( this->style | style ) == this->style;
  236. }
  237. // Gibt zurück, ob bestimmte Styles nicht gesetzt wurden
  238. // style: Die Styles, die geprüft werden sollen
  239. // return: 1, falls alle Styles in style nicht gesetzt wurden
  240. bool Kam3D::hatStyleNicht( __int64 style ) const
  241. {
  242. return ( this->style | style ) != this->style;
  243. }
  244. // Gibt einen Zeiger auf den Viewport zurück
  245. const ViewPort *Kam3D::zViewPort() const
  246. {
  247. return &viewport;
  248. }
  249. // Gibt die Position der Kamera in der Welt zurück
  250. const Vec3< float > &Kam3D::getWorldPosition() const
  251. {
  252. return pos;
  253. }
  254. // Gibt die Projektionsmatrix der Kamera zurück
  255. const Mat4< float > &Kam3D::getProjectionMatrix() const
  256. {
  257. return proj;
  258. }
  259. // Gibt die Ansichtsmatrix der Kamera zurück
  260. const Mat4< float > &Kam3D::getViewMatrix() const
  261. {
  262. return view;
  263. }
  264. // Gibt die Welt zurück
  265. Welt3D *Kam3D::getWelt() const
  266. {
  267. return welt ? welt->getThis() : 0;
  268. }
  269. // Gibt die Welt zurück
  270. Welt3D *Kam3D::zWelt() const
  271. {
  272. return welt;
  273. }
  274. // Erhöht den Reference Counter um 1
  275. // Return: Ein zeiger auf diesen Shader
  276. Kam3D *Kam3D::getThis()
  277. {
  278. ref++;
  279. return this;
  280. }
  281. // Verringert den Reference Counter und löscht den Shader, falls der Refeence Counter auf 0 ist
  282. // Return: 0
  283. Kam3D *Kam3D::release()
  284. {
  285. ref--;
  286. if( !ref )
  287. delete this;
  288. return 0;
  289. }