Изменить код

#include <windows.h>
#include "freeglut.h"
#include <iostream>
 
int points[100][100];
 
const int view_side_size = 40;
const int period = 40;
 
const int side_size = 900;
const int qwe = 7;
 
struct vec2_t {
    int x = 0, y = 0;
    vec2_t(int x, int y) : x(x), y(y) {}
    vec2_t() {}
    float len() {
        return sqrt(x * x + y * y);
    }
 
    int len_int() {
        return len();
    }
};
 
vec2_t operator-(vec2_t a, vec2_t b) {
    return vec2_t(a.x - b.x, a.y - b.y);
}
 
vec2_t to_inner_coords(int x, int y) {
    vec2_t out;
    out.x = x;
    out.y = y;
    out.x = round(((out.x - side_size / 2.0f) / side_size) * (view_side_size * 2.0f));
    out.y = round(((side_size / 2.0f - out.y) / side_size) * (view_side_size * 2.0f));
 
    return out;
}
 
vec2_t g[qwe];
int gi = 0;
 
std::ostream &operator<<(std::ostream &os, vec2_t v) {
    os << v.x << " " << v.y;
    return os;
}
 
void mb(int button, int state, int x, int y)
{
    if (button == GLUT_LEFT_BUTTON)
    {
        if (state == GLUT_UP && gi < qwe){
            vec2_t coords = to_inner_coords(x, y);
            std::cout << coords << "\n";
            g[gi++] = coords;
        }
    }
}
 
struct color_t
{
    double r, g, b, a;
    void setThis() const
    {
        const color_t &color = *this;
        glColor4d(color.r, color.g, color.b, color.a);
    }
};
 
const color_t black = { 0, 0, 0, 1 };
const color_t blue = { 0, 0.1, 0.8, 1 };
const color_t green = { 0.5, 1.0, 0.0, 1 };
const color_t red = { 1, 0, 0, 1 };
const color_t orange = { 1, 0.5, 0.0, 1 };
const color_t grey = { 0.2, 0.2, 0.2, 0.5 };
const color_t white = { 1.0, 1.0, 1.0, 1.0 };
 
void DrawFatPixel(int x, int y, color_t color = black)
{
    color.setThis();
    glBegin(GL_POLYGON);
    glVertex2d(x - 0.5, y - 0.5);
    glVertex2d(x - 0.5, y + 0.5);
    glVertex2d(x + 0.5, y + 0.5);
    glVertex2d(x + 0.5, y - 0.5);
    glEnd();
}
 
void DrawCell()
{
    glLineWidth(1);
    black.setThis();
 
    for (int i = -view_side_size; i <= view_side_size; ++i)
    {
        glBegin(GL_LINES);
        glVertex2f(i + 0.5f, -view_side_size + .0f);
        glVertex2f(i + 0.5f, view_side_size + .0f);
        glVertex2f(-view_side_size + .0f, i + 0.5f);
        glVertex2f(view_side_size + .0f, i + 0.5f);
        glEnd();
    }
}
 
void DrawAxes()
{
    glLineWidth(2);
    red.setThis();
    glBegin(GL_LINES);
    glVertex2i(-view_side_size, 0);
    glVertex2i(view_side_size, 0);
    glVertex2i(0, -view_side_size);
    glVertex2i(0, view_side_size);
    glEnd();
}
 
void DrawLineBrezenhem(int x0, int y0, int x1, int y1, int flag, color_t color = blue)
{
    bool steep = false;
    if (std::abs(x0 - x1)<std::abs(y0 - y1))
    {
        std::swap(x0, y0);
        std::swap(x1, y1);
        steep = true;
    }
    if (x0>x1)
    {
        std::swap(x0, x1);
        std::swap(y0, y1);
    }
    int dx = x1 - x0;
    int dy = y1 - y0;
    int derror2 = std::abs(dy) * 2;
    int error2 = 0;
    int y = y0;
    int i = 0;
    for (int x = x0; x <= x1; x++)
    {
        if (steep)
        {
            DrawFatPixel(y, x, color);
            points[y + 50][x + 50] |= flag;
        }
        else
        {
            DrawFatPixel(x, y, color);
            points[x + 50][y + 50] |= flag;
        }
 
        error2 += derror2;
 
        if (error2>dx)
        {
            y += (y1>y0 ? 1 : -1);
            error2 -= dx * 2;
        }
    }
}
 
int count_bits(int i) {
    int res = 0;
    while (i) {
        if (i & 1) res++;
        i = i >> 1;
    }
    return res;
}
 
void DrawPolygon(const int tick)
{
    int ymin = 100, ymax = -100;
    for (int y = 0; y < 100 && y < tick; y++)
    {
        for (int x = 1; x < 100; x++)
        {
            if (points[x][y])
            {
                if (y < ymin) ymin = y;
                if (y > ymax) ymax = y;
            }
        }
    }
 
    for (int y = 0; y < 100 && y < tick; y++)
    {
        bool is_in = false;
        for (int x = 1; x < 100; x++)
        {
            if (points[x][y] && !(points[x][y] & points[x - 1][y]))
            {
                is_in = !is_in;
            }
            if (is_in) {
                DrawFatPixel(x - 50, y - 50, blue);
            }
        }
    }
 
    for (int y = 0; y < 100 && y < tick; y++)
    {
        for (int x = 99; x > 0; --x) {
            if (points[x][y]) break;
            DrawFatPixel(x - 50, y - 50, white);
        }
    }
}
 
void Display()
{
    glClear(GL_COLOR_BUFFER_BIT);
    if (gi > qwe) {
        static int tick = 0;
        tick++;
        for (int i = 0; i < qwe-1; i++)
        {
            DrawLineBrezenhem(g[i].x, g[i].y, g[i + 1].x, g[i + 1].y, 1 << i);
        }
        DrawLineBrezenhem(g[qwe-1].x, g[qwe-1].y, g[0].x, g[0].y - 1, 1 << qwe-1);
        DrawPolygon(tick);
    }
    else {
        for (int i = 0; i < gi; ++i) {
            DrawFatPixel(g[i].x, g[i].y, blue);
        }
        if (gi == qwe) gi++;
    }
    DrawAxes();
    DrawCell();
 
    glFlush();
}
 
void timf(int value)
{
    glutPostRedisplay();
    glutTimerFunc(period, timf, 0);
}
 
void Initialize()
{
    glClearColor(1.0, 1.0, 1.0, 1.0);
    glEnable(GL_BLEND);
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    glOrtho(-view_side_size, view_side_size, -view_side_size, view_side_size, -1.0, 1.0);
    for (int y = 0; y < 100; y++)
    {
        for (int x = 0; x < 100; x++)
        {
            points[x][y] = 0;
        }
    }
}
 
int main(int argc, char **argv)
{
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
    glutInitWindowSize(side_size, side_size);
    glutInitWindowPosition(100, 100);
    glutCreateWindow("Labwork 3. Polygons");
    Initialize();
    glutDisplayFunc(Display);
    glutMouseFunc(mb);
    glutTimerFunc(period, timf, 0);
    glutMainLoop();
    return 0;
}