Buffers (VBO, VAO, EBO)

GLuint vbo;
glGenBuffers(1, &vbo);
glBindBuffer(GL_ARRAY_BUFFER, vbo);
glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);

// Full upload (allocates storage)
glBufferData(target, sizeBytes, data, usage);
// data can be nullptr to allocate without initializing

// Partial update (does NOT reallocate — must fit in existing allocation)
glBufferSubData(target, offsetBytes, sizeBytes, data);

// Copy between two bound buffers
glBindBuffer(GL_COPY_READ_BUFFER,  src);
glBindBuffer(GL_COPY_WRITE_BUFFER, dst);
glCopyBufferSubData(GL_COPY_READ_BUFFER, GL_COPY_WRITE_BUFFER,
                    readOffset, writeOffset, sizeBytes);

GLuint vbo;
glCreateBuffers(1, &vbo);                         // allocates immediately
glNamedBufferData(vbo, sizeBytes, data, GL_STATIC_DRAW);
glNamedBufferSubData(vbo, offset, size, data);

// Map entire buffer
void* ptr = glMapBuffer(GL_ARRAY_BUFFER, GL_WRITE_ONLY);
memcpy(ptr, data, size);
glUnmapBuffer(GL_ARRAY_BUFFER);  // returns GL_FALSE if mapping corrupted

// Map a range (more efficient — allows unsynchronized access)
void* ptr = glMapBufferRange(GL_ARRAY_BUFFER, offset, length,
    GL_MAP_WRITE_BIT | GL_MAP_INVALIDATE_RANGE_BIT | GL_MAP_UNSYNCHRONIZED_BIT);
glUnmapBuffer(GL_ARRAY_BUFFER);

// DSA version
void* ptr = glMapNamedBufferRange(vbo, offset, length, accessFlags);
glUnmapNamedBuffer(vbo);

GLuint vao;
glGenVertexArrays(1, &vao);
glBindVertexArray(vao);               // start recording

    glBindBuffer(GL_ARRAY_BUFFER, vbo);

    // Attribute 0: 3 floats at offset 0, stride 20 bytes
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 20, (void*)0);
    glEnableVertexAttribArray(0);

    // Attribute 1: 2 floats at offset 12
    glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 20, (void*)12);
    glEnableVertexAttribArray(1);

    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ebo);  // EBO stored in VAO

glBindVertexArray(0);                 // stop recording

glVertexAttribPointer(
    GLuint  index,      // attribute location (layout(location=N))
    GLint   size,       // number of components: 1, 2, 3, or 4
    GLenum  type,       // GL_FLOAT, GL_INT, GL_UNSIGNED_BYTE, ...
    GLboolean normalized, // normalize integer types to [-1,1] or [0,1]
    GLsizei stride,     // bytes between consecutive vertices (0 = tightly packed)
    const void* offset  // byte offset within the buffer
);

// Integer attributes (no normalization, no float conversion)
glVertexAttribIPointer(index, size, type, stride, offset);

// Double-precision attributes (GL 4.1+)
glVertexAttribLPointer(index, size, GL_DOUBLE, stride, offset);

GLuint vao;
glCreateVertexArrays(1, &vao);

// Bind VBO to binding point 0 with stride
glVertexArrayVertexBuffer(vao, /*bindingIndex=*/0, vbo, /*offset=*/0, /*stride=*/20);

// Format of attribute 0 (bound to binding point 0)
glVertexArrayAttribFormat(vao, /*attribIndex=*/0, 3, GL_FLOAT, GL_FALSE, /*relOffset=*/0);
glVertexArrayAttribBinding(vao, 0, 0); // attrib 0 → binding point 0
glEnableVertexArrayAttrib(vao, 0);

// Attribute 1
glVertexArrayAttribFormat(vao, 1, 2, GL_FLOAT, GL_FALSE, 12);
glVertexArrayAttribBinding(vao, 1, 0);
glEnableVertexArrayAttrib(vao, 1);

// Attach EBO
glVertexArrayElementBuffer(vao, ebo);

GLuint ebo;
glGenBuffers(1, &ebo);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ebo);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW);
// (while VAO is bound, this EBO is recorded into the VAO)

// Draw indexed
glDrawElements(GL_TRIANGLES, indexCount, GL_UNSIGNED_INT, (void*)0);

glEnable(GL_PRIMITIVE_RESTART);
glPrimitiveRestartIndex(0xFFFF);  // when this index is encountered, restart strip
// GL 4.3+: glEnable(GL_PRIMITIVE_RESTART_FIXED_INDEX) — always uses max uint

// GLSL
layout(std140, binding = 0) uniform Matrices {
    mat4 view;
    mat4 projection;
};

// CPU: create and fill
GLuint ubo;
glCreateBuffers(1, &ubo);
glNamedBufferData(ubo, sizeof(MatricesBlock), &data, GL_DYNAMIC_DRAW);

// Bind to binding point 0
glBindBufferBase(GL_UNIFORM_BUFFER, 0, ubo);
// or a range:
glBindBufferRange(GL_UNIFORM_BUFFER, 0, ubo, offsetBytes, sizeBytes);

layout(std430, binding = 1) buffer Particles {
    vec4 positions[];
};

GLuint ssbo;
glCreateBuffers(1, &ssbo);
glNamedBufferData(ssbo, size, data, GL_DYNAMIC_COPY);
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 1, ssbo);

// After compute writes — flush before read
glMemoryBarrier(GL_SHADER_STORAGE_BARRIER_BIT);

// Hint driver to discard contents (enables orphaning / avoid stall)
glInvalidateBufferData(vbo);
glInvalidateBufferSubData(vbo, offsetBytes, sizeBytes);

GLbitfield flags = GL_MAP_WRITE_BIT | GL_MAP_PERSISTENT_BIT | GL_MAP_COHERENT_BIT;
glNamedBufferStorage(vbo, size, nullptr, flags); // immutable storage
void* ptr = glMapNamedBufferRange(vbo, 0, size, flags);
// ptr remains valid forever; use fences to avoid races

// Fence sync to prevent writing into in-flight data
GLsync fence = glFenceSync(GL_SYNC_GPU_COMMANDS_COMPLETE, 0);
GLenum result = glClientWaitSync(fence, GL_SYNC_FLUSH_COMMANDS_BIT, timeout_ns);
glDeleteSync(fence);