Model3D.cpp 25 KB

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