Model2D.h 12 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274
  1. #ifndef Model2D_H
  2. #define Model2D_H
  3. #include <functional>
  4. #include "Array.h"
  5. #include "DreieckListe.h"
  6. #include "Punkt.h"
  7. #include "Vec3.h"
  8. #include "Welt2D.h"
  9. #include "Zeichnung.h"
  10. namespace Framework
  11. {
  12. class Textur2D;
  13. //! Eine Polygon Struktur, die von Model2D verwendet wird
  14. //! Model2D Klasse löscht die Zeiger
  15. struct Polygon2D
  16. {
  17. bool transparent;
  18. Text* name;
  19. Array<Vertex>* vertex;
  20. Array<Vertex>* tKordinaten;
  21. Vertex* schwerpunkt;
  22. };
  23. //! Die Daten für ein 2D Model
  24. class Model2DData : public virtual ReferenceCounter
  25. {
  26. private:
  27. RCArray<Array<Punkt>> outList;
  28. //! Überprüft, ob ein Punkt im Model ist
  29. //! \param p Der Punkt
  30. //! \param polygonId Die Id des Polygons, das geprüft werden soll
  31. bool istPunktInnen(Vertex p, int polygonId = -1) const;
  32. //! Überprüft, ob eine Linie innerhalb des Models ist
  33. //! \param a Der Startpunkt der Linie
  34. //! \param b Der Endpunkt der Linie
  35. bool istLinieInnen(Vertex a, Vertex b, int polygonId = -1) const;
  36. public:
  37. Array<Polygon2D>* polygons;
  38. RCArray<RCArray<DreieckListe<Vertex>>>* vListen;
  39. Punkt minP, maxP;
  40. //! Konstruktor
  41. __declspec(dllexport) Model2DData();
  42. //! Destruktor
  43. __declspec(dllexport) ~Model2DData();
  44. //! Erstellt die Dreieck Listen anhand aller gegebenen Eckpunkte der
  45. //! Polygons \param polygons Ein Array von Polygons \return gibt immer 1
  46. //! zurück
  47. __declspec(dllexport) bool erstelleModell(Array<Polygon2D>* polygons);
  48. //! Löscht die erstellten Dreiecklisten und die Eckpunkte
  49. __declspec(dllexport) void removeModell();
  50. //! gibt das polygon mit einem bestimmten namen zurück
  51. //! \param pos Der Stützvektor der Linie
  52. //! \param dir Der richtungsvektor der Linie
  53. //! \param polygonName Der Name des polygons mit dem der schnittpunkt
  54. //! berechnet werden soll \param hitPoint eine referenz auf die variable
  55. //! in dem der schnittpunkt gespeichert werden soll \param moveSpeed die
  56. //! aus der Krafteinwirkung resultierende bewegungsgeschwindigkeit
  57. //! \param rotSpeed die aus der Krafteinwirkung resultierende
  58. //! drehgeschwindigkeit \return 1, fals ein Schnittpunkt existiert
  59. __declspec(dllexport) bool calcHitPoint(Vertex pos,
  60. Vertex dir,
  61. const char* polygonName,
  62. Vertex& hitpoint,
  63. Vertex& moveSpeed,
  64. float& rotSpeed) const;
  65. //! Teil ein bestimmtes polygon in zwei teile
  66. //! \param pos Startposition des risses
  67. //! \param dir Startrichtung des risses
  68. //! \param polygonName der Name des Polygons
  69. //! \param partA ein Zeiger auf ein Model2DData objekt, in dem die eine
  70. //! hälfte gespeichert werden soll (ausgabe) \param partB ein Zeiger auf
  71. //! ein Model2DData objekt, in dem die andere hälfte gespeichert werden
  72. //! soll (ausgabe) \param posA die Position des einen neuen Polygons
  73. //! (ausgabe) \param posB die Position des anderen neuen Polygons
  74. //! (ausgabe) \param random eine funktion die zufällige werte zurückgibt
  75. __declspec(dllexport) bool split(Vertex pos,
  76. Vertex dir,
  77. char* polygonName,
  78. Polygon2D& partA,
  79. Polygon2D& partB,
  80. Punkt& posA,
  81. Punkt& posB,
  82. std::function<double()> random) const;
  83. //! Gibt die Masse des 2D Modells zurück (summe der Flächen der nicht
  84. //! transparenten Polygone)
  85. __declspec(dllexport) float getMasse() const;
  86. };
  87. class Model2DObject : public Object2D
  88. {
  89. private:
  90. Model2DData* rData;
  91. RCArray<Textur2D>* textur;
  92. public:
  93. //! Konstruktor
  94. __declspec(dllexport) Model2DObject();
  95. //! Destruktor
  96. __declspec(dllexport) virtual ~Model2DObject();
  97. //! Setzt die Daten des Models
  98. //! \param mdl Die Model Daten
  99. __declspec(dllexport) void setModel(Model2DData* mdl);
  100. //! Setzt die Textur
  101. //! \param t Das Bild, das als Textur verwendet werden soll
  102. __declspec(dllexport) void setTextur(Textur2D* t);
  103. //! Setzt die Textur
  104. //! \param t Das Bild, das als Textur verwendet werden soll
  105. //! \param polygonName Der name des Polygons, was die Textur bekommen
  106. //! soll
  107. __declspec(dllexport) void setTextur(
  108. Textur2D* t, const char* polygonName);
  109. __declspec(dllexport) void impuls(
  110. Vertex start, Vertex speed, float strength = 1.f) override;
  111. //! Zeichnet die Zeihnung in ein bestimmtes Bild
  112. //! \param zRObj Das Bild, in das gezeichnet werden soll
  113. __declspec(dllexport) void render(
  114. Mat3<float>& kamMat, Bild& zRObj, const char* kamName) override;
  115. //! Gibt zurück, ob ein Punkt in dem Model enthalten ist
  116. //! \param p Der Punkt
  117. //! \param ignoreTransparentFlag wenn 1, dann werden auch collisionen
  118. //! mit transparenten polygonen beachtet
  119. __declspec(dllexport) bool istPunktInnen(
  120. Vertex p, bool ignoreTransparent = 0) const override;
  121. //! Überprüft, ob eine Linie im Model enthalten ist
  122. //! \param a Der startpunkt der Linie
  123. //! \param b Der endpunkt der Linie
  124. //! \param ignoreTransparentFlag wenn 1, dann werden auch collisionen
  125. //! mit transparenten polygonen beachtet
  126. __declspec(dllexport) bool istLinieInnen(
  127. Vertex a, Vertex b, bool ignoreTransparent = 0) const override;
  128. //! Überprüft, ob sich das Objekt mit einem anderen Überschneidet
  129. //! \param zObj Ein Zeiger auf das andere Objekt ohne erhöhten Reference
  130. //! Counter \param sp Ein Zeiger auf einen Punkt, in dem der
  131. //! Schnittpunkt gespeichert wird \param end 0, falls alle Ecken beider
  132. //! Objekte überprüft werdden sollen. 1, falls nur die Punkte dieses
  133. //! Models im anderen gesucht werden sollen \param ignoreTransparentFlag
  134. //! wenn 1, dann werden auch collisionen mit transparenten polygonen
  135. //! beachtet
  136. __declspec(dllexport) virtual bool istModelInnen(const Object2D* zObj,
  137. Vertex* sp = 0,
  138. bool end = 0,
  139. bool ignoreTransparent = 0) const;
  140. __declspec(dllexport) Rect2<float> getBoundingBox() const override;
  141. //! Bestimmt den Aufschlagspunkt eines Strahls, der von pos ausgehend in
  142. //! Richtung dir abgegeben wird. \param pos Der Stützvektor der Linie
  143. //! \param dir Der richtungsvektor der Linie
  144. //! \param hitPoint eine referenz auf die variable in dem der
  145. //! schnittpunkt gespeichert werden soll \return 1, fals ein
  146. //! Schnittpunkt existiert
  147. __declspec(dllexport) bool calcHitPoint(
  148. Vertex pos, Vertex dir, Vertex& hitpoint) const override;
  149. __declspec(dllexport) float getLuftWiederstand() const override;
  150. //! Gibt die Masse des 2D Modells zurück (summe der Flächen der nicht
  151. //! transparenten Polygone)
  152. __declspec(dllexport) float getMasse() const override;
  153. //! Gibt die Textur des ersten Polygons zurück
  154. __declspec(dllexport) Textur2D* getTextur() const;
  155. //! Gibt die Textur eines Polygons zurück
  156. //! \param polygonName Der Name des Polygons
  157. __declspec(dllexport) Textur2D* getTextur(
  158. const char* polygonName) const;
  159. //! Gibt die Textur des ersten Polygons ohne erhöhten Reference Counter
  160. //! zurück
  161. __declspec(dllexport) Textur2D* zTextur() const;
  162. //! Gibt die Textur eines Polygons ohne erhöhten Reference Counter
  163. //! zurück \param polygonName Der Name des Polygons
  164. __declspec(dllexport) Textur2D* zTextur(const char* polygonName) const;
  165. //! Gibt die Model Daten zurück
  166. __declspec(dllexport) Model2DData* getModel() const;
  167. //! Gibt die Model Daten ohne erhöhten Reference Counter zurück
  168. __declspec(dllexport) Model2DData* zModel() const;
  169. };
  170. //! Eine Zeichnung von einem Model
  171. class Model2D : public Zeichnung
  172. {
  173. public:
  174. class Style : public Zeichnung::Style
  175. {
  176. public:
  177. static const __int64 Textur
  178. = 0x8; //! Wenn dieser Flag gesetzt ist, wird beim Zeichnen eine
  179. //! Textur verwendet
  180. static const __int64 Rahmen
  181. = 0x10; //! Wenn dieser Flag gesetzt ist, werden die Render der
  182. //! Polygone gezeichnet
  183. static const __int64 Alpha
  184. = 0x40; //! Wenn dieser Fag gesetzt ist, wird beim Zeichnen
  185. //! alphablending verwendet
  186. static const __int64 Mesh
  187. = 0x20; //! Wenn dieser Flag gesetzt ist, werden die Render der
  188. //! Dreiecke gezeichnet
  189. };
  190. private:
  191. Model2DData* rData;
  192. float drehung;
  193. float size;
  194. int farbe;
  195. RCArray<Textur2D>* textur;
  196. public:
  197. //! Konstruktor
  198. __declspec(dllexport) Model2D();
  199. //! Destruktor
  200. __declspec(dllexport) virtual ~Model2D();
  201. //! Setzt die Daten des Models
  202. //! \param mdl Die Model Daten
  203. __declspec(dllexport) void setModel(Model2DData* mdl);
  204. //! Setzt die Drehung des Models gegen den Uhrzeigersinn
  205. //! \param drehung Der winkel in Bogenmas
  206. __declspec(dllexport) void setDrehung(float drehung);
  207. //! Fügt zum aktuellen Drehungswinkel etwas hinzu
  208. //! \param drehung Der Winkel in Bogenmas, der hinzugefügt werden soll
  209. __declspec(dllexport) void addDrehung(float drehung);
  210. //! Setzt die Skallierung des Modells
  211. //! \param size Der Faktor, mit dem Skalliert wird
  212. __declspec(dllexport) void setSize(float size);
  213. //! Addiert zur Skallierung einen bestimmten Wert hinzu
  214. //! \param size Der Wert, der zur skallierung hinzugefügt werden soll
  215. __declspec(dllexport) void addSize(float size);
  216. //! Setzt die Textur
  217. //! \param t Das Bild, das als Textur verwendet werden soll
  218. __declspec(dllexport) void setTextur(Textur2D* t);
  219. //! Setzt die Textur
  220. //! \param t Das Bild, das als Textur verwendet werden soll
  221. //! \param polygonName Der name des Polygons, was die Textur bekommen
  222. //! soll
  223. __declspec(dllexport) void setTextur(
  224. Textur2D* t, const char* polygonName);
  225. //! Setzt die Farbe
  226. //! \param f Die Farbe im A8R8G8B8 Format
  227. __declspec(dllexport) void setFarbe(int f);
  228. //! Verarbeitet die Zeit, die seit dem letzten aufruf dieser Funktion
  229. //! vergangen ist \param tickVal Die vergangene Zeit in Sekunden
  230. __declspec(dllexport) bool tick(double tickVal) override;
  231. //! Zeichnet die Zeihnung in ein bestimmtes Bild
  232. //! \param zRObj Das Bild, in das gezeichnet werden soll
  233. __declspec(dllexport) void render(Bild& zRObj) override;
  234. //! gibt die Drehung des Models zurück
  235. __declspec(dllexport) float getDrehung() const;
  236. //! gibt den Skallierungs Faktor zurück
  237. __declspec(dllexport) float getSize() const;
  238. //! Gibt zurück, ob ein Punkt in dem Model enthalten ist
  239. //! \param p Der Punkt
  240. __declspec(dllexport) bool istPunktInnen(int x, int y) const override;
  241. //! Gibt zurück, ob ein Punkt in dem Model enthalten ist
  242. //! \param p Der Punkt
  243. __declspec(dllexport) bool istPunktInnen(Vertex p) const;
  244. //! Überprüft, ob eine Linie im Model enthalten ist
  245. //! \param a Der startpunkt der Linie
  246. //! \param b Der endpunkt der Linie
  247. __declspec(dllexport) bool istLinieInnen(Vertex a, Vertex b) const;
  248. //! Überprüft, ob sich das Model mit einem anderen Überschneidet
  249. //! \param zMdl Ein Zeiger auf das andere Model ohne erhöhten Reference
  250. //! Counter \param end 0, falls alle Ecken beider Modele überprüft
  251. //! werdden sollen. 1, falls nur die Punkte dieses Models im anderen
  252. //! gesucht werden sollen
  253. __declspec(dllexport) bool istModelInnen(
  254. const Model2D* zMdl, bool end = 0) const;
  255. //! Gibt die Model Daten zurück
  256. __declspec(dllexport) Model2DData* getModel() const;
  257. //! Gibt die Model Daten ohne erhöhten Reference Counter zurück
  258. __declspec(dllexport) Model2DData* zModel() const;
  259. };
  260. } // namespace Framework
  261. #endif