Не открывается окно при использовании graphics.h

#include <stdio.h>
#include <graphics.h>
 
void BrezLine(POINT from, POINT to, COLORREF color)
{
    int x, y, xend, yend, s, dx, dy, d, inc1, inc2;
    int x1, x2, y1, y2;
 
    x1 = from.x;
    x2 = to.x;
    y1 = from.y;
    y2 = to.y;
    dx = abs(x2-x1);
    dy = abs(y2-y1);
 
    if(dx > dy)
    {
        inc1 = 2*dy;
        inc2 = 2*(dy-dx);
        d = 2*dy-dx;
 
        if(x1 < x2)
        {
            x = x1; y = y1; xend = x2;
            (y1 < y2) ? s = 1 : s = -1;
        }
        else
        {
            x = x2;
            y = y2;
            xend = x1;
            (y1 > y2) ? s = 1 : s = -1;
        }
 
        putpixel(x,y,color);
 
        while(x < xend)
        {
            x++;
            if(d > 0)
            {
                y += s;
                d += inc2;
            }
            else d += inc1;
            putpixel(x,y,color);
        }
    }
    else
    {
        inc1 = 2*dx;
        inc2 = 2*(dx-dy);
        d = 2*dx-dy;
 
        if(y1 < y2)
        {
            y = y1; x = x1; yend = y2;
            (x1 < x2) ? s = 1 : s = -1;
        }
        else
        {
            y = y2;
            x = x2;
            yend = y1;
            (x1 > x2) ? s = 1 : s = -1;
        }
 
        putpixel(x,y,color);
 
        while(y < yend)
        {
            y++;
            if(d > 0)
            {
                x += s;
                d += inc2;
            }
            else d += inc1;
            putpixel(x,y,color);
        }
    }
}
 
int main()
{
    POINT f, t, q, w;
    f.x = 45; f.y = -98;
    t.x = 700; t.y = 400;
 
    initwindow(800,600);
    BrezLine(f,t,0x00ff00b2);
 
    getch();
    closegraph();
    return 0;
}

#include <Gl/freeglut.h>
#include <string>
 
void DrawText(float x, float y, std::string text)
{
    glRasterPos2f(x, y);
    glutBitmapString(GLUT_BITMAP_8_BY_13, (const unsigned char*)text.c_str());
}
 
void Initialize()
{
    glClearColor(0.933f, 0.945f, 0.945f, 1.0);
 
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    glOrtho(0.0f, 100.0f, 0.0f, 100.0f, -1.0f, 1.0f);
}
 
void Draw()
{
    glClear(GL_COLOR_BUFFER_BIT);
 
    glBegin(GL_LINES);
    {
        // First Line
        glColor3f(0.0f, 1.0f, 0.0f);
        glVertex2f(0.0f, 0.0f);
        glVertex2f(25.0f, 50.0f);
 
        // Second Line
        glColor3f(1.0f, 0.0f, 0.0f);
        glVertex2f(25.0f, 50.0f);
        glVertex2f(75.0f, 60.0f);
 
        // Third Line
        glColor3f(0.298f, 0.549f, 0.803f);
        glVertex2f(75.0f, 60.0f);
        glVertex2f(100.0f, 90.0f);
    }
    glEnd();
 
    glColor3f(0.0f, 0.0f, 0.0f);
    DrawText(4.0f, 3.0f, "(0, 0)");
    DrawText(15.0f, 55.0f, "(25, 50)");
    DrawText(65.0f, 53.0f, "(75, 60)");
    DrawText(73.0f, 90.0f, "(100, 90)");
 
    glutSwapBuffers();
}
 
int main(int argc, char **argv)
{
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB);
    glutInitWindowSize(256, 256);
    glutInitWindowPosition(100, 100);
    glutCreateWindow("Lines");
    Initialize();
    glutDisplayFunc(Draw);
    glutMainLoop();
 
    return 0;
}

#include <wx/wx.h>
#include <wx/graphics.h>
 
class MyApp : public wxApp
{
public:
    virtual bool OnInit();
};
 
class MyFrame : public wxFrame
{
public:
    MyFrame();
 
private:
    void OnPaint(wxPaintEvent &event);
 
};
 
wxIMPLEMENT_APP(MyApp);
 
bool MyApp::OnInit()
{
    MyFrame *frame = new MyFrame();
    frame->Show(true);
    return true;
}
 
MyFrame::MyFrame() : wxFrame(NULL, wxID_ANY, "graphics")
{
    Bind(wxEVT_PAINT, &MyFrame::OnPaint, this);
}
 
 
void MyFrame::OnPaint(wxPaintEvent &event)
{
    wxPaintDC dc(this);
    wxGraphicsContext *gc = wxGraphicsContext::Create( dc );
    if (gc)
    {
        gc->SetPen( *wxRED_PEN );
        wxGraphicsPath path = gc->CreatePath();
        path.MoveToPoint(50.0, 50.0);
        path.AddLineToPoint(100.0, 100.0);
        path.AddLineToPoint(250.0, 150.0 );
        gc->StrokePath(path);
        delete gc;
    }
}

#include <glad/glad.h>
#include <GLFW/glfw3.h>
#include <glm/gtc/matrix_transform.hpp>
 
#include <string>
#include <iostream>
#include <fstream>
#include <vector>
 
typedef unsigned short  ushort;
typedef glm::vec2       vec2;
typedef glm::mat4       mat4;
 
struct Vertex
{
    vec2 pos;
};
 
void showErrorMessageAndExit(std::string message)
{
    std::cout << message << std::endl;
    std::cout << "\nPress Enter key for exit." << std::endl;
    glfwTerminate();
    std::getchar();
    exit(1);
}
 
std::string readStringFromFile(std::string filename)
{
    std::string res;
    std::string line;
    std::ifstream in(filename);
 
    if (in.is_open())
    {
        while (getline(in, line))
        {
            res += line + "\n";
        }
    }
    in.close();
 
    return res;
}
 
GLint CompileShader(std::string filename)
{
    GLint vs = glCreateShader(GL_VERTEX_SHADER);
    std::string cString = readStringFromFile("Data\\Shaders\\" + filename + ".vert.glsl");
    GLchar const* files[] = { cString.c_str() };
    GLint lengths[] = { cString.size() };
    glShaderSource(vs, 1, files, lengths);
    glCompileShader(vs);
 
    GLint success;
    GLchar infoLog[512];
    glGetShaderiv(vs, GL_COMPILE_STATUS, &success);
    if (!success)
    {
        glGetShaderInfoLog(vs, 512, NULL, infoLog);
        showErrorMessageAndExit("Vertex Shader Error. " + std::string(infoLog));
    }
 
    GLint fs = glCreateShader(GL_FRAGMENT_SHADER);
    cString = readStringFromFile("Data\\Shaders\\" + filename + ".frag.glsl");
    GLchar const* files1[] = { cString.c_str() };
    GLint lengths1[] = { cString.size() };
    glShaderSource(fs, 1, files1, lengths1);
    glCompileShader(fs);
 
    glGetShaderiv(fs, GL_COMPILE_STATUS, &success);
    if (!success)
    {
        glGetShaderInfoLog(fs, 512, NULL, infoLog);
        showErrorMessageAndExit("Fragment Shader Error. " + std::string(infoLog));
    }
 
    GLint prog = glCreateProgram();
    glAttachShader(prog, vs);
    glAttachShader(prog, fs);
    glLinkProgram(prog);
    glUseProgram(prog);
 
    glDetachShader(prog, vs);
    glDetachShader(prog, fs);
    glDeleteShader(vs);
    glDeleteShader(fs);
 
    return prog;
}
 
void initVertexBuffers(GLint program)
{
    // Vertices
    std::vector<Vertex> verts(5);
    verts[0].pos = vec2(0.0f, 30.0f);
    verts[1].pos = vec2(20.0f, 50.0f);
    verts[2].pos = vec2(40.0f, 40.0f);
    verts[3].pos = vec2(60.0f, 70.0f);
    verts[4].pos = vec2(80.0f, 80.0f);
 
    // Indices
    std::vector<ushort> inds(verts.size());
    for (size_t i = 0; i < verts.size(); i++)
    {
        inds[i] = i;
    }
 
    GLuint vertexBufferObject;
    GLuint indexBufferObject;
    glGenBuffers(1, &vertexBufferObject);
    glGenBuffers(1, &indexBufferObject);
 
    glBindBuffer(GL_ARRAY_BUFFER, vertexBufferObject);
    glBufferData(GL_ARRAY_BUFFER, sizeof(Vertex) * verts.size(), &(verts[0].pos.x), GL_STATIC_DRAW);
 
    GLint aPositionLoc = glGetAttribLocation(program, "aPosition");
    if (aPositionLoc == -1) showErrorMessageAndExit("Failed to get a \"aPosition\" variable.");
    glVertexAttribPointer(aPositionLoc, 2, GL_FLOAT, GL_FALSE, sizeof(Vertex), (const GLvoid*)(offsetof(Vertex, pos)));
    glEnableVertexAttribArray(aPositionLoc);
 
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indexBufferObject);
    glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(ushort) * inds.size(), &(inds[0]), GL_STATIC_DRAW);
}
 
void initialize()
{
    // Load definitions of OpenGL functions
    if (!gladLoadGL()) showErrorMessageAndExit("Failed to load definitions of OpenGL functions.");
 
    // Set a background color
    glClearColor(0.9f, 0.9f, 0.9f, 1.0f);
 
    // Get a color shader program
    GLint program = CompileShader("Color");
 
    // Initialize vertex buffers
    initVertexBuffers(program);
 
    // Initialize a projection matrix in the vertex shader
    mat4 projMatrix = glm::ortho(0.0f, 100.0f, 0.0f, 100.0f);
    GLint uProjMatrixLocation = glGetUniformLocation(program, "uProjMatrix");
    if (uProjMatrixLocation == -1)
    {
        showErrorMessageAndExit("Failed to get the uProjMatrix variable.");
    }
    glUniformMatrix4fv(uProjMatrixLocation, 1, false, &projMatrix[0][0]);
}
 
void draw()
{
    // Clear the screen with the background color
    glClear(GL_COLOR_BUFFER_BIT);
 
    // Draw the lines
    glDrawElements(GL_LINE_STRIP, 5, GL_UNSIGNED_SHORT, 0);
}
 
int main()
{
    // Initialize GLFW
    if (!glfwInit()) showErrorMessageAndExit("Failed to initialize GLFW.");
    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 1);
    glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_FALSE);
    glfwWindowHint(GLFW_RESIZABLE, GL_FALSE);
    GLFWwindow* window = glfwCreateWindow(256, 256, "Lines", nullptr, nullptr);
    // Create a window
    if (!window) showErrorMessageAndExit("Failed to create a window.");
    // Make context current
    glfwMakeContextCurrent(window);
    // Initialize
    initialize();
    // Show window and run a window loop
    while (!glfwWindowShouldClose(window))
    {
        glfwPollEvents();
 
        // Close window if the user press the Escape key
        if (glfwGetKey(window, GLFW_KEY_ESCAPE) == GLFW_PRESS)
        {
            glfwSetWindowShouldClose(window, true);
        }
 
        // Clear a render area with the background color
        glClear(GL_COLOR_BUFFER_BIT);
 
        draw();
 
        // Swap the back and the front buffers
        glfwSwapBuffers(window);
    }
 
    glfwTerminate();
    return 0;
}