View difference between Paste ID: ifzpcN0M and 71kkfRGd

 #include "Graphics.h"
 #include "StdAfx.h"
 #include "GF.h"
 #include <functional>
 #include <vector>
 #include <algorithm>
 #include <bitset>
 #include <cstdlib>
 #include <cstring>
 #include <string>
 #include <string.h>
 #include <random>
 #include <iostream>
 
 #define all(x) (x).begin(),(x).end()
 
 #ifndef M_PI
 const double M_PI = 3.1415926535897932384626433832795;
 #endif
 
 const char CONVEX = 1;
 const char COMPLEX = 2;
 const char NONCONVEX = 3;
 
 std::mt19937 rng(39);
 
 class TPoint;
 void DrawLine(TPoint a, TPoint b, const RGBPIXEL& color);
 void DrawLine(int x0, int y0, int x1, int y1, const RGBPIXEL& color);
 bool Intersect(const TPoint& a, const TPoint& b, const TPoint& c, const TPoint& d);
 int SignArea(const TPoint& a, const TPoint& b, const TPoint& c);
 
 class TPoint {
 public:
 	int x, y;
 	TPoint(int x = 0, int y = 0)
 		: x(x)
 		, y(y)
 	{
 	}
 
 	TPoint(const TPoint& a, const TPoint& b)
 		: x(b.x - a.x)
 		, y(b.y - a.y)
 	{
 	}
 
 	double Length() {
 		return hypot(x, y);
 	}
 
 	TPoint operator + (const TPoint& o) {
 		return TPoint(x + o.x, y + o.y);
 	}
 
 	TPoint operator - (const TPoint& o) {
 		return TPoint(x - o.x, y - o.y);
 	}
 
 	bool operator < (const TPoint& o) {
 		return x < o.x || x == o.x && y < o.y;
 	}
 
 	bool operator == (const TPoint& o) {
 		return x == o.x && y == o.y;
 	}
 
 	bool operator != (const TPoint& o) {
 		return !(*this == o);
 	}
 
 private:
 
 };
 
 class TPoint3D {
 public:
 	int x, y, z;
 	TPoint3D(int x = 0, int y = 0, int z = 0)
 		: x(x)
 		, y(y)
 		, z(z)
 	{
 	}
 
 	TPoint3D(const TPoint3D& a, const TPoint3D& b)
 		: x(b.x - a.x)
 		, y(b.y - a.y)
 		, z(b.z - a.z)
 	{
 	}
 
 	double Length() {
 		return std::sqrt(x * x + y * y + z * z);
 	}
 
 	TPoint3D operator + (const TPoint3D& o) {
 		return TPoint3D(x + o.x, y + o.y, z + o.z);
 	}
 
 	TPoint3D operator - (const TPoint3D& o) {
 		return TPoint3D(x - o.x, y - o.y, z - o.z);
 	}
 
 	bool operator < (const TPoint3D& o) {
 		if (x != o.x) return x < o.x;
 		if (y != o.y) return y < o.y;
 		return z < o.z;
 	}
 
 	bool operator == (const TPoint3D& o) {
 		return x == o.x && y == o.y && z == o.z;
 	}
 
 	bool operator != (const TPoint3D& o) {
 		return !(*this == o);
 	}
 };
 
 class TPolygon {
 public:
 	TPolygon(int n)
 		: n(n)
 		, p(std::vector<TPoint>(n))
 	{
 	}
 
 	void SetRandomPoint(int index, int w, int h) {
 		if (index >= 0 && index < n) {
 			p[index].x = rng() % w;
 			p[index].y = rng() % h;
 		}
 	}
 
 	void SetRandom(int w, int h) {
 		for (int i = 0; i < n; i++) {
 			SetRandomPoint(i, w, h);
 		}
 	}
 
 	void Draw(const RGBPIXEL& color) {
 		for (int i = 0; i < n; i++) {
 			DrawLine(p[i].x, p[i].y, p[(i + 1) % n].x, p[(i + 1) % n].y, color);
 		}
 	}
 
 	// should be with multithreading
 	void Fill(TPoint minPoint, TPoint maxPoint, RGBPIXEL color, const std::function<bool(TPoint)>& f) {
 		for (int x = minPoint.x; x <= maxPoint.x; x++) {
 			for (int y = minPoint.y; y <= maxPoint.y; y++) {
 				if (f({ x, y })) {
 					gfSetPixel(x, y, color);
 				}
 			}
 		}
 	}
 
 	int Size() const {
 		return n;
 	}
 
 	TPoint& operator [] (int i) {
 		i %= n;
 		if (i < 0) i += n;
 		return p[i];
 	};
 
 	TPoint* begin() {
 		return &p[0];
 	}
 
 	TPoint* end() {
 		return std::next(&p.back());
 	}
 
 	bool IsComplex() {
 		n = p.size();
 		if (n <= 3) {
 			return false;
 		}
 		for (int i = 0; i < n; i++) {
 			for (int j = i + 2; j < n; j++) {
 				if (j == n - 1 && i == 0) continue;
 				if (Intersect(p[i], p[(i + 1) % n], p[j], p[(j + 1) % n])) {
 					return true;
 				}
 			}
 		}
 		return false;
 	}
 
 	bool IsConvex() {
 		n = p.size();
 		if (n <= 3) {
 			return true;
 		}
 		if (IsComplex()) {
 			return false;
 		}
 		int pos = 0;
 		int neg = 0;
 		for (int i = 0; i < n; i++) {
 			const int s = SignArea(p[(i - 1 + n) % n], p[i], p[(i + 1) % n]);
 			if (s > 0) {
 				pos++;
 			}
 			if (s < 0) {
 				neg++;
 			}
 			if (pos > 0 && neg > 0) {
 				return false;
 			}
 		}
 		if (pos > 0 && neg > 0) {
 			return false;
 		}
 		return true;
 	}
 
 	char Classify() {
 		if (IsConvex()) {
 			return CONVEX;
 		}
 		else if (IsComplex()) {
 			return COMPLEX;
 		}
 		else {
 			return NONCONVEX;
 		}
 	}
 
 	void MakeConvex() {
 		sort(all(p));
 		auto cw = [&](const TPoint & a, const TPoint & b) {
 			return a.x * b.y - a.y * b.x;
 		};
 		auto norm = [&](const TPoint& a) {
 			return 1ll * a.x * a.x + 1ll * a.y * a.y;
 		};
 		p.erase(unique(all(p)), p.end());
 		sort(p.begin() + 1, p.end(), [&](TPoint& a, TPoint& b) {
 			long long val = cw(a - p[0], b - p[0]);
 			if (val != 0) return val < 0;
 			return norm(a - p[0]) < norm(b - p[0]);
 		});
 		const int n = p.size();
 		if (n <= 2) {
 			this->n = n;
 			return;
 		}
 		std::vector<TPoint> ans = { p[0], p[1] };
 		int sz = 2;
 		for (int i = 2; i < n; i++) {
 			while (sz >= 2 && cw(ans[sz - 1] - ans[sz - 2], p[i] - ans[sz - 1]) >= 0) {
 				ans.pop_back();
 				sz--;
 			}
 			sz++;
 			ans.push_back(p[i]);
 		}
 		while (sz >= 2 && cw(ans[sz - 1] - ans[sz - 2], ans[0] - ans[sz - 1]) >= 0) {
 			ans.pop_back();
 			sz--;
 		}
 		p = ans;
 		this->n = p.size();
 	}
 
 private:
 	int n;
 	std::vector<TPoint> p;
 };
 
 void DrawLine(int x0, int y0, int x1, int y1, const RGBPIXEL& color) {
 	const int deltaX = abs(x0 - x1);
 	const int deltaY = abs(y0 - y1);
 	const int signX = x0 < x1 ? 1 : -1;
 	const int signY = y0 < y1 ? 1 : -1;
 	int d = deltaX - deltaY;
 	gfSetPixel(x1, y1, color);
 	while (x0 != x1 || y0 != y1) {
 		gfSetPixel(x0, y0, color);
 		const int d2 = d << 1;
 		if (d2 > -deltaY) { // d > -dy / 2
 			d -= deltaY;
 			x0 += signX;
 		}
 		if (d2 < deltaX) {
 			d += deltaX;
 			y0 += signY;
 		}
 	}
 }
 
 void DrawLine(TPoint a, TPoint b, const RGBPIXEL& color) {
 	DrawLine(a.x, a.y, b.x, b.y, color);
 }
 
 inline bool cw(const TPoint& a, const TPoint& b, const TPoint& c) { // clockwise
 	return a.x * (b.y - c.y) + b.x * (c.y - a.y) + c.x * (a.y - b.y) < 0;
 }
 
 int sign(long long a) {
 	if (a > 0) return 1;
 	if (a < 0) return -1;
 	return 0;
 }
 
 inline int SignArea(const TPoint& a, const TPoint& b, const TPoint& c) {
 	return sign(static_cast<long long>(b.x - a.x) * (c.y - a.y) - static_cast<long long>(b.y - a.y) * (c.x - a.x));
 }
 
 inline int Area(const TPoint& a, const TPoint& b) {
 	return a.x * b.y - a.y * b.x;
 }
 
 inline bool Intersect_1(int a, int b, int c, int d) {
 	if (a > b)  std::swap(a, b);
 	if (c > d)  std::swap(c, d);
 	return max(a, c) <= min(b, d);
 }
 
 bool Intersect(const TPoint& a, const TPoint& b, const TPoint& c, const TPoint& d) {
 	return Intersect_1(a.x, b.x, c.x, d.x)
 		&& Intersect_1(a.y, b.y, c.y, d.y)
 		&& SignArea(a, b, c) * SignArea(a, b, d) <= 0
 		&& SignArea(c, d, a) * SignArea(c, d, b) <= 0;
 }
 
 inline RGBPIXEL RandColor() {
 	return RGBPIXEL(rand() % 256, rand() % 256, rand() % 256);
 }
 
 bool PointInPolygonWithEvenOddRule(TPolygon& p, const TPoint& a) {
 	bool counter = 0;
 	const int inf = 2000;
 	TPoint b = { a.x, a.y - inf };
 	bool pre = false;
 	bool cur = false;
 	const int n = p.Size();
 	for (int i = 0; i < n; i++) {
 		cur = Intersect(p[i], p[(i + 1) % n], a, b);
 		if (cur && pre && p[i].x == a.x) {
 			if ((p[(i - 1 + n) % n].x > a.x) ^ (p[(i + 1) % n].x > a.x)) {
 				continue;
 			}
 		}
 		counter ^= cur;
 		pre = cur;
 	}
 	return counter;
 }
 
 bool PointInPolygonWithNonZeroWindingRule(TPolygon& p, const TPoint& a) {
 	int counter = 0;
 	const int inf = 9000;
 	TPoint b = { a.x, a.y + inf };
 	bool pref = false;
 	bool cur = false;
 	const int n = p.Size();
 	for (int i = 0; i < n; i++) {
 		if (cur = Intersect(p[i], p[(i + 1) % n], a, b)) {
 			if (cur && pref && p[i].x == a.x) {
 				if ((p[(i - 1 + n) % n].x - a.x) * (p[(i + 1) % n].x - a.x) < 0) {
 					continue;
 				}
 			}
 			counter += SignArea(p[i], p[(i + 1) % n], a);
 		}
 		pref = cur;
 	}
 	return counter;
 }
 
 const TCHAR* GetTextForDraw(const std::string& s) {
 	char* answer = new char[s.size() + 1];
 	for (int i = 0; i < s.size(); i++) {
 		answer[i] = s[i];
 	}
 	answer[s.size()] = '\0';
 	return answer;
 }
 
 template<typename T>
 const TCHAR* GetTextForDraw(const T& value) {
 	return GetTextForDraw(std::to_string(value));
 }
 
 std::pair<TPoint, TPoint> MinMaxBorders(TPolygon& polygon) {
 	const int inf = 1 << 30;
 	TPoint minPoint = { inf, inf };
 	TPoint maxPoint = { -inf, -inf };
 	for (const auto& p : polygon) {
 		minPoint.x = min(minPoint.x, p.x);
 		minPoint.y = min(minPoint.y, p.y);
 		maxPoint.x = max(maxPoint.x, p.x);
 		maxPoint.y = max(maxPoint.y, p.y);
 	}
 	return { minPoint, maxPoint };
 }
 
 long long DistQrt(const TPoint& a, const TPoint& b) {
 	return static_cast<long long>(a.x - b.x) * (a.x - b.x) + static_cast<long long>(a.y - b.y) * (a.y - b.y);
 }
 
 double C(int n, int m) {
 	double answer = 1;
 	for (int i = 1; i <= n; i++) {
 		answer *= i;
 	}
 	for (int i = 1; i <= m; i++) {
 		answer /= i;
 	}
 	for (int i = 1; i <= n - m; i++) {
 		answer /= i;
 	}
 	return answer;
 }
 
 void DrawBezierLine(std::vector<TPoint>& arr, const RGBPIXEL& color) {
 	const int n = arr.size();
 	if (n <= 2) {
 		DrawLine(arr[0], arr.back(), color);
 		return;
 	}
 	auto dist = [&](const TPoint& a) {
 		return abs(a.x) + abs(a.y);
 	};
 	long long D = 0;
 	for (int i = 2; i < n; i++) {
 		D = max(D, dist(arr[i - 2] - arr[i - 1] - arr[i - 1] + arr[i]));
 	}
 	double N = 1 + sqrt(n * D);
 	double dt = 1 / N;
 	auto R = [&](double t) {
 		double x = 0;
 		double y = 0;
 		for (int i = 0; i < n; i++) {
 			double p = C(n - 1, i) * pow(t, i) * pow(1 - t, n - 1 - i);
 			x += arr[i].x * p;
 			y += arr[i].y * p;
 		}
 		return TPoint(x + 0.5, y + 0.5);
 	};
 	std::vector<TPoint> a;
 	int q = 1 / dt + 1;
 	for (int i = 0; i < q; i++) {
 		a.push_back(R(i * 1.0 / q));
 	}
 	a.push_back(arr.back());
 	for (int i = 1; i < a.size(); i++) {
 		DrawLine(a[i - 1], a[i], color);
 	}
 }
 
 
 std::vector<TPoint> GetBezierLine(std::vector<TPoint>& arr, const RGBPIXEL& color) {
 	const int n = arr.size();
 	if (n <= 2) {
 		DrawLine(arr[0], arr.back(), color);
 		return arr;
 	}
 	auto dist = [&](const TPoint& a) {
 		return abs(a.x) + abs(a.y);
 	};
 	long long D = 0;
 	for (int i = 2; i < n; i++) {
 		D = max(D, dist(arr[i - 2] - arr[i - 1] - arr[i - 1] + arr[i]));
 	}
 	double N = 1 + sqrt(n * D);
 	double dt = 1 / N;
 	auto R = [&](double t) {
 		double x = 0;
 		double y = 0;
 		for (int i = 0; i < n; i++) {
 			double p = C(n - 1, i) * pow(t, i) * pow(1 - t, n - 1 - i);
 			x += arr[i].x * p;
 			y += arr[i].y * p;
 		}
 		return TPoint(x + 0.5, y + 0.5);
 	};
 	std::vector<TPoint> a;
 	int q = 1 / dt + 1;
 	for (int i = 0; i < q; i++) {
 		a.push_back(R(i * 1.0 / q));
 	}
 	a.push_back(arr.back());
 	return a;
 }
 
 /*
 de Kasteljo
 */
 void DrawBezierLine2(std::vector<TPoint>& arr, const RGBPIXEL& color) {
 	const int n = arr.size();
 	if (n <= 2) {
 		DrawLine(arr[0], arr.back(), color);
 		return;
 	}
 	const int bits = 7;
 	const int size = 1 << bits;
 	const int halfsize = 1 << (bits - 1);
 	std::function<TPoint(const TPoint&, const TPoint&, int)> get = [&](const TPoint& a, const TPoint& b, int pr) {
 		return TPoint(a.x + (pr * (b.x - a.x) + halfsize >> bits), a.y + (pr * (b.y - a.y) + halfsize >> bits));
 	};
 
 	std::function<TPoint(std::vector<TPoint>, int)> findPoint = [&](std::vector<TPoint> a, int pr) {
 		if (a.size() <= 2) {
 			return get(a[0], a.back(), pr);
 		}
 		else {
 			for (int i = 0; i + 1 < a.size(); i++) {
 				a[i] = get(a[i], a[i + 1], pr);
 			}
 			a.pop_back();
 			return findPoint(a, pr);
 		}
 	};
 
 	std::vector<TPoint> result;
 
 	for (int t = 0; t <= size; t++) {
 		result.push_back(findPoint(arr, t));
 	}
 	for (int i = 0; i + 1 < result.size(); i++) {
 		DrawLine(result[i], result[i + 1], color);
 	}
 }
 
 int ClipLine(TPoint& a, TPoint& b, TPolygon& arr) {
 
 	double t0 = 0, t1 = 1, t;
 	TPoint s = TPoint(b.x - a.x, b.y - a.y); // vector colinear with current
 	long long nx, ny, num, denom, x1, y1, x2, y2;
 	const int n = arr.Size();
 	if (n <= 2 || !arr.IsConvex()) {
 		return 1;
 	}
 	bool isCw = false;
 	for (int i = 0; i + 2 < n; i++) {
 		isCw |= SignArea(arr[i + 0], arr[i + 1], arr[i + 2]) < 0; // polygon contains edges in clock wise order
 	}
 
 	for (int i = (isCw ? 0 : n - 1); (isCw ? i < n : i >= 0); (isCw ? i++ : i--)) {
 		nx = arr[i + (isCw ? 1 : -1)].y - arr[i].y;
 		ny = arr[i].x - arr[i + (isCw ? 1 : -1)].x;
 		denom = nx * s.x + ny * s.y;
 		num = nx * (a.x - arr[i].x) + ny * (a.y - arr[i].y);
 		if (abs(denom) > 1e-9) {
 			t = -num * 1.0 / denom;
 			if (denom > 0) {
 				if (t > t0) {
 					t0 = t;
 				}
 			}
 			else {
 				if (t < t1) {
 					t1 = t;
 				}
 			}
 		}
 		else {
 			if (num < 0) {
 				return 1;
 			}
 		}
 	}
 	if (t0 <= t1) {
 		x1 = a.x + t0 * (b.x - a.x);
 		y1 = a.y + t0 * (b.y - a.y);
 		x2 = a.x + t1 * (b.x - a.x);
 		y2 = a.y + t1 * (b.y - a.y);
 		a = TPoint(x1 + 0.5, y1 + 0.5); // update values
 		b = TPoint(x2 + 0.5, y2 + 0.5);
 		return 0;
 	}
 	return 1; // no visible part
 }
 
 bool PointIntoTriangle(TPoint a, TPoint b, TPoint c, TPoint x) {
 	return SignArea(a, b, x) * SignArea(a, x, c) <= 0 && SignArea(b, c, x) * SignArea(b, x, a) <= 0 && SignArea(c, a, x) * SignArea(c, x, b) <= 0;
 }
 
 bool PointIntoConvexPolygon(TPolygon p, TPoint x) {
 	bool ans = false;
 	const int n = p.Size();
 	if (n <= 2) return false;
 	for (int i = 2; !ans && i < n; i++) {
 		ans |= PointIntoTriangle(p[i - 2], p[i - 1], p[0], x);
 	}
 	return ans;
 }
 
 int Y = 15;
 int Dy = 20;
 
 std::vector<TPolygon> BuildProjectionOfParallelepiped(const std::vector<std::vector<TPoint3D>>& p) {
 	const int n = p.size();
 	int ITR = 0;
 
 	auto isInvisible = [&](TPoint3D& pt, int index) {
 		for (int i = 0; i < n; i++) {
 			if (i == index) continue;
 			TPolygon cur(p[i].size());
 			for (int j = 0; j < p[i].size(); j++) {
 				cur[j] = TPoint(p[i][j].x, p[i][j].y);
 			}
 			if (!PointIntoConvexPolygon(cur, TPoint(pt.x, pt.y))) continue;
 			TPoint X = TPoint(pt.x, pt.y) - cur[0];
 			TPoint A = cur[1] - cur[0];
 			TPoint B = cur[2] - cur[0];
 			int dZ1 = p[i][1].z - p[i][0].z;
 			int dZ2 = p[i][2].z - p[i][0].z;
 			int dZ = pt.z - p[i][0].z;
 			double t2 = static_cast<double>(X.x * A.y - A.x * X.y) / (A.y * B.x - A.x * B.y);
 			double t1 = static_cast<double>(X.x - B.x * t2) / A.x;
 			double curX = t1 * A.x + t2 * B.x;
 			double curY = t1 * A.y + t2 * B.y;
 			double curZ = dZ1 * t1 + dZ2 * t2 + p[i][0].z;
 			auto myCeil = [&](double x) {
 				if (x < 0) return static_cast<int>(x - 0.5);
 				return static_cast<int>(x + 0.5);
 			};
 			curX = myCeil(curX);
 			curY = myCeil(curY);
 			curZ = myCeil(curZ);
 
 			if (curZ < pt.z) {
 				return true;
 			}
 		}
 		return false;
 	};
 	std::vector<TPolygon> res;
 	for (int i = 0; i < n; i++) {
 		TPoint3D mnPt = p[i][0];
 		for (auto& pt : p[i]) {
 			if (pt.z < mnPt.z) {
 				mnPt = pt;
 			}
 		}
 		if (isInvisible(mnPt, i)) {
 			res.emplace_back(p[i].size());
 			for (int j = 0; j < p[i].size(); j++) {
 				res.back()[j] = TPoint(p[i][j].x, p[i][j].y);
 			}
 		}
 	}
 	return res;
 }
 
 
 std::vector<bool> BuildProjectionOfParallelepiped2(const std::vector<std::vector<TPoint3D>>& p) {
 	std::vector<bool> result(p.size(), true);
 	int itr = 0;
 	for (const auto& v : p) {
 		const int n = v.size();
 		bool isInvisible = false;
 		for (int i = 0; !isInvisible && i < n; i++) {
 			TPoint a{ v[i].x, v[i].y };
 			TPoint b{ v[(i + 1) % n].x, v[(i + 1) % n].y };
 			TPoint c{ v[(i + 2) % n].x, v[(i + 2) % n].y };
 			isInvisible = Area(b - a, c - b) > 0;
 		}
 		result[itr++] = !isInvisible;
 	}
 	return result;
 }
 
 
 std::vector<bool> BuildPointProjection(std::vector<std::vector<TPoint3D>>& p, int k) {
 	for (auto& v : p) {
 		for (auto& pt : v) {
 
 		}
 	}
 	return BuildProjectionOfParallelepiped2(p);
 }
 
 std::vector<std::vector<TPoint3D>> p;
 double phi = M_PI / 20;
 double x = 6;
 double y = 1;
 double z = 9;
 double angle = 0;
 
 std::vector<RGBPIXEL> colors = {
 	RGBPIXEL::White(),
 	RGBPIXEL::Red(),
 	RGBPIXEL::Green(),
 	RGBPIXEL::Blue(),
 	RGBPIXEL::DkMagenta(),
 	RGBPIXEL::Yellow(),
 };
 
 const int WINDOW_H = 900;
 const int WINDOW_W = 1.5 * 900;
 
 
 bool gfInitScene() {
 	try {
 		const int WINDOW_SIZE = 900;
 		gfSetWindowSize(WINDOW_W, WINDOW_H);
 		const int A = 180;
 		const int B = 100;
 		const int C = 150;
 		int Norm = x * x + y * y + z * z;
 		x /= sqrt(Norm);
 		y /= sqrt(Norm);
 		z /= sqrt(Norm);
 		p = {
 			{ { 0, 0, 0 },{ 0, B, 0 },{ 0, B, C },{ 0, 0, C } },
 		{ { A, 0, C },{ A, B, C },{ A, B, 0 },{ A, 0, 0 } },
 
 		{ { 0, 0, 0 },{ 0, 0, C },{ A, 0, C },{ A, 0, 0 } },
 		{ { A, B, 0 },{ A, B, C },{ 0, B, C },{ 0, B, 0 } },
 
 		{ { A, 0, 0 },{ A, B, 0 },{ 0, B, 0 },{ 0, 0, 0 } },
 		{ { 0, 0, C },{ 0, B, C },{ A, B, C },{ A, 0, C } }
 		};
 
 		for (auto& v : p) {
 			for (auto& pt : v) {
 				pt.x += 300;
 				pt.y += 300;
 			}
 		}
 		double xyAngle = 45.0 / 180.0 * M_PI;
 		double xzAngle = 45.0 / 180.0 * M_PI;
 		double yzAngle = 0 / 180.0 * M_PI;
 		double cosxy = cos(xyAngle);
 		double cosxz = cos(xzAngle);
 		double cosyz = cos(yzAngle);
 
 		double sinxy = sin(xyAngle);
 		double sinxz = sin(xzAngle);
 		double sinyz = sin(yzAngle);
 
 
 		// xy
 		for (auto& v : p) {
 			for (auto& pt : v) {
 				TPoint3D nxt;
 				nxt.x = cosxy * pt.x - sinxy * pt.y;
 				nxt.y = sinxy * pt.x + cosxy * pt.y;
 				nxt.z = pt.z;
 				pt = nxt;
 			}
 		}
 
 		// xz
 		for (auto& v : p) {
 			for (auto& pt : v) {
 				TPoint3D nxt;
 				nxt.x = cosxz * pt.x - sinxz * pt.z;
 				nxt.z = sinxz * pt.x + cosxz * pt.z;
 				nxt.y = pt.y;
 				pt = nxt;
 			}
 		}
 
 		// yz
 		for (auto& v : p) {
 			for (auto& pt : v) {
 				TPoint3D nxt;
 				nxt.y = cosyz * pt.y - sinyz * pt.z;
 				nxt.z = sinyz * pt.y + cosyz * pt.z;
 				nxt.x = pt.x;
 				pt = nxt;
 			}
 		}
 
 		int mnX = 1e9;
 		int mnY = 1e9;
 		int mnZ = 1e9;
 		for (auto& v : p) {
 			for (auto& pt : v) {
 				mnX = min(mnX, pt.x);
 				mnY = min(mnY, pt.y);
 				mnZ = min(mnZ, pt.z);
 			}
 		}
 
 		for (auto& v : p) {
 			for (auto& pt : v) {
 				pt.x -= mnX - 100;
 				pt.y -= mnY - 100;
 				pt.z -= mnZ - 100;
 			}
 		}
 
 		for (auto v : p) {
 			int dx = 0;
 			for (int i = 0; i < v.size(); i++) {
 				DrawLine(TPoint(v[i].x + dx, v[i].y), TPoint(v[(i + 1) % v.size()].x + dx, v[(i + 1) % v.size()].y), RGBPIXEL::Green());
 			}
 		}
 
 		auto cur = BuildProjectionOfParallelepiped2(p);
 		for (int i = 0; i < cur.size(); i++) {
 			if (cur[i]) {
 				TPolygon x(p[i].size());
 				for (int j = 0; j < p[i].size(); j++) {
 					x[j] = TPoint(p[i][j].x, p[i][j].y);
 				}
 				x.Draw(RGBPIXEL::White());
 			}
 		}
 		const int DX = 500;
 		auto myWay = BuildProjectionOfParallelepiped(p);
 		for (auto& v : myWay) {
 			for (auto& pt : v) {
 				pt.x += DX;
 			}
 			v.Draw(RGBPIXEL::Red());
 		}
 		TPoint3D mxPt = p[0][0];
 		for (auto& v : p) {
 			for (auto& pt : v) {
 				if (pt.z > mxPt.z) {
 					mxPt = pt;
 				}
 			}
 		}
 		gfDrawRectangle(mxPt.x - 5, mxPt.y - 5, mxPt.x + 5, mxPt.y + 5, RGBPIXEL::Red());
 		gfDrawRectangle(mxPt.x - 5 + DX, mxPt.y - 5, mxPt.x + 5 + DX, mxPt.y + 5, RGBPIXEL::Red());
 	}
 	catch (...) {
 		return false;
 	}
 	return true;
 }
 
 int dx = 10;
 int dy = 15;
 int sx = 0;
 int sy = 0;
 int ITR = 0;
 
 void gfDrawScene()
 {
 	gfClearScreen(RGBPIXEL::Black());
 	angle += phi;
 	double s = sin(angle);
 	double c = cos(angle);
 
 
 	const int Y1 = 50;
 	const int X1 = 100;
 	ITR++;
 	ITR %= 500;
 	std::string str1 = "спокойствие...";
 	std::string str2 = "блаженство...";
 	if (ITR < 250) {
 
 		gfDrawText(X1, Y1, GetTextForDraw(str1), RGBPIXEL::White());
 	}
 	else {
 		gfDrawText(X1 + 50, Y1 + 50, GetTextForDraw(str2), RGBPIXEL::White());
 	}
 
 	std::vector<std::vector<TPoint3D>> cur;
 	for (auto& v : p) {
 		cur.emplace_back();
 		for (auto& pt : v) {
 			TPoint3D nxt;
 
 			double cx = (c + (1 - c) * x * x) * pt.x + ((1 - c) * x * y - s * z) * pt.y + ((1 - c) * x * z + s * y) * pt.z;
 			double cy = ((1 - c) * y * x + s * z) * pt.x + (c + (1 - c) * y * y) * pt.y + ((1 - c) * y * z - s * x) * pt.z;
 			double cz = ((1 - c) * z * x - s * y) * pt.x + ((1 - c) * z * y + s * x) * pt.y + (c + (1 - c) * z * z) * pt.z;
 
-			int k = 100;   //with point projection
+			int k = 0;
-			double H = cz / k + 1;
+			k = 125;
-			nxt.x = cx / H;
+			if (k > 0) {
-			nxt.y = cy / H;
+				double H = cz / k + 1;
-			nxt.z = k / H;
+				nxt.x = cx / H;
 				nxt.y = cy / H;
-			/*nxt.x = cx;  //without point projection
+				nxt.z = k / H;
-			nxt.y = cy;
+			} else {
-			nxt.z = cz; */
+				nxt.x = cx;
 				nxt.y = cy;
 				nxt.z = cz;
 			}
 
 			cur.back().push_back(nxt);
 		}
 	}
 	auto kek = BuildProjectionOfParallelepiped2(cur);
 	for (int i = 0; i < kek.size(); i++) {
 		if (kek[i]) {
 			TPolygon curp(cur[i].size());
 			for (int j = 0; j < curp.Size(); j++) {
 				curp[j] = TPoint(cur[i][j].x + 500, cur[i][j].y + 500);
 			}
 			curp.Draw(RGBPIXEL::White());
 		}
 	}
 	//
 }
 
 void gfCleanupScene() {
 }
 
 void gfOnLMouseClick(int x, int y) {
 }
 
 void gfOnRMouseClick(int x, int y) {
 }
 
 void gfOnKeyDown(UINT key) {
 }
 
 void gfOnKeyUp(UINT key)
 {
 }