Animation.cpp 8.3 KB

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