Model3D.h 17 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398
  1. #pragma once
  2. #include "Array.h"
  3. #include "Mat4.h"
  4. #include "Vec2.h"
  5. #include "Zeichnung3D.h"
  6. struct ID3D11Buffer;
  7. namespace Framework
  8. {
  9. struct Polygon2D; //! Model2D.h
  10. class Textur; //! Textur.h
  11. class Model2DData; //! Model2D.h
  12. class DXBuffer; //! DXBuffer.h
  13. class Render3D; //! Render3D.h
  14. class Model3DTextur; //! Model3D.h
  15. class Model3DList; //! Model3DList.h
  16. class Welt3D; //! Welt3D.h
  17. class DXBuffer;
  18. class Shader;
  19. class GraphicsApi;
  20. class M3Datei;
  21. //! Repräsentiert einen Knochen eines 3D Models. Kann annimiert werden
  22. class Bone
  23. {
  24. private:
  25. Vec3<float> pos;
  26. Vec3<float> rot;
  27. Bone* sibling;
  28. Bone* child;
  29. int id;
  30. public:
  31. //! Constructor
  32. //! \param id the id of the bone
  33. DLLEXPORT Bone(int id);
  34. //! Destructor
  35. DLLEXPORT ~Bone();
  36. //! set the position of the bone relative to the parent bone
  37. //! \param pos the position
  38. DLLEXPORT void setPosition(const Vec3<float>& pos);
  39. //! Set the rotation of the bone relative to the parent bone
  40. //! \param rot thr rotation
  41. DLLEXPORT void setRotation(const Vec3<float>& rot);
  42. //! add a sibling bone to this bone that shares the same parent bone
  43. //! \param b Der Knochen, der hinzugefügt werden soll
  44. void addSiblingBone(Bone* b);
  45. //! add a child bone to a specific child bone
  46. //! \param id the id of the bone the new bone should be a child of
  47. //! \param b the bone that should be added
  48. //! \return true if the bone was added, false if the bone with the given
  49. //! parent id was not found
  50. DLLEXPORT bool addChildBone(int id, Bone* b);
  51. //! calculates the matrixes of this bone, all child bones and sibling
  52. //! bones
  53. //! \param elternMat the already calculated matrix of the parent bone
  54. //! \param matBuffer the array to store the calculated matrixes
  55. //! \param scaleFactor the scaling of the object
  56. //! \param camMatrix the view-projection matrix of the used camera
  57. DLLEXPORT void calculateMatrix(Mat4<float>& elternMat,
  58. Mat4<float>* matBuffer,
  59. float scaleFactor,
  60. Mat4<float>& camMatrix);
  61. //! \return the first sibling bone
  62. DLLEXPORT Bone* zFirstSibling() const;
  63. //! \return the first child bone
  64. DLLEXPORT Bone* zFirstChild() const;
  65. //! returns a copy of this bone with copies of all child and
  66. //! sibling bones
  67. DLLEXPORT Bone* copyBone() const;
  68. //! \return the id of this bone
  69. DLLEXPORT int getId() const;
  70. //! \return the rotation of this bone
  71. DLLEXPORT Vec3<float> getRotation() const;
  72. //! \return the position of this bone
  73. DLLEXPORT Vec3<float> getPosition() const;
  74. //! \return the radius of this bone
  75. float getRadius() const;
  76. };
  77. //! Repräsentiert alle Knochen eines Models, mit denen es Annimiert werden
  78. //! kann
  79. class Skeleton : public virtual ReferenceCounter
  80. {
  81. private:
  82. Bone* rootBone;
  83. int nextId;
  84. Bone* zBone(Bone* zCurrent, int id) const;
  85. public:
  86. //! Constructor
  87. DLLEXPORT Skeleton();
  88. //! Destructor
  89. DLLEXPORT ~Skeleton();
  90. //! add a bone to the sceleton
  91. //! \param pos the position of the bone
  92. //! \param rot the rotation of the bone
  93. //! \param the id of the parent bone where the new bone should be added
  94. //! as a child
  95. //! \return the id of the added bone or -1 if the bone could not be
  96. //! added
  97. DLLEXPORT int addBone(
  98. Vec3<float> pos, Vec3<float> rot, int parentId = -1);
  99. //! calculates the matrices of all bones in this sceleton
  100. //! \param modelMatrix the already calculated matrix of the used 3d
  101. //! model \param matBuffer the array to store the calculated matrixes
  102. //! \param scaleFactor the scaling of the object
  103. //! \param camMatrix the view-projection matrix of the used camera
  104. DLLEXPORT int calculateMatrix(Mat4<float>& modelMatrix,
  105. Mat4<float>* matBuffer,
  106. float scaleFactor,
  107. Mat4<float>& camMatrix);
  108. //! \return the radius of the sceleton
  109. DLLEXPORT float getRadius() const;
  110. //! \return the root bone of the sceleton
  111. DLLEXPORT Bone* zRootBone() const;
  112. //! \return the bone with a specific id
  113. DLLEXPORT Bone* zBone(int id) const;
  114. //! \return a deep copy of the sceleton
  115. DLLEXPORT Skeleton* copySceleton() const;
  116. //! \return the next id for a bone ther can be only MAX_KNOCHEN_ANZ
  117. //! bones in a sceleton. if the sceleton is full -1 is returned
  118. DLLEXPORT int getNextBoneId() const;
  119. friend M3Datei;
  120. };
  121. //! Eine struktor um für eine Ecke eines 3D Models die Raum Position, die
  122. //! Textur Koordinaten und den zugehörigen Knochen speichert
  123. struct Vertex3D
  124. {
  125. Vec3<float>
  126. pos; //! Die Position der Ecke basierend zur Position des Knochens
  127. Vec2<float> tPos; //! Die Textur Koordinaten der Ecke
  128. Vec3<float> normal; //! Die Normale (zeigt nach außen und steht
  129. //! senkrecht auf der Oberfläche des models)
  130. int knochenId; //! Die Id des Knochens, mit dem sich die Ecke bei einer
  131. //! Annimation mitbewegt
  132. int id; //! Der index des vertexes im vertex buffer
  133. };
  134. //! Eine Struktur, die alle Dreiecke eines 3D Polygons speichert
  135. struct Polygon3D
  136. {
  137. int* indexList; //! Die Liste mit den IDs der Ecken
  138. int indexAnz; //! Die Länge der Liste mit den Ids der Ecken
  139. //! Konstruktor
  140. DLLEXPORT Polygon3D();
  141. //! Destruktor
  142. DLLEXPORT ~Polygon3D();
  143. };
  144. //! Speichert alle Geometrischen Daten eines Modells, also
  145. //! Raum - und Textur Koordinaten und Knochenzugehörigkeit aller Eckpunkte
  146. class Model3DData : public virtual ReferenceCounter
  147. {
  148. private:
  149. Skeleton* skelett;
  150. Vertex3D* vertexList;
  151. int vertexCount;
  152. Array<Polygon3D*>* polygons;
  153. float ambientFactor;
  154. float diffusFactor;
  155. float specularFactor;
  156. float radius;
  157. int* indexBuffer;
  158. int indexCount;
  159. DXBuffer* dxIndexBuffer;
  160. DXBuffer* dxVertexBuffer;
  161. Vec3<float> minPos;
  162. Vec3<float> maxPos;
  163. int id;
  164. public:
  165. //! Konstruktor
  166. DLLEXPORT Model3DData(
  167. DXBuffer* dxVertexBuffer, DXBuffer* dxIndexBuffer, int id);
  168. //! Destruktor
  169. DLLEXPORT ~Model3DData();
  170. //! updates the DX Buffer gpu memory if changed
  171. DLLEXPORT void updateGPUMemory();
  172. //! Löscht alle Model daten
  173. DLLEXPORT void clearModel();
  174. //! Berechnet die normalen für die Eckpunkte des Modells
  175. DLLEXPORT void calculateNormals();
  176. //! Erstellt einen buffer für alle polygon indizes
  177. DLLEXPORT void buildIndexBuffer();
  178. //! Setzt den Zeiger auf ein standartmäßig verwendete Skelett
  179. //! \param s Das Skelett, das verwendet werden soll
  180. DLLEXPORT void setSkelettZ(Skeleton* s);
  181. //! Setzt einen Zeiger auf eine Liste mit allen Vertecies des Models
  182. //! \param vertexList Ein Array mit Vertecies
  183. //! \param anz Die Anzahl der Vertecies im Array
  184. DLLEXPORT void setVertecies(Vertex3D* vertexList, int anz);
  185. //! Fügt ein Polygon zum Model hinzu
  186. //! \param polygon Das Polygon, das hinzugefügt erden soll
  187. DLLEXPORT void addPolygon(Polygon3D* polygon);
  188. //! Git den Factor an, mit dem das umgebungslicht (textur farbe)
  189. //! multipliziert wird \param f der neue Faktor (von 0 bis 1, ambient +
  190. //! specular + diffuse = 1)
  191. DLLEXPORT void setAmbientFactor(float f);
  192. //! Git den Factor an, mit dem die Lichtfarbe von Lichtquellen
  193. //! multipliziert wird \param f der neue Faktor (von 0 bis 1, ambient +
  194. //! specular + diffuse = 1)
  195. DLLEXPORT void setDiffusFactor(float f);
  196. //! Git den Factor an, mit dem die Reflektion von Lichtquellen
  197. //! multipliziert wird \param f der neue Faktor (von 0 bis 1, ambient +
  198. //! specular + diffuse = 1)
  199. DLLEXPORT void setSpecularFactor(float f);
  200. //! Konvertiert ein 2d Model zu 3D
  201. //! \param model Das 2d Model, das zu 3d konvertiert werden soll
  202. //! \param z Die z koordinate aller punkte des Models
  203. DLLEXPORT void copyModel2D(Model2DData* model, float z);
  204. //! Entfernt ein Polygon
  205. //! \param index Der Index des Polygons
  206. DLLEXPORT void removePolygon(int index);
  207. //! Berechnet die Matrizen der Knochen des Standart Skeletts
  208. //! \param modelMatrix Die Matrix, die das Skelett in den Raum der Welt
  209. //! transformiert \param matBuffer Ein Array von Matrizen, der durch die
  210. //! Knochen Matrizen gefüllt wird \param scaleFactor Die Skallierung des
  211. //! Modells \param kamMatrix Die vereiniegung der view und projektions
  212. //! Matrizen \return gibt die Anzahl der verwendeten Matrizen zurück. 0,
  213. //! falls kein Standart Skelett gesetzt wurde
  214. int kalkulateMatrix(Mat4<float>& modelMatrix,
  215. Mat4<float>* matBuffer,
  216. float scaleFactor,
  217. Mat4<float>& kamMatrix) const;
  218. //! Gibt die Anzahl an Polygonen zurück
  219. DLLEXPORT int getPolygonAnzahl() const;
  220. //! Gibt ein bestimmtes Polygon zurück
  221. //! \param index Der Index des Polygons
  222. DLLEXPORT Polygon3D* getPolygon(int index) const;
  223. //! Gibt einen Iterator zurück, mit dem sich die Polygons auflisten
  224. //! lassen
  225. DLLEXPORT Iterator<Polygon3D*> getPolygons() const;
  226. //! Gibt den radius einer Kugel zurück, die das gesammte Model
  227. //! umschließt
  228. DLLEXPORT float getRadius() const;
  229. //! Gibt die Id der Daten zurück, wenn sie in einer Model3DList
  230. //! registriert wurden. (siehe Framework::zM3DRegister())
  231. DLLEXPORT int getId() const;
  232. //! Git den Factor an, mit dem das umgebungslicht (textur farbe)
  233. //! multipliziert wird
  234. DLLEXPORT float getAmbientFactor() const;
  235. //! Git den Factor an, mit dem die Lichtfarbe von Lichtquellen
  236. //! multipliziert wird
  237. DLLEXPORT float getDiffusFactor() const;
  238. //! Git den Factor an, mit dem die Reflektion von Lichtquellen
  239. //! multipliziert wird
  240. DLLEXPORT float getSpecularFactor() const;
  241. //! Gibt eine Kopie des Skeletts zurück, welches für annimationen
  242. //! verwendet werden kann
  243. DLLEXPORT Skeleton* copySkelett() const;
  244. //! Gibt die Anzahl an Vertices zurück
  245. DLLEXPORT int getVertexAnzahl() const;
  246. //! Gibt einen Buffer mit allen Vertecies des Models zurück
  247. DLLEXPORT const Vertex3D* zVertexBuffer() const;
  248. //! Gibt eine refferenz auf den beginn des indexBuffers zurück
  249. DLLEXPORT const int* getIndexBuffer() const;
  250. //! Gibt eine die Anzahl der indizes im indexBuffer zurück
  251. DLLEXPORT int getIndexCount() const;
  252. //! Gibt den Index buffer zurück;
  253. DLLEXPORT DXBuffer* zDXIndexBuffer() const;
  254. //! Gibt den Vertex buffer zurück;
  255. DLLEXPORT DXBuffer* zDXVertexBuffer() const;
  256. //! gibt den minnimalen Punkt der Bounding box des Models zurück
  257. DLLEXPORT Vec3<float> getMinPos() const;
  258. //! gibt den maximalen Punkt der bounding box des Mopdels zurück
  259. DLLEXPORT Vec3<float> getMaxPos() const;
  260. };
  261. //! Speichert eine Liste mit Texturen und für welche Polygone welche Textur
  262. //! benutzt werden soll
  263. class Model3DTextur : public virtual ReferenceCounter
  264. {
  265. private:
  266. Textur** textures;
  267. int textureCount;
  268. public:
  269. //! Konstruktor
  270. DLLEXPORT Model3DTextur();
  271. //! Destruktor
  272. DLLEXPORT ~Model3DTextur();
  273. //! Legt fest, welche Textur für welches Polygon ist
  274. //! \param pI Der Index des Polygons
  275. //! \param txt Die Textur des Polygons
  276. DLLEXPORT void setPolygonTextur(int pI, Textur* txt);
  277. //! Gibt einen Zeiger auf die Textur eines Polygons zurück ohne erhöhten
  278. //! Reference Counter \param i Der Index des Polygons
  279. DLLEXPORT Textur* zPolygonTextur(int i) const;
  280. };
  281. //! Eine Zeichnung des 3D Frameworks, die ein 3D Model mit Textur und
  282. //! Animation darstellen kann
  283. class Model3D : public Zeichnung3D
  284. {
  285. protected:
  286. Skeleton* skelett;
  287. Model3DData* model;
  288. Model3DTextur* textur;
  289. float ambientFactor;
  290. float diffusFactor;
  291. float specularFactor;
  292. public:
  293. //! Konstruktor
  294. DLLEXPORT Model3D();
  295. //! Destruktor
  296. DLLEXPORT virtual ~Model3D();
  297. //! Setzt die Daten des Models
  298. //! \param data Die Daten
  299. DLLEXPORT void setModelDaten(Model3DData* data);
  300. //! Setzt die zum Zeichnen zu benutzenden Texturen
  301. //! \param txt Ein Liste mit Texturen zu den verschiedenen Polygonen
  302. //! zugeordnet
  303. DLLEXPORT void setModelTextur(Model3DTextur* txt);
  304. //! Git den Factor an, mit dem das umgebungslicht (textur farbe)
  305. //! multipliziert wird \param f der neue Faktor (von 0 bis 1, ambient +
  306. //! specular + diffuse = 1)
  307. DLLEXPORT void setAmbientFactor(float f);
  308. //! Git den Factor an, mit dem die Lichtfarbe von Lichtquellen
  309. //! multipliziert wird \param f der neue Faktor (von 0 bis 1, ambient +
  310. //! specular + diffuse = 1)
  311. DLLEXPORT void setDiffusFactor(float f);
  312. //! Git den Factor an, mit dem die Reflektion von Lichtquellen
  313. //! multipliziert wird \param f der neue Faktor (von 0 bis 1, ambient +
  314. //! specular + diffuse = 1)
  315. DLLEXPORT void setSpecularFactor(float f);
  316. //! Errechnet die Matrizen aller Knochen des Skeletts des Models
  317. //! \param viewProj Die miteinander multiplizierten Kameramatrizen
  318. //! \param matBuffer Ein Array mit Matrizen, der gefüllt werden soll
  319. //! \return Die Anzahl der Matrizen, die das Model benötigt
  320. DLLEXPORT int errechneMatrizen(
  321. Mat4<float>& viewProj, Mat4<float>* matBuffer) override;
  322. //! Verarbeitet die vergangene Zeit
  323. //! \param tickval Die zeit in sekunden, die seit dem letzten Aufruf der
  324. //! Funktion vergangen ist \return true, wenn sich das Objekt verändert
  325. //! hat, false sonnst.
  326. DLLEXPORT virtual bool tick(double tickval) override;
  327. //! zum aktualisieren der shader daten
  328. DLLEXPORT virtual void beforeRender(
  329. GraphicsApi* api, Shader* zVertexShader, Shader* zPixelShader);
  330. DLLEXPORT virtual void afterRender(
  331. GraphicsApi* api, Shader* zVertexShader, Shader* zPixelShader);
  332. //! Gibt die Textur zurück
  333. DLLEXPORT Model3DTextur* getTextur();
  334. //! Gibt die Textur zurück (ohne erhöhten Reference Counter)
  335. DLLEXPORT Model3DTextur* zTextur();
  336. //! Gibt die ModelDaten zurück
  337. DLLEXPORT Model3DData* getModelData();
  338. //! Gibt die ModelDaten zurück (ohne erhöhten Reference Counter)
  339. DLLEXPORT Model3DData* zModelData();
  340. //! prüft, ob ein Strahl dieses Objekt trifft
  341. //! \param point der startpunkt des Strahls in Weltkoordinaten
  342. //! \param dir die Richtung des Strahls in Weltkoordinaten
  343. //! \param maxSqDist Die maximale quadratische distanz die erlaubt ist
  344. //! \param pId die Id des Polygons, zu dem der Schnittpunkt gehört
  345. //! \return den quadratischen Abstand des Schnittpunktes zum Ursprung
  346. //! des Strahls oder -1, wenn kein schnittpunkt existiert
  347. DLLEXPORT virtual float traceRay(Vec3<float>& point,
  348. Vec3<float>& dir,
  349. float maxSqDist,
  350. int& pId) const;
  351. //! berechnet die Farbe des Schnittpunktes deines Strahls
  352. //! \param point der startpunkt des Strahls in Weltkoordinaten
  353. //! \param dir die Richtung des Strahls in Weltkoordinaten
  354. //! \param zWelt die Welt, aus der der Strahl kommt
  355. //! \return die Farbe des Schnittpunktes
  356. DLLEXPORT virtual int traceRay(
  357. Vec3<float>& point, Vec3<float>& dir, int pId, Welt3D* zWelt) const;
  358. //! Gibt die Id der Daten zurück, wenn sie in einer Model3DList
  359. //! registriert wurden. (siehe Framework::zM3DRegister())
  360. DLLEXPORT int getDatenId() const;
  361. //! Git den Factor an, mit dem das umgebungslicht (textur farbe)
  362. //! multipliziert wird
  363. DLLEXPORT float getAmbientFactor() const;
  364. //! Git den Factor an, mit dem die Lichtfarbe von Lichtquellen
  365. //! multipliziert wird
  366. DLLEXPORT float getDiffusFactor() const;
  367. //! Git den Factor an, mit dem die Reflektion von Lichtquellen
  368. //! multipliziert wird
  369. DLLEXPORT float getSpecularFactor() const;
  370. //! Gibt die Anzahl an Vertices zurück
  371. DLLEXPORT int getVertexAnzahl() const;
  372. //! Gibt einen Buffer mit allen Vertecies des Models zurück
  373. DLLEXPORT const Vertex3D* zVertexBuffer() const;
  374. //! Gibt true zurück wenn ein bestimmtes polygon gezeichnet werden muss
  375. DLLEXPORT virtual bool needRenderPolygon(int index);
  376. DLLEXPORT virtual Textur* zEffectTextur();
  377. DLLEXPORT virtual float getEffectPercentage();
  378. };
  379. } // namespace Framework