Model3D.cpp 25 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003
  1. #include "Model3D.h"
  2. #include "Model2D.h"
  3. #include "DXBuffer.h"
  4. #include "Textur.h"
  5. #include "Animation3D.h"
  6. #include "Welt3D.h"
  7. #include "Textur.h"
  8. #include "Bild.h"
  9. #ifdef WIN32
  10. #include <d3d11.h>
  11. #endif
  12. #include <stdexcept>
  13. using namespace Framework;
  14. // Inhalt der Knochen Klasse
  15. // Konstruktor
  16. Knochen::Knochen(int id)
  17. {
  18. pos = Vec3< float >(0, 0, 0);
  19. winkel = Vec3< float >(0, 0, 0);
  20. geschwister = 0;
  21. kinder = 0;
  22. this->id = id;
  23. }
  24. // Destruktor
  25. Knochen::~Knochen()
  26. {
  27. delete geschwister;
  28. delete kinder;
  29. }
  30. // public
  31. // Setzt die Position des Knochens relativ zum Model Ursprung
  32. // pos: Die Position
  33. void Knochen::setPosition(Vec3< float >& pos)
  34. {
  35. this->pos = pos;
  36. }
  37. // Setzt die Drehung des Knochens relativ zum Model Ursprung
  38. // winkel: Ein Vektor der die Drehung um die verschiedenen Achsen als Komponenten hat
  39. void Knochen::setDrehung(Vec3< float >& winkel)
  40. {
  41. this->winkel = winkel;
  42. }
  43. // Fügt dem Knochen ein Geschwister Knochen hinzu
  44. // k: Der Knochen, der hinzugefügt werden soll
  45. void Knochen::addGeschwisterKnochen(Knochen* k)
  46. {
  47. if (!geschwister)
  48. geschwister = k;
  49. else
  50. geschwister->addGeschwisterKnochen(k);
  51. }
  52. // Fügt einem bestimmten Knochen ein Kind Knochen hinzu
  53. // id: Die id des Knochens, wo der Knochen als Kind hinzugefügt werden soll
  54. // k: Der Knochen, der hinzugefügt werden soll
  55. void Knochen::addKind(int id, Knochen* k)
  56. {
  57. if (this->id == id)
  58. {
  59. if (!kinder)
  60. kinder = k;
  61. else
  62. kinder->addGeschwisterKnochen(k);
  63. }
  64. else
  65. {
  66. if (kinder)
  67. kinder->addKind(id, k);
  68. else
  69. {
  70. Text err = "Es wurde kein Knochen mit der Id: ";
  71. err += id;
  72. err += " im Skelett gefunden, um ein Kind Knochen hinzuzufügen. Datei:" __FILE__ ", Zeile: ";
  73. err += __LINE__;
  74. err += "!";
  75. delete k;
  76. throw std::out_of_range(err);
  77. }
  78. }
  79. }
  80. // Berechnet die Matrizen des Knochen und die von all seinen Geschwister Knochen und Kind Knochen
  81. // elternMat: Die fertig berechnete Matrix des Elternknochens
  82. // matBuffer: Ein Array, in dem alle berechneten Matrizen gespeichert werden sollen
  83. // scaleFactor: Die Skallierung des Modells
  84. // kamMatrix: Die vereiniegung der view und projektions Matrizen
  85. void Knochen::kalkulateMatrix(Mat4< float >& elternMat, Mat4< float >* matBuffer, float scaleFactor, Mat4< float >& kamMat)
  86. {
  87. if (geschwister)
  88. geschwister->kalkulateMatrix(elternMat, matBuffer, scaleFactor, kamMat);
  89. matBuffer[id] = matBuffer[id].translation(pos * scaleFactor) * matBuffer[id].rotationZ(winkel.z) * matBuffer[id].rotationX(winkel.x) * matBuffer[id].rotationY(winkel.y) * matBuffer[id].scaling(scaleFactor);
  90. matBuffer[id] = elternMat * matBuffer[id];
  91. if (kinder)
  92. kinder->kalkulateMatrix(matBuffer[id], matBuffer, scaleFactor, kamMat);
  93. matBuffer[id] = kamMat * matBuffer[id];
  94. }
  95. Knochen* Framework::Knochen::zGeschwister() const
  96. {
  97. return geschwister;
  98. }
  99. Knochen* Framework::Knochen::zKind() const
  100. {
  101. return kinder;
  102. }
  103. // Kopiert den Knochen mit allen Geschwister Knochen und Kind Knochen
  104. Knochen* Knochen::kopiereKnochen() const
  105. {
  106. Knochen* ret = new Knochen(id);
  107. ret->pos = pos;
  108. ret->winkel = winkel;
  109. if (geschwister)
  110. ret->geschwister = geschwister->kopiereKnochen();
  111. if (kinder)
  112. ret->kinder = kinder->kopiereKnochen();
  113. return ret;
  114. }
  115. // Gibt die Id des Knochens zurück
  116. int Knochen::getId() const
  117. {
  118. return id;
  119. }
  120. // Gibt die Drehung des Knochens zurück
  121. Vec3< float > Knochen::getDrehung() const
  122. {
  123. return winkel;
  124. }
  125. // Gibt die Position des Knochens zurück
  126. Vec3< float > Knochen::getPosition() const
  127. {
  128. return pos;
  129. }
  130. // Gibt den Radius des Knochens zurück
  131. float Knochen::getRadius() const
  132. {
  133. float r = pos.getLength();
  134. if (geschwister)
  135. r = MAX(r, geschwister->getRadius());
  136. if (kinder)
  137. r += kinder->getRadius();
  138. return r;
  139. }
  140. // Inhalt der Skelett Klasse
  141. // Konstruktor
  142. Skelett::Skelett()
  143. : ReferenceCounter()
  144. {
  145. k = 0;
  146. nextId = 0;
  147. }
  148. // Destruktor
  149. Skelett::~Skelett()
  150. {
  151. if (k)
  152. delete k;
  153. }
  154. // Gibt die Id des nächsten Knochens zurück und berechnet die neue Id für den Knochen danach
  155. // Es können maximal MAX_KNOCHEN_ANZ Knochen für ein Skelett existieren. Wenn diese Zahl überschritten wird, so wird -1 zurückgegeben
  156. int Skelett::getNextKnochenId()
  157. {
  158. return nextId++;
  159. }
  160. void Framework::Skelett::setNextKnochenId(int id)
  161. {
  162. nextId = id;
  163. }
  164. // Fügt dem Skellet einen Knochen hinzu
  165. // k: Der Knochen
  166. // elternId: Die Id des Eltern Knochens. Wenn der Knochen kein Elternknochen besitzt, kannder Parameter weggelassen werden.
  167. void Skelett::addKnochen(Knochen* k, int elternId)
  168. {
  169. if (!this->k)
  170. this->k = k;
  171. else
  172. this->k->addKind(elternId, k);
  173. if (k->getId() >= nextId)
  174. nextId = k->getId() + 1;
  175. }
  176. // Berechnet die Matrizen der Knochen
  177. // modelMatrix: Die Matrix, die das Skelett in den Raum der Welt transformiert
  178. // matBuffer: Ein Array von Matrizen, der durch die Knochen Matrizen gefüllt wird
  179. // scaleFactor: Die skallierung des Objektes
  180. // kamMatrix: Die vereiniegung der view und projektions Matrizen
  181. // return: gibt die Anzahl der verwendeten Matrizen zurück
  182. int Skelett::kalkulateMatrix(Mat4< float >& modelMatrix, Mat4< float >* matBuffer, float scaleFactor, Mat4< float >& kamMatrix)
  183. {
  184. k->kalkulateMatrix(modelMatrix, matBuffer, scaleFactor, kamMatrix);
  185. return nextId;
  186. }
  187. // Berechnet den Radius des Skeletts
  188. float Skelett::getRadius() const
  189. {
  190. if (k)
  191. return k->getRadius();
  192. return 0;
  193. }
  194. // gibt den Wurzel Knochen zurück
  195. Knochen* Framework::Skelett::zKnochen() const
  196. {
  197. return k;
  198. }
  199. // Kopiert das Skelett
  200. Skelett* Skelett::kopiereSkelett() const
  201. {
  202. Skelett* ret = new Skelett();
  203. ret->nextId = nextId;
  204. if (k)
  205. ret->addKnochen(k->kopiereKnochen());
  206. return ret;
  207. }
  208. int Framework::Skelett::zNextKnochenId() const
  209. {
  210. return nextId;
  211. }
  212. // Inhalt des Polygon3D Struct
  213. // Konstruktor
  214. Polygon3D::Polygon3D()
  215. {
  216. indexAnz = 0;
  217. indexList = 0;
  218. }
  219. // Destruktor
  220. Polygon3D::~Polygon3D()
  221. {
  222. delete[] indexList;
  223. }
  224. // Inhalt der Model3DData Klasse
  225. // Konstruktor
  226. Model3DData::Model3DData(DXBuffer* dxVertexBuffer, DXBuffer* dxIndexBuffer, int id)
  227. : ReferenceCounter(),
  228. dxIndexBuffer(dxIndexBuffer),
  229. dxVertexBuffer(dxVertexBuffer),
  230. id(id)
  231. {
  232. skelett = 0;
  233. vertexList = 0;
  234. vertexCount = 0;
  235. polygons = new Array< Polygon3D* >();
  236. ambientFactor = 1.f;
  237. diffusFactor = 0.f;
  238. specularFactor = 0.f;
  239. indexCount = 0;
  240. indexBuffer = 0;
  241. radius = 0;
  242. }
  243. // Destruktor
  244. Model3DData::~Model3DData()
  245. {
  246. clearModel();
  247. polygons->release();
  248. dxIndexBuffer->release();
  249. dxVertexBuffer->release();
  250. delete[] indexBuffer;
  251. }
  252. // updates the DX Buffer gpu memory if changed
  253. DLLEXPORT void Model3DData::updateGPUMemory()
  254. {
  255. dxIndexBuffer->copieren();
  256. dxVertexBuffer->copieren();
  257. }
  258. // Löscht alle Model daten
  259. void Model3DData::clearModel()
  260. {
  261. delete[] vertexList;
  262. vertexCount = 0;
  263. vertexList = 0;
  264. for (Polygon3D* i : *polygons)
  265. delete i;
  266. polygons->leeren();
  267. if (skelett)
  268. skelett->release();
  269. skelett = 0;
  270. radius = 0;
  271. delete[] indexBuffer;
  272. indexBuffer = 0;
  273. indexCount = 0;
  274. }
  275. // Berechnet die normalen für die Eckpunkte des Modells
  276. void Model3DData::calculateNormals()
  277. {
  278. for (int i = 0; i < vertexCount; i++)
  279. {
  280. Vec3< float > normal(0, 0, 0);
  281. for (Polygon3D* p : *polygons)
  282. {
  283. int begin = 0;
  284. for (int j = 0; j < p->indexAnz; j++)
  285. {
  286. if (j % 3 == 0)
  287. begin = j;
  288. if (p->indexList[j] == i)
  289. {
  290. Vec3< float > a = vertexList[p->indexList[begin]].pos;
  291. Vec3< float > b = vertexList[p->indexList[begin + 1]].pos;
  292. Vec3< float > c = vertexList[p->indexList[begin + 2]].pos;
  293. normal += (b - a).crossProduct(c - a).normalize();
  294. normal.normalize();
  295. }
  296. }
  297. }
  298. vertexList[i].normal = normal;
  299. }
  300. }
  301. //! Erstellt einen buffer für alle polygon indizes
  302. void Model3DData::buildIndexBuffer()
  303. {
  304. delete[] indexBuffer;
  305. indexCount = 0;
  306. for (Polygon3D* p : *polygons)
  307. indexCount += p->indexAnz;
  308. indexBuffer = new int[indexCount];
  309. int current = 0;
  310. for (Polygon3D* p : *polygons)
  311. {
  312. memcpy(indexBuffer + current, p->indexList, sizeof(int) * p->indexAnz);
  313. current += p->indexAnz;
  314. }
  315. dxIndexBuffer->setLength((int)(indexCount * sizeof(int)));
  316. dxIndexBuffer->setData(indexBuffer);
  317. }
  318. // Setzt den Zeiger auf ein standartmäßig verwendete Skelett
  319. // s: Das Skelett, das verwendet werden soll
  320. void Model3DData::setSkelettZ(Skelett* s)
  321. {
  322. if (skelett)
  323. skelett->release();
  324. skelett = s;
  325. }
  326. // Setzt einen Zeiger auf eine Liste mit allen Vertecies des Models
  327. // vertexList: Ein Array mit Vertecies
  328. // anz: Die Anzahl der Vertecies im Array
  329. void Model3DData::setVertecies(Vertex3D* vertexList, int anz)
  330. {
  331. delete[] this->vertexList;
  332. this->vertexList = vertexList;
  333. vertexCount = anz;
  334. maxPos = { -INFINITY, -INFINITY, -INFINITY };
  335. minPos = { INFINITY, INFINITY, INFINITY };
  336. radius = 0;
  337. for (int i = 0; i < anz; i++)
  338. {
  339. float r = vertexList[i].pos.getLength();
  340. if (r > radius)
  341. radius = r;
  342. if (vertexList[i].pos.x < minPos.x)
  343. minPos.x = vertexList[i].pos.x;
  344. if (vertexList[i].pos.y < minPos.y)
  345. minPos.y = vertexList[i].pos.y;
  346. if (vertexList[i].pos.z < minPos.z)
  347. minPos.z = vertexList[i].pos.z;
  348. if (vertexList[i].pos.x > maxPos.x)
  349. maxPos.x = vertexList[i].pos.x;
  350. if (vertexList[i].pos.y > maxPos.y)
  351. maxPos.y = vertexList[i].pos.y;
  352. if (vertexList[i].pos.z > maxPos.z)
  353. maxPos.z = vertexList[i].pos.z;
  354. vertexList[i].id = i;
  355. }
  356. dxVertexBuffer->setLength((int)(anz * sizeof(Vertex3D)));
  357. dxVertexBuffer->setData(vertexList);
  358. }
  359. // Fügt ein Polygon zum Model hinzu
  360. // polygon: Das Polygon, das hinzugefügt erden soll
  361. void Model3DData::addPolygon(Polygon3D* polygon)
  362. {
  363. polygons->add(polygon);
  364. buildIndexBuffer();
  365. }
  366. // Git den Factor an, mit dem das umgebungslicht (textur farbe) multipliziert wird
  367. // f: der neue Faktor (von 0 bis 1, ambient + specular + diffuse = 1)
  368. void Model3DData::setAmbientFactor(float f)
  369. {
  370. ambientFactor = f;
  371. }
  372. // Git den Factor an, mit dem die Lichtfarbe von Lichtquellen multipliziert wird
  373. // f: der neue Faktor (von 0 bis 1, ambient + specular + diffuse = 1)
  374. void Model3DData::setDiffusFactor(float f)
  375. {
  376. diffusFactor = f;
  377. }
  378. // Git den Factor an, mit dem die Reflektion von Lichtquellen multipliziert wird
  379. // f: der neue Faktor (von 0 bis 1, ambient + specular + diffuse = 1)
  380. void Model3DData::setSpecularFactor(float f)
  381. {
  382. specularFactor = f;
  383. }
  384. // Konvertiert ein 2d Model zu 3D
  385. // model: Das 2d Model, das zu 3d konvertiert werden soll
  386. // z: Die z koordinate aller punkte des Models
  387. void Model3DData::copyModel2D(Model2DData* model, float z)
  388. {
  389. if (model && model->vListen && model->polygons)
  390. {
  391. clearModel();
  392. int vAnz = 0;
  393. for (const Polygon2D& p : *model->polygons)
  394. vAnz += p.vertex->getEintragAnzahl();
  395. Vertex3D* vertexList = new Vertex3D[vAnz];
  396. int index = 0;
  397. for (auto i : *model->vListen)
  398. {
  399. Polygon3D* p = new Polygon3D();
  400. p->indexAnz = 0;
  401. for (auto j : *i)
  402. {
  403. for (auto k = j->zListe()->begin(); k && k.hasNext() && k.next().hasNext(); k++)
  404. p->indexAnz += 3;
  405. }
  406. p->indexList = new int[p->indexAnz];
  407. p->indexAnz = 0;
  408. for (auto j : *i)
  409. {
  410. for (auto k = j->zListe()->begin(); k; k++)
  411. {
  412. assert(index < vAnz);
  413. if (index < vAnz)
  414. {
  415. vertexList[index].pos = Vec3< float >(k->punkt->x, k->punkt->y, z);
  416. vertexList[index].tPos = (Vec2< float >) * k->textur;
  417. if (k.hasNext() && k.next().hasNext())
  418. {
  419. p->indexList[p->indexAnz] = index;
  420. p->indexAnz++;
  421. p->indexList[p->indexAnz] = index + 1;
  422. p->indexAnz++;
  423. p->indexList[p->indexAnz] = index + 2;
  424. p->indexAnz++;
  425. }
  426. }
  427. else
  428. break;
  429. index++;
  430. }
  431. }
  432. addPolygon(p);
  433. }
  434. this->setVertecies(vertexList, vAnz);
  435. buildIndexBuffer();
  436. calculateNormals();
  437. }
  438. }
  439. // Entfernt ein Polygon
  440. // index: Der Index des Polygons
  441. void Model3DData::removePolygon(int index)
  442. {
  443. if (!polygons->hat(index))
  444. return;
  445. delete polygons->get(index);
  446. polygons->remove(index);
  447. buildIndexBuffer();
  448. }
  449. // Berechnet die Matrizen der Knochen
  450. // modelMatrix: Die Matrix, die das Skelett in den Raum der Welt transformiert
  451. // matBuffer: Ein Array von Matrizen, der durch die Knochen Matrizen gefüllt wird
  452. // scaleFactor: Die Skallierung des Modells
  453. // kamMatrix: Die vereiniegung der view und projektions Matrizen
  454. // return: gibt die Anzahl der verwendeten Matrizen zurück
  455. int Model3DData::kalkulateMatrix(Mat4< float >& modelMatrix, Mat4< float >* matBuffer, float scaleFactor, Mat4< float >& kamMatrix) const
  456. {
  457. if (!skelett)
  458. return 0;
  459. return skelett->kalkulateMatrix(modelMatrix, matBuffer, scaleFactor, kamMatrix);
  460. }
  461. // Gibt die Anzahl an Polygonen zurück
  462. int Model3DData::getPolygonAnzahl() const
  463. {
  464. return polygons->getEintragAnzahl();
  465. }
  466. // Gibt ein bestimmtes Polygon zurück
  467. // index: Der Index des Polygons
  468. Polygon3D* Model3DData::getPolygon(int index) const
  469. {
  470. if (!polygons->hat(index))
  471. return 0;
  472. return polygons->get(index);
  473. }
  474. // Gibt einen Iterator zurück, mit dem sich die Polygons auflisten lassen
  475. Iterator< Polygon3D* > Model3DData::getPolygons() const
  476. {
  477. return polygons->begin();
  478. }
  479. // Gibt den radius einer Kugel zurück, die das gesammte Model umschließt
  480. float Model3DData::getRadius() const
  481. {
  482. return radius;
  483. }
  484. // Gibt die Id der Daten zurück, wenn sie in einer Model3DList registriert wurden. (siehe Framework::zM3DRegister())
  485. int Model3DData::getId() const
  486. {
  487. return id;
  488. }
  489. // Git den Factor an, mit dem das umgebungslicht (textur farbe) multipliziert wird
  490. float Model3DData::getAmbientFactor() const
  491. {
  492. return ambientFactor;
  493. }
  494. // Git den Factor an, mit dem die Lichtfarbe von Lichtquellen multipliziert wird
  495. float Model3DData::getDiffusFactor() const
  496. {
  497. return diffusFactor;
  498. }
  499. // Git den Factor an, mit dem die Reflektion von Lichtquellen multipliziert wird
  500. float Model3DData::getSpecularFactor() const
  501. {
  502. return specularFactor;
  503. }
  504. // Gibt eine Kopie des Skeletts zurück, welches für annimationen verwendet werden kann
  505. Skelett* Model3DData::copySkelett() const
  506. {
  507. return skelett ? skelett->kopiereSkelett() : 0;
  508. }
  509. // Gibt die Anzahl an Vertices zurück
  510. int Model3DData::getVertexAnzahl() const
  511. {
  512. return vertexCount;
  513. }
  514. // Gibt einen Buffer mit allen Vertecies des Models zurück
  515. const Vertex3D* Model3DData::zVertexBuffer() const
  516. {
  517. return vertexList;
  518. }
  519. //! Gibt eine refferenz auf den beginn des indexBuffers zurück
  520. const int* Model3DData::getIndexBuffer() const
  521. {
  522. return indexBuffer;
  523. }
  524. //! Gibt eine die Anzahl der indizes im indexBuffer zurück
  525. int Model3DData::getIndexCount() const
  526. {
  527. return indexCount;
  528. }
  529. //! Gibt den Index buffer zurück;
  530. DXBuffer* Model3DData::zDXIndexBuffer() const
  531. {
  532. return dxIndexBuffer;
  533. }
  534. //! Gibt den Vertex buffer zurück;
  535. DXBuffer* Model3DData::zDXVertexBuffer() const
  536. {
  537. return dxVertexBuffer;
  538. }
  539. //! gibt den minnimalen Punkt der Bounding box des Models zurück
  540. Vec3<float> Model3DData::getMinPos() const
  541. {
  542. return minPos;
  543. }
  544. //! gibt den maximalen Punkt der bounding box des Mopdels zurück
  545. Vec3<float> Model3DData::getMaxPos() const
  546. {
  547. return maxPos;
  548. }
  549. // Inhalt der Model3DTextur
  550. // Konstruktor
  551. Model3DTextur::Model3DTextur()
  552. : ReferenceCounter()
  553. {
  554. textures = new Textur * [1];
  555. textures[0] = 0;
  556. textureCount = 1;
  557. }
  558. // Destruktor
  559. Model3DTextur::~Model3DTextur()
  560. {
  561. for (int i = 0; i < textureCount; i++)
  562. {
  563. if (textures[i])
  564. textures[i]->release();
  565. }
  566. delete[] textures;
  567. }
  568. // Legt fest, welche Textur für welches Polygon ist
  569. // pI: Der Index des Polygons
  570. // txt: Die Textur des Polygons
  571. void Model3DTextur::setPolygonTextur(int pI, Textur* txt)
  572. {
  573. if (pI >= textureCount)
  574. {
  575. Textur** tmp = textures;
  576. textures = new Textur * [pI + 1];
  577. memcpy(textures, tmp, sizeof(Textur*) * textureCount);
  578. memset(textures + textureCount, 0, sizeof(Textur*) * (pI + 1 - textureCount));
  579. delete[] tmp;
  580. textureCount = pI + 1;
  581. }
  582. if (textures[pI])
  583. textures[pI]->release();
  584. textures[pI] = txt;
  585. }
  586. // Gibt einen Zeiger auf die Textur eines Polygons zurück ohne erhöhten Reference Counter
  587. // i: Der Index des Polygons
  588. Textur* Model3DTextur::zPolygonTextur(int i) const
  589. {
  590. return textures[i];
  591. }
  592. // Inhalt der AnimationData Struktur
  593. Model3D::AnimationData* Model3D::AnimationData::getThis()
  594. {
  595. return this;
  596. }
  597. Model3D::AnimationData* Model3D::AnimationData::release()
  598. {
  599. a->release();
  600. delete this;
  601. return 0;
  602. }
  603. // Inhalt der Model3D Klasse
  604. // Konstruktor
  605. Model3D::Model3D()
  606. : Zeichnung3D()
  607. {
  608. model = 0;
  609. textur = 0;
  610. skelett = 0;
  611. animations = new RCArray< AnimationData >();
  612. ambientFactor = 1.f;
  613. diffusFactor = 0.f;
  614. specularFactor = 0.f;
  615. }
  616. // Destruktor
  617. Model3D::~Model3D()
  618. {
  619. if (model)
  620. model->release();
  621. if (textur)
  622. textur->release();
  623. if (skelett)
  624. skelett->release();
  625. animations->release();
  626. }
  627. // Fügt eine Animation hinzu
  628. // a: Die neue Animation
  629. void Model3D::addAnimation(Animation3D* a, double speed)
  630. {
  631. AnimationData* d = new AnimationData();
  632. d->a = a;
  633. d->speed = speed;
  634. d->offset = 0;
  635. animations->add(d);
  636. }
  637. // Entfernt eine Animation
  638. // zA: Die zu entfernende Animation
  639. void Model3D::removeAnimation(Animation3D* zA)
  640. {
  641. for (int i = 0; i < animations->getEintragAnzahl(); i++)
  642. {
  643. if (animations->z(i)->a == zA)
  644. {
  645. animations->remove(i);
  646. return;
  647. }
  648. }
  649. }
  650. // Setzt die Daten des Models
  651. // data: Die Daten
  652. void Model3D::setModelDaten(Model3DData* data)
  653. {
  654. if (model)
  655. model->release();
  656. if (skelett)
  657. skelett = (Skelett*)skelett->release();
  658. model = data;
  659. if (model)
  660. {
  661. skelett = model->copySkelett();
  662. this->ambientFactor = model->getAmbientFactor();
  663. this->specularFactor = model->getSpecularFactor();
  664. this->diffusFactor = model->getDiffusFactor();
  665. }
  666. }
  667. // Setzt die zum Zeichnen zu benutzenden Texturen
  668. // txt: Ein Liste mit Texturen zu den verschiedenen Polygonen zugeordnet
  669. void Model3D::setModelTextur(Model3DTextur* txt)
  670. {
  671. if (textur)
  672. textur->release();
  673. textur = txt;
  674. }
  675. // Git den Factor an, mit dem das umgebungslicht (textur farbe) multipliziert wird
  676. // f: der neue Faktor (von 0 bis 1, ambient + specular + diffuse = 1)
  677. void Framework::Model3D::setAmbientFactor(float f)
  678. {
  679. this->ambientFactor = f;
  680. }
  681. // Git den Factor an, mit dem die Lichtfarbe von Lichtquellen multipliziert wird
  682. // f: der neue Faktor (von 0 bis 1, ambient + specular + diffuse = 1)
  683. void Framework::Model3D::setDiffusFactor(float f)
  684. {
  685. diffusFactor = f;
  686. }
  687. // Git den Factor an, mit dem das umgebungslicht (textur farbe) multipliziert wird
  688. // f: der neue Faktor (von 0 bis 1, ambient + specular + diffuse = 1)
  689. void Framework::Model3D::setSpecularFactor(float f)
  690. {
  691. specularFactor = f;
  692. }
  693. // Errechnet die Matrizen aller Knochen des Skeletts des Models
  694. // viewProj: Die miteinander multiplizierten Kameramatrizen
  695. // matBuffer: Ein Array mit Matrizen, der gefüllt werden soll
  696. // return: Die Anzahl der Matrizen, die das Model benötigt
  697. int Model3D::errechneMatrizen(Mat4< float >& viewProj, Mat4< float >* matBuffer)
  698. {
  699. int ret = 0;
  700. if (skelett)
  701. ret = skelett->kalkulateMatrix(welt, matBuffer, size, viewProj);
  702. else if (model)
  703. ret = model->kalkulateMatrix(welt, matBuffer, size, viewProj);
  704. if (!ret)
  705. return Zeichnung3D::errechneMatrizen(viewProj, matBuffer);
  706. return ret;
  707. }
  708. // Verarbeitet die vergangene Zeit
  709. // tickval: Die zeit in sekunden, die seit dem letzten Aufruf der Funktion vergangen ist
  710. // return: true, wenn sich das Objekt verändert hat, false sonnst.
  711. bool Model3D::tick(double tickval)
  712. {
  713. radius = model ? model->getRadius() : 0;
  714. if (skelett)
  715. {
  716. radius += skelett->getRadius();
  717. for (auto i = animations->begin(); i && i._; i++)
  718. {
  719. rend = i->speed > 0;
  720. i->a->apply(skelett, i->offset, tickval * i->speed);
  721. }
  722. }
  723. return Zeichnung3D::tick(tickval);
  724. }
  725. //! zum aktualisieren der shader daten
  726. void Model3D::beforeRender(GraphicsApi* api, Shader* zVertexShader, Shader* zPixelShader)
  727. {}
  728. void Model3D::afterRender(GraphicsApi* api, Shader* zVertexShader, Shader* zPixelShader)
  729. {}
  730. // Gibt die Textur zurück
  731. Model3DTextur* Model3D::getTextur()
  732. {
  733. return textur ? dynamic_cast<Model3DTextur*>(textur->getThis()) : 0;
  734. }
  735. // Gibt die Textur zurück (ohne erhöhten Reference Counter)
  736. Model3DTextur* Model3D::zTextur()
  737. {
  738. return textur;
  739. }
  740. // Gibt die ModelDaten zurück
  741. Model3DData* Model3D::getModelData()
  742. {
  743. return model ? dynamic_cast<Model3DData*>(model->getThis()) : 0;
  744. }
  745. // Gibt die ModelDaten zurück (ohne erhöhten Reference Counter)
  746. Model3DData* Model3D::zModelData()
  747. {
  748. return model;
  749. }
  750. // prüft, ob ein Strahl dieses Objekt trifft
  751. // point: der startpunkt des Strahls in Weltkoordinaten
  752. // dir: die Richtung des Strahls in Weltkoordinaten
  753. // maxSqDist: Die maximale quadratische distanz die erlaubt ist
  754. // pId: die Id des Polygons, zu dem der Schnittpunkt gehört
  755. // return: den quadratischen Abstand des Schnittpunktes zum Ursprung des Strahls oder -1, wenn kein schnittpunkt existiert
  756. float Model3D::traceRay(Vec3< float >& p, Vec3< float >& d, float maxSqDist, int& pId) const
  757. {
  758. if (!model)
  759. return -1;
  760. Vec3< float > dir = d;
  761. dir.rotateY(-angle.y);
  762. dir.rotateX(-angle.x);
  763. dir.rotateZ(-angle.z);
  764. Vec3< float > point = p;
  765. point.rotateY(-angle.y);
  766. point.rotateX(-angle.x);
  767. point.rotateZ(-angle.z);
  768. point -= pos;
  769. float nearest = (-dir.x * point.x - dir.y * point.y - dir.z * point.z) / (dir.x * dir.x + dir.y * dir.y + dir.z * dir.z);
  770. float dist = (point + dir * nearest).getLengthSq();
  771. if (dist > (radius * size) * (radius * size) || (dir * nearest).getLength() - radius * size > sqrt(maxSqDist) || (nearest < 0 && (dir * nearest).getLengthSq() > radius * size * radius * size)) // es gibt kein schnittpunkt
  772. return -1;
  773. bool existsHit = 0;
  774. if (skelett)
  775. { // todo
  776. }
  777. else
  778. {
  779. int index = 0;
  780. for (auto p = model->getPolygons(); p; p++)
  781. {
  782. for (int j = 0; j < p->indexAnz; j++)
  783. {
  784. if (j % 3 == 0)
  785. {
  786. Vec3< float > a = model->zVertexBuffer()[p->indexList[j]].pos;
  787. Vec3< float > b = model->zVertexBuffer()[p->indexList[j + 1]].pos;
  788. Vec3< float > c = model->zVertexBuffer()[p->indexList[j + 2]].pos;
  789. Vec3< float > normal = (b - a).crossProduct(c - a).normalize();
  790. if (normal * dir < 0) // Prüfe ob die Normale in Richtung des Strahl ursprungs zeigt
  791. {
  792. nearest = (a * normal - point * normal) / (dir * normal);
  793. Vec3< float > hit = point + dir * nearest;
  794. if ((b - a).angle(hit - a) <= (b - a).angle(c - a) &&
  795. (c - a).angle(hit - a) <= (b - a).angle(c - a) &&
  796. (a - b).angle(hit - b) <= (a - b).angle(c - b))
  797. {
  798. maxSqDist = (hit - point).getLengthSq();
  799. pId = index;
  800. existsHit = 1;
  801. }
  802. }
  803. index++;
  804. }
  805. }
  806. }
  807. }
  808. return existsHit ? maxSqDist : -1;
  809. }
  810. // berechnet die Farbe des Schnittpunktes deines Strahls
  811. // point: der startpunkt des Strahls in Weltkoordinaten
  812. // dir: die Richtung des Strahls in Weltkoordinaten
  813. // zWelt: die Welt, aus der der Strahl kommt
  814. // return: die Farbe des Schnittpunktes
  815. int Model3D::traceRay(Vec3< float >& p, Vec3< float >& d, int pId, Welt3D* zWelt) const
  816. {
  817. Vec3< float > dir = d;
  818. dir.rotateY(-angle.y);
  819. dir.rotateX(-angle.x);
  820. dir.rotateZ(-angle.z);
  821. Vec3< float > point = p;
  822. point.rotateY(-angle.y);
  823. point.rotateX(-angle.x);
  824. point.rotateZ(-angle.z);
  825. point -= pos;
  826. int index = 0;
  827. for (auto p = model->getPolygons(); p; p++, index++)
  828. {
  829. for (int j = 0; j < p->indexAnz; j++)
  830. {
  831. if (j % 3 == 0)
  832. {
  833. if (pId == 0)
  834. {
  835. const Vec3< float >& a = model->zVertexBuffer()[p->indexList[j]].pos;
  836. const Vec3< float >& b = model->zVertexBuffer()[p->indexList[j + 1]].pos;
  837. const Vec3< float >& c = model->zVertexBuffer()[p->indexList[j + 2]].pos;
  838. Vertex at = model->zVertexBuffer()[p->indexList[j]].tPos;
  839. Vertex bt = model->zVertexBuffer()[p->indexList[j + 1]].tPos;
  840. Vertex ct = model->zVertexBuffer()[p->indexList[j + 2]].tPos;
  841. Vec3< float > normal = (b - a).crossProduct(c - a).normalize();
  842. float t = (a * normal - point * normal) / (dir * normal);
  843. Vec3< float > hit = point + dir * t;
  844. float a0 = (a - b).crossProduct(a - c).getLength() / 2;
  845. float a1 = (b - hit).crossProduct(c - hit).getLength() / 2 / a0;
  846. float a2 = (c - hit).crossProduct(a - hit).getLength() / 2 / a0;
  847. float a3 = (a - hit).crossProduct(b - hit).getLength() / 2 / a0;
  848. Vertex ht = at * a1 + bt * a2 + ct * a3;
  849. Bild* tex = textur->zPolygonTextur(index)->zBild();
  850. if (ht.x >= 0 && ht.y >= 0 && ht.x <= 1 && ht.y <= 1)
  851. return tex->getPixel((int)(ht.x * ((float)tex->getBreite() - 1.f) + 0.5f), (int)(ht.y * ((float)tex->getHeight() - 1.f) + 0.5f));
  852. return 0xFF000000;
  853. }
  854. pId--;
  855. }
  856. }
  857. }
  858. return 0xFF000000;
  859. }
  860. // Gibt die Id der Daten zurück, wenn sie in einer Model3DList registriert wurden. (siehe Framework::zM3DRegister())
  861. int Model3D::getDatenId() const
  862. {
  863. return model ? model->getId() : -1;
  864. }
  865. // Git den Factor an, mit dem das umgebungslicht (textur farbe) multipliziert wird
  866. float Model3D::getAmbientFactor() const
  867. {
  868. return ambientFactor;
  869. }
  870. // Git den Factor an, mit dem die Lichtfarbe von Lichtquellen multipliziert wird
  871. float Model3D::getDiffusFactor() const
  872. {
  873. return diffusFactor;
  874. }
  875. // Git den Factor an, mit dem die Reflektion von Lichtquellen multipliziert wird
  876. float Model3D::getSpecularFactor() const
  877. {
  878. return specularFactor;
  879. }
  880. // Gibt die Anzahl an Vertices zurück
  881. int Model3D::getVertexAnzahl() const
  882. {
  883. return model ? model->getVertexAnzahl() : 0;
  884. }
  885. // Gibt einen Buffer mit allen Vertecies des Models zurück
  886. const Vertex3D* Model3D::zVertexBuffer() const
  887. {
  888. return model ? model->zVertexBuffer() : 0;
  889. }
  890. //! Gibt true zurück wenn ein bestimmtes polygon gezeichnet werden muss
  891. bool Model3D::needRenderPolygon(int index)
  892. {
  893. return 1;
  894. }
  895. Textur* Model3D::zEffectTextur()
  896. {
  897. return 0;
  898. }
  899. float Model3D::getEffectPercentage()
  900. {
  901. return 0;
  902. }