Model3D.cpp 24 KB

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