Не работает клик мыши

#include <cglm/cglm.h>
#include <glad/glad.h>
#include <stdbool.h>
#include <windows.h>
 
const char *vertexShaderSource =
    "#version 330 core\n"
    "layout (location = 0) in vec3 aPosition;\n"
    "uniform mat4 mvp;\n"
    "void main()\n"
    "{\n"
    "   gl_Position = mvp * vec4(aPosition, 1.0);\n"
    "}\n";
 
const char *fragmentShaderSource =
    "#version 330 core\n"
    "out vec4 fragColor;\n"
    "void main()\n"
    "{\n"
    "   fragColor = vec4(1.0f, 0.5f, 0.2f, 1.0f);\n"
    "}\n";
 
HWND g_hWnd = NULL;
HDC g_hDC = NULL;
HGLRC g_hRC = NULL;
bool g_running = true;
 
typedef BOOL(WINAPI *PFNWGLSWAPINTERVALEXTPROC)(int interval);
 
LRESULT CALLBACK WindowProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
    switch (uMsg)
    {
        case WM_CLOSE:
        case WM_DESTROY:
            g_running = false;
            PostQuitMessage(0);
            return 0;
        case WM_SIZE:
            if (g_hRC != NULL)
            {
                glViewport(0, 0, LOWORD(lParam), HIWORD(lParam));
            }
            return 0;
    }
    return DefWindowProc(hWnd, uMsg, wParam, lParam);
}
 
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nShowCmd)
{
    WNDCLASS wc = { 0 };
    wc.lpfnWndProc = WindowProc;
    wc.hInstance = hInstance;
    wc.lpszClassName = "Sample Window Class";
    wc.style = CS_OWNDC;
    RegisterClass(&wc);
 
    g_hWnd = CreateWindowEx(0, wc.lpszClassName, "OpenGL 3.3, WinAPI, C",
        WS_OVERLAPPED | WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX,
        CW_USEDEFAULT, CW_USEDEFAULT, 350, 350,
        NULL, NULL, hInstance, NULL);
 
    ShowWindow(g_hWnd, nShowCmd); 
    UpdateWindow(g_hWnd);
 
    g_hDC = GetDC(g_hWnd);
    PIXELFORMATDESCRIPTOR pfd = { sizeof(pfd), 1, PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER, PFD_TYPE_RGBA, 32 };
    SetPixelFormat(g_hDC, ChoosePixelFormat(g_hDC, &pfd), &pfd);
 
    g_hRC = wglCreateContext(g_hDC);
    wglMakeCurrent(g_hDC, g_hRC);
 
    if (!gladLoadGL())
        return -1;
 
    // Compile vertex shader
    unsigned int vertexShader = glCreateShader(GL_VERTEX_SHADER);
    glShaderSource(vertexShader, 1, &vertexShaderSource, NULL);
    glCompileShader(vertexShader);
 
    // Compile fragment shader
    unsigned int fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
    glShaderSource(fragmentShader, 1, &fragmentShaderSource, NULL);
    glCompileShader(fragmentShader);
 
    // Link shader program
    unsigned int shaderProgram = glCreateProgram();
    glAttachShader(shaderProgram, vertexShader);
    glAttachShader(shaderProgram, fragmentShader);
    glLinkProgram(shaderProgram);
    glDeleteShader(vertexShader);
    glDeleteShader(fragmentShader);
 
    // Setup triangle data
    float vertices[] = {
        -0.5f, -0.5f, 0.0f,
        0.5f, -0.5f, 0.0f,
        0.0f, 0.5f, 0.0f
    };
 
    unsigned int VBO, VAO;
    glGenVertexArrays(1, &VAO);
    glGenBuffers(1, &VBO);
 
    glBindVertexArray(VAO);
    glBindBuffer(GL_ARRAY_BUFFER, VBO);
    glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
 
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void *)0);
    glEnableVertexAttribArray(0);
 
    int mvpLoc = glGetUniformLocation(shaderProgram, "mvp");
 
    glClearColor(50.f / 255.f, 50.f / 255.f, 50.f / 255.f, 1.f);
 
    // Get the function from the driver
    PFNWGLSWAPINTERVALEXTPROC wglSwapIntervalEXT =
        (PFNWGLSWAPINTERVALEXTPROC)wglGetProcAddress("wglSwapIntervalEXT");
 
    // Enable VSync (1 = On, 0 = Off)
    if (wglSwapIntervalEXT)
    {
        wglSwapIntervalEXT(1);
    }
 
    float rotation = 0.0f;
 
    // Setup a timer
    LARGE_INTEGER frequency, lastTime, currentTime;
    QueryPerformanceFrequency(&frequency);
    QueryPerformanceCounter(&lastTime);
 
    MSG msg = { 0 };
    while (g_running)
    {
        while (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
        {
            TranslateMessage(&msg);
            DispatchMessage(&msg);
        }
 
        glClear(GL_COLOR_BUFFER_BIT);
        glUseProgram(shaderProgram);
 
        QueryPerformanceCounter(&currentTime);
        float deltaTime = (float)(currentTime.QuadPart - lastTime.QuadPart) / frequency.QuadPart;
        lastTime = currentTime;
 
        // Rotate 1 radian per second
        rotation += 1.0f * deltaTime;
 
        mat4 model;
        glm_mat4_identity(model);
        glm_translate(model, (vec3) { 0.2f, 0.0f, 0.0f });
        glm_rotate(model, rotation, (vec3) { 0.0f, 0.0f, 1.0f });
        glm_scale(model, (vec3) { 1.5f, 1.5f, 1.0f });
 
        mat4 view;
        glm_mat4_identity(view);
        glm_translate(view, (vec3) { 0.0f, 0.0f, -3.0f }); // Move camera back
 
        mat4 projection;
        // Arguments: left, right, bottom, top, near, far
        glm_ortho(-2.0f, 2.0f, -2.0f, 2.0f, 0.1f, 100.f, projection);
 
        mat4 mvp;
        glm_mat4_mul(projection, view, mvp);
        glm_mat4_mul(mvp, model, mvp); // Final MVP = P * V * M
 
        // Send the final matrix to shader
        glUniformMatrix4fv(mvpLoc, 1, GL_FALSE, (float *)mvp);
 
        glBindVertexArray(VAO);
        glDrawArrays(GL_TRIANGLES, 0, 3);
 
        SwapBuffers(g_hDC);
    }
 
    glDeleteVertexArrays(1, &VAO);
    glDeleteBuffers(1, &VBO);
    glDeleteProgram(shaderProgram);
 
    wglMakeCurrent(NULL, NULL);
    wglDeleteContext(g_hRC);
    ReleaseDC(g_hWnd, g_hDC);
 
    return 0;
}

    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    // glOrtho(left, right, bottom, top, near, far)
    glOrtho(0.0, 512.0, 512.0, 0.0, -1.0, 1.0);
    //      left,right, bottom,top, near, far

        mat4 projection;
        // Arguments: left, right, bottom, top, near, far
        glm_ortho(-2.0f, 2.0f, -2.0f, 2.0f, 0.1f, 100.f, projection);

        glm_scale(model, (vec3) { 1.5f, 1.5f, 1.0f });