Animation.cpp 8.6 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430
  1. #include "Animation.h"
  2. #include "Bild.h"
  3. #include "DateiSystem.h"
  4. #include "Text.h"
  5. #include "InitDatei.h"
  6. #include "ToolTip.h"
  7. #include "Rahmen.h"
  8. using namespace Framework;
  9. // Inhalt der Animation2DData Klasse aus Animation.h
  10. // Konstruktor
  11. Animation2DData::Animation2DData()
  12. : bilder( 0 ),
  13. bildAnzahl( 0 ),
  14. fps( 0 ),
  15. wiederhohlen( 0 ),
  16. transparent( 0 ),
  17. ref( 1 )
  18. {}
  19. // Destruktor
  20. Animation2DData::~Animation2DData()
  21. {
  22. reset();
  23. }
  24. // nicht constant
  25. void Animation2DData::lock()
  26. {
  27. cs.lock();
  28. }
  29. void Animation2DData::unlock()
  30. {
  31. cs.unlock();
  32. }
  33. void Animation2DData::ladeAnimation( InitDatei *datei )
  34. {
  35. if( !datei )
  36. return;
  37. reset();
  38. int anz = datei->getWertAnzahl();
  39. lock();
  40. if( datei->wertExistiert( "fps" ) )
  41. {
  42. --anz;
  43. fps = TextZuInt( datei->zWert( "fps" )->getText(), 10 );
  44. }
  45. if( datei->wertExistiert( "wiederhohlen" ) )
  46. {
  47. --anz;
  48. wiederhohlen = datei->zWert( "wiederhohlen" )->istGleich( "true" );
  49. }
  50. if( datei->wertExistiert( "transparent" ) )
  51. {
  52. --anz;
  53. transparent = datei->zWert( "transparent" )->istGleich( "true" );
  54. }
  55. Bild **bilder = new Bild*[ anz ];
  56. int j = 0;
  57. for( int i = 0; i < anz; ++i )
  58. {
  59. if( datei->zName( i )->istGleich( "fps" ) ||
  60. datei->zName( i )->istGleich( "wiederhohlen" ) ||
  61. datei->zName( i )->istGleich( "transparent" ) )
  62. continue;
  63. bilder[ j ] = 0;
  64. Text pfad = datei->zWert( i )->getText();
  65. if( pfad.hat( ".ltdb/" ) && pfad.getLength() > 7 )
  66. {
  67. Text *name = pfad.getTeilText( pfad.positionVon( ".ltdb/", pfad.anzahlVon( ".ltdb/" ) - 1 ) + 6 );
  68. pfad.setText( pfad.getTeilText( 0, pfad.getLength() - name->getLength() - 1 ) );
  69. LTDBDatei *dat = new LTDBDatei();
  70. dat->setDatei( pfad.getThis() );
  71. dat->leseDaten( 0 );
  72. bilder[ j ] = dat->laden( 0, name );
  73. dat->release();
  74. }
  75. ++j;
  76. }
  77. this->bilder = new Bild*[ bildAnzahl ];
  78. j = 0;
  79. for( int i = 0; i < anz; ++i )
  80. {
  81. if( !bilder[ i ] )
  82. ++j;
  83. else
  84. this->bilder[ i - j ] = bilder[ i ];
  85. }
  86. delete[] bilder;
  87. unlock();
  88. datei->release();
  89. }
  90. void Animation2DData::ladeAnimation( LTDBDatei *datei )
  91. {
  92. if( !datei )
  93. return;
  94. reset();
  95. datei->leseDaten( 0 );
  96. int anz = datei->getBildAnzahl();
  97. RCArray< Text > *list = datei->zBildListe();
  98. lock();
  99. Bild **bilder = new Bild*[ anz ];
  100. for( int i = 0; i < anz; ++i )
  101. {
  102. bilder[ i ] = datei->laden( 0, list->get( i ) );
  103. if( bilder[ i ] )
  104. ++bildAnzahl;
  105. }
  106. this->bilder = new Bild*[ bildAnzahl ];
  107. int j = 0;
  108. for( int i = 0; i < anz; ++i )
  109. {
  110. if( !bilder[ i ] )
  111. ++j;
  112. else
  113. this->bilder[ i - j ] = bilder[ i ];
  114. }
  115. delete[] bilder;
  116. unlock();
  117. datei->release();
  118. }
  119. void Animation2DData::setFPS( int fps )
  120. {
  121. this->fps = fps;
  122. }
  123. void Animation2DData::setWiederhohlend( bool wh )
  124. {
  125. wiederhohlen = wh;
  126. }
  127. void Animation2DData::setTransparent( bool trp )
  128. {
  129. transparent = trp;
  130. }
  131. void Animation2DData::reset()
  132. {
  133. lock();
  134. for( int i = 0; i < bildAnzahl; ++i )
  135. bilder[ i ] = bilder[ i ]->release();
  136. delete[] bilder;
  137. bilder = 0;
  138. bildAnzahl = 0;
  139. fps = 30;
  140. wiederhohlen = 0;
  141. transparent = 0;
  142. unlock();
  143. }
  144. // constant
  145. Bild *Animation2DData::getBild( int i ) const
  146. {
  147. return ( i >= 0 && i < bildAnzahl ) ? bilder[ i ]->getThis() : 0;
  148. }
  149. Bild *Animation2DData::zBild( int i ) const
  150. {
  151. return ( i >= 0 && i < bildAnzahl ) ? bilder[ i ] : 0;
  152. }
  153. int Animation2DData::getBildAnzahl() const
  154. {
  155. return bildAnzahl;
  156. }
  157. int Animation2DData::getFPS() const
  158. {
  159. return fps;
  160. }
  161. bool Animation2DData::istWiederhohlend() const
  162. {
  163. return wiederhohlen;
  164. }
  165. bool Animation2DData::istTransparent() const
  166. {
  167. return transparent;
  168. }
  169. // Reference Counting
  170. Animation2DData *Animation2DData::getThis()
  171. {
  172. ++ref;
  173. return this;
  174. }
  175. Animation2DData *Animation2DData::release()
  176. {
  177. --ref;
  178. if( !ref )
  179. delete this;
  180. return 0;
  181. }
  182. // Inhalt der Animation2D Klasse aus Animation.h
  183. // Konstruktor
  184. Animation2D::Animation2D()
  185. : Zeichnung(),
  186. data( 0 ),
  187. jetzt( 0 ),
  188. ausgleich( 0 ),
  189. alpha( 0 ),
  190. maxAlpha( 255 ),
  191. rahmen( 0 ),
  192. ram( 0 ),
  193. aps( 255 * 60 ),
  194. sichtbar( 0 )
  195. {}
  196. // Destruktor
  197. Animation2D::~Animation2D()
  198. {
  199. if( data )
  200. data->release();
  201. if( ram )
  202. ram->release();
  203. }
  204. // nicht constant
  205. void Animation2D::setRahmen( bool ram )
  206. {
  207. rahmen = ram;
  208. }
  209. void Animation2D::setRahmenZ( Rahmen *ram )
  210. {
  211. if( this->ram )
  212. this->ram->release();
  213. this->ram = ram;
  214. }
  215. void Animation2D::setRahmenBreite( int br )
  216. {
  217. if( !ram )
  218. ram = new LRahmen();
  219. ram->setRamenBreite( br );
  220. }
  221. void Animation2D::setRahmenFarbe( int f )
  222. {
  223. if( !ram )
  224. ram = new LRahmen();
  225. ram->setFarbe( f );
  226. }
  227. void Animation2D::setAnimationDataZ( Animation2DData *data )
  228. {
  229. lockZeichnung();
  230. if( this->data )
  231. this->data->release();
  232. this->data = data;
  233. if( alpha )
  234. rend = 1;
  235. unlockZeichnung();
  236. }
  237. void Animation2D::setAlphaMaske( unsigned char alpha )
  238. {
  239. maxAlpha = alpha;
  240. }
  241. void Animation2D::setAPS( int aps )
  242. {
  243. this->aps = aps;
  244. }
  245. void Animation2D::setSichtbar( bool sichtbar )
  246. {
  247. this->sichtbar = sichtbar;
  248. }
  249. bool Animation2D::tick( double zeit )
  250. {
  251. lockZeichnung();
  252. if( !data || ( !alpha && !sichtbar ) )
  253. {
  254. bool ret = rend;
  255. rend = 0;
  256. unlockZeichnung();
  257. return ret;
  258. }
  259. if( sichtbar && alpha < maxAlpha )
  260. {
  261. if( alpha + aps * zeit >= maxAlpha )
  262. alpha = maxAlpha;
  263. else
  264. alpha = (unsigned char)( alpha + aps * zeit );
  265. rend = 1;
  266. }
  267. else if( !sichtbar && alpha > 0 )
  268. {
  269. if( alpha - aps * zeit <= 0 )
  270. alpha = 0;
  271. else
  272. alpha = (unsigned char)( alpha - aps * zeit );
  273. rend = 1;
  274. }
  275. ausgleich += zeit;
  276. int tmp = jetzt;
  277. data->lock();
  278. if( ausgleich >= 1.0 / data->getFPS() )
  279. {
  280. ausgleich -= 1.0 / data->getFPS();
  281. ++jetzt;
  282. if( jetzt >= data->getBildAnzahl() )
  283. {
  284. if( data->istWiederhohlend() )
  285. jetzt = 0;
  286. else
  287. jetzt = data->getBildAnzahl();
  288. }
  289. }
  290. data->unlock();
  291. if( tmp != jetzt )
  292. rend = 1;
  293. unlockZeichnung();
  294. return Zeichnung::tick( zeit );
  295. }
  296. void Animation2D::render( Bild &zRObj )
  297. {
  298. lockZeichnung();
  299. if( !data )
  300. {
  301. unlockZeichnung();
  302. return;
  303. }
  304. Zeichnung::render( zRObj );
  305. data->lock();
  306. if( data->zBild( jetzt ) )
  307. {
  308. zRObj.setAlpha( alpha );
  309. if( data->istTransparent() )
  310. zRObj.alphaBild( pos.x, pos.y, gr.x, gr.y, *data->zBild( jetzt ) );
  311. else
  312. zRObj.drawBild( pos.x, pos.y, gr.x, gr.y, *data->zBild( jetzt ) );
  313. if( ram && rahmen )
  314. {
  315. ram->setPosition( pos );
  316. ram->setSize( gr );
  317. ram->render( zRObj );
  318. }
  319. zRObj.releaseAlpha();
  320. }
  321. data->unlock();
  322. unlockZeichnung();
  323. }
  324. // constant
  325. Animation2DData *Animation2D::getAnimationData() const
  326. {
  327. return data ? data->getThis() : 0;
  328. }
  329. Animation2DData *Animation2D::zAnimationData() const
  330. {
  331. return data;
  332. }
  333. bool Animation2D::istSichtbar() const
  334. {
  335. return sichtbar;
  336. }
  337. int Animation2D::getJetzt() const
  338. {
  339. return jetzt;
  340. }
  341. unsigned char Animation2D::getAlphaMaske() const
  342. {
  343. return maxAlpha;
  344. }
  345. bool Animation2D::hatRahmen() const
  346. {
  347. return rahmen;
  348. }
  349. Rahmen *Animation2D::getRahmen() const
  350. {
  351. return ram ? (Rahmen*)ram->getThis() : 0;
  352. }
  353. Rahmen *Animation2D::zRahmen() const
  354. {
  355. return ram;
  356. }
  357. int Animation2D::getRahmenBreite() const
  358. {
  359. return ram ? ram->getRBreite() : 0;
  360. }
  361. int Animation2D::getRahmenFarbe() const
  362. {
  363. return ram ? ram->getFarbe() : 0;
  364. }
  365. Zeichnung *Animation2D::dublizieren() const
  366. {
  367. Animation2D *ret = new Animation2D();
  368. ret->setPosition( pos );
  369. ret->setSize( gr );
  370. ret->setMausEreignisParameter( makParam );
  371. ret->setTastaturEreignisParameter( takParam );
  372. ret->setMausEreignis( mak );
  373. ret->setTastaturEreignis( tak );
  374. if( toolTip )
  375. ret->setToolTipZ( (ToolTip*)toolTip->dublizieren() );
  376. if( data )
  377. ret->setAnimationDataZ( data->getThis() );
  378. ret->setAPS( aps );
  379. ret->setSichtbar( sichtbar );
  380. ret->setAlphaMaske( maxAlpha );
  381. ret->setRahmen( rahmen );
  382. if( ram )
  383. {
  384. ret->setRahmenBreite( ram->getRBreite() );
  385. ret->setRahmenFarbe( ram->getFarbe() );
  386. }
  387. return ret;
  388. }