Welt3D.cpp 5.0 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199
  1. #include "Welt3D.h"
  2. #include "Zeichnung3D.h"
  3. #include "Render3D.h"
  4. using namespace Framework;
  5. // Inhalt der Welt3D Klasse aus Welt3D.h
  6. // Konstructor
  7. Welt3D::Welt3D()
  8. {
  9. arraySize = 100;
  10. arraySizeAlpha = 100;
  11. members = new Zeichnung3D*[ arraySize ];
  12. membersAlpha = new Zeichnung3D*[ arraySizeAlpha ];
  13. used = new bool[ arraySizeAlpha ];
  14. distSq = new float[ arraySizeAlpha ];
  15. alphaVS = new Zeichnung3D*[ arraySizeAlpha ];
  16. for( int i = 0; i < arraySize; i++ )
  17. members[ i ] = 0;
  18. for( int i = 0; i < arraySizeAlpha; i++ )
  19. membersAlpha[ i ] = 0;
  20. ref = 1;
  21. }
  22. // Destruktor
  23. Welt3D::~Welt3D()
  24. {
  25. delete[] members;
  26. delete[] membersAlpha;
  27. delete[] used;
  28. delete[] distSq;
  29. delete[] alphaVS;
  30. }
  31. // Fügt der Welt ein Objekt hinzu
  32. // obj: Das Objekt, was hinzugefügt werden soll
  33. void Welt3D::addZeichnung( Zeichnung3D *obj )
  34. {
  35. Zeichnung3D **tmp = members;
  36. int max = arraySize;
  37. if( obj->hatAlpha() )
  38. {
  39. tmp = membersAlpha;
  40. max = arraySizeAlpha;
  41. }
  42. for( int i = 0; i < max; i++ )
  43. {
  44. if( !*tmp )
  45. {
  46. *tmp = obj;
  47. return;
  48. }
  49. tmp++;
  50. }
  51. if( obj->hatAlpha() )
  52. {
  53. arraySizeAlpha += 100;
  54. Zeichnung3D **nm = new Zeichnung3D*[ arraySizeAlpha ];
  55. memcpy( nm, membersAlpha, sizeof( Zeichnung3D * ) * ( arraySizeAlpha - 100 ) );
  56. memset( &nm[ arraySizeAlpha - 100 ], 0, sizeof( Zeichnung3D * ) * 100 );
  57. delete[] membersAlpha;
  58. membersAlpha = nm;
  59. membersAlpha[ arraySizeAlpha - 100 ] = obj;
  60. delete[] used;
  61. delete[] distSq;
  62. delete[] alphaVS;
  63. used = new bool[ arraySizeAlpha ];
  64. distSq = new float[ arraySizeAlpha ];
  65. alphaVS = new Zeichnung3D*[ arraySizeAlpha ];
  66. return;
  67. }
  68. arraySize += 100;
  69. Zeichnung3D **nm = new Zeichnung3D*[ arraySize ];
  70. memcpy( nm, members, sizeof( Zeichnung3D * ) * ( arraySize - 100 ) );
  71. memset( &nm[ arraySize - 100 ], 0, sizeof( Zeichnung3D * ) * 100 );
  72. delete[] members;
  73. members = nm;
  74. members[ arraySize - 100 ] = obj;
  75. }
  76. // Entfernt ein Objekt aus der Welt
  77. // obj: Das Objekt, das entwernt werden soll
  78. void Welt3D::removeZeichnung( Zeichnung3D *obj )
  79. {
  80. int index = 0;
  81. if( !obj->hatAlpha() )
  82. {
  83. for( Zeichnung3D **i = members; index < arraySize; i++, index++ )
  84. {
  85. if( *i == obj )
  86. {
  87. *i = 0;
  88. return;
  89. }
  90. }
  91. return;
  92. }
  93. for( Zeichnung3D **i = membersAlpha; index < arraySizeAlpha; i++, index++ )
  94. {
  95. if( *i == obj )
  96. {
  97. *i = 0;
  98. return;
  99. }
  100. }
  101. }
  102. // Verarbeitet die vergangene Zeit
  103. // tickval: Die zeit in sekunden, die seit dem letzten Aufruf der Funktion vergangen ist
  104. // return: true, wenn sich das Objekt verändert hat, false sonnst.
  105. bool Welt3D::tick( double tickval )
  106. {
  107. int index = 0;
  108. bool ret = 0;
  109. for( Zeichnung3D **i = members; index < arraySize; i++, index++ )
  110. {
  111. if( *i && ( *i )->hatAlpha() )
  112. {
  113. addZeichnung( *i );
  114. *i = 0;
  115. continue;
  116. }
  117. ret |= *i ? ( *i )->tick( tickval ) : 0;
  118. }
  119. index = 0;
  120. for( Zeichnung3D **i = membersAlpha; index < arraySizeAlpha; i++, index++ )
  121. {
  122. ret |= *i ? ( *i )->tick( tickval ) : 0;
  123. if( *i && !( *i )->hatAlpha() )
  124. {
  125. addZeichnung( *i );
  126. *i = 0;
  127. continue;
  128. }
  129. }
  130. return ret;
  131. }
  132. // Zeichnet einen ausschnitt der Welt
  133. // zRObj: Enthällt alle Werkzeuge, die zum Zeichnen verwendet werden
  134. void Welt3D::render( Render3D *zRObj )
  135. {
  136. int index = 0;
  137. for( Zeichnung3D **i = members; index < arraySize; i++, index++ )
  138. {
  139. if( *i && zRObj->isInFrustrum( (*i)->getPos(), (*i)->getRadius() ) )
  140. ( *i )->render( zRObj );
  141. }
  142. memset( used, 0, arraySizeAlpha * sizeof( bool ) );
  143. memset( alphaVS, 0, arraySizeAlpha * sizeof( Zeichnung3D * ) );
  144. index = 0;
  145. int index2 = 0;
  146. for( Zeichnung3D **i = membersAlpha; index < arraySizeAlpha; i++, index++ )
  147. {
  148. if( *i && zRObj->isInFrustrum( ( *i )->getPos(), ( *i )->getRadius(), &distSq[ index2 ] ) )
  149. {
  150. alphaVS[ index2 ] = *i;
  151. index2++;
  152. }
  153. }
  154. float maxEntf;
  155. int ind;
  156. do
  157. {
  158. maxEntf = -1;
  159. ind = -1;
  160. for( int i = 0; i < index2; i++ )
  161. {
  162. if( !used[ i ] && distSq[ i ] > maxEntf )
  163. {
  164. maxEntf = distSq[ i ];
  165. ind = i;
  166. }
  167. }
  168. if( ind >= 0 )
  169. {
  170. alphaVS[ ind ]->render( zRObj );
  171. used[ ind ] = 1;
  172. }
  173. }
  174. while( ind >= 0 );
  175. }
  176. // Erhöht den Reference Counting Zähler.
  177. // return: this.
  178. Welt3D *Welt3D::getThis()
  179. {
  180. ref++;
  181. return this;
  182. }
  183. // Verringert den Reference Counting Zähler. Wenn der Zähler 0 erreicht, wird das Zeichnung automatisch gelöscht.
  184. // return: 0.
  185. Welt3D *Welt3D::release()
  186. {
  187. ref--;
  188. if( !ref )
  189. delete this;
  190. return 0;
  191. }