Bildschirm.cpp 13 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559
  1. #include "Bildschirm.h"
  2. #include "Bild.h"
  3. #include "Fenster.h"
  4. #include "Text.h"
  5. #include "Zeichnung.h"
  6. #include "Globals.h"
  7. #include "Zeit.h"
  8. #include "ToolTip.h"
  9. #include "MausEreignis.h"
  10. #include <iostream>
  11. #include "Datei.h"
  12. #include "Mat3.h"
  13. #include "Model3D.h"
  14. #include "GraphicsApi.h"
  15. #ifdef WIN32
  16. #include "Kam3D.h"
  17. #include <DirectXMath.h>
  18. #include <D3Dcompiler.h>
  19. #include <d3d11.h>
  20. #include <d3d9.h>
  21. #include "comdef.h"
  22. #endif
  23. using namespace Framework;
  24. // Inhalt der Bildschirmklass aus Bildschirm.h
  25. // Konstruktor
  26. Bildschirm::Bildschirm( WFenster *f )
  27. : ReferenceCounter(),
  28. api( 0 ),
  29. fenster( f ),
  30. members( new RCArray<Zeichnung>() ),
  31. fillColor( 0xFF000000 ),
  32. deckFarbe( 0 ),
  33. onTop( 0 ),
  34. renderOnTop( 0 ),
  35. renderZeichnungen( 1 ),
  36. rendering( 0 ),
  37. renderZeit( new ZeitMesser() ),
  38. tips( new RCArray< ToolTip >() ),
  39. tipAnzahl( 0 ),
  40. testRend( 1 ),
  41. fill( 1 ),
  42. rend( 0 )
  43. {}
  44. // Destruktor
  45. Bildschirm::~Bildschirm()
  46. {
  47. lock();
  48. #ifdef WIN32
  49. if( fenster )
  50. fenster->release();
  51. #endif
  52. members->release();
  53. tipAnzahl = 0;
  54. tips->release();
  55. renderZeit->release();
  56. if( onTop )
  57. onTop->release();
  58. if( api )
  59. api->release();
  60. unlock();
  61. }
  62. // nicht konstant
  63. void Bildschirm::lock()
  64. {
  65. cs.lock();
  66. }
  67. void Bildschirm::unlock()
  68. {
  69. cs.unlock();
  70. }
  71. void Bildschirm::setFill( bool f )
  72. {
  73. fill = f;
  74. }
  75. // Aktualisiert die Objekte, mit der die Grafikkarte verwaltet wird
  76. void Bildschirm::update()
  77. {
  78. lock();
  79. api->update();
  80. unlock();
  81. }
  82. void Bildschirm::setTestRend( bool tr ) // legt fest, ob vo rendern auf updates geprüft werden soll
  83. {
  84. testRend = tr;
  85. }
  86. void Bildschirm::setRenderZeichnungen( bool rO ) // legt fest, ob die Zeichnunge gerendert werden
  87. {
  88. lock();
  89. renderZeichnungen = rO;
  90. rend = 1;
  91. unlock();
  92. }
  93. void Bildschirm::setOnTop( bool onTop ) // legt fest, ob das onTop Zeichnung gerendert wid
  94. {
  95. renderOnTop = onTop;
  96. rend = 1;
  97. }
  98. void Bildschirm::setOnTopZeichnung( Zeichnung *obj ) // setzt das OnTop Zeichnung
  99. {
  100. lock();
  101. if( onTop )
  102. onTop->release();
  103. onTop = obj;
  104. rend = 1;
  105. unlock();
  106. }
  107. void Bildschirm::setdeckFarbe( int f ) // setzt die deckFarbe
  108. {
  109. deckFarbe = f;
  110. rend = 1;
  111. }
  112. void Bildschirm::addMember( Zeichnung *obj ) // Fügt ein Zeichnung hinzu
  113. {
  114. lock();
  115. members->add( obj );
  116. rend = 1;
  117. unlock();
  118. }
  119. void Bildschirm::removeMember( Zeichnung *zObj ) // Entfernt ein Zeichnung
  120. {
  121. lock();
  122. for( int i = 0; i < members->getEintragAnzahl(); i++ )
  123. {
  124. if( members->z( i ) == zObj )
  125. members->remove( i );
  126. }
  127. rend = 1;
  128. unlock();
  129. }
  130. // Zeichnet ein Bild und präsentiert es auf dem Bildschirm
  131. void Bildschirm::render()
  132. {
  133. lock();
  134. api->update();
  135. rend = 1;
  136. unlock();
  137. }
  138. void Bildschirm::setFillFarbe( int f ) // setzt die Fill Farbe
  139. {
  140. fillColor = f;
  141. rend = 1;
  142. }
  143. void Bildschirm::setVollbild( bool vollbild ) // setzt vollbild
  144. {
  145. lock();
  146. api->setFullScreen( vollbild );
  147. unlock();
  148. }
  149. void Bildschirm::tick( double tickval )
  150. {
  151. lock();
  152. if( !renderOnTop )
  153. {
  154. for( int i = 0; i < tipAnzahl; ++i )
  155. rend |= tips->z( i )->tick( tickval );
  156. for( Zeichnung *i : *members )
  157. rend |= i->tick( tickval );
  158. }
  159. else if( onTop )
  160. {
  161. rend |= onTop->tick( tickval );
  162. for( int i = 0; i < tipAnzahl; ++i )
  163. rend |= tips->z( i )->tick( tickval );
  164. }
  165. unlock();
  166. }
  167. void Bildschirm::setBackBufferSize( int breite, int height ) // setzt die Größe des Backbuffers
  168. {
  169. lock();
  170. api->setBackBufferSize( Vec2< int >( breite, height ) );
  171. unlock();
  172. }
  173. void Bildschirm::setBackBufferSize( Punkt &size )
  174. {
  175. lock();
  176. api->setBackBufferSize( size );
  177. unlock();
  178. }
  179. void Bildschirm::doMausEreignis( MausEreignis &me ) // sendet maus Ereignis
  180. {
  181. int fBr = api->getBackBufferSize().x;
  182. int fHi = api->getBackBufferSize().y;
  183. #ifdef WIN32
  184. if( fenster )
  185. {
  186. fBr = fenster->getKörperBreite();
  187. fHi = fenster->getKörperHöhe();
  188. }
  189. #endif
  190. me.mx = (int)( me.mx * api->getBackBufferSize().x / (double)fBr + 0.5 );
  191. me.my = (int)( me.my * api->getBackBufferSize().y / (double)fHi + 0.5 );
  192. lock();
  193. if( !renderOnTop )
  194. {
  195. for( int i = tipAnzahl - 1; i >= 0; i-- )
  196. tips->z( i )->doPublicMausEreignis( me );
  197. for( int i = members->getEintragAnzahl() - 1; i >= 0; i-- )
  198. members->z( i )->doPublicMausEreignis( me );
  199. }
  200. else if( onTop )
  201. {
  202. onTop->doPublicMausEreignis( me );
  203. for( int i = tipAnzahl - 1; i >= 0; i-- )
  204. tips->z( i )->doPublicMausEreignis( me );
  205. }
  206. unlock();
  207. }
  208. void Bildschirm::doTastaturEreignis( TastaturEreignis &te ) // sendet tastatur Ereignis
  209. {
  210. lock();
  211. if( !renderOnTop )
  212. {
  213. for( int i = members->getEintragAnzahl() - 1; i >= 0; i-- )
  214. members->z( i )->doTastaturEreignis( te );
  215. }
  216. for( int i = tipAnzahl - 1; i >= 0; i-- )
  217. tips->z( i )->doTastaturEreignis( te );
  218. unlock();
  219. }
  220. void Bildschirm::addToolTip( ToolTip *tip ) // fügt ToolTip hinzu
  221. {
  222. lock();
  223. tips->add( tip, tipAnzahl );
  224. ++tipAnzahl;
  225. rend = 1;
  226. unlock();
  227. }
  228. bool Bildschirm::removeToolTip( ToolTip *zTip ) // entfernt ToolTip
  229. {
  230. lock();
  231. bool gefunden = 0;
  232. for( int i = 0; i < tipAnzahl; ++i )
  233. {
  234. ToolTip *tmp = tips->z( i );
  235. if( tmp == zTip )
  236. {
  237. tips->remove( i );
  238. --tipAnzahl;
  239. gefunden = 1;
  240. rend = 1;
  241. break;
  242. }
  243. }
  244. unlock();
  245. return gefunden;
  246. }
  247. // constant
  248. Bild *Bildschirm::getRenderBild() const
  249. {
  250. return dynamic_cast<Bild *>( api->zUIRenderBild()->getThis() );
  251. }
  252. Bild *Bildschirm::zRenderBild() const
  253. {
  254. return api->zUIRenderBild();
  255. }
  256. Iterator<Zeichnung *> Bildschirm::getMembers() const // gibt die Zeichnunge zurück
  257. {
  258. return members->begin();
  259. }
  260. int Bildschirm::getFillFarbe() const // gibt die Füll Farbe zurück
  261. {
  262. return fillColor;
  263. }
  264. bool Bildschirm::istVolbild() const // gibt zurück, ob vollbild an ist
  265. {
  266. return api->isFullScreen();
  267. }
  268. const Punkt Bildschirm::getBackBufferSize() const // gibt die Größe des Backbuffers zurück
  269. {
  270. return api->getBackBufferSize();
  271. }
  272. void Bildschirm::warteAufRendern() const // wartet auf die render Funktion
  273. {
  274. while( rendering )
  275. {
  276. if( !rendering )
  277. return;
  278. }
  279. }
  280. double Bildschirm::getRenderZeit() const // gibt zurück wie viele Sekunden das Rendern dauert
  281. {
  282. return renderZeit->getSekunden();
  283. }
  284. // Gibt die Grafik API zurück (ohne erhöhten Reference Counter)
  285. GraphicsApi *Bildschirm::zGraphicsApi() const
  286. {
  287. return api;
  288. }
  289. // Gibt die Grafik API zurück
  290. GraphicsApi *Bildschirm::getGraphicsApi() const
  291. {
  292. return api ? dynamic_cast<GraphicsApi *>( api->getThis() ) : 0;
  293. }
  294. #ifdef WIN32
  295. int MonitorEnum( HMONITOR m, HDC dc, LPRECT r, LPARAM p )
  296. {
  297. Monitor *mon = new Monitor();
  298. mon->existiert = 1;
  299. mon->x = r->left;
  300. mon->y = r->top;
  301. mon->breite = r->right - r->left;
  302. mon->height = r->bottom - r->top;
  303. ( ( Array< Monitor * > * )p )->add( mon );
  304. return 1;
  305. }
  306. Monitor Framework::getMonitor( int id )
  307. {
  308. if( id < 0 )
  309. {
  310. Monitor m;
  311. m.existiert = 0;
  312. return m;
  313. }
  314. Array< Monitor * > *monitore = new Array< Monitor * >();
  315. EnumDisplayMonitors( 0, 0, (MONITORENUMPROC)MonitorEnum, (LPARAM)monitore );
  316. int anz = monitore->getEintragAnzahl();
  317. if( id >= monitore->getEintragAnzahl() )
  318. {
  319. for( int i = 0; i < anz; ++i )
  320. delete monitore->get( i );
  321. delete monitore;
  322. Monitor m;
  323. m.existiert = 0;
  324. return m;
  325. }
  326. Monitor m = *monitore->get( id );
  327. for( int i = 0; i < anz; ++i )
  328. delete monitore->get( i );
  329. delete monitore;
  330. return m;
  331. }
  332. // Bildschirm2D
  333. // Konstruktor
  334. Bildschirm2D::Bildschirm2D( WFenster *fenster )
  335. : Bildschirm( fenster )
  336. {
  337. api = new DirectX9();
  338. api->initialize( dynamic_cast<WFenster *>( fenster->getThis() ), fenster->getKörperGröße(), 0 );
  339. }
  340. // Destruktor
  341. Bildschirm2D::~Bildschirm2D()
  342. {}
  343. void Bildschirm2D::render() // Zeichnet das Bild
  344. {
  345. if( !rend && testRend )
  346. return;
  347. rendering = 1;
  348. Bild *ui = api->zUIRenderBild();
  349. if( ui )
  350. {
  351. lock();
  352. renderZeit->messungStart();
  353. api->beginFrame( fill && ( rend || !testRend ), 0, fillColor );
  354. if( renderZeichnungen )
  355. {
  356. if( renderOnTop && deckFarbe && ( deckFarbe & ( fillColor | 0xFF000000 ) ) == deckFarbe )
  357. {
  358. ui->setAlpha( 255 - (unsigned char)( deckFarbe >> 24 ) );
  359. for( Zeichnung *z : *members )
  360. z->render( *ui ); // zeichnen nach zwischenbuffer
  361. ui->releaseAlpha();
  362. }
  363. else
  364. {
  365. for( Zeichnung *z : *members )
  366. z->render( *ui ); // zeichnen nach zwischenbuffer
  367. if( renderOnTop && deckFarbe )
  368. ui->alphaRegion( 0, 0, ui->getBreite(), ui->getHeight(), deckFarbe );
  369. }
  370. for( int i = 0; i < tipAnzahl; ++i )
  371. tips->z( i )->render( *ui );
  372. }
  373. if( renderOnTop && onTop )
  374. onTop->render( *ui );
  375. api->presentFrame();
  376. renderZeit->messungEnde();
  377. unlock();
  378. }
  379. rendering = 0;
  380. rend = 0;
  381. }
  382. // Bildschirm3D
  383. // Konstruktor
  384. Bildschirm3D::Bildschirm3D( WFenster *fenster )
  385. : Bildschirm( fenster ),
  386. kameras( new RCArray< Kam3D >() ),
  387. rend3D( 0 )
  388. {
  389. if( DirectX12::isAvailable() )
  390. api = new DirectX12();
  391. else if( DirectX11::isAvailable() )
  392. api = new DirectX11();
  393. else
  394. api = new DirectX9();
  395. api->initialize( dynamic_cast<WFenster *>( fenster->getThis() ), fenster->getKörperGröße(), 0 );
  396. }
  397. Bildschirm3D::Bildschirm3D( WFenster *fenster, GraphicApiType apiTyp )
  398. : Bildschirm( fenster ),
  399. kameras( new RCArray< Kam3D >() ),
  400. rend3D( 0 )
  401. {
  402. if( apiTyp == DIRECTX9 )
  403. api = new DirectX9();
  404. if( apiTyp == DIRECTX11 )
  405. api = new DirectX11();
  406. if( apiTyp == DIRECTX12 )
  407. api = new DirectX12();
  408. api->initialize( dynamic_cast<WFenster *>( fenster->getThis() ), fenster->getKörperGröße(), 0 );
  409. }
  410. // Destruktor
  411. Bildschirm3D::~Bildschirm3D()
  412. {
  413. kameras->release();
  414. }
  415. // nicht constant
  416. void Bildschirm3D::addKamera( Kam3D *obj ) // Fügt ein Zeichnung hinzu
  417. {
  418. lock();
  419. kameras->add( obj );
  420. rend3D = 1;
  421. unlock();
  422. }
  423. void Bildschirm3D::removeKamera( Kam3D *zObj ) // Entfernt ein Zeichnung
  424. {
  425. lock();
  426. for( int i = 0; kameras->z( i ); i++ )
  427. {
  428. if( kameras->z( i ) == zObj )
  429. {
  430. kameras->remove( i );
  431. break;
  432. }
  433. }
  434. rend3D = 1;
  435. unlock();
  436. }
  437. void Bildschirm3D::tick( double tickval )
  438. {
  439. lock();
  440. __super::tick( tickval );
  441. for( Kam3D *k : *kameras )
  442. rend3D |= k->tick( tickval );
  443. unlock();
  444. }
  445. void Bildschirm3D::doMausEreignis( MausEreignis &me ) // sendet maus Ereignis
  446. {
  447. lock();
  448. __super::doMausEreignis( me );
  449. for( int i = kameras->getEintragAnzahl() - 1; i >= 0; i-- )
  450. kameras->z( i )->doMausEreignis( me );
  451. unlock();
  452. }
  453. void Bildschirm3D::doTastaturEreignis( TastaturEreignis &te ) // sendet tastatur Ereignis
  454. {
  455. lock();
  456. __super::doTastaturEreignis( te );
  457. for( int i = kameras->getEintragAnzahl() - 1; i >= 0; i-- )
  458. kameras->z( i )->doTastaturEreignis( te );
  459. unlock();
  460. }
  461. void Bildschirm3D::render() // Zeichnet das Bild
  462. {
  463. if( !rend && !rend3D && testRend )
  464. return;
  465. rendering = 1;
  466. lock();
  467. renderZeit->messungStart();
  468. // Clear the back buffer.
  469. api->beginFrame( fill && ( rend || !testRend ), fill && ( rend3D || !testRend || rend ), fillColor );
  470. if( rend3D || !testRend || rend )
  471. {
  472. // Render 3d Objects
  473. for( Kam3D *k : *kameras )
  474. api->renderKamera( k );
  475. rend3D = 0;
  476. }
  477. // render User Interface
  478. Bild *ui = api->zUIRenderBild();
  479. if( ( rend || !testRend ) && ui )
  480. {
  481. if( renderZeichnungen )
  482. {
  483. if( renderOnTop && deckFarbe && ( deckFarbe & ( fillColor | 0xFF000000 ) ) == deckFarbe )
  484. {
  485. ui->setAlpha( 255 - (unsigned char)( deckFarbe >> 24 ) );
  486. for( Zeichnung *z : *members )
  487. z->render( *ui ); // zeichnen nach zwischenbuffer
  488. ui->releaseAlpha();
  489. }
  490. else
  491. {
  492. for( Zeichnung *z : *members )
  493. z->render( *ui ); // zeichnen nach zwischenbuffer
  494. if( renderOnTop && deckFarbe )
  495. ui->alphaRegion( 0, 0, ui->getBreite(), ui->getHeight(), deckFarbe );
  496. }
  497. for( int i = 0; i < tipAnzahl; ++i )
  498. tips->z( i )->render( *ui );
  499. }
  500. if( renderOnTop && onTop )
  501. onTop->render( *ui );
  502. }
  503. api->presentFrame();
  504. unlock();
  505. renderZeit->messungEnde();
  506. #ifdef _DEBUG
  507. //std::cout << renderZeit->getSekunden() << "\n";
  508. #endif
  509. rendering = 0;
  510. rend = 0;
  511. }
  512. #endif