Welt3D.cpp 7.5 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309
  1. #include "Welt3D.h"
  2. #include "DXBuffer.h"
  3. #include "Globals.h"
  4. #include "GraphicsApi.h"
  5. #include "MausEreignis.h"
  6. #include "Model3D.h"
  7. #include "Zeichnung3D.h"
  8. using namespace Framework;
  9. // Inhalt der Welt3D Klasse aus Welt3D.h
  10. // Konstructor
  11. Welt3D::Welt3D()
  12. : Model3DCollection()
  13. {
  14. members = new RCArray<Model3D>();
  15. pointLightCount = 0;
  16. diffuseLightCount = 0;
  17. pointLights = 0;
  18. diffuseLights = 0;
  19. rend = 0;
  20. }
  21. // Destruktor
  22. Welt3D::~Welt3D()
  23. {
  24. members->release();
  25. delete[] pointLights;
  26. delete[] diffuseLights;
  27. }
  28. // Blockiert den zugriff auf das Objekt und wartet gegebenfalls auf den Zugriff
  29. void Welt3D::lock()
  30. {
  31. cs.lock();
  32. }
  33. // Gibt das Objekt für andere Threads frei
  34. void Welt3D::unlock()
  35. {
  36. cs.unlock();
  37. }
  38. // Fügt der Welt ein Objekt hinzu
  39. // obj: Das Objekt, was hinzugefügt werden soll
  40. void Welt3D::addZeichnung(Model3D* obj)
  41. {
  42. cs.lock();
  43. if (debugDX)
  44. {
  45. for (auto i : *members)
  46. {
  47. if (i == obj) throw std::exception();
  48. }
  49. }
  50. members->add(obj);
  51. rend = 1;
  52. cs.unlock();
  53. }
  54. // Entfernt ein Objekt aus der Welt
  55. // obj: Das Objekt, das entwernt werden soll
  56. void Welt3D::removeZeichnung(Model3D* obj)
  57. {
  58. cs.lock();
  59. int index = 0;
  60. for (Model3D* member : *members)
  61. {
  62. if (member == obj)
  63. {
  64. members->remove(index);
  65. rend = 1;
  66. break;
  67. }
  68. index++;
  69. }
  70. cs.unlock();
  71. }
  72. //! Fügt der Welt eine Collection von Objekten hinzu
  73. //! \param collection Die Collection, die hinzugefügt werden soll
  74. void Welt3D::addCollection(Model3DCollection* collection)
  75. {
  76. cs.lock();
  77. modelCollections.add(collection);
  78. rend = 1;
  79. cs.unlock();
  80. }
  81. //! removes a collection of models from the world
  82. //! \param zCollection Die Collection die entfernt werden soll
  83. void Welt3D::removeCollection(Model3DCollection* zCollection)
  84. {
  85. cs.lock();
  86. int index = 0;
  87. for (Model3DCollection* collection : modelCollections)
  88. {
  89. if (collection == zCollection)
  90. {
  91. modelCollections.remove(index);
  92. rend = 1;
  93. break;
  94. }
  95. index++;
  96. }
  97. cs.unlock();
  98. }
  99. // Verarbeitet ein Mausereignis
  100. // me: Das Mausereignis, das verarbeitet werden soll
  101. void Welt3D::doMausEreignis(MausEreignis3D& me)
  102. {
  103. // cs.lock()
  104. // int anz = 0;
  105. // int index = 0;
  106. // for( Zeichnung3D **i = members; index < arraySize; i++, index++ )
  107. //{
  108. // if( *i )
  109. // {
  110. // distSq[ anz ] = me.pos.abstandSq( ( *i )->getPos() );
  111. // alphaVS[ anz ] = *i;
  112. // anz++;
  113. // }
  114. // }
  115. // index = 0;
  116. // for( Zeichnung3D **i = membersAlpha; index < arraySizeAlpha; i++, index++
  117. // )
  118. //{
  119. // if( *i )
  120. // {
  121. // distSq[ anz ] = me.pos.abstandSq( ( *i )->getPos() );
  122. // alphaVS[ anz ] = *i;
  123. // anz++;
  124. // }
  125. // }
  126. // float maxEntf;
  127. // int ind;
  128. // do
  129. //{
  130. // maxEntf = -1;
  131. // ind = -1;
  132. // for( int i = 0; i < anz; i++ )
  133. // {
  134. // if( !used[ i ] && distSq[ i ] > maxEntf )
  135. // {
  136. // maxEntf = distSq[ i ];
  137. // ind = i;
  138. // }
  139. // }
  140. // if( ind >= 0 )
  141. // {
  142. // alphaVS[ ind ]->doMausEreignis( me );
  143. // if( me.verarbeitet )
  144. // {
  145. // cs.unlock();
  146. // return;
  147. // }
  148. // used[ ind ] = 1;
  149. // }
  150. // } while( ind >= 0 );
  151. // cs.unlock();
  152. }
  153. // Verarbeitet die vergangene Zeit
  154. // tickval: Die zeit in sekunden, die seit dem letzten Aufruf der Funktion
  155. // vergangen ist return: true, wenn sich das Objekt verändert hat, false
  156. // sonnst.
  157. bool Welt3D::tick(double tickval)
  158. {
  159. cs.lock();
  160. rend |= tick(
  161. [this, &tickval](Model3D* m) { rend |= m->tick(tickval); }, tickval);
  162. cs.unlock();
  163. bool tmp = rend;
  164. rend = 0;
  165. return tmp;
  166. }
  167. // brerechnet die Farbe eines Sichtstrahls, der von einem bestimmten punkt aus
  168. // in eine bestimmte richtung schaut
  169. // point: Der ursprung des Strahls,
  170. // dir: Die Richtung des Strahls
  171. // return: Die Farbe des Strahls
  172. int Welt3D::traceRay(Vec3<float>& point, Vec3<float>& dir)
  173. {
  174. float min = INFINITY;
  175. int pId = 0;
  176. Model3D* nearest = 0;
  177. forAll([this, &point, &dir, &pId, &min, &nearest](Model3D* m) {
  178. float tmp = m->traceRay(point, dir, min, pId);
  179. if (min > tmp && tmp >= 0)
  180. {
  181. min = tmp;
  182. nearest = m;
  183. }
  184. });
  185. if (nearest) return nearest->traceRay(point, dir, pId, this);
  186. return 0xFF000000;
  187. }
  188. //! führt eine funktion auf jedem Model aus
  189. void Framework::Welt3D::forAll(std::function<void(Model3D*)> f)
  190. {
  191. for (auto m : *members)
  192. f(m);
  193. for (auto c : modelCollections)
  194. c->forAll(f);
  195. }
  196. //! führt eine tick funktion auf jedem Model aus
  197. bool Welt3D::tick(std::function<void(Model3D*)> f, double time)
  198. {
  199. for (auto m : *members)
  200. f(m);
  201. bool res = 0;
  202. for (auto c : modelCollections)
  203. res |= c->tick(f, time);
  204. return res;
  205. }
  206. //! führt eine render funktion auf jedem Model aus
  207. void Welt3D::render(std::function<void(Model3D*)> f)
  208. {
  209. for (auto m : *members)
  210. f(m);
  211. for (auto c : modelCollections)
  212. c->render(f);
  213. }
  214. int Framework::Welt3D::getPointLightCount() const
  215. {
  216. return pointLightCount;
  217. }
  218. int Framework::Welt3D::getDiffuseLightCount() const
  219. {
  220. return diffuseLightCount;
  221. }
  222. void Framework::Welt3D::copyLight(DXBuffer* zDiffuse, DXBuffer* zPoints) const
  223. {
  224. zDiffuse->setData(diffuseLights);
  225. zDiffuse->setLength(diffuseLightCount * (int)sizeof(DiffuseLight));
  226. zDiffuse->copieren();
  227. zPoints->setData(pointLights);
  228. zPoints->setLength(pointLightCount * (int)sizeof(PointLight));
  229. zPoints->copieren();
  230. }
  231. //! fügt eine neue diffuse lichtquelle hinzu
  232. //! \param light Die neue Lichtquelle
  233. void Framework::Welt3D::addDiffuseLight(DiffuseLight light)
  234. {
  235. DiffuseLight* tmp = new DiffuseLight[diffuseLightCount + 1];
  236. memcpy(tmp, diffuseLights, sizeof(DiffuseLight) * diffuseLightCount);
  237. tmp[diffuseLightCount] = light;
  238. delete[] diffuseLights;
  239. diffuseLights = tmp;
  240. diffuseLightCount++;
  241. }
  242. //! fügt eine neue Punkt lichtquelle hinzu
  243. //! \param light Die neue Lichtquelle
  244. void Framework::Welt3D::addPointLight(PointLight light)
  245. {
  246. PointLight* tmp = new PointLight[pointLightCount + 1];
  247. memcpy(tmp, pointLights, sizeof(PointLight) * pointLightCount);
  248. tmp[pointLightCount] = light;
  249. delete[] pointLights;
  250. pointLights = tmp;
  251. pointLightCount++;
  252. }
  253. //! Gibt die Referenz auf eine Diffuse Lichtquelle zurück
  254. //! \param index Der Index der Lichtquelle
  255. DiffuseLight& Framework::Welt3D::getDiffuseLight(int index) const
  256. {
  257. return diffuseLights[index];
  258. }
  259. //! Gibt die Referenz auf eine Punkt Lichtquelle zurück
  260. //! \param index Der Index der Lichtquelle
  261. PointLight& Framework::Welt3D::getPointLight(int index) const
  262. {
  263. return pointLights[index];
  264. }
  265. //! removes a specific fiffuse light from the world
  266. //! \param index the index of the light
  267. DLLEXPORT void Framework::Welt3D::removeDiffuseLight(int index)
  268. {
  269. for (int i = index; i < diffuseLightCount - 1; i++)
  270. {
  271. diffuseLights[i] = diffuseLights[i + 1];
  272. }
  273. diffuseLightCount--;
  274. }
  275. //! removes a specific point light from the world
  276. //! \param index the index of the light
  277. DLLEXPORT void Framework::Welt3D::removePointLight(int index)
  278. {
  279. for (int i = index; i < pointLightCount - 1; i++)
  280. {
  281. pointLights[i] = pointLights[i + 1];
  282. }
  283. pointLightCount--;
  284. }