How can i do an hexagon? VS only shows a triangle

Question

I'm trying to do an hexagon and learn tessellation but when i execute all i can see is a triangle.

I have a Nvidia 4080, drivers up to the date. I already did a check in the libraries and seems that they are fine.

#include <glad/glad.h>
#include <GLFW/glfw3.h>
#include <glm/glm.hpp>
#include <glm/gtc/type_ptr.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include <iostream>


glm::vec3 hexagonPoints[] = {
    {0.0f,  0.5f, 0.0f},
    {0.433f,  0.25f, 0.0f},
    {0.433f, -0.25f, 0.0f},
    {0.0f, -0.5f, 0.0f},
    {-0.433f, -0.25f, 0.0f},
    {-0.433f,  0.25f, 0.0f},
};


GLuint hexagonVBO, hexagonVAO;


const char* vertexShaderSource = R"(
#version 400 core
layout (location = 0) in vec3 aPos;
void main() {
    gl_Position = vec4(aPos, 1.0);
}
)";

const char* tessControlShaderSource = R"(
#version 400 core
layout(vertices = 6) out;
void main() {
    if (gl_InvocationID == 0) {
        gl_TessLevelInner[0] = 1.0;
        gl_TessLevelInner[1] = 1.0;
        gl_TessLevelOuter[0] = 1.0;
        gl_TessLevelOuter[1] = 1.0;
        gl_TessLevelOuter[2] = 1.0;
        gl_TessLevelOuter[3] = 1.0;
    }
    gl_out[gl_InvocationID].gl_Position = gl_in[gl_InvocationID].gl_Position;
}
)";

const char* tessEvalShaderSource = R"(
#version 400 core
layout(triangles) in;
void main() {
    gl_Position = (gl_TessCoord.x * gl_in[0].gl_Position) +
                  (gl_TessCoord.y * gl_in[1].gl_Position) +
                  (gl_TessCoord.z * gl_in[2].gl_Position);
}
)";

const char* fragmentShaderSource = R"(
#version 400 core
out vec4 FragColor;
void main() {
    FragColor = vec4(1.0, 0.0, 0.0, 1.0);
}
)";

void setupHexagonVAO() {
    glGenVertexArrays(1, &hexagonVAO);
    glBindVertexArray(hexagonVAO);

    glGenBuffers(1, &hexagonVBO);
    glBindBuffer(GL_ARRAY_BUFFER, hexagonVBO);
    glBufferData(GL_ARRAY_BUFFER, sizeof(hexagonPoints), hexagonPoints, GL_STATIC_DRAW);

    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void*)0);
    glEnableVertexAttribArray(0);
}

GLuint compileShader(GLenum type, const char* source) {
    GLuint shader = glCreateShader(type);
    glShaderSource(shader, 1, &source, nullptr);
    glCompileShader(shader);

    int success;
    char infoLog[512];
    glGetShaderiv(shader, GL_COMPILE_STATUS, &success);
    if (!success) {
        glGetShaderInfoLog(shader, 512, nullptr, infoLog);
        std::cerr << "Error compiling shader: " << infoLog << std::endl;
    }
    return shader;
}

GLuint createTessellationProgram() {
    GLuint vertexShader = compileShader(GL_VERTEX_SHADER, vertexShaderSource);
    GLuint tessControlShader = compileShader(GL_TESS_CONTROL_SHADER, tessControlShaderSource);
    GLuint tessEvalShader = compileShader(GL_TESS_EVALUATION_SHADER, tessEvalShaderSource);
    GLuint fragmentShader = compileShader(GL_FRAGMENT_SHADER, fragmentShaderSource);

    GLuint shaderProgram = glCreateProgram();
    glAttachShader(shaderProgram, vertexShader);
    glAttachShader(shaderProgram, tessControlShader);
    glAttachShader(shaderProgram, tessEvalShader);
    glAttachShader(shaderProgram, fragmentShader);
    glLinkProgram(shaderProgram);

    int success;
    char infoLog[512];
    glGetProgramiv(shaderProgram, GL_LINK_STATUS, &success);
    if (!success) {
        glGetProgramInfoLog(shaderProgram, 512, nullptr, infoLog);
        std::cerr << "Error linking shader program: " << infoLog << std::endl;
    }

    glDeleteShader(vertexShader);
    glDeleteShader(tessControlShader);
    glDeleteShader(tessEvalShader);
    glDeleteShader(fragmentShader);

    return shaderProgram;
}

int main() {

    if (!glfwInit()) {
        std::cerr << "Failed to initialize GLFW" << std::endl;
        return -1;
    }

    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 4);
    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);

    GLFWwindow* window = glfwCreateWindow(800, 600, "Tessellation Hexagon", nullptr, nullptr);
    if (!window) {
        std::cerr << "Failed to create GLFW window" << std::endl;
        glfwTerminate();
        return -1;
    }

    glfwMakeContextCurrent(window);

    if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress)) {
        std::cerr << "Failed to initialize GLAD" << std::endl;
        return -1;
    }

    glViewport(0, 0, 800, 600);
    glEnable(GL_DEPTH_TEST);

    setupHexagonVAO();

    GLuint tessShaderProgram = createTessellationProgram();

    while (!glfwWindowShouldClose(window)) {

        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

        glUseProgram(tessShaderProgram);
        glPatchParameteri(GL_PATCH_VERTICES, 6);
        glBindVertexArray(hexagonVAO);
        glDrawArrays(GL_PATCHES, 0, 6);

        glfwSwapBuffers(window);
        glfwPollEvents();
    }


    glDeleteVertexArrays(1, &hexagonVAO);
    glDeleteBuffers(1, &hexagonVBO);
    glDeleteProgram(tessShaderProgram);

    glfwTerminate();
    return 0;
}

This is all i can see when i execute the code Triangle