Bildschirm.cpp 15 KB

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