Model3D.cpp 26 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946
  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( (const char*)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. radius = 0;
  335. for( int i = 0; i < anz; i++ )
  336. {
  337. float r = vertexList[ i ].pos.getLength();
  338. if( r > radius )
  339. radius = r;
  340. }
  341. dxVertexBuffer->setLength( (int)(anz * sizeof( Vertex3D )) );
  342. dxVertexBuffer->setData( vertexList );
  343. }
  344. // Fügt ein Polygon zum Model hinzu
  345. // polygon: Das Polygon, das hinzugefügt erden soll
  346. void Model3DData::addPolygon( Polygon3D* polygon )
  347. {
  348. polygons->add( polygon );
  349. buildIndexBuffer();
  350. }
  351. // Git den Factor an, mit dem das umgebungslicht (textur farbe) multipliziert wird
  352. // f: der neue Faktor (von 0 bis 1, ambient + specular + diffuse = 1)
  353. void Model3DData::setAmbientFactor( float f )
  354. {
  355. ambientFactor = f;
  356. }
  357. // Git den Factor an, mit dem die Lichtfarbe von Lichtquellen multipliziert wird
  358. // f: der neue Faktor (von 0 bis 1, ambient + specular + diffuse = 1)
  359. void Model3DData::setDiffusFactor( float f )
  360. {
  361. diffusFactor = f;
  362. }
  363. // Git den Factor an, mit dem die Reflektion von Lichtquellen multipliziert wird
  364. // f: der neue Faktor (von 0 bis 1, ambient + specular + diffuse = 1)
  365. void Model3DData::setSpecularFactor( float f )
  366. {
  367. specularFactor = f;
  368. }
  369. // Konvertiert ein 2d Model zu 3D
  370. // model: Das 2d Model, das zu 3d konvertiert werden soll
  371. // z: Die z koordinate aller punkte des Models
  372. void Model3DData::copyModel2D( Model2DData* model, float z )
  373. {
  374. if( model && model->vListen && model->polygons )
  375. {
  376. clearModel();
  377. int vAnz = 0;
  378. for( Polygon2D p : *model->polygons )
  379. vAnz += p.vertex->getEintragAnzahl();
  380. vertexList = new Vertex3D[ vAnz ];
  381. int index = 0;
  382. for( auto i : *model->vListen )
  383. {
  384. Polygon3D* p = new Polygon3D();
  385. p->indexAnz = 0;
  386. for( auto j : *i )
  387. {
  388. for( auto k = j->zListe()->begin(); k.hasNext() && k.next().hasNext(); k++ )
  389. p->indexAnz += 3;
  390. }
  391. p->indexList = new int[ p->indexAnz ];
  392. p->indexAnz = 0;
  393. for( auto j : *i )
  394. {
  395. for( auto k = j->zListe()->begin(); k; k++ )
  396. {
  397. vertexList[ index ].pos = Vec3< float >( k->punkt->x, k->punkt->y, z );
  398. vertexList[ index ].tPos = (Vec2< float >) * k->textur;
  399. if( k.hasNext() && k.next().hasNext() )
  400. {
  401. p->indexList[ p->indexAnz ] = index;
  402. p->indexAnz++;
  403. p->indexList[ p->indexAnz ] = index + 1;
  404. p->indexAnz++;
  405. p->indexList[ p->indexAnz ] = index + 2;
  406. p->indexAnz++;
  407. }
  408. index++;
  409. }
  410. }
  411. addPolygon( p );
  412. }
  413. dxVertexBuffer->setLength( (int)(vAnz * sizeof( Vertex3D )) );
  414. dxVertexBuffer->setData( vertexList );
  415. }
  416. }
  417. // Entfernt ein Polygon
  418. // index: Der Index des Polygons
  419. void Model3DData::removePolygon( int index )
  420. {
  421. if( !polygons->hat( index ) )
  422. return;
  423. delete polygons->get( index );
  424. polygons->remove( index );
  425. buildIndexBuffer();
  426. }
  427. // Berechnet die Matrizen der Knochen
  428. // modelMatrix: Die Matrix, die das Skelett in den Raum der Welt transformiert
  429. // matBuffer: Ein Array von Matrizen, der durch die Knochen Matrizen gefüllt wird
  430. // scaleFactor: Die Skallierung des Modells
  431. // kamMatrix: Die vereiniegung der view und projektions Matrizen
  432. // return: gibt die Anzahl der verwendeten Matrizen zurück
  433. int Model3DData::kalkulateMatrix( Mat4< float >& modelMatrix, Mat4< float >* matBuffer, float scaleFactor, Mat4< float >& kamMatrix ) const
  434. {
  435. if( !skelett )
  436. return 0;
  437. return skelett->kalkulateMatrix( modelMatrix, matBuffer, scaleFactor, kamMatrix );
  438. }
  439. // Gibt die Anzahl an Polygonen zurück
  440. int Model3DData::getPolygonAnzahl() const
  441. {
  442. return polygons->getEintragAnzahl();
  443. }
  444. // Gibt ein bestimmtes Polygon zurück
  445. // index: Der Index des Polygons
  446. Polygon3D* Model3DData::getPolygon( int index ) const
  447. {
  448. if( !polygons->hat( index ) )
  449. return 0;
  450. return polygons->get( index );
  451. }
  452. // Gibt einen Iterator zurück, mit dem sich die Polygons auflisten lassen
  453. Iterator< Polygon3D* > Model3DData::getPolygons() const
  454. {
  455. return polygons->begin();
  456. }
  457. // Gibt den radius einer Kugel zurück, die das gesammte Model umschließt
  458. float Model3DData::getRadius() const
  459. {
  460. return radius;
  461. }
  462. // Gibt die Id der Daten zurück, wenn sie in einer Model3DList registriert wurden. (siehe Framework::zM3DRegister())
  463. int Model3DData::getId() const
  464. {
  465. return id;
  466. }
  467. // Git den Factor an, mit dem das umgebungslicht (textur farbe) multipliziert wird
  468. float Model3DData::getAmbientFactor() const
  469. {
  470. return ambientFactor;
  471. }
  472. // Git den Factor an, mit dem die Lichtfarbe von Lichtquellen multipliziert wird
  473. float Model3DData::getDiffusFactor() const
  474. {
  475. return diffusFactor;
  476. }
  477. // Git den Factor an, mit dem die Reflektion von Lichtquellen multipliziert wird
  478. float Model3DData::getSpecularFactor() const
  479. {
  480. return specularFactor;
  481. }
  482. // Gibt eine Kopie des Skeletts zurück, welches für annimationen verwendet werden kann
  483. Skelett* Model3DData::copySkelett() const
  484. {
  485. return skelett ? skelett->kopiereSkelett() : 0;
  486. }
  487. // Gibt die Anzahl an Vertices zurück
  488. int Model3DData::getVertexAnzahl() const
  489. {
  490. return vertexCount;
  491. }
  492. // Gibt einen Buffer mit allen Vertecies des Models zurück
  493. const Vertex3D* Model3DData::zVertexBuffer() const
  494. {
  495. return vertexList;
  496. }
  497. //! Gibt eine refferenz auf den beginn des indexBuffers zurück
  498. const int* Model3DData::getIndexBuffer() const
  499. {
  500. return indexBuffer;
  501. }
  502. //! Gibt eine die Anzahl der indizes im indexBuffer zurück
  503. int Model3DData::getIndexCount() const
  504. {
  505. return indexCount;
  506. }
  507. //! Gibt den Index buffer zurück;
  508. DXBuffer* Model3DData::zDXIndexBuffer() const
  509. {
  510. return dxIndexBuffer;
  511. }
  512. //! Gibt den Vertex buffer zurück;
  513. DXBuffer* Model3DData::zDXVertexBuffer() const
  514. {
  515. return dxVertexBuffer;
  516. }
  517. // Inhalt der Model3DTextur
  518. // Konstruktor
  519. Model3DTextur::Model3DTextur()
  520. : ReferenceCounter()
  521. {
  522. textures = new RCArray< Textur >();
  523. }
  524. // Destruktor
  525. Model3DTextur::~Model3DTextur()
  526. {
  527. textures->release();
  528. }
  529. // Legt fest, welche Textur für welches Polygon ist
  530. // pI: Der Index des Polygons
  531. // txt: Die Textur des Polygons
  532. void Model3DTextur::setPolygonTextur( int pI, Textur* txt )
  533. {
  534. while( pI > textures->getLastIndex() )
  535. textures->add( 0 );
  536. textures->set( txt, pI );
  537. }
  538. // Gibt einen Zeiger auf die Textur eines Polygons zurück ohne erhöhten Reference Counter
  539. // i: Der Index des Polygons
  540. Textur* Model3DTextur::zPolygonTextur( int i ) const
  541. {
  542. return textures->z( i );
  543. }
  544. // Inhalt der AnimationData Struktur
  545. Model3D::AnimationData* Model3D::AnimationData::getThis()
  546. {
  547. return this;
  548. }
  549. Model3D::AnimationData* Model3D::AnimationData::release()
  550. {
  551. a->release();
  552. delete this;
  553. return 0;
  554. }
  555. // Inhalt der Model3D Klasse
  556. // Konstruktor
  557. Model3D::Model3D()
  558. : Zeichnung3D()
  559. {
  560. model = 0;
  561. textur = 0;
  562. skelett = 0;
  563. animations = new RCArray< AnimationData >();
  564. ambientFactor = 1.f;
  565. diffusFactor = 0.f;
  566. specularFactor = 0.f;
  567. }
  568. // Destruktor
  569. Model3D::~Model3D()
  570. {
  571. if( model )
  572. model->release();
  573. if( textur )
  574. textur->release();
  575. if( skelett )
  576. skelett->release();
  577. animations->release();
  578. }
  579. // Fügt eine Animation hinzu
  580. // a: Die neue Animation
  581. void Model3D::addAnimation( Animation3D* a, double speed )
  582. {
  583. AnimationData* d = new AnimationData();
  584. d->a = a;
  585. d->speed = speed;
  586. d->offset = 0;
  587. animations->add( d );
  588. }
  589. // Entfernt eine Animation
  590. // zA: Die zu entfernende Animation
  591. void Model3D::removeAnimation( Animation3D* zA )
  592. {
  593. for( int i = 0; i < animations->getEintragAnzahl(); i++ )
  594. {
  595. if( animations->z( i )->a == zA )
  596. {
  597. animations->remove( i );
  598. return;
  599. }
  600. }
  601. }
  602. // Setzt die Daten des Models
  603. // data: Die Daten
  604. void Model3D::setModelDaten( Model3DData* data )
  605. {
  606. if( model )
  607. model->release();
  608. if( skelett )
  609. skelett = (Skelett*)skelett->release();
  610. model = data;
  611. if( model )
  612. {
  613. skelett = model->copySkelett();
  614. this->ambientFactor = model->getAmbientFactor();
  615. this->specularFactor = model->getSpecularFactor();
  616. this->diffusFactor = model->getDiffusFactor();
  617. }
  618. }
  619. // Setzt die zum Zeichnen zu benutzenden Texturen
  620. // txt: Ein Liste mit Texturen zu den verschiedenen Polygonen zugeordnet
  621. void Model3D::setModelTextur( Model3DTextur* txt )
  622. {
  623. if( textur )
  624. textur->release();
  625. textur = txt;
  626. }
  627. // Git den Factor an, mit dem das umgebungslicht (textur farbe) multipliziert wird
  628. // f: der neue Faktor (von 0 bis 1, ambient + specular + diffuse = 1)
  629. void Framework::Model3D::setAmbientFactor( float f )
  630. {
  631. this->ambientFactor = f;
  632. }
  633. // Git den Factor an, mit dem die Lichtfarbe von Lichtquellen multipliziert wird
  634. // f: der neue Faktor (von 0 bis 1, ambient + specular + diffuse = 1)
  635. void Framework::Model3D::setDiffusFactor( float f )
  636. {
  637. diffusFactor = f;
  638. }
  639. // Git den Factor an, mit dem das umgebungslicht (textur farbe) multipliziert wird
  640. // f: der neue Faktor (von 0 bis 1, ambient + specular + diffuse = 1)
  641. void Framework::Model3D::setSpecularFactor( float f )
  642. {
  643. specularFactor = f;
  644. }
  645. // Errechnet die Matrizen aller Knochen des Skeletts des Models
  646. // viewProj: Die miteinander multiplizierten Kameramatrizen
  647. // matBuffer: Ein Array mit Matrizen, der gefüllt werden soll
  648. // return: Die Anzahl der Matrizen, die das Model benötigt
  649. int Model3D::errechneMatrizen( Mat4< float >& viewProj, Mat4< float >* matBuffer )
  650. {
  651. int ret = 0;
  652. if( skelett )
  653. ret = skelett->kalkulateMatrix( welt, matBuffer, size, viewProj );
  654. else if( model )
  655. ret = model->kalkulateMatrix( welt, matBuffer, size, viewProj );
  656. if( !ret )
  657. return Zeichnung3D::errechneMatrizen( viewProj, matBuffer );
  658. return ret;
  659. }
  660. // Verarbeitet die vergangene Zeit
  661. // tickval: Die zeit in sekunden, die seit dem letzten Aufruf der Funktion vergangen ist
  662. // return: true, wenn sich das Objekt verändert hat, false sonnst.
  663. bool Model3D::tick( double tickval )
  664. {
  665. radius = model ? model->getRadius() : 0;
  666. if( skelett )
  667. {
  668. radius += skelett->getRadius();
  669. for( auto i = animations->begin(); i && i._; i++ )
  670. {
  671. rend = i->speed > 0;
  672. i->a->apply( skelett, i->offset, tickval * i->speed );
  673. }
  674. }
  675. return Zeichnung3D::tick( tickval );
  676. }
  677. // Gibt die Textur zurück
  678. Model3DTextur* Model3D::getTextur()
  679. {
  680. return textur ? dynamic_cast<Model3DTextur*>(textur->getThis()) : 0;
  681. }
  682. // Gibt die Textur zurück (ohne erhöhten Reference Counter)
  683. Model3DTextur* Model3D::zTextur()
  684. {
  685. return textur;
  686. }
  687. // Gibt die ModelDaten zurück
  688. Model3DData* Model3D::getModelData()
  689. {
  690. return model ? dynamic_cast<Model3DData*>(model->getThis()) : 0;
  691. }
  692. // Gibt die ModelDaten zurück (ohne erhöhten Reference Counter)
  693. Model3DData* Model3D::zModelData()
  694. {
  695. return model;
  696. }
  697. // prüft, ob ein Strahl dieses Objekt trifft
  698. // point: der startpunkt des Strahls in Weltkoordinaten
  699. // dir: die Richtung des Strahls in Weltkoordinaten
  700. // maxSqDist: Die maximale quadratische distanz die erlaubt ist
  701. // pId: die Id des Polygons, zu dem der Schnittpunkt gehört
  702. // return: den quadratischen Abstand des Schnittpunktes zum Ursprung des Strahls oder -1, wenn kein schnittpunkt existiert
  703. float Model3D::traceRay( Vec3< float >& p, Vec3< float >& d, float maxSqDist, int& pId ) const
  704. {
  705. if( !model )
  706. return -1;
  707. Vec3< float > dir = d;
  708. dir.rotateY( -angle.y );
  709. dir.rotateX( -angle.x );
  710. dir.rotateZ( -angle.z );
  711. Vec3< float > point = p;
  712. point.rotateY( -angle.y );
  713. point.rotateX( -angle.x );
  714. point.rotateZ( -angle.z );
  715. point -= pos;
  716. 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);
  717. float dist = (point + dir * nearest).getLengthSq();
  718. 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
  719. return -1;
  720. bool existsHit = 0;
  721. if( skelett )
  722. { // todo
  723. }
  724. else
  725. {
  726. int index = 0;
  727. for( auto p = model->getPolygons(); p; p++ )
  728. {
  729. for( int j = 0; j < p->indexAnz; j++ )
  730. {
  731. if( j % 3 == 0 )
  732. {
  733. Vec3< float > a = model->zVertexBuffer()[ p->indexList[ j ] ].pos;
  734. Vec3< float > b = model->zVertexBuffer()[ p->indexList[ j + 1 ] ].pos;
  735. Vec3< float > c = model->zVertexBuffer()[ p->indexList[ j + 2 ] ].pos;
  736. Vec3< float > normal = (b - a).crossProduct( c - a ).normalize();
  737. if( normal * dir < 0 ) // Prüfe ob die Normale in Richtung des Strahl ursprungs zeigt
  738. {
  739. nearest = (a * normal - point * normal) / (dir * normal);
  740. Vec3< float > hit = point + dir * nearest;
  741. if( (b - a).angle( hit - a ) <= (b - a).angle( c - a ) &&
  742. (c - a).angle( hit - a ) <= (b - a).angle( c - a ) &&
  743. (a - b).angle( hit - b ) <= (a - b).angle( c - b ) )
  744. {
  745. maxSqDist = (hit - point).getLengthSq();
  746. pId = index;
  747. existsHit = 1;
  748. }
  749. }
  750. index++;
  751. }
  752. }
  753. }
  754. }
  755. return existsHit ? maxSqDist : -1;
  756. }
  757. // berechnet die Farbe des Schnittpunktes deines Strahls
  758. // point: der startpunkt des Strahls in Weltkoordinaten
  759. // dir: die Richtung des Strahls in Weltkoordinaten
  760. // zWelt: die Welt, aus der der Strahl kommt
  761. // return: die Farbe des Schnittpunktes
  762. int Model3D::traceRay( Vec3< float >& p, Vec3< float >& d, int pId, Welt3D* zWelt ) const
  763. {
  764. Vec3< float > dir = d;
  765. dir.rotateY( -angle.y );
  766. dir.rotateX( -angle.x );
  767. dir.rotateZ( -angle.z );
  768. Vec3< float > point = p;
  769. point.rotateY( -angle.y );
  770. point.rotateX( -angle.x );
  771. point.rotateZ( -angle.z );
  772. point -= pos;
  773. int index = 0;
  774. for( auto p = model->getPolygons(); p; p++, index++ )
  775. {
  776. for( int j = 0; j < p->indexAnz; j++ )
  777. {
  778. if( j % 3 == 0 )
  779. {
  780. if( pId == 0 )
  781. {
  782. const Vec3< float >& a = model->zVertexBuffer()[ p->indexList[ j ] ].pos;
  783. const Vec3< float >& b = model->zVertexBuffer()[ p->indexList[ j + 1 ] ].pos;
  784. const Vec3< float >& c = model->zVertexBuffer()[ p->indexList[ j + 2 ] ].pos;
  785. Vertex at = model->zVertexBuffer()[ p->indexList[ j ] ].tPos;
  786. Vertex bt = model->zVertexBuffer()[ p->indexList[ j + 1 ] ].tPos;
  787. Vertex ct = model->zVertexBuffer()[ p->indexList[ j + 2 ] ].tPos;
  788. Vec3< float > normal = (b - a).crossProduct( c - a ).normalize();
  789. float t = (a * normal - point * normal) / (dir * normal);
  790. Vec3< float > hit = point + dir * t;
  791. float a0 = (a - b).crossProduct( a - c ).getLength() / 2;
  792. float a1 = (b - hit).crossProduct( c - hit ).getLength() / 2 / a0;
  793. float a2 = (c - hit).crossProduct( a - hit ).getLength() / 2 / a0;
  794. float a3 = (a - hit).crossProduct( b - hit ).getLength() / 2 / a0;
  795. Vertex ht = at * a1 + bt * a2 + ct * a3;
  796. Bild* tex = textur->zPolygonTextur( index )->zBild();
  797. if( ht.x >= 0 && ht.y >= 0 && ht.x <= 1 && ht.y <= 1 )
  798. return tex->getPixel( (int)(ht.x * ((float)tex->getBreite() - 1.f) + 0.5f), (int)(ht.y * ((float)tex->getHeight() - 1.f) + 0.5f) );
  799. return 0xFF000000;
  800. }
  801. pId--;
  802. }
  803. }
  804. }
  805. return 0xFF000000;
  806. }
  807. // Gibt die Id der Daten zurück, wenn sie in einer Model3DList registriert wurden. (siehe Framework::zM3DRegister())
  808. int Model3D::getDatenId() const
  809. {
  810. return model ? model->getId() : -1;
  811. }
  812. // Git den Factor an, mit dem das umgebungslicht (textur farbe) multipliziert wird
  813. float Model3D::getAmbientFactor() const
  814. {
  815. return ambientFactor;
  816. }
  817. // Git den Factor an, mit dem die Lichtfarbe von Lichtquellen multipliziert wird
  818. float Model3D::getDiffusFactor() const
  819. {
  820. return diffusFactor;
  821. }
  822. // Git den Factor an, mit dem die Reflektion von Lichtquellen multipliziert wird
  823. float Model3D::getSpecularFactor() const
  824. {
  825. return specularFactor;
  826. }
  827. // Gibt die Anzahl an Vertices zurück
  828. int Model3D::getVertexAnzahl() const
  829. {
  830. return model ? model->getVertexAnzahl() : 0;
  831. }
  832. // Gibt einen Buffer mit allen Vertecies des Models zurück
  833. const Vertex3D* Model3D::zVertexBuffer() const
  834. {
  835. return model ? model->zVertexBuffer() : 0;
  836. }
  837. //! Gibt true zurück wenn ein bestimmtes polygon gezeichnet werden muss
  838. bool Model3D::needRenderPolygon( int index )
  839. {
  840. return 1;
  841. }
  842. Textur* Model3D::zEffectTextur()
  843. {
  844. return 0;
  845. }
  846. float Model3D::getEffectPercentage()
  847. {
  848. return 0;
  849. }