Model3D.cpp 24 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862
  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. // private
  31. // Fügt dem Knochen ein Geschwister Knochen hinzu
  32. // k: Der Knochen, der hinzugefügt werden soll
  33. void Knochen::addGeschwisterKnochen( Knochen *k )
  34. {
  35. if( !geschwister )
  36. geschwister = k;
  37. else
  38. geschwister->addGeschwisterKnochen( k );
  39. }
  40. // public
  41. // Setzt die Position des Knochens relativ zum Model Ursprung
  42. // pos: Die Position
  43. void Knochen::setPosition( Vec3< float > &pos )
  44. {
  45. this->pos = pos;
  46. }
  47. // Setzt die Drehung des Knochens relativ zum Model Ursprung
  48. // winkel: Ein Vektor der die Drehung um die verschiedenen Achsen als Komponenten hat
  49. void Knochen::setDrehung( Vec3< float > &winkel )
  50. {
  51. this->winkel = winkel;
  52. }
  53. // Fügt einem bestimmten Knochen ein Kind Knochen hinzu
  54. // id: Die id des Knochens, wo der Knochen als Kind hinzugefügt werden soll
  55. // k: Der Knochen, der hinzugefügt werden soll
  56. void Knochen::addKind( int id, Knochen *k )
  57. {
  58. if( this->id == id )
  59. {
  60. if( !kinder )
  61. kinder = k;
  62. else
  63. kinder->addGeschwisterKnochen( k );
  64. }
  65. else
  66. {
  67. if( kinder )
  68. kinder->addKind( id, k );
  69. else
  70. {
  71. Text err = "Es wurde kein Knochen mit der Id: ";
  72. err += id;
  73. err += " im Skelett gefunden, um ein Kind Knochen hinzuzufügen. Datei:" __FILE__ ", Zeile: ";
  74. err += __LINE__;
  75. err += "!";
  76. delete k;
  77. throw std::out_of_range( (const char *)err );
  78. }
  79. }
  80. }
  81. // Berechnet die Matrizen des Knochen und die von all seinen Geschwister Knochen und Kind Knochen
  82. // elternMat: Die fertig berechnete Matrix des Elternknochens
  83. // matBuffer: Ein Array, in dem alle berechneten Matrizen gespeichert werden sollen
  84. // scaleFactor: Die Skallierung des Modells
  85. // kamMatrix: Die vereiniegung der view und projektions Matrizen
  86. void Knochen::kalkulateMatrix( Mat4< float > &elternMat, Mat4< float > *matBuffer, float scaleFactor, Mat4< float > &kamMat )
  87. {
  88. if( geschwister )
  89. geschwister->kalkulateMatrix( elternMat, matBuffer, scaleFactor, kamMat );
  90. 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 );
  91. matBuffer[ id ] = elternMat * matBuffer[ id ];
  92. if( kinder )
  93. kinder->kalkulateMatrix( matBuffer[ id ], matBuffer, scaleFactor, kamMat );
  94. matBuffer[ id ] = kamMat * matBuffer[ id ];
  95. }
  96. // Kopiert den Knochen mit allen Geschwister Knochen und Kind Knochen
  97. Knochen *Knochen::kopiereKnochen() const
  98. {
  99. Knochen *ret = new Knochen( id );
  100. ret->pos = pos;
  101. ret->winkel = winkel;
  102. if( geschwister )
  103. ret->geschwister = geschwister->kopiereKnochen();
  104. if( kinder )
  105. ret->kinder = kinder->kopiereKnochen();
  106. return ret;
  107. }
  108. // Gibt die Id des Knochens zurück
  109. int Knochen::getId() const
  110. {
  111. return id;
  112. }
  113. // Gibt die Drehung des Knochens zurück
  114. Vec3< float > Knochen::getDrehung() const
  115. {
  116. return winkel;
  117. }
  118. // Gibt die Position des Knochens zurück
  119. Vec3< float > Knochen::getPosition() const
  120. {
  121. return pos;
  122. }
  123. // Gibt den Radius des Knochens zurück
  124. float Knochen::getRadius() const
  125. {
  126. float r = pos.getLength();
  127. if( geschwister )
  128. r = MAX( r, geschwister->getRadius() );
  129. if( kinder )
  130. r += kinder->getRadius();
  131. return r;
  132. }
  133. // Inhalt der Skelett Klasse
  134. // Konstruktor
  135. Skelett::Skelett()
  136. {
  137. k = 0;
  138. nextId = 0;
  139. ref = 1;
  140. }
  141. // Destruktor
  142. Skelett::~Skelett()
  143. {
  144. if( k )
  145. delete k;
  146. }
  147. // Gibt die Id des nächsten Knochens zurück und berechnet die neue Id für den Knochen danach
  148. // Es können maximal MAX_KNOCHEN_ANZ Knochen für ein Skelett existieren. Wenn diese Zahl überschritten wird, so wird -1 zurückgegeben
  149. int Skelett::getNextKnochenId()
  150. {
  151. return nextId++;
  152. }
  153. // Fügt dem Skellet einen Knochen hinzu
  154. // k: Der Knochen
  155. // elternId: Die Id des Eltern Knochens. Wenn der Knochen kein Elternknochen besitzt, kannder Parameter weggelassen werden.
  156. void Skelett::addKnochen( Knochen *k, int elternId )
  157. {
  158. if( !this->k )
  159. this->k = k;
  160. else
  161. this->k->addKind( elternId, k );
  162. if( k->getId() >= nextId )
  163. nextId = k->getId() + 1;
  164. }
  165. // Berechnet die Matrizen der Knochen
  166. // modelMatrix: Die Matrix, die das Skelett in den Raum der Welt transformiert
  167. // matBuffer: Ein Array von Matrizen, der durch die Knochen Matrizen gefüllt wird
  168. // scaleFactor: Die skallierung des Objektes
  169. // kamMatrix: Die vereiniegung der view und projektions Matrizen
  170. // return: gibt die Anzahl der verwendeten Matrizen zurück
  171. int Skelett::kalkulateMatrix( Mat4< float > & modelMatrix, Mat4< float > * matBuffer, float scaleFactor, Mat4< float > & kamMatrix )
  172. {
  173. k->kalkulateMatrix( modelMatrix, matBuffer, scaleFactor, kamMatrix );
  174. return nextId;
  175. }
  176. // Berechnet den Radius des Skeletts
  177. float Skelett::getRadius() const
  178. {
  179. if( k )
  180. return k->getRadius();
  181. return 0;
  182. }
  183. // Kopiert das Skelett
  184. Skelett *Skelett::kopiereSkelett() const
  185. {
  186. Skelett *ret = new Skelett();
  187. ret->nextId = nextId;
  188. if( k )
  189. ret->addKnochen( k->kopiereKnochen() );
  190. return ret;
  191. }
  192. // Erhöht den Reference Counting Zähler.
  193. Skelett *Skelett::getThis()
  194. {
  195. ref++;
  196. return this;
  197. }
  198. // Verringert den Reference Counting Zähler. Wenn der Zähler 0 erreicht, wird das Zeichnung automatisch gelöscht.
  199. // return: 0.
  200. Skelett *Skelett::release()
  201. {
  202. ref--;
  203. if( !ref )
  204. delete this;
  205. return 0;
  206. }
  207. // Inhalt des Polygon3D Struct
  208. // Konstruktor
  209. Polygon3D::Polygon3D()
  210. {
  211. indexAnz = 0;
  212. indexList = 0;
  213. }
  214. // Destruktor
  215. Polygon3D::~Polygon3D()
  216. {
  217. delete[] indexList;
  218. }
  219. // Inhalt der Model3DData Klasse
  220. // Konstruktor
  221. Model3DData::Model3DData()
  222. {
  223. id = -1;
  224. skelett = 0;
  225. vertexList = 0;
  226. vertexCount = 0;
  227. polygons = new Array< Polygon3D * >();
  228. ambientFactor = 1.f;
  229. diffusFactor = 0.f;
  230. specularFactor = 0.f;
  231. radius = 0;
  232. ref = 1;
  233. }
  234. // Destruktor
  235. Model3DData::~Model3DData()
  236. {
  237. clearModel();
  238. polygons->release();
  239. }
  240. // Löscht alle Model daten
  241. void Model3DData::clearModel()
  242. {
  243. delete[] vertexList;
  244. vertexCount = 0;
  245. vertexList = 0;
  246. for( auto i = polygons->getIterator(); i; i++ )
  247. delete i;
  248. polygons->leeren();
  249. if( skelett )
  250. skelett->release();
  251. skelett = 0;
  252. radius = 0;
  253. }
  254. // Berechnet die normalen für die Eckpunkte des Modells
  255. void Model3DData::calculateNormals()
  256. {
  257. for( int i = 0; i < vertexCount; i++ )
  258. {
  259. Vec3< float > normal( 0, 0, 0 );
  260. for( auto p = polygons->getIterator(); p; p++ )
  261. {
  262. int begin = 0;
  263. for( int j = 0; j < p->indexAnz; j++ )
  264. {
  265. if( j % 3 == 0 )
  266. begin = j;
  267. if( p->indexList[ j ] == i )
  268. {
  269. Vec3< float > a = vertexList[ p->indexList[ begin ] ].pos;
  270. Vec3< float > b = vertexList[ p->indexList[ begin + 1 ] ].pos;
  271. Vec3< float > c = vertexList[ p->indexList[ begin + 2 ] ].pos;
  272. normal += ( b - a ).crossProduct( c - a ).normalize();
  273. normal.normalize();
  274. }
  275. }
  276. }
  277. vertexList[ i ].normal = normal;
  278. }
  279. }
  280. // Setzt den Zeiger auf ein standartmäßig verwendete Skelett
  281. // s: Das Skelett, das verwendet werden soll
  282. void Model3DData::setSkelettZ( Skelett * s )
  283. {
  284. if( skelett )
  285. skelett->release();
  286. skelett = s;
  287. }
  288. // Setzt einen Zeiger auf eine Liste mit allen Vertecies des Models
  289. // vertexList: Ein Array mit Vertecies
  290. // anz: Die Anzahl der Vertecies im Array
  291. void Model3DData::setVertecies( Vertex3D * vertexList, int anz )
  292. {
  293. delete[] this->vertexList;
  294. this->vertexList = vertexList;
  295. vertexCount = anz;
  296. radius = 0;
  297. for( int i = 0; i < anz; i++ )
  298. {
  299. float r = vertexList[ i ].pos.getLength();
  300. if( r > radius )
  301. radius = r;
  302. }
  303. }
  304. // Fügt ein Polygon zum Model hinzu
  305. // polygon: Das Polygon, das hinzugefügt erden soll
  306. void Model3DData::addPolygon( Polygon3D * polygon )
  307. {
  308. polygons->add( polygon );
  309. }
  310. // Git den Factor an, mit dem das umgebungslicht (textur farbe) multipliziert wird
  311. // f: der neue Faktor (von 0 bis 1, ambient + specular + diffuse = 1)
  312. void Model3DData::setAmbientFactor( float f )
  313. {
  314. ambientFactor = f;
  315. }
  316. // Git den Factor an, mit dem die Lichtfarbe von Lichtquellen multipliziert wird
  317. // f: der neue Faktor (von 0 bis 1, ambient + specular + diffuse = 1)
  318. void Model3DData::setDiffusFactor( float f )
  319. {
  320. diffusFactor = f;
  321. }
  322. // Git den Factor an, mit dem die Reflektion von Lichtquellen multipliziert wird
  323. // f: der neue Faktor (von 0 bis 1, ambient + specular + diffuse = 1)
  324. void Model3DData::setSpecularFactor( float f )
  325. {
  326. specularFactor = f;
  327. }
  328. // Konvertiert ein 2d Model zu 3D
  329. // model: Das 2d Model, das zu 3d konvertiert werden soll
  330. // z: Die z koordinate aller punkte des Models
  331. void Model3DData::copyModel2D( Model2DData * model, float z )
  332. {
  333. if( model && model->vListen && model->polygons )
  334. {
  335. clearModel();
  336. int vAnz = 0;
  337. for( auto i = model->polygons->getIterator(); i; i++ )
  338. vAnz += i._.vertex->getEintragAnzahl();
  339. vertexList = new Vertex3D[ vAnz ];
  340. int index = 0;
  341. for( auto i = model->vListen->getIterator(); i; i++ )
  342. {
  343. Polygon3D *p = new Polygon3D();
  344. p->indexAnz = 0;
  345. for( auto j = i->getIterator(); j; j++ )
  346. {
  347. for( auto k = j->zListe()->getIterator(); k.hasNext() && k.next().hasNext(); k++ )
  348. p->indexAnz += 3;
  349. }
  350. p->indexList = new int[ p->indexAnz ];
  351. p->indexAnz = 0;
  352. for( auto j = i->getIterator(); j; j++ )
  353. {
  354. for( auto k = j->zListe()->getIterator(); k; k++ )
  355. {
  356. vertexList[ index ].pos = Vec3< float >( k->punkt->x, k->punkt->y, z );
  357. vertexList[ index ].tPos = ( Vec2< float > ) * k->textur;
  358. if( k.hasNext() && k.next().hasNext() )
  359. {
  360. p->indexList[ p->indexAnz ] = index;
  361. p->indexAnz++;
  362. p->indexList[ p->indexAnz ] = index + 1;
  363. p->indexAnz++;
  364. p->indexList[ p->indexAnz ] = index + 2;
  365. p->indexAnz++;
  366. }
  367. index++;
  368. }
  369. }
  370. addPolygon( p );
  371. }
  372. }
  373. }
  374. // Entfernt ein Polygon
  375. // index: Der Index des Polygons
  376. void Model3DData::removePolygon( int index )
  377. {
  378. if( !polygons->hat( index ) )
  379. return;
  380. delete polygons->get( index );
  381. polygons->remove( index );
  382. }
  383. // Berechnet die Matrizen der Knochen
  384. // modelMatrix: Die Matrix, die das Skelett in den Raum der Welt transformiert
  385. // matBuffer: Ein Array von Matrizen, der durch die Knochen Matrizen gefüllt wird
  386. // scaleFactor: Die Skallierung des Modells
  387. // kamMatrix: Die vereiniegung der view und projektions Matrizen
  388. // return: gibt die Anzahl der verwendeten Matrizen zurück
  389. int Model3DData::kalkulateMatrix( Mat4< float > & modelMatrix, Mat4< float > * matBuffer, float scaleFactor, Mat4< float > & kamMatrix ) const
  390. {
  391. if( !skelett )
  392. return 0;
  393. return skelett->kalkulateMatrix( modelMatrix, matBuffer, scaleFactor, kamMatrix );
  394. }
  395. // Gibt die Anzahl an Polygonen zurück
  396. int Model3DData::getPolygonAnzahl() const
  397. {
  398. return polygons->getEintragAnzahl();
  399. }
  400. // Gibt ein bestimmtes Polygon zurück
  401. // index: Der Index des Polygons
  402. Polygon3D *Model3DData::getPolygon( int index ) const
  403. {
  404. if( !polygons->hat( index ) )
  405. return 0;
  406. return polygons->get( index );
  407. }
  408. // Gibt einen Iterator zurück, mit dem sich die Polygons auflisten lassen
  409. Iterator< Polygon3D * > Model3DData::getPolygons() const
  410. {
  411. return polygons->getIterator();
  412. }
  413. // Gibt den radius einer Kugel zurück, die das gesammte Model umschließt
  414. float Model3DData::getRadius() const
  415. {
  416. return radius;
  417. }
  418. // Gibt die Id der Daten zurück, wenn sie in einer Model3DList registriert wurden. (siehe Framework::zM3DRegister())
  419. int Model3DData::getId() const
  420. {
  421. return id;
  422. }
  423. // Git den Factor an, mit dem das umgebungslicht (textur farbe) multipliziert wird
  424. float Model3DData::getAmbientFactor() const
  425. {
  426. return ambientFactor;
  427. }
  428. // Git den Factor an, mit dem die Lichtfarbe von Lichtquellen multipliziert wird
  429. float Model3DData::getDiffusFactor() const
  430. {
  431. return diffusFactor;
  432. }
  433. // Git den Factor an, mit dem die Reflektion von Lichtquellen multipliziert wird
  434. float Model3DData::getSpecularFactor() const
  435. {
  436. return specularFactor;
  437. }
  438. // Gibt eine Kopie des Skeletts zurück, welches für annimationen verwendet werden kann
  439. Skelett *Model3DData::copySkelett() const
  440. {
  441. return skelett ? skelett->kopiereSkelett() : 0;
  442. }
  443. // Gibt die Anzahl an Vertices zurück
  444. int Model3DData::getVertexAnzahl() const
  445. {
  446. return vertexCount;
  447. }
  448. // Gibt einen Buffer mit allen Vertecies des Models zurück
  449. const Vertex3D *Model3DData::zVertexBuffer() const
  450. {
  451. return vertexList;
  452. }
  453. // Erhöht den Reference Counting Zähler.
  454. // return: this.
  455. Model3DData *Model3DData::getThis()
  456. {
  457. ref++;
  458. return this;
  459. }
  460. // Verringert den Reference Counting Zähler. Wenn der Zähler 0 erreicht, wird das Zeichnung automatisch gelöscht.
  461. // return: 0.
  462. Model3DData *Model3DData::release()
  463. {
  464. ref--;
  465. if( !ref )
  466. delete this;
  467. return 0;
  468. }
  469. // Inhalt der Model3DTextur
  470. // Konstruktor
  471. Model3DTextur::Model3DTextur()
  472. {
  473. textures = new RCArray< Textur >();
  474. ref = 1;
  475. }
  476. // Destruktor
  477. Model3DTextur::~Model3DTextur()
  478. {
  479. textures->release();
  480. }
  481. // Legt fest, welche Textur für welches Polygon ist
  482. // pI: Der Index des Polygons
  483. // txt: Die Textur des Polygons
  484. void Model3DTextur::setPolygonTextur( int pI, Textur * txt )
  485. {
  486. textures->set( txt, pI );
  487. }
  488. // Gibt einen Zeiger auf die Textur eines Polygons zurück ohne erhöhten Reference Counter
  489. // i: Der Index des Polygons
  490. Textur *Model3DTextur::zPolygonTextur( int i ) const
  491. {
  492. return textures->z( i );
  493. }
  494. // Erhöht den Reference Counting Zähler.
  495. // return: this.
  496. Model3DTextur *Model3DTextur::getThis()
  497. {
  498. ref++;
  499. return this;
  500. }
  501. // Verringert den Reference Counting Zähler. Wenn der Zähler 0 erreicht, wird das Zeichnung automatisch gelöscht.
  502. // return: 0.
  503. Model3DTextur *Model3DTextur::release()
  504. {
  505. ref--;
  506. if( !ref )
  507. delete this;
  508. return 0;
  509. }
  510. // Inhalt der AnimationData Struktur
  511. Model3D::AnimationData *Model3D::AnimationData::getThis()
  512. {
  513. return this;
  514. }
  515. Model3D::AnimationData *Model3D::AnimationData::release()
  516. {
  517. a->release();
  518. delete this;
  519. return 0;
  520. }
  521. // Inhalt der Model3D Klasse
  522. // Konstruktor
  523. Model3D::Model3D()
  524. : Zeichnung3D()
  525. {
  526. model = 0;
  527. textur = 0;
  528. skelett = 0;
  529. animations = new RCArray< AnimationData >();
  530. }
  531. // Destruktor
  532. Model3D::~Model3D()
  533. {
  534. if( model )
  535. model->release();
  536. if( textur )
  537. textur->release();
  538. if( skelett )
  539. skelett->release();
  540. animations->release();
  541. }
  542. // Fügt eine Animation hinzu
  543. // a: Die neue Animation
  544. void Model3D::addAnimation( Animation3D * a, double speed )
  545. {
  546. AnimationData *d = new AnimationData();
  547. d->a = a;
  548. d->speed = speed;
  549. d->offset = 0;
  550. animations->add( d );
  551. }
  552. // Entfernt eine Animation
  553. // zA: Die zu entfernende Animation
  554. void Model3D::removeAnimation( Animation3D * zA )
  555. {
  556. for( int i = 0; i < animations->getEintragAnzahl(); i++ )
  557. {
  558. if( animations->z( i )->a == zA )
  559. {
  560. animations->remove( i );
  561. return;
  562. }
  563. }
  564. }
  565. // Setzt die Daten des Models
  566. // data: Die Daten
  567. void Model3D::setModelDaten( Model3DData * data )
  568. {
  569. if( model )
  570. model->release();
  571. if( skelett )
  572. skelett = skelett->release();
  573. model = data;
  574. skelett = model->copySkelett();
  575. }
  576. // Setzt die zum Zeichnen zu benutzenden Texturen
  577. // txt: Ein Liste mit Texturen zu den verschiedenen Polygonen zugeordnet
  578. void Model3D::setModelTextur( Model3DTextur * txt )
  579. {
  580. if( textur )
  581. textur->release();
  582. textur = txt;
  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 ? 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 ? 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 * ( tex->getBreite() - 1 ) + 0.5f ), (int)( ht.y * ( tex->getHeight() - 1 ) + 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 model ? model->getAmbientFactor() : 0.f;
  755. }
  756. // Git den Factor an, mit dem die Lichtfarbe von Lichtquellen multipliziert wird
  757. float Model3D::getDiffusFactor() const
  758. {
  759. return model ? model->getDiffusFactor() : 0.f;
  760. }
  761. // Git den Factor an, mit dem die Reflektion von Lichtquellen multipliziert wird
  762. float Model3D::getSpecularFactor() const
  763. {
  764. return model ? model->getSpecularFactor() : 0.f;
  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. }