Model3D.cpp 25 KB

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