Advertisement
allekco

Graphics.cpp

Dec 12th, 2019
204
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 20.01 KB | None | 0 0
  1. #include "StdAfx.h"
  2. #include "GF.h"
  3. #include <iostream>
  4. #include <vector>
  5.  
  6. using namespace std;
  7.  
  8. #ifndef M_PI
  9. const double M_PI = 3.1415926535897932384626433832795;
  10. #endif
  11.  
  12. enum { LEFT, RIGHT, BEYOND, BEHIND, ORIGIN, DEST, BETWEEN, COLLINEAR, PARALLEL, CROSS, SKEW, SKEW_CROSS,
  13.     SKEW_NO_CROSS, CROSS_LEFT, CROSS_RIGHT, INESSNTIAL, TOUCHING, COMPLEX, SIMPLE, CONVEX, NON_CONVEX,
  14.     INSIDE, OUTSIDE, CLOCKWISE, COUNTERCLOCKWISE };
  15.  
  16.  
  17. // Ваша реализация необходимых вам функций
  18. void DrawLine( int x0, int y0, int x1, int y1, RGBPIXEL color )
  19. {
  20.     int dx = abs(x1 - x0);      //
  21.     int dy = abs(y1 - y0);
  22.     int signX = x1 > x0 ? 1 : -1;       //if x1>x0 -> 1
  23.     int signY = y1 > y0 ? 1 : -1;
  24.     if (dx == 0 && dy == 0)
  25.     {
  26.         gfSetPixel(x0, y0, color);      //ставит один пиксель
  27.     }
  28.     else
  29.     {
  30.         if (dx - dy >= 0)       //прямоульгольник вытянут по x
  31.         {
  32.             int x = x0;
  33.             int y = y0;
  34.             int E = 2 * dy - dx;        //ошибка
  35.             while (x != x1 || y != y1)      //пока не дойдем в кон точку
  36.             {
  37.                 gfSetPixel(x, y, color);
  38.                 if (signY >= 0)     //усл для того чтобы одинаковая прямая от x0 и обратно
  39.                 {
  40.                     if (E >= 0)     //всегда измен x, иногда измен y
  41.                     {
  42.                         E -= 2 * dx;
  43.                         y += signY;    
  44.                     }
  45.                 }
  46.                 else
  47.                 {
  48.                     if (E > 0)
  49.                     {
  50.                         E -= 2 * dx;
  51.                         y += signY;
  52.                     }
  53.                 }
  54.                 x += signX;     //увеличиваем или умен на шаг в 1 пиксель
  55.                 E += 2 * dy;
  56.  
  57.             }
  58.             gfSetPixel(x, y, color);
  59.         }
  60.         else        //прям вытянут по y
  61.         {
  62.             int x = x0;
  63.             int y = y0;
  64.             int E = 2 * dx - dy;
  65.             while (x != x1 || y != y1)
  66.             {
  67.                 gfSetPixel(x, y, color);
  68.                 if (signX >= 0)
  69.                 {
  70.                     if (E >= 0)
  71.                     {
  72.                         E -= 2 * dy;
  73.                         x += signX;
  74.                     }
  75.                 }
  76.                 else
  77.                 {
  78.                     if (E > 0)
  79.                     {
  80.                         E -= 2 * dy;
  81.                         x += signX;
  82.                     }
  83.                 }
  84.                 y += signY;
  85.                 E += 2 * dx;
  86.             }
  87.             gfSetPixel(x, y, color);
  88.         }
  89.     }
  90.    
  91. }
  92.  
  93. void DrawPolygon(vector<vector<int>>& P, RGBPIXEL color)        // рисуем полигон. в динамический массиве 2 x n сначала x,потом y
  94. {
  95.     if (P.size() == 2)      //проверка что два столбика
  96.     {
  97.         if (P[0].size() == P[1].size())     //количество x должно совпадать с y
  98.         {
  99.             for (int i = 0; i < P[0].size() - 1; i++)      
  100.             {
  101.                 DrawLine(P[0][i], P[1][i], P[0][i + 1], P[1][i + 1], color);
  102.             }
  103.             DrawLine(P[0][P[0].size() - 1], P[1][P[0].size() - 1], P[0][0], P[1][0], color);        //прорисовываем отдельно последнюю строчку
  104.         }
  105.     }
  106. }
  107.  
  108. int Classify(int x1, int y1, int x2, int y2, int x, int y)      //где лежит точка относительно прямой
  109. {
  110.     int ax = x2 - x1;       //вектор a=(ax,ay) совпадает с прямой
  111.     int ay = y2 - y1;
  112.     int bx = x - x1;
  113.     int by = y - y1;
  114.     int s = ax * by - bx * ay; //определитель смотрим знак у k
  115.     if (s > 0)
  116.         return LEFT;
  117.     if (s < 0)
  118.         return RIGHT;  
  119.     //если прошел сюда то векторы колинеарны
  120.     if ((ax * bx < 0) || (ay * by < 0))     //на прямой продолжающей отрезок сзади
  121.         return BEHIND;
  122.     if ((ax * ax + ay * ay) < (bx * bx + by * by)) // спереди
  123.         return BEYOND;
  124.     if ((x == x1) && (y == y1)) //в начало попали
  125.         return ORIGIN;
  126.     if ((x == x2) && (y == y2))
  127.         return DEST;
  128.     return BETWEEN; // попали четко на отрезок
  129. }
  130.  
  131. int PolyTypeConv(vector<vector<int>>& P) //определяет тип полигона: выпуклый, невыпуклый
  132. {
  133.     if (P[0].size() <= 2)       //чтобы было 3 x,y
  134.     {
  135.         return -1; //не полигон
  136.     }
  137.     int type0 = Classify(P[0][0], P[1][0], P[0][1], P[1][1], P[0][2], P[1][2]); //запоминаем тип 3 точки относительно отрезка 1-2 точек
  138.     for (int j = 0; j < P[0].size() - 1; j++)  //пробегаем по всем ребрам
  139.         for (int i = j + 2; i < P[0].size() + j - 1; i++)       //пробегаем по точкам, кроме ребра
  140.         {
  141.             int type = Classify(P[0][j], P[1][j], P[0][j + 1], P[1][j + 1], P[0][i % P[0].size()], P[1][i % P[0].size()]);
  142.             if (type == DEST || type == ORIGIN || type == BEYOND || type == BEHIND)
  143.             {
  144.                 return -1; //не полигон
  145.             }
  146.             if (type != type0) {
  147.             return NON_CONVEX;      //невыпуклый полигон
  148.             }
  149.         }
  150.     return CONVEX;
  151. }
  152.  
  153. int Intersect(int xa, int ya, int xb, int yb, int xc, int yc, int xd, int yd, double& t)    //пересекаются 2 прямые ab и cd или нет
  154. {
  155.     int nx = yd - yc;       //направляющий вектор
  156.     int ny = xc - xd;
  157.     int denom = nx * (xb - xa) + ny * (yb - ya);        //знаменатель
  158.     if (denom == 0)
  159.     {
  160.         int type = Classify(xc, yc, xd, yd, xa, ya);
  161.         if ((type == LEFT) || (type == RIGHT))
  162.             return PARALLEL;
  163.         else
  164.             return COLLINEAR;       //на одной прямой
  165.     }
  166.     int num = nx * (xa - xc) + ny * (ya - yc);
  167.     t = -double(num) / double(denom);       //именно для отрезков пересечение если t от 0 до 1
  168.     return CROSS;
  169. }
  170.  
  171. int PolyTypeSimp(vector<vector<int>>& P) //простой или самопересечениями
  172. {
  173.     if (PolyTypeConv(P) == -1)
  174.     {
  175.         return -1; //не полигон
  176.     }
  177.     if (PolyTypeConv(P) == CONVEX) {
  178.         return SIMPLE;
  179.     }
  180.  
  181.     for (int j = 0; j < P[0].size() - 1; j++)
  182.         for (int i = j + 2; i < j + P[0].size() - 1; i++)
  183.         {
  184.             double t1 = -1; //заданы произвольно, меняются в intersect
  185.             double t2 = -2;
  186.             int type1 = Intersect(P[0][j], P[1][j], P[0][j + 1], P[1][j + 1], P[0][(i % P[0].size())], P[1][(i % P[0].size())], P[0][((i + 1) % P[0].size())], P[1][((i + 1) % P[0].size())], t1);
  187.             int type2 = Intersect(P[0][(i % P[0].size())], P[1][(i % P[0].size())], P[0][((i + 1) % P[0].size())], P[1][((i + 1) % P[0].size())], P[0][j], P[1][j], P[0][j + 1], P[1][j + 1], t2);
  188.             if (type1 == CROSS && type2 == CROSS)
  189.                 if (t1 >= 0 && t1 <= 1 && t2 >= 0 && t2 <= 1) { //если обе t находятся от 0 до 1
  190.                     return COMPLEX;     //сложный
  191.                 }
  192.         }
  193.     return SIMPLE;
  194. }
  195.  
  196. int EdgeType(int x0, int y0, int x1, int y1, int x, int y)      //каким образом прямая из точки x,y пересекает прямую. для заливки
  197. {
  198.     switch (Classify(x0, y0, x1, y1, x, y))
  199.     {
  200.     case LEFT:
  201.         if (y > y0 && y <= y1)
  202.             return CROSS_LEFT;
  203.         else
  204.             return INESSNTIAL;  // не пересекает
  205.     case RIGHT:
  206.         if (y > y1 && y <= y0)
  207.             return CROSS_RIGHT;
  208.         else
  209.             return INESSNTIAL;
  210.     case BETWEEN:
  211.     case ORIGIN:
  212.     case DEST:
  213.         return TOUCHING;
  214.     default:
  215.         return INESSNTIAL;
  216.     }
  217. }
  218.  
  219. int PInPolyEO(int x, int y, vector<vector<int>>& P)     // even-odd(считает число пересевчений, направл не интересует) закрашивает тольок ушки звезды
  220. {
  221.     int prm = 0;
  222.     for (int i = 0; i < P[0].size(); i++)
  223.     {
  224.         switch (EdgeType(P[0][i], P[1][i], P[0][(i + 1) % P[0].size()], P[1][(i + 1) % P[0].size()], x, y))
  225.         {
  226.         case TOUCHING:
  227.             return INSIDE;
  228.         case CROSS_LEFT:
  229.         case CROSS_RIGHT:
  230.             prm = 1 - prm;
  231.             break;
  232.         }
  233.     }
  234.     if (prm == 0)
  235.         return OUTSIDE;
  236.     else
  237.         return INSIDE;
  238. }
  239.  
  240. int PInPolyNZW(int x, int y, vector<vector<int>>& P) // закрасит всю звезду (учитывает и направления тоже)
  241. {
  242.     int prm = 0;
  243.     for (int i = 0; i < P[0].size(); i++)
  244.     {
  245.         switch (EdgeType(P[0][i], P[1][i], P[0][(i + 1) % P[0].size()], P[1][(i + 1) % P[0].size()], x, y))
  246.         {
  247.         case TOUCHING:
  248.             return INSIDE;
  249.         case CROSS_LEFT:
  250.             prm = prm + 1;
  251.             break;
  252.         case CROSS_RIGHT:
  253.             prm = prm - 1;
  254.             break;
  255.         }
  256.     }
  257.     if (prm != 0)
  258.         return INSIDE;
  259.     else
  260.         return OUTSIDE;
  261. }
  262.  
  263. int Max_El_1D(vector<int>& P) //максимальный элемент одномерного массива
  264. {
  265.     int max = P[0];
  266.     for (int i = 0; i < P.size(); i++)
  267.     {
  268.         if (P[i] > max)
  269.             max = P[i];
  270.     }
  271.     return max;
  272. }
  273.  
  274. int Min_El_1D(vector<int>& P)
  275. {
  276.     int min = P[0];
  277.     for (int i = 0; i < P.size(); i++)
  278.     {
  279.         if (P[i] < min)
  280.             min = P[i];
  281.     }
  282.     return min;
  283. }
  284.  
  285. void FillingEO(vector<vector<int>>& P, RGBPIXEL color)
  286. {
  287.     int x_max = Max_El_1D(P[0]);
  288.     int x_min = Min_El_1D(P[0]);
  289.     int y_max = Max_El_1D(P[1]);
  290.     int y_min = Min_El_1D(P[1]);
  291.     for (int y = y_min; y <= y_max; y++) //увеличиваем по пикселю и закрашиваем если внутри
  292.         for (int x = x_min; x <= x_max; x++)
  293.         {
  294.             if (PInPolyEO(x, y, P) == INSIDE)
  295.                 gfSetPixel(x, y, color);
  296.         }
  297. }
  298.  
  299. void FillingNZW(vector<vector<int>>& P, RGBPIXEL color)
  300. {
  301.     int x_max = Max_El_1D(P[0]);
  302.     int x_min = Min_El_1D(P[0]);
  303.     int y_max = Max_El_1D(P[1]);
  304.     int y_min = Min_El_1D(P[1]);
  305.     for (int y = y_min; y <= y_max; y++)
  306.         for (int x = x_min; x <= x_max; x++)
  307.         {
  308.             if (PInPolyNZW(x, y, P) == INSIDE)
  309.                 gfSetPixel(x, y, color);
  310.         }
  311. }
  312.  
  313.  
  314. //2 ЛР
  315.  
  316. vector<int> R3(double t, vector<vector<int>>& P) // параметрическое задание кривой безье 3 порядка
  317. {
  318.     vector<int> R = { 0 , 0 }; //точка
  319.     R[0] = int((1 - t) * (1 - t) * (1 - t) * P[0][0] + 3 * t * (1 - t) * (1 - t) * P[0][1] + 3 * t * t * (1 - t) * P[0][2] + t * t * t * P[0][3]);
  320.     R[1] = int((1 - t) * (1 - t) * (1 - t) * P[1][0] + 3 * t * (1 - t) * (1 - t) * P[1][1] + 3 * t * t * (1 - t) * P[1][2] + t * t * t * P[1][3]);
  321.     return R;
  322. }
  323.  
  324. int dist(int x, int y)  
  325. {
  326.     return abs(x) + abs(y);
  327. }
  328.  
  329. void DrawBesie3(vector<vector<int>>& P, RGBPIXEL color)
  330. {
  331.     int D = Max(dist(P[0][0] - 2 * P[0][1] + P[0][2], P[1][0] - 2 * P[1][1] + P[1][2]), dist(P[0][1] - 2 * P[0][2] + P[0][3], P[1][1] - 2 * P[1][2] + P[1][3]));
  332.     double N = 1 + sqrt(3 * D);
  333.     double dt = 1 / N;
  334.     double t = dt;
  335.     vector<int> P1, P2;
  336.     P1 = R3(0, P); //нач точка
  337.     while (t <= 1)
  338.     {
  339.         P2 = R3(t, P);
  340.         t += dt;
  341.         DrawLine(P1[0], P1[1], P2[0], P2[1], color);
  342.         P1 = P2;
  343.     }
  344.     P2 = R3(1, P);
  345.     DrawLine(P1[0], P1[1], P2[0], P2[1], color);
  346. }
  347.  
  348. int PolyTypeConvOrient(vector<vector<int>>& P, int& t) //проверка на ориентацию
  349. {
  350.     t = -1;
  351.     if (P[0].size() <= 2)
  352.     {
  353.         gfDrawText(300, 300, "Not polygon", RGBPIXEL::Cyan());
  354.         return -1;
  355.     }
  356.     int type0 = Classify(P[0][0], P[1][0], P[0][1], P[1][1], P[0][2], P[1][2]);
  357.     for (int j = 0; j < P[0].size() - 1; j++)
  358.         for (int i = j + 2; i < P[0].size() + j - 1; i++)
  359.         {
  360.             int type = Classify(P[0][j], P[1][j], P[0][j + 1], P[1][j + 1], P[0][i % P[0].size()], P[1][i % P[0].size()]);
  361.             if (type == DEST || type == ORIGIN || type == BEYOND || type == BEHIND)
  362.             {
  363.                 gfDrawText(300, 300, "Not polygon", RGBPIXEL::Cyan());
  364.                 return -1;
  365.             }
  366.             if (type != type0)
  367.                 return NON_CONVEX;
  368.         }
  369.     if (type0 == LEFT)
  370.         t = CLOCKWISE;  //по часовой(система левосторонняя)
  371.     if (type0 == RIGHT)
  372.         t = COUNTERCLOCKWISE;
  373.     return CONVEX;
  374. }
  375.  
  376. void ClipLine(vector<vector<int>>& line, vector<vector<int>>& Poly, RGBPIXEL color) //алгоритм отсечения Кируса-Бека
  377. {
  378.     int n = Poly[0].size();  //количество вершин(точек)
  379.     int trigger = -1; //отвечает за по\против часовой (ориентация)
  380.     int type = PolyTypeConvOrient(Poly, trigger);
  381.     if (type == NON_CONVEX)
  382.         gfDrawText(500, 100, "Невыпуклый", RGBPIXEL::Red());
  383.     else
  384.     {
  385.         if (trigger == CLOCKWISE) //переворачиваем, делаем копию buff и меняем
  386.         {
  387.             vector<vector<int>> buff = Poly;
  388.             for (int j = 0; j < 2; j++)
  389.                 for (int i = 1; i < n; i++)
  390.                 {
  391.                     buff[j][i] = Poly[j][n - i];
  392.                 }
  393.             Poly = buff;
  394.         }
  395.         double t0 = 0, t1 = 1, t;
  396.         int sx = line[0][1] - line[0][0];
  397.         int sy = line[1][1] - line[1][0];
  398.         int nx, ny;
  399.         double num, denom;
  400.         for (int i = 0; i < n; i++)
  401.         {
  402.             nx = Poly[1][(i + 1) % n] - Poly[1][i];
  403.             ny = Poly[0][i] - Poly[0][(i + 1) % n];
  404.             denom = nx * sx + ny * sy;
  405.             num = nx * (line[0][0] - Poly[0][i]) + ny * (line[1][0] - Poly[1][i]);
  406.             if (abs(denom) > 0.01)
  407.             {
  408.                 t = -num / denom;
  409.                 if (denom > 0)
  410.                 {
  411.                     if (t > t0)
  412.                         t0 = t;
  413.  
  414.                 }
  415.                 else
  416.                 {
  417.                     if (t < t1)
  418.                         t1 = t;
  419.                 }
  420.             }
  421.         }
  422.         if (t0 <= t1) //&& t1>0)
  423.             DrawLine(int(line[0][0] + t0 * sx), int(line[1][0] + t0 * sy), int(line[0][0] + t1 * sx), int(line[1][0] + t1 * sy), color);
  424.     }
  425.  
  426. }
  427.  
  428.  
  429. // Вызывается один раз в самом начале при инициализации приложения
  430. bool gfInitScene()
  431. {
  432.     // 1 лр
  433.     gfSetWindowSize(1150, 600);
  434.     DrawLine(100, 100, 160, 160, RGBPIXEL::Green());
  435.     DrawLine(100, 100, 160, 120, RGBPIXEL(200, 200, 200));
  436.     DrawLine(100, 100, 160, 100, RGBPIXEL::Cyan());
  437.     DrawLine(100, 100, 160, 60, RGBPIXEL(100, 100, 0));
  438.     DrawLine(100, 100, 160, 40, RGBPIXEL::Red());
  439.     DrawLine(100, 100, 120, 40, RGBPIXEL(100, 100, 0));
  440.     DrawLine(100, 100, 100, 40, RGBPIXEL::Yellow());
  441.     DrawLine(100, 100, 80, 40, RGBPIXEL(150, 100, 0));
  442.     DrawLine(100, 100, 40, 40, RGBPIXEL::Blue());
  443.     DrawLine(100, 100, 40, 60, RGBPIXEL(100, 100, 0));
  444.     DrawLine(100, 100, 40, 100, RGBPIXEL::White());
  445.     DrawLine(100, 100, 40, 120, RGBPIXEL(150, 100, 10));
  446.     DrawLine(100, 100, 40, 160, RGBPIXEL::Magenta());
  447.     DrawLine(100, 100, 80, 160, RGBPIXEL(200, 150, 0));
  448.     DrawLine(100, 100, 100, 160, RGBPIXEL::DkCyan());
  449.     DrawLine(100, 100, 120, 160, RGBPIXEL(200, 200, 0));
  450.  
  451.     vector<vector<int>> Poly = { {40, 160, 100, 40}, {240, 240, 200, 300} };
  452.     DrawPolygon(Poly, RGBPIXEL::Red());
  453.  
  454.     if (PolyTypeConv(Poly) == CONVEX) gfDrawText(60, 310, "CONVEX", RGBPIXEL::Blue());
  455.     else gfDrawText(60, 310, "NON CONVEX", RGBPIXEL::Blue());
  456.  
  457.     if (PolyTypeSimp(Poly) == SIMPLE) gfDrawText(60, 330, "SIMPLE", RGBPIXEL::Blue());
  458.     else gfDrawText(60, 330, "COMPLEX", RGBPIXEL::Blue());
  459.    
  460.  
  461.     vector<vector<int>> Poly0 = { {300, 360, 240, 360, 240}, {40, 160, 80, 80, 160} };
  462.     DrawPolygon(Poly0, RGBPIXEL::Cyan());
  463.    
  464.     if (PolyTypeConv(Poly0) == CONVEX) gfDrawText(260, 170, "CONVEX", RGBPIXEL::Blue());
  465.     else gfDrawText(260, 170, "NON CONVEX", RGBPIXEL::Blue());
  466.  
  467.     if (PolyTypeSimp(Poly0) == SIMPLE) gfDrawText(260, 200, "SIMPLE", RGBPIXEL::Blue());
  468.     else gfDrawText(260, 200, "COMPLEX", RGBPIXEL::Blue());
  469.  
  470.  
  471.     vector<vector<int>> PolyStar = { {300, 320, 360, 320, 300, 280, 240, 280}, {240, 280, 300, 320, 360, 320, 300, 280} };
  472.     DrawPolygon(PolyStar, RGBPIXEL::Cyan());
  473.  
  474.     if (PolyTypeConv(PolyStar) == CONVEX) gfDrawText(260, 380, "CONVEX", RGBPIXEL::Blue());
  475.     else gfDrawText(260, 380, "NON CONVEX", RGBPIXEL::Blue());
  476.  
  477.     if (PolyTypeSimp(PolyStar) == SIMPLE) gfDrawText(260, 400, "SIMPLE", RGBPIXEL::Blue());
  478.     else gfDrawText(260, 400, "COMPLEX", RGBPIXEL::Blue());
  479.  
  480.  
  481.     vector<vector<int>> Poly1 = { {500, 560, 440, 560, 440}, {40, 160, 80, 80, 160} };
  482.     DrawPolygon(Poly1, RGBPIXEL::Cyan());
  483.     gfDrawText(470, 10, "EVEN-ODD", RGBPIXEL::Blue());
  484.     FillingEO(Poly1, RGBPIXEL::Yellow());
  485.  
  486.     if (PolyTypeConv(Poly1) == CONVEX) gfDrawText(460, 170, "CONVEX", RGBPIXEL::Blue());
  487.     else gfDrawText(460, 170, "NON CONVEX", RGBPIXEL::Blue());
  488.  
  489.     if (PolyTypeSimp(Poly1) == SIMPLE) gfDrawText(460, 200, "SIMPLE", RGBPIXEL::Blue());
  490.     else gfDrawText(460, 200, "COMPLEX", RGBPIXEL::Blue());
  491.  
  492.  
  493.     vector<vector<int>> Poly2 = { {500 + 200, 560 + 200, 440 + 200, 560 + 200, 440 + 200}, {40, 160, 80, 80, 160} };
  494.     DrawPolygon(Poly2, RGBPIXEL::Magenta());
  495.     gfDrawText(630, 10, "NON-ZERO-WINDING", RGBPIXEL::Blue());
  496.     FillingNZW(Poly2, RGBPIXEL::Yellow());
  497.  
  498.     if (PolyTypeConv(Poly2) == CONVEX) gfDrawText(460+200, 170, "CONVEX", RGBPIXEL::Blue());
  499.     else gfDrawText(460+200, 170, "NON CONVEX", RGBPIXEL::Blue());
  500.  
  501.     if (PolyTypeSimp(Poly2) == SIMPLE) gfDrawText(460+200, 200, "SIMPLE", RGBPIXEL::Blue());
  502.     else gfDrawText(460+200, 200, "COMPLEX", RGBPIXEL::Blue());
  503.    
  504.  
  505.     //2 лр
  506.    
  507.     vector<vector<int>> LineBesie1 = { {450,700,400,600},{400,200,200,400} };
  508.     DrawBesie3(LineBesie1, RGBPIXEL::Red());
  509.  
  510.     vector<vector<int>> LineBesie2 = { {650,700,700,750},{400,200,200,400} };
  511.     DrawBesie3(LineBesie2, RGBPIXEL::Green());
  512.  
  513.     vector<vector<int>> ConvexPoly = { {850,1000, 1050, 1050, 900},{60, 60, 150, 400, 400} };
  514.     DrawPolygon(ConvexPoly, RGBPIXEL::Red());
  515.    
  516.     vector<vector<int>> LineFirst = { {800, 1100},{450, 350}};
  517.     DrawLine(LineFirst[0][0], LineFirst[1][0], LineFirst[0][1], LineFirst[1][1], RGBPIXEL::Blue());
  518.     ClipLine(LineFirst, ConvexPoly, RGBPIXEL::Green());
  519.  
  520.     vector<vector<int>> LineSecond = { {800, 950},{250, 300} };
  521.     DrawLine(LineSecond[0][0], LineSecond[1][0], LineSecond[0][1], LineSecond[1][1], RGBPIXEL::Blue());
  522.     ClipLine(LineSecond, ConvexPoly, RGBPIXEL::Green());
  523.  
  524.     vector<vector<int>> LineThird = { {900, 1100},{150, 150} };
  525.     DrawLine(LineThird[0][0], LineThird[1][0], LineThird[0][1], LineThird[1][1], RGBPIXEL::Blue());
  526.     ClipLine(LineThird, ConvexPoly, RGBPIXEL::Green());
  527.    
  528.  
  529.     vector<vector<int>> LineFourth = { {800, 820},{300, 400} };
  530.     DrawLine(LineFourth[0][0], LineFourth[1][0], LineFourth[0][1], LineFourth[1][1], RGBPIXEL::Blue());
  531.     ClipLine(LineFourth, ConvexPoly, RGBPIXEL::Green());
  532.  
  533.     vector<vector<int>> Linefifth = { {970, 990},{260, 340} };
  534.     DrawLine(Linefifth[0][0], Linefifth[1][0], Linefifth[0][1], Linefifth[1][1], RGBPIXEL::Blue());
  535.     ClipLine(Linefifth, ConvexPoly, RGBPIXEL::Green());
  536.    
  537.     //ClipLine(line, Poly, RGBPIXEL::Red());
  538.     //gfSetPixel( 20, 20, RGBPIXEL(255, 255, 0) );
  539.     //FillingEO(Poly, RGBPIXEL::Red());
  540.     //FillingNZW(Poly2, RGBPIXEL::Red());
  541.     //gfDrawRectangle( 100, 120, 170, 150, RGBPIXEL(255, 255, 0) );
  542.     //gfDrawText( 200, 200, "Hello World", RGBPIXEL(0, 128, 255));
  543.     //gfDisplayMessage("Message!");
  544.  
  545. /*  int l = 5;
  546.     vector<vector<int>> line1 = { {430, 590, 590, 430}, {300+l/2, 300+l/2, 300-l/2, 300-l/2} };
  547.     DrawPolygon(line1, RGBPIXEL::Red());
  548.     FillingEO(line1, RGBPIXEL::Red());
  549.  
  550.     l = 5;
  551.     vector<vector<int>> line2 = { {510, 590, 590, 510}, {300 + l / 2, 240 + l / 2, 240 - l / 2, 300 - l / 2} };
  552.     DrawPolygon(line2, RGBPIXEL::Yellow());
  553.     FillingEO(line2, RGBPIXEL::Yellow());
  554.  
  555.     l = 5;
  556.     vector<vector<int>> line3 = { {510+l/2, 510+l/2, 510-l/2, 510-l/2}, {300, 240, 240, 300} };
  557.     DrawPolygon(line3, RGBPIXEL::Cyan());
  558.     FillingEO(line3, RGBPIXEL::Cyan());
  559.  
  560.     l = 5;
  561.     vector<vector<int>> line4 = { {510, 430, 430, 510}, {300 + l / 2, 240 + l / 2, 240 - l / 2, 300 - l / 2} };
  562.     DrawPolygon(line4, RGBPIXEL::Blue());
  563.     FillingEO(line4, RGBPIXEL::Blue());
  564. */
  565.  
  566.     return true;
  567. }
  568.  
  569. // Вызывается в цикле до момента выхода из приложения.
  570. // Следует использовать для создания анимационных эффектов
  571. void gfDrawScene()
  572. {
  573.     //gfClearScreen(RGBPIXEL::Black());
  574.  
  575.     //static int x = 0;
  576.     //gfDrawRectangle(x, 100, x + 50, 130, RGBPIXEL::Blue());
  577.     //x = (x + 1) % gfGetWindowWidth() ;
  578.  
  579.     //int x = gfGetMouseX(),
  580.     //    y = gfGetMouseY();
  581.     //gfDrawRectangle(x - 10, y - 10, x + 10, y + 10, RGBPIXEL::Green());
  582. }
  583.  
  584. // Вызывается один раз перед выходом из приложения.
  585. // Следует использовать для освобождения выделенных
  586. // ресурсов (памяти, файлов и т.п.)
  587. void gfCleanupScene()
  588. {
  589. }
  590.  
  591. // Вызывается когда пользователь нажимает левую кнопку мыши
  592. void gfOnLMouseClick( int x, int y )
  593. {
  594.     x; y;
  595.     gfDrawRectangle(x - 10, y - 10, x + 10, y + 10, RGBPIXEL::Green());
  596. }
  597.  
  598. // Вызывается когда пользователь нажимает правую кнопку мыши
  599. void gfOnRMouseClick( int x, int y )
  600. {
  601.     x; y;
  602. }
  603.  
  604. // Вызывается когда пользователь нажимает клавишу на клавиатуре
  605. void gfOnKeyDown( UINT key )
  606. {
  607.     key;
  608.  
  609.     if( key == 'A' )
  610.         gfDisplayMessage( "'A' key has been pressed" );
  611. }
  612.  
  613. // Вызывается когда пользователь отжимает клавишу на клавиатуре
  614. void gfOnKeyUp( UINT key )
  615. {
  616.     key;
  617.  
  618.     //if( key == 'B' )
  619.     //    gfDisplayMessage( "'B' key has been un-pressed" );
  620. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement