fork download
copy 
  1. #include <iostream>
  2. #include <fstream>
  3. #include <string>
  4. //#include "Tortoise.h"
  5.  
  6.  
  7. //#pragma once
  8. #include <vector>
  9. #include <cstdint>
  10. #include <initializer_list>
  11.  
  12. class Surface32 {
  13. public:
  14. 	struct Element {
  15. 		Element() {
  16. 			this->ui32 = 0xffffffff;
  17. 		}
  18. 		Element(std::uint32_t Color) {
  19. 			this->ui32 = Color;
  20. 		}
  21. 		Element(std::uint8_t R, std::uint8_t G, std::uint8_t B) {
  22. 			this->R = R;
  23. 			this->G = G;
  24. 			this->B = B;
  25. 			this->A = 0xff;
  26. 		}
  27. 		Element(std::uint8_t R, std::uint8_t G, std::uint8_t B, std::uint8_t A) {
  28. 			this->R = R;
  29. 			this->G = G;
  30. 			this->B = B;
  31. 			this->A = A;
  32. 		}
  33. 		union {
  34. 			struct
  35. 			{
  36. 				std::uint8_t b, g, r, a;//バイトオーダーが絡むときがあるのでここの並びが大事です！
  37. 			};
  38. 			struct
  39. 			{
  40. 				std::uint8_t B, G, R, A;//これも！
  41. 			};
  42. 			std::uint32_t ui32;
  43. 			std::uint8_t ui8a[4];
  44. 		};
  45. 	};
  46. protected:
  47. 	typedef std::vector<Element> RowType;
  48. 	typedef std::vector<RowType> Surface;
  49. public:
  50. 	Surface32() = delete;
  51. 	Surface32(std::size_t Width, std::size_t Height) {
  52. 		Resize(Width, Height);
  53. 	}
  54. 	Surface32(std::initializer_list<RowType> i) :S(i.begin(), i.end()) {
  55. 		H = i.size();
  56. 		W = (*(i.begin())).size();
  57. 		Resize(W, H);
  58. 	}
  59. 	bool Resize(std::size_t Width, std::size_t Height) {
  60. 		W = Width;
  61. 		H = Height;
  62. 		S.resize(Height);
  63. 		for (auto&o : S) {
  64. 			o.resize(Width);
  65. 		}
  66. 		return true;
  67. 	}
  68. 	bool Fill(const Element& E) {
  69. 		for (auto&oo : S) {
  70. 			for (auto&o : oo) {
  71. 				o = E;
  72. 			}
  73. 		}
  74. 		return true;
  75. 	}
  76.  
  77. 	RowType& operator [](const std::size_t& Idx) {//このインデックスは縦方向を指定しています。
  78. 		return S[Idx];//返るのは横方向です。
  79. 	}
  80.  
  81. 	Surface::iterator begin() {
  82. 		return S.begin();
  83. 	}
  84. 	Surface::iterator end() {
  85. 		return S.end();
  86. 	}
  87. 	std::size_t Width() {
  88. 		return W;
  89. 	}
  90. 	std::size_t Height() {
  91. 		return H;
  92. 	}
  93.  
  94. 	bool SetPixel(const std::size_t& X, const std::size_t& Y, const Element& E) {
  95. 		if (X >= W) return false;
  96. 		if (Y >= H) return false;
  97. 		S[Y][X] = E;
  98. 		return true;
  99. 	}
  100.  
  101. protected:
  102. 	std::size_t W;
  103. 	std::size_t H;
  104. 	Surface S;
  105. };
  106. #include <cstdint>
  107. #include <tuple>
  108. #include <cmath>
  109. #include <algorithm>
  110. //#include "Surface32.h"
  111.  
  112. //read this. http://w...content-available-to-author-only...o.jp/dp/4774136182
  113. //but japanese.
  114.  
  115. class TortoiseGraphic {
  116. public:
  117. 	typedef std::tuple <double, double> Vector2D;
  118. public:
  119. 	TortoiseGraphic() = delete;
  120. 	TortoiseGraphic(Surface32* Screen) :S(Screen), Angle(), TurnHorizon(false), TurnVertical(true) {}
  121.  
  122. 	bool SetPixel(const std::int64_t& X, const std::int64_t& Y, const Surface32::Element& E, bool Tranceform = true) {
  123. 		if (S == nullptr)return false;
  124. 		std::int64_t A = X;
  125. 		std::int64_t B = Y;
  126. 		if (Tranceform == true) {
  127. 			double OX, OY;
  128. 			std::tie(OX, OY) = Origin;
  129. 			A = static_cast<std::int64_t>(X + OX);
  130. 			if (TurnHorizon == true) A = S->Width() - A;
  131. 			B = static_cast<std::int64_t>(Y + OY);
  132. 			if (TurnVertical == true) B = S->Height() - B;
  133. 		}
  134.  
  135. 		return S->SetPixel(A, B, E);
  136. 	}
  137. 	Surface32::Element GetPixel(const std::int64_t& X, const std::int64_t& Y, bool Tranceform = true) {
  138. 		if (S == nullptr)return false;
  139. 		std::int64_t A = X;
  140. 		std::int64_t B = Y;
  141. 		if (Tranceform == true) {
  142. 			double OX, OY;
  143. 			std::tie(OX, OY) = Origin;
  144.  
  145. 			A = static_cast<std::int64_t>(X + OX);
  146. 			if (TurnHorizon == true) A = S->Width() - A;
  147. 			B = static_cast<std::int64_t>(Y + OY);
  148. 			if (TurnVertical == true) B = S->Height() - B;
  149. 		}
  150. 		//////////////
  151. 		if (A < 0) return 0x00000000;
  152. 		if (A >= S->Width()) return 0x00000000;
  153. 		if (B < 0) return 0x00000000;
  154. 		if (B >= S->Height()) return 0x00000000;
  155.  
  156.  
  157.  
  158. 		return (*S)[B][A];
  159. 	}
  160. 	bool SetTurnVertical(bool F = true) {
  161. 		TurnVertical = F;
  162. 		return true;
  163. 	}
  164. 	bool GetTurnVertical() {
  165. 		return TurnVertical;
  166. 	}
  167. 	bool SetTurnHorizon(bool F = false) {
  168. 		TurnHorizon = F;
  169. 		return true;
  170. 	}
  171. 	bool GetTurnHorizon() {
  172. 		return TurnHorizon;
  173. 	}
  174.  
  175. 	bool SetAngle(double A) {
  176. 		Angle = A;
  177. 		return true;
  178. 	}
  179. 	bool Turn(double A) {
  180. 		Angle += A;
  181. 		Angle = std::fmod(Angle, 360);
  182. 		return true;
  183. 	}
  184. 	bool SetPoint(double X, double Y) {
  185. 		Now = std::make_tuple(X, Y);
  186. 		return true;
  187. 	}
  188. 	Vector2D GetPoint() {
  189. 		return Now;
  190. 	}
  191. 	bool SetOrigin(double X, double Y) {
  192. 		Origin = std::make_tuple(X, Y);
  193. 		return true;
  194. 	}
  195. 	Vector2D GetOrigin() {
  196. 		return Origin;
  197. 	}
  198.  
  199. 	bool SetColor(const Surface32::Element& Color) {
  200. 		C = Color;
  201. 		return true;
  202. 	}
  203. 	Surface32::Element GetColor() {
  204. 		return C;
  205. 	}
  206. 	bool Line(std::int64_t x0, std::int64_t y0, std::int64_t x1, std::int64_t y1, bool InDirect = false) {
  207. 		std::int64_t dx = std::abs(x1 - x0);
  208. 		std::int64_t dy = std::abs(y1 - y0);
  209. 		std::int64_t sx, sy;
  210. 		if (x0 < x1) { sx = 1; }
  211. 		else { sx = -1; }
  212. 		if (y0 < y1) { sy = 1; }
  213. 		else { sy = -1; }
  214. 		std::int64_t err = dx - dy;
  215. 		while (true) {
  216. 			SetPixel(x0, y0, C, !InDirect);
  217. 			if ((x0 == x1) && (y0 == y1)) break;
  218. 			std::int64_t e2 = 2 * err;
  219. 			if (e2 > -dy) {
  220. 				err = err - dy;
  221. 				x0 += sx;
  222. 			}
  223. 			if (e2 < dx) {
  224. 				err = err + dx;
  225. 				y0 += sy;
  226. 			}
  227. 		}
  228. 		return true;
  229. 	}
  230.  
  231. 	bool Move(double L) {
  232. 		double Nx, Ny;
  233. 		std::tie(Nx, Ny) = Now;
  234. 		double X = L * std::cos(Rad*Angle);
  235. 		double Y = L * std::sin(Rad*Angle);
  236.  
  237. 		Line(Nx, Ny, Nx + X, Ny + Y);
  238. 		SetPoint(Nx + X, Ny + Y);
  239. 		return true;
  240. 	}
  241. 	bool MoveTo(double X, double Y) {
  242. 		double Nx, Ny;
  243. 		std::tie(Nx, Ny) = Now;
  244. 		Line(Nx, Ny, X, Y);
  245. 		SetPoint(X, Y);
  246. 		return true;
  247. 	}
  248. 	bool Clear() {
  249. 		if (S == nullptr) return false;
  250. 		S->Fill(C);
  251. 		return true;
  252. 	}
  253. 	bool ClearUnderFloatingPoint() {
  254. 		double X, Y;
  255. 		std::tie(X, Y) = Now;
  256. 		Now = std::make_tuple(std::floor(X), std::floor(Y));
  257. 		return true;
  258. 	}
  259. 	Surface32* GetSurface() {
  260. 		return S;
  261. 	}
  262.  
  263. protected:
  264. 	Surface32* S;
  265. 	double Angle;
  266. 	Vector2D Now;
  267. 	Vector2D Origin;
  268. 	bool TurnVertical;
  269. 	bool TurnHorizon;
  270. 	double PI = 3.14159265359;
  271. 	double Rad = PI / 180.0;
  272. 	Surface32::Element C;
  273. };
  274.  
  275. bool WritePPM(std::ostream& os, Surface32& S, std::string comment = "No Comment") {
  276.  
  277. 	//write header
  278. 	os << "P3" << std::endl;
  279. 	//write comment
  280. 	os << "#" << comment << std::endl;
  281. 	//write size
  282. 	os << S.Width() << ' ' << S.Height() << std::endl;
  283. 	//bytemax
  284. 	os << "255" << std::endl;
  285.  
  286. 	for (auto& oo : S) {
  287. 		for (auto& o : oo) {
  288. 			os << static_cast<std::int16_t>(o.R) << ' ' << static_cast<std::int16_t>(o.G) << ' ' << static_cast<std::int16_t>(o.B) << std::endl;
  289. 		}
  290. 	}
  291.  
  292. 	return true;
  293. }
  294.  
  295. bool MakeHoge(TortoiseGraphic& T) {
  296.  
  297. 	T.SetOrigin(T.GetSurface()->Width() / 2, T.GetSurface()->Height() / 2);
  298. 	T.SetTurnVertical();
  299.  
  300. 	for (int i = 0; i < 2; i++) {
  301. 		T.SetColor({ 0,0,0, });
  302. 		T.SetAngle(0);//輪郭
  303. 		T.SetPoint(0, -80);
  304. 		T.Move(96);
  305. 		T.Turn(60);
  306. 		T.Move(58);
  307. 		T.Turn(30);
  308. 		T.Move(32);
  309. 		T.Turn(30);
  310. 		T.Move(58);
  311. 		T.Turn(30);
  312. 		T.Move(58);
  313. 		T.Turn(30);
  314. 		T.Move(48);	
  315.  
  316. 		T.SetAngle(0);//輪郭
  317. 		T.SetPoint(0, -64);
  318. 		T.Move(96/2);
  319. 		T.Turn(60);
  320. 		T.Move(58/2);
  321. 		T.Turn(30);
  322. 		T.Move(32/2);
  323. 		T.Turn(30);
  324. 		T.Move(58/2);
  325. 		T.Turn(30);
  326. 		T.Move(58/2);
  327. 		T.Turn(30);
  328. 		T.Move(48/2);
  329.  
  330. 		T.SetAngle(0);//鼻
  331. 		T.SetPoint(0, 0);
  332. 		T.Move(32);
  333. 		T.Turn(-160);
  334. 		T.Move(34);	
  335.  
  336. 		T.SetAngle(0);//口
  337. 		T.SetPoint(0, -40);
  338. 		T.Move(16);
  339. 		T.Turn(32);
  340. 		T.Move(24);	
  341.  
  342. 		T.SetPoint(74, 64);//耳
  343. 		T.SetAngle(8);		
  344. 		T.Move(32);
  345. 		T.Turn(90);
  346. 		T.Move(32);
  347. 		T.Turn(45);
  348. 		T.Move(32);
  349. 		T.Turn(45);
  350. 		T.Move(32);	
  351. 		T.Turn(90);
  352. 		T.Move(32);
  353. 		T.Turn(45);
  354. 		T.Move(32);
  355.  
  356. 		T.SetPoint(77, 72);//耳内側
  357. 		T.SetAngle(8);		
  358. 		T.Move(16);
  359. 		T.Turn(90);
  360. 		T.Move(16);
  361. 		T.Turn(45);
  362. 		T.Move(16);
  363. 		T.Turn(45);
  364. 		T.Move(16);	
  365. 		T.Turn(90);
  366. 		T.Move(16);
  367. 		T.Turn(45);
  368. 		T.Move(16);
  369.  
  370. 		T.SetPoint(68, 0);//目
  371. 		T.SetAngle(60);		
  372. 		T.Move(16);
  373. 		T.Turn(30);
  374. 		T.Move(24);
  375. 		T.Turn(30);
  376. 		T.Move(16);
  377. 		T.Turn(60);
  378. 		T.Move(16);	
  379. 		T.Turn(60);
  380. 		T.Move(16);
  381. 		T.Turn(30);
  382. 		T.Move(24);		
  383. 		T.Turn(60);
  384. 		T.Move(16);
  385. 		T.Turn(30);
  386. 		T.Move(16);
  387.  
  388. 		T.SetPoint(60, 40);//目
  389. 		T.SetAngle(-90);
  390. 		T.Move(30);
  391.  
  392. 		T.SetColor({ 255, 0 ,0 });
  393. 		T.SetPoint(100, -58);//頬
  394. 		T.SetAngle(60);		
  395. 		T.Move(16);
  396. 		T.Turn(30);
  397. 		T.Move(24);
  398. 		T.Turn(30);
  399. 		T.Move(16);
  400. 		T.Turn(60);
  401. 		T.Move(16);	
  402. 		T.Turn(60);
  403. 		T.Move(16);
  404. 		T.Turn(30);
  405. 		T.Move(24);		
  406. 		T.Turn(60);
  407. 		T.Move(16);
  408. 		T.Turn(30);
  409. 		T.Move(16);
  410.  
  411.  
  412.  
  413. 		T.SetTurnHorizon(true);
  414.  
  415.  
  416.  
  417. 	}
  418. 	return true;
  419. }
  420.  
  421. int main() {
  422.  
  423. 	Surface32 S(256, 256);
  424. 	TortoiseGraphic T(&S);
  425. 	std::ofstream fs("kumamon.ppm");
  426.  
  427. 	MakeHoge(T);
  428.  
  429. 	WritePPM(fs, S, "This is KUMAMON?");
  430. }
Success #stdin #stdout 0s 16072KB
comments (?)
stdin
copy 
Standard input is empty
stdout
copy 
Standard output is empty
https://ideone.com/eJ2xul
language:
C++14 (gcc 8.3)
created:
6 years ago
visibility:
public

Share or Embed source code

Discover > Sphere Engine API

The brand new service which powers Ideone!

Discover > IDE Widget

Widget for compiling and running the source code in a web browser!