M2Datei.cpp 9.6 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379
  1. #include "M2Datei.h"
  2. #include "Datei.h"
  3. #include "Model2D.h"
  4. #include "Text.h"
  5. using namespace Framework;
  6. // Inhalt der M2Datei Klasse aus M2Datei.h
  7. // Konstruktor
  8. M2Datei::M2Datei()
  9. : ReferenceCounter()
  10. {
  11. pfad = new Text();
  12. modelName = new RCArray<Text>();
  13. modelPos = new Array<__int64>();
  14. }
  15. M2Datei::M2Datei(const char* pfad)
  16. : ReferenceCounter()
  17. {
  18. this->pfad = new Text(pfad);
  19. modelName = new RCArray<Text>();
  20. modelPos = new Array<__int64>();
  21. }
  22. M2Datei::M2Datei(Text* pfad)
  23. : ReferenceCounter()
  24. {
  25. this->pfad = pfad;
  26. modelName = new RCArray<Text>();
  27. modelPos = new Array<__int64>();
  28. }
  29. // Destruktor
  30. M2Datei::~M2Datei()
  31. {
  32. pfad->release();
  33. modelName->release();
  34. modelPos->release();
  35. }
  36. // nicht constant
  37. void M2Datei::setPfad(const char* pfad)
  38. {
  39. this->pfad->setText(pfad);
  40. }
  41. void M2Datei::setPfadZ(Text* pfad)
  42. {
  43. if (this->pfad) this->pfad->release();
  44. this->pfad = pfad;
  45. }
  46. void M2Datei::leseDaten()
  47. {
  48. Datei d;
  49. d.setDatei(pfad->getText());
  50. d.open(Datei::Style::lesen);
  51. char anz = 0;
  52. d.lese(&anz, 1);
  53. modelName->leeren();
  54. modelPos->leeren();
  55. for (int i = 0; i < anz; i++)
  56. {
  57. char len = 0;
  58. d.lese(&len, 1);
  59. char* txt = new char[len + 1];
  60. d.lese(txt, len);
  61. txt[(int)len] = 0;
  62. modelName->set(new Text(txt), i);
  63. delete[] txt;
  64. __int64 pos = 0;
  65. d.lese((char*)&pos, 8);
  66. modelPos->set(pos, i);
  67. }
  68. d.close();
  69. }
  70. bool M2Datei::saveModel(Model2DData* zMdr, Text* name)
  71. {
  72. bool ret = saveModel(zMdr, name->getText());
  73. name->release();
  74. return ret;
  75. }
  76. bool M2Datei::saveModel(Model2DData* zMdr, const char* name)
  77. {
  78. int anz = modelName->getEintragAnzahl();
  79. for (int i = 0; i < anz; i++)
  80. {
  81. if (modelName->z(i)->istGleich(name))
  82. {
  83. if (!removeModel(name)) return 0;
  84. break;
  85. }
  86. }
  87. anz = modelName->getEintragAnzahl();
  88. Datei d;
  89. d.setDatei(pfad->getText());
  90. d.open(Datei::Style::lesen);
  91. Datei neu;
  92. neu.setDatei(pfad->getText());
  93. neu.zPfad()->append("0");
  94. while (neu.existiert())
  95. neu.zPfad()->append("0");
  96. if (!neu.open(Datei::Style::schreiben))
  97. {
  98. if (d.istOffen()) d.close();
  99. return 0;
  100. }
  101. modelName->add(new Text(name));
  102. int offs = textLength(name) + 9;
  103. for (int i = 0; i < anz; i++)
  104. modelPos->set(modelPos->get(i) + offs, i);
  105. if (d.getSize() < 0)
  106. modelPos->add(offs + 1);
  107. else
  108. modelPos->add(d.getSize() + offs);
  109. anz++;
  110. char tmp = (char)anz;
  111. neu.schreibe(&tmp, 1);
  112. for (int i = 0; i < anz; i++)
  113. {
  114. char len = (char)modelName->z(i)->getLength();
  115. neu.schreibe(&len, 1);
  116. neu.schreibe(modelName->z(i)->getText(), len);
  117. __int64 pos = modelPos->get(i);
  118. neu.schreibe((char*)&pos, 8);
  119. }
  120. if (d.existiert())
  121. {
  122. d.setLPosition(modelPos->get(0) - offs, 0);
  123. __int64 dl = d.getSize() - d.getLPosition();
  124. char bytes[2048];
  125. while (dl)
  126. {
  127. int l = dl > 2048 ? 2048 : (int)dl;
  128. d.lese(bytes, l);
  129. neu.schreibe(bytes, l);
  130. dl -= l;
  131. }
  132. }
  133. d.close();
  134. char pAnz = (char)zMdr->polygons->getEintragAnzahl();
  135. neu.schreibe(&pAnz, 1);
  136. for (int p = 0; p < pAnz; p++)
  137. {
  138. char pNameL = (char)zMdr->polygons->get(p).name->getLength();
  139. int vAnz = zMdr->polygons->get(p).vertex->getEintragAnzahl();
  140. char options = 1;
  141. for (int i = 0; i < vAnz; i++)
  142. options
  143. = (char)(options
  144. & (char)zMdr->polygons->get(p).tKordinaten->hat(i));
  145. if (pNameL != 0) options |= 2;
  146. if (zMdr->polygons->get(p).transparent) options |= 4;
  147. neu.schreibe(&options, 1);
  148. if ((options | 2) == options) // name
  149. {
  150. neu.schreibe(&pNameL, 1);
  151. neu.schreibe(zMdr->polygons->get(p).name->getText(), pNameL);
  152. }
  153. neu.schreibe((char*)&vAnz, 4);
  154. for (int i = 0; i < vAnz; i++)
  155. {
  156. float v = zMdr->polygons->get(p).vertex->get(i).x;
  157. neu.schreibe((char*)&v, 4);
  158. v = zMdr->polygons->get(p).vertex->get(i).y;
  159. neu.schreibe((char*)&v, 4);
  160. if ((options | 1) == options) // textur
  161. {
  162. float t = zMdr->polygons->get(p).tKordinaten->get(i).x;
  163. neu.schreibe((char*)&t, 4);
  164. t = zMdr->polygons->get(p).tKordinaten->get(i).y;
  165. neu.schreibe((char*)&t, 4);
  166. }
  167. }
  168. }
  169. d.remove();
  170. neu.close();
  171. neu.umbenennen(pfad->getText());
  172. leseDaten();
  173. return 1;
  174. }
  175. bool M2Datei::removeModel(Text* name)
  176. {
  177. bool ret = removeModel(name->getText());
  178. name->release();
  179. return ret;
  180. }
  181. bool M2Datei::removeModel(const char* name)
  182. {
  183. int anz = modelName->getEintragAnzahl();
  184. int p = -1;
  185. for (int i = 0; i < anz; i++)
  186. {
  187. if (modelName->z(i)->istGleich(name))
  188. {
  189. p = i;
  190. break;
  191. }
  192. }
  193. if (p < 0) return 0;
  194. Datei d;
  195. d.setDatei(pfad->getText());
  196. if (!d.open(Datei::Style::lesen)) return 0;
  197. Datei neu;
  198. neu.setDatei(pfad->getText());
  199. neu.zPfad()->append("0");
  200. while (neu.existiert())
  201. neu.zPfad()->append("0");
  202. if (!neu.open(Datei::Style::schreiben))
  203. {
  204. if (d.istOffen()) d.close();
  205. return 0;
  206. }
  207. char nAnz = (char)(anz - 1);
  208. neu.schreibe(&nAnz, 1);
  209. int offs = modelName->z(p)->getLength() + 9;
  210. __int64 startP = 0, endP = 0, start2P = 0;
  211. for (int i = 0; i < anz; i++)
  212. {
  213. char nLen = (char)modelName->z(i)->getLength();
  214. const char* n = modelName->z(i)->getText();
  215. __int64 pos = modelPos->get(i);
  216. if (!startP) startP = pos;
  217. if (i == p + 1) start2P = pos;
  218. if (i == p)
  219. {
  220. if (!endP) endP = pos;
  221. if (i < anz - 1) offs += (int)(modelPos->get(i + 1) - pos);
  222. }
  223. if (i != p)
  224. {
  225. pos -= offs;
  226. neu.schreibe(&nLen, 1);
  227. neu.schreibe(n, nLen);
  228. neu.schreibe((char*)&pos, 8);
  229. }
  230. }
  231. if (d.istOffen())
  232. {
  233. d.setLPosition(startP, 0);
  234. __int64 bLen = endP - startP;
  235. char bytes[2048];
  236. while (bLen > 0)
  237. {
  238. int l = 2048 > bLen ? (int)bLen : 2048;
  239. d.lese(bytes, l);
  240. neu.schreibe(bytes, l);
  241. bLen -= l;
  242. }
  243. if (start2P)
  244. {
  245. d.setLPosition(start2P, 0);
  246. bLen = d.getSize() - start2P;
  247. while (bLen > 0)
  248. {
  249. int l = 2048 > bLen ? (int)bLen : 2048;
  250. d.lese(bytes, l);
  251. neu.schreibe(bytes, l);
  252. bLen -= l;
  253. }
  254. }
  255. d.close();
  256. }
  257. d.remove();
  258. neu.close();
  259. neu.umbenennen(pfad->getText());
  260. leseDaten();
  261. return 1;
  262. }
  263. // constant
  264. Model2DData* M2Datei::ladeModel(Text* name) const
  265. {
  266. Model2DData* ret = ladeModel(name->getText());
  267. name->release();
  268. return ret;
  269. }
  270. Model2DData* M2Datei::ladeModel(const char* name) const
  271. {
  272. Datei d;
  273. d.setDatei(pfad->getText());
  274. if (!d.open(Datei::Style::lesen)) return 0;
  275. int anz = modelName->getEintragAnzahl();
  276. for (int i = 0; i < anz; i++)
  277. {
  278. if (modelName->z(i)->istGleich(name))
  279. {
  280. d.setLPosition(modelPos->get(i), 0);
  281. break;
  282. }
  283. }
  284. if (!d.getLPosition())
  285. {
  286. d.close();
  287. return 0;
  288. }
  289. char pAnz = 0;
  290. d.lese(&pAnz, 1);
  291. Array<Polygon2D>* polygons = new Array<Polygon2D>();
  292. for (int p = 0; p < pAnz; p++)
  293. {
  294. char options = 0;
  295. d.lese(&options, 1);
  296. Polygon2D polygon;
  297. polygon.schwerpunkt = new Vertex(0, 0);
  298. polygon.transparent = (options | 4) == options;
  299. polygon.name = new Text();
  300. if ((options | 2) == options)
  301. {
  302. char nameL = 0;
  303. d.lese(&nameL, 1);
  304. char* name = new char[nameL + 1];
  305. name[(int)nameL] = 0;
  306. d.lese(name, nameL);
  307. polygon.name->setText(name);
  308. delete[] name;
  309. }
  310. int vAnz = 0;
  311. d.lese((char*)&vAnz, 4);
  312. if (polygons->hat(p))
  313. {
  314. if (polygons->get(p).vertex) polygons->get(p).vertex->release();
  315. if (polygons->get(p).tKordinaten)
  316. polygons->get(p).tKordinaten->release();
  317. }
  318. polygon.vertex = new Array<Vertex>();
  319. if ((options | 1) == options) // wenn textur
  320. polygon.tKordinaten = new Array<Vertex>();
  321. else
  322. polygon.tKordinaten = 0;
  323. for (int v = 0; v < vAnz; v++)
  324. {
  325. Vertex p;
  326. d.lese((char*)&p.x, 4);
  327. d.lese((char*)&p.y, 4);
  328. *polygon.schwerpunkt += p * (float)(1.0 / vAnz);
  329. polygon.vertex->add(p);
  330. if ((options | 1) == options) // wenn textur
  331. {
  332. Vertex tp;
  333. d.lese((char*)&tp.x, 4);
  334. d.lese((char*)&tp.y, 4);
  335. polygon.tKordinaten->add(tp);
  336. }
  337. }
  338. polygons->add(polygon);
  339. }
  340. d.close();
  341. Model2DData* ret = new Model2DData();
  342. ret->erstelleModell(polygons);
  343. return ret;
  344. }
  345. bool M2Datei::hatModel(const char* name) const
  346. {
  347. int anz = modelName->getEintragAnzahl();
  348. for (int i = 0; i < anz; i++)
  349. {
  350. if (modelName->z(i)->istGleich(name)) return 1;
  351. }
  352. return 0;
  353. }
  354. int M2Datei::getModelAnzahl() const
  355. {
  356. return modelName->getEintragAnzahl();
  357. }
  358. Text* M2Datei::zModelName(int i) const
  359. {
  360. return modelName->z(i);
  361. }