Drawing

glBindVertexArray(vao);
glUseProgram(prog);

// Non-indexed
glDrawArrays(GL_TRIANGLES, 0, 6);  // first=0, count=6 vertices

// Indexed
glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, (void*)0);
// last arg = byte offset into the EBO (not a pointer when EBO is bound)

// Set patch size for tessellation
glPatchParameteri(GL_PATCH_VERTICES, 3);  // triangles (default)

glDrawArrays(mode, first, count);

// Instanced — gl_InstanceID in shader
glDrawArraysInstanced(mode, first, count, instanceCount);

// Instanced with base instance (gl_BaseInstance)
glDrawArraysInstancedBaseInstance(mode, first, count, instanceCount, baseInstance);

// Multi-draw — separate range per sub-call
const GLint   firsts[]  = { 0, 6 };
const GLsizei counts[]  = { 6, 3 };
glMultiDrawArrays(mode, firsts, counts, 2);

// Indirect (command from GPU buffer)
glBindBuffer(GL_DRAW_INDIRECT_BUFFER, indirectBuf);
glDrawArraysIndirect(mode, (void*)offset);

// Multi indirect (GL 4.3+)
glMultiDrawArraysIndirect(mode, (void*)offset, drawCount, stride);

glDrawElements(mode, count, indexType, offsetPtr);

glDrawElementsBaseVertex(mode, count, indexType, offsetPtr, baseVertex);
// baseVertex added to each index before fetching (allows shared VBO regions)

glDrawElementsInstanced(mode, count, indexType, offsetPtr, instanceCount);

glDrawElementsInstancedBaseVertex(mode, count, indexType, offsetPtr,
                                   instanceCount, baseVertex);

glDrawElementsInstancedBaseVertexBaseInstance(mode, count, indexType, offsetPtr,
                                              instanceCount, baseVertex, baseInstance);

glDrawRangeElements(mode, start, end, count, indexType, offsetPtr);
// Hint: indices are in [start, end] — may improve performance

glMultiDrawElements(mode, counts, indexType, offsets, drawCount);

glMultiDrawElementsBaseVertex(mode, counts, indexType, offsets, drawCount, baseVertices);

glDrawElementsIndirect(mode, indexType, (void*)offset);

glMultiDrawElementsIndirect(mode, indexType, (void*)offset, drawCount, stride);

// For glDrawArraysIndirect
struct DrawArraysIndirectCommand {
    GLuint count;
    GLuint instanceCount;
    GLuint first;
    GLuint baseInstance;
};

// For glDrawElementsIndirect
struct DrawElementsIndirectCommand {
    GLuint count;
    GLuint instanceCount;
    GLuint firstIndex;   // index into EBO (in element units, not bytes)
    GLint  baseVertex;
    GLuint baseInstance;
};

// Per-instance vertex attribute (divisor = 1 means advance once per instance)
glVertexAttribDivisor(attribIndex, 1);  // 0 = per-vertex (default), N = per N instances

// DSA equivalent
glVertexArrayBindingDivisor(vao, bindingIndex, 1);

// Vertex shader
layout(location = 2) in vec3 aOffset;  // divisor=1 attribute

void main() {
    gl_Position = uVP * vec4(aPos + aOffset, 1.0);
}

// Setup
GLuint tfo;
glGenTransformFeedbacks(1, &tfo);
glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, tfo);

const char* varyings[] = { "outPos", "outVel" };
glTransformFeedbackVaryings(prog, 2, varyings, GL_INTERLEAVED_ATTRIBS);
// GL_SEPARATE_ATTRIBS: one binding point per varying
glLinkProgram(prog);  // must relink after setting varyings

glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, captureBuffer);

// Draw
glEnable(GL_RASTERIZER_DISCARD);  // optional: skip fragment stage
glBeginTransformFeedback(GL_TRIANGLES);
    glDrawArrays(GL_TRIANGLES, 0, vertCount);
glEndTransformFeedback();
glDisable(GL_RASTERIZER_DISCARD);

GLuint query;
glGenQueries(1, &query);
glBeginQuery(GL_SAMPLES_PASSED, query);
    // bounding box draw
glEndQuery(GL_SAMPLES_PASSED);

glBeginConditionalRender(query, GL_QUERY_WAIT);
    // expensive draw — skipped if query result == 0
glEndConditionalRender();

GLuint query;
glGenQueries(1, &query);

glBeginQuery(GL_SAMPLES_PASSED, query);  // or GL_ANY_SAMPLES_PASSED
    // draw occluder
glEndQuery(GL_SAMPLES_PASSED);

// Non-blocking check
GLint available = 0;
glGetQueryObjectiv(query, GL_QUERY_RESULT_AVAILABLE, &available);
if (available) {
    GLuint result;
    glGetQueryObjectuiv(query, GL_QUERY_RESULT, &result);
}

GLuint queries[2];
glGenQueries(2, queries);

glQueryCounter(queries[0], GL_TIMESTAMP);
    // draw calls
glQueryCounter(queries[1], GL_TIMESTAMP);

GLuint64 t0, t1;
glGetQueryObjectui64v(queries[0], GL_QUERY_RESULT, &t0);
glGetQueryObjectui64v(queries[1], GL_QUERY_RESULT, &t1);
double ms = (t1 - t0) / 1e6;

glEnable(GL_SCISSOR_TEST);
glScissor(x, y, width, height);  // pixels, lower-left origin
// Only fragments within this rect are written
glDisable(GL_SCISSOR_TEST);

// Set multiple viewports at once
float vps[8] = { 0,0,400,600,  400,0,400,600 };
glViewportArrayv(0, 2, vps);

float depths[4] = { 0,1,  0,1 };
glDepthRangeArrayv(0, 2, depths);

// Geometry shader selects viewport/layer
// gl_ViewportIndex = 0 or 1;
// gl_Layer = cubemap face index;

// Insert a fence
GLsync fence = glFenceSync(GL_SYNC_GPU_COMMANDS_COMPLETE, 0);

// CPU waits for GPU
GLenum result = glClientWaitSync(fence, GL_SYNC_FLUSH_COMMANDS_BIT, 5000000000ULL);
// result: GL_ALREADY_SIGNALED, GL_CONDITION_SATISFIED, GL_TIMEOUT_EXPIRED, GL_WAIT_FAILED

// GPU waits for fence (no CPU stall)
glWaitSync(fence, 0, GL_TIMEOUT_IGNORED);

glDeleteSync(fence);

// Memory barrier — order shader writes before subsequent reads
glMemoryBarrier(GL_SHADER_STORAGE_BARRIER_BIT
              | GL_TEXTURE_FETCH_BARRIER_BIT);