API tools faq
paste
allekco

comp lab1 2

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