How do I draw vertices that are stored in a SSBO?

Question

This is a question following OpenGL and loading/reading data in AoSoA (hybrid SoA) format.

I am trying to use a shader storage buffer object (SSBO) to store vertex data which is represented in AoSoA format. I am having trouble drawing the vertices, which obviously means that I am doing something wrong somewhere. The problem is that I can't seem to figure out what or where. The answer to the initial question above seems to indicate that I should not be using vertex attribute arrays, so the question then becomes, how do I render this SSBO, given the code I am about to present?

VertexData structure

constexpr auto VECTOR_WIDTH = 4;
constexpr auto VERTEX_COUNT = 16;

struct VertexData
{
    std::array<float, VECTOR_WIDTH> px;
    std::array<float, VECTOR_WIDTH> py;
};
// Later stored in a std::vector
std::vector<VertexData> vertices(VERTEX_COUNT / VECTOR_WIDTH);

Vertex shader (should this really be a compute shader?)

struct Vertex4
{
    float px[4]; // position x
    float py[4]; // position y
};

layout(std430, binding=0) buffer VertexData
{
    Vertex4 vertices[];
};

void main()
{
  int dataIx = gl_VertexID / 4;
  int vertexIx = gl_VertexID % 4;
  vec2 vertexPosition = vec2(vertices[dataIx].px[vertexIx], vertices[dataIx].py[vertexIx]);
}

Assign vertexPosition index

// Do I need this? Where do I use it? glEnableVertexAttribArray(position_attrib_index)?
const GLuint position_attrib_index = 0;
glBindAttribLocation(program, position_attrib_index, "vertexPosition");

SSBO setup

const GLuint ssbo_binding_point = 0;
GLuint ssbo{};
glGenBuffers(1, &ssbo);
glBindBuffer(GL_SHADER_STORAGE_BUFFER, ssbo);
//glBufferStorage(GL_SHADER_STORAGE_BUFFER, vertices.size() * sizeof(VertexData), vertices.data(), GL_MAP_WRITE_BIT);
glBufferData(GL_SHADER_STORAGE_BUFFER, vertices.size() * sizeof(VertexData), vertices.data(), GL_STATIC_DRAW);
const auto block_index = glGetProgramResourceIndex(program, GL_SHADER_STORAGE_BLOCK, "VertexData");
glShaderStorageBlockBinding(program, block_index, ssbo_binding_point);
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, ssbo_binding_point, ssbo);
glBindBuffer(GL_SHADER_STORAGE_BUFFER, 0);

Render loop

while (!glfwWindowShouldClose(window)) {
    process_input(window);
    glClear(GL_COLOR_BUFFER_BIT);

    glUseProgram(program);

    // ???

    glfwSwapBuffers(window);
    glfwPollEvents();
}

---

I just can't seem to figure out how this is supposed to work. Grabbing at straws, I also tried creating a VAO with a later call to glDrawArrays(GL_POINTS, 0, VERTEX_COUNT), but it didn't work either:

GLuint vao{};
glGenVertexArrays(1, &vao);
glBindVertexArray(vao);
glEnableVertexAttribArray(position_attrib_index);
glVertexAttribPointer(position_attrib_index, 2, GL_FLOAT, GL_FALSE, 0, nullptr);

It seems to me that I should be using position_attrib_index (which should point to vertexPosition) for something, the question is for what?

Complete example code

• requires OpenGL 4.3, GLEW and GLFW
• build command example: g++ -std=c++17 main.cpp -lGLEW -lglfw -lGL -o ssbo

#include <GL/glew.h>
#include <GLFW/glfw3.h>
#include <array>
#include <iostream>
#include <vector>

void process_input(GLFWwindow *window)
{
    if (glfwGetKey(window, GLFW_KEY_ESCAPE) == GLFW_PRESS) {
        glfwSetWindowShouldClose(window, true);
    }
}

void glfw_error_callback(int error_code, const char *description)
{
    std::cerr << "GLFW Error: [" << error_code << "] " << description << '\n';
}

void framebuffer_size_callback(GLFWwindow *window, int width, int height)
{
    glViewport(0, 0, width, height);
}

auto create_glfw_window()
{
    glfwInit();
    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 4);
    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
    return glfwCreateWindow(800, 600, "OpenGL and AoSoA layout", nullptr, nullptr);
}

void set_callbacks(GLFWwindow *window)
{
    glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);
    glfwSetErrorCallback(glfw_error_callback);
}

void print_versions()
{
    std::cout << "Using GLFW " << glfwGetVersionString() << '\n';
    std::cout << "Using GLEW " << glewGetString(GLEW_VERSION) << '\n';
}

bool init_loader()
{
    GLenum err = glewInit();
    if (GLEW_OK != err) {
        std::cerr << "GLEW error: " << glewGetErrorString(err);
    }
    return err == GLEW_OK;
}

void GLAPIENTRY MessageCallback(
    GLenum source,
    GLenum type,
    GLuint id,
    GLenum severity,
    GLsizei length,
    const GLchar* message,
    const void* userParam = nullptr)
{
    std::cerr << "[GL DEBUG] " << (type == GL_DEBUG_TYPE_ERROR ? "Error: " : "") << message << '\n';
}

constexpr auto VECTOR_WIDTH = 4;
constexpr auto VERTEX_COUNT = 16;

struct VertexData
{
    std::array<float, VECTOR_WIDTH> px;
    std::array<float, VECTOR_WIDTH> py;
};

static const char* vertex_shader_source =
    "#version 430\n"
    "struct Vertex4\n"
    "{\n"
    "    float px[4]; // position x\n"
    "    float py[4]; // position y\n"
    "};\n"
    "layout(std430, binding=0) buffer VertexData\n"
    "{\n"
    "    Vertex4 vertices[];\n"
    "};\n"
    "void main()\n"
    "{\n"
    "  int dataIx = gl_VertexID / 4;\n"
    "  int vertexIx = gl_VertexID % 4;\n"
    "  vec2 vertexPosition = vec2(vertices[dataIx].px[vertexIx], vertices[dataIx].py[vertexIx]);\n"
    "}\n";

static const char* fragment_shader_source =
    "#version 430\n"
    "out vec4 out_color;\n"
    "void main()\n"
    "{\n"
    "    out_color = vec4(1.0, 0.5, 0.5, 0.25);\n"
    "}\n";

int main(int argc, char *argv[])
{
    glewExperimental = GL_TRUE;

    auto window = create_glfw_window();

    if (window == nullptr) {
        std::cout << "Failed to create GLFW window" << std::endl;
        glfwTerminate();
        return -1;
    }

    glfwMakeContextCurrent(window);

    set_callbacks(window);
    init_loader();
    print_versions();

    glEnable(GL_DEBUG_OUTPUT);
    glDebugMessageCallback(MessageCallback, nullptr);

    std::vector<VertexData> vertices(VERTEX_COUNT / VECTOR_WIDTH);

    vertices[0] = {
        {-0.75f, 0.75f, 0.75f, -0.75f},
        {-0.75f, -0.75f, 0.75f, 0.75f}
    };
    vertices[1] = {
        {-0.50f, 0.50f, 0.50f, -0.50f},
        {-0.50f, -0.50f, 0.50f, 0.50f},
    };
    vertices[2] = {
        {-0.25f, 0.25f, 0.25f, -0.25f},
        {-0.25f, -0.25f, 0.25f, 0.25f},
    };
    vertices[3] = {
        {-0.05f, 0.05f, 0.05f, -0.05f},
        {-0.05f, -0.05f, 0.05f, 0.05f},
    };

    auto vertex_shader = glCreateShader(GL_VERTEX_SHADER);
    glShaderSource(vertex_shader, 1, &vertex_shader_source, nullptr);
    glCompileShader(vertex_shader);

    auto fragment_shader = glCreateShader(GL_FRAGMENT_SHADER);
    glShaderSource(fragment_shader, 1, &fragment_shader_source, nullptr);
    glCompileShader(fragment_shader);

    auto program = glCreateProgram();
    glAttachShader(program, vertex_shader);
    glAttachShader(program, fragment_shader);

    const GLuint position_attrib_index = 0;
    glBindAttribLocation(program, position_attrib_index, "vertexPosition");

    glLinkProgram(program);

    //glUseProgram(program);

    glDeleteShader(vertex_shader);
    glDeleteShader(fragment_shader);

    //
    // SSBO
    //
    const GLuint ssbo_binding_point = 0;
    GLuint ssbo{};
    glGenBuffers(1, &ssbo);
    glBindBuffer(GL_SHADER_STORAGE_BUFFER, ssbo);
    //glBufferStorage(GL_SHADER_STORAGE_BUFFER, vertices.size() * sizeof(VertexData), vertices.data(), GL_MAP_WRITE_BIT);
    glBufferData(GL_SHADER_STORAGE_BUFFER, vertices.size() * sizeof(VertexData), vertices.data(), GL_STATIC_DRAW);
    const auto block_index = glGetProgramResourceIndex(program, GL_SHADER_STORAGE_BLOCK, "VertexData");
    glShaderStorageBlockBinding(program, block_index, ssbo_binding_point);
    glBindBufferBase(GL_SHADER_STORAGE_BUFFER, ssbo_binding_point, ssbo);
    glBindBuffer(GL_SHADER_STORAGE_BUFFER, 0);

    //
    // VAO
    //
    //GLuint vao{};
    //glGenVertexArrays(1, &vao);
    //glBindVertexArray(vao);
    //glEnableVertexAttribArray(position_attrib_index);
    //glVertexAttribPointer(position_attrib_index, 2, GL_FLOAT, GL_FALSE, 0, nullptr);

    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
    glEnable(GL_BLEND);
    glClearColor(0.15f, 0.15f, 0.2f, 1.0f);
    glPointSize(10.0f);

    while (!glfwWindowShouldClose(window)) {
        process_input(window);
        glClear(GL_COLOR_BUFFER_BIT);

        glUseProgram(program);
        //glDrawArrays(GL_POINTS, 0, VERTEX_COUNT);

        glfwSwapBuffers(window);
        glfwPollEvents();
    }

    glfwDestroyWindow(window);
    glfwTerminate();

    return 0;
}

Answer 1

This is the correct way to issue a draw with the data you have:

glBindVertexArray(vao);
glDrawArrays(GL_POINTS, 0, VERTEX_COUNT);

However, your issue is that your vertex shader does not write to gl_Position, therefore nothing gets rasterized (whatever undefined behavior happens). You should set the position of the vertices in the shader as follows:

//...
out gl_PerVertex {
    vec4 gl_Position;
};
void main()
{
    int dataIx = gl_VertexID / 4;
    int vertexIx = gl_VertexID % 4;
    vec2 vertexPosition = vec2(vertices[dataIx].px[vertexIx], vertices[dataIx].py[vertexIx]);
    gl_Position = vec4(vertexPosition, 0, 1);
}

You can get rid of "Assign vertexPosition index", and your VAO doesn't need to have any attributes.