Bildschirm.cpp 13 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557
  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. : api( 0 ),
  28. fenster( f ),
  29. ref( 1 ),
  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( auto i = members->getIterator(); i; i++ )
  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 )->doMausEreignis( me );
  197. for( int i = members->getEintragAnzahl() - 1; i >= 0; i-- )
  198. members->z( i )->doMausEreignis( me );
  199. }
  200. else if( onTop )
  201. {
  202. onTop->doMausEreignis( me );
  203. for( int i = tipAnzahl - 1; i >= 0; i-- )
  204. tips->z( i )->doMausEreignis( 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 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->getIterator();
  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 ? api->getThis() : 0;
  293. }
  294. // Reference Counting
  295. Bildschirm *Bildschirm::getThis()
  296. {
  297. ++ref;
  298. return this;
  299. }
  300. Bildschirm *Bildschirm::release()
  301. {
  302. --ref;
  303. if( !ref )
  304. delete this;
  305. return 0;
  306. }
  307. #ifdef WIN32
  308. int MonitorEnum( HMONITOR m, HDC dc, LPRECT r, LPARAM p )
  309. {
  310. Monitor *mon = new Monitor();
  311. mon->existiert = 1;
  312. mon->x = r->left;
  313. mon->y = r->top;
  314. mon->breite = r->right - r->left;
  315. mon->height = r->bottom - r->top;
  316. ( ( Array< Monitor * > * )p )->add( mon );
  317. return 1;
  318. }
  319. Monitor Framework::getMonitor( int id )
  320. {
  321. if( id < 0 )
  322. {
  323. Monitor m;
  324. m.existiert = 0;
  325. return m;
  326. }
  327. Array< Monitor * > *monitore = new Array< Monitor * >();
  328. EnumDisplayMonitors( 0, 0, (MONITORENUMPROC)MonitorEnum, (LPARAM)monitore );
  329. int anz = monitore->getEintragAnzahl();
  330. if( id >= monitore->getEintragAnzahl() )
  331. {
  332. for( int i = 0; i < anz; ++i )
  333. delete monitore->get( i );
  334. delete monitore;
  335. Monitor m;
  336. m.existiert = 0;
  337. return m;
  338. }
  339. Monitor m = *monitore->get( id );
  340. for( int i = 0; i < anz; ++i )
  341. delete monitore->get( i );
  342. delete monitore;
  343. return m;
  344. }
  345. // Bildschirm2D
  346. // Konstruktor
  347. Bildschirm2D::Bildschirm2D( WFenster * fenster )
  348. : Bildschirm( fenster )
  349. {
  350. api = new DirectX9();
  351. api->initialize( fenster->getThis(), fenster->getKörperGröße(), 0 );
  352. }
  353. // Destruktor
  354. Bildschirm2D::~Bildschirm2D()
  355. {}
  356. void Bildschirm2D::render() // Zeichnet das Bild
  357. {
  358. if( !rend && testRend )
  359. return;
  360. rendering = 1;
  361. Bild * ui = api->zUIRenderBild();
  362. if( ui )
  363. {
  364. lock();
  365. renderZeit->messungStart();
  366. api->beginFrame( fill && ( rend || !testRend ), 0, fillColor );
  367. if( renderZeichnungen )
  368. {
  369. if( renderOnTop &&deckFarbe && ( deckFarbe &( fillColor | 0xFF000000 ) ) == deckFarbe )
  370. {
  371. ui->setAlpha( 255 - (unsigned char)( deckFarbe >> 24 ) );
  372. for( auto i = members->getIterator(); i; i++ )
  373. i->render( *ui ); // zeichnen nach zwischenbuffer
  374. ui->releaseAlpha();
  375. }
  376. else
  377. {
  378. for( auto i = members->getIterator(); i; i++ )
  379. i->render( *ui ); // zeichnen nach zwischenbuffer
  380. if( renderOnTop &&deckFarbe )
  381. ui->alphaRegion( 0, 0, ui->getBreite(), ui->getHeight(), deckFarbe );
  382. }
  383. for( int i = 0; i < tipAnzahl; ++i )
  384. tips->z( i )->render( *ui );
  385. }
  386. if( renderOnTop &&onTop )
  387. onTop->render( *ui );
  388. api->presentFrame();
  389. renderZeit->messungEnde();
  390. unlock();
  391. }
  392. rendering = 0;
  393. rend = 0;
  394. }
  395. // Bildschirm3D
  396. // Konstruktor
  397. Bildschirm3D::Bildschirm3D( WFenster * fenster )
  398. : Bildschirm( fenster ),
  399. kameras( new RCArray< Kam3D >() ),
  400. rend3D( 0 )
  401. {
  402. if( DirectX12::isAvailable() )
  403. api = new DirectX12();
  404. else
  405. api = new DirectX11();
  406. api->initialize( fenster->getThis(), fenster->getKörperGröße(), 0 );
  407. }
  408. // Destruktor
  409. Bildschirm3D::~Bildschirm3D()
  410. {
  411. kameras->release();
  412. }
  413. // nicht constant
  414. void Bildschirm3D::addKamera( Kam3D * obj ) // Fügt ein Zeichnung hinzu
  415. {
  416. lock();
  417. kameras->add( obj );
  418. rend3D = 1;
  419. unlock();
  420. }
  421. void Bildschirm3D::removeKamera( Kam3D * zObj ) // Entfernt ein Zeichnung
  422. {
  423. lock();
  424. for( int i = 0; kameras->z( i ); i++ )
  425. {
  426. if( kameras->z( i ) == zObj )
  427. {
  428. kameras->remove( i );
  429. break;
  430. }
  431. }
  432. rend3D = 1;
  433. unlock();
  434. }
  435. void Bildschirm3D::tick( double tickval )
  436. {
  437. lock();
  438. __super::tick( tickval );
  439. for( auto i = kameras->getIterator(); i; i++ )
  440. rend3D |= i->tick( tickval );
  441. unlock();
  442. }
  443. void Bildschirm3D::doMausEreignis( MausEreignis & me ) // sendet maus Ereignis
  444. {
  445. lock();
  446. __super::doMausEreignis( me );
  447. for( int i = kameras->getEintragAnzahl() - 1; i >= 0; i-- )
  448. kameras->z( i )->doMausEreignis( me );
  449. unlock();
  450. }
  451. void Bildschirm3D::doTastaturEreignis( TastaturEreignis & te ) // sendet tastatur Ereignis
  452. {
  453. lock();
  454. __super::doTastaturEreignis( te );
  455. for( int i = kameras->getEintragAnzahl() - 1; i >= 0; i-- )
  456. kameras->z( i )->doTastaturEreignis( te );
  457. unlock();
  458. }
  459. void Bildschirm3D::render() // Zeichnet das Bild
  460. {
  461. if( !rend && !rend3D && testRend )
  462. return;
  463. rendering = 1;
  464. lock();
  465. renderZeit->messungStart();
  466. // Clear the back buffer.
  467. api->beginFrame( fill && ( rend || !testRend ), fill && ( rend3D || !testRend || rend ), fillColor );
  468. if( rend3D || !testRend || rend )
  469. {
  470. // Render 3d Objects
  471. for( auto i = kameras->getIterator(); i; i++ )
  472. api->renderKamera( i._ );
  473. rend3D = 0;
  474. }
  475. // render User Interface
  476. Bild *ui = api->zUIRenderBild();
  477. if( ( rend || !testRend ) && ui )
  478. {
  479. if( renderZeichnungen )
  480. {
  481. if( renderOnTop &&deckFarbe && ( deckFarbe &( fillColor | 0xFF000000 ) ) == deckFarbe )
  482. {
  483. ui->setAlpha( 255 - (unsigned char)( deckFarbe >> 24 ) );
  484. for( auto i = members->getIterator(); i; i++ )
  485. i->render( *ui ); // zeichnen nach zwischenbuffer
  486. ui->releaseAlpha();
  487. }
  488. else
  489. {
  490. for( auto i = members->getIterator(); i; i++ )
  491. i->render( *ui ); // zeichnen nach zwischenbuffer
  492. if( renderOnTop &&deckFarbe )
  493. ui->alphaRegion( 0, 0, ui->getBreite(), ui->getHeight(), deckFarbe );
  494. }
  495. for( int i = 0; i < tipAnzahl; ++i )
  496. tips->z( i )->render( *ui );
  497. }
  498. if( renderOnTop &&onTop )
  499. onTop->render( *ui );
  500. }
  501. unlock();
  502. api->presentFrame();
  503. renderZeit->messungEnde();
  504. #ifdef _DEBUG
  505. //std::cout << renderZeit->getSekunden() << "\n";
  506. #endif
  507. rendering = 0;
  508. rend = 0;
  509. }
  510. #endif