TRIM6
      glBegin(GL_TRIANGLES);
      glColor4f(1, 0, 0, 0.5);
      glVertex3f(0, 1, 1);
      glVertex3f(1, 1, 1);
      glVertex3f(1, 0, 1);
      glEnd();
  

TRIM6
      glVertexPointer
      glColorPointer
      glNormalPointer
  

TRIM6
      glNewList
      glCallList
  

TRIM6
      GL_QUAD_STRIP, GL_QUADS, GL_POLYGON
  

Don't use any of this stuff -- it's old!

TRIM6
      glVertexAttrib3d
      glVertexAttrib4i
      glVertexAttribI4i
      glVertexAttribL2d
      etc...
  

TRIM6
      glVertexAttribPointer
      glVertexAttribIPointer
      glVertexAttribLPointer
  

TRIM6
      GL_PATCHES
  

Note the optional capital letters (I and L) in the function signatures. The capital letter denotes the width of stored data, while the small letter indicates the type of data you're passing in.

GL_PATCHES is used in lieu of GL_TRIANGLES when tessellation shaders are attached to the current program.

VAO's encapsulate the vertex attribute state that you need to change when rendering new geometry. The default VAO has a handle of 0, which isn't valid in the core profile. You must create a VAO in the core profile!

TRIM6
      const GLuint PositionSlot = 0;
      const GLuint NormalSlot = 1;
      
      GLuint vao;
      glGenVertexArrays(1, &vao);
      glBindVertexArray(vao);
      
      glEnableVertexAttribArray(PositionSlot);
      glEnableVertexAttribArray(NormalSlot);
      
      glBindBuffer(GL_ARRAY_BUFFER, positionsVbo);
      glVertexAttribPointer(PositionSlot, 3, GL_FLOAT, GL_FALSE,
                            sizeof(float)*3, 0);
      glBindBuffer(GL_ARRAY_BUFFER, normalsVbo);
      glVertexAttribPointer(NormalSlot, 3, GL_FLOAT, GL_FALSE,
                            sizeof(float)*3, 0);
  

All Buffer Targets glBufferData glBufferSubData glMapBufferRange​ glCopyBufferSubData	GL_PIXEL_PACK_BUFFER​ glTexImage* glTexSubImage*​ glDrawPixels
GL_PIXEL_UNPACK_BUFFER​ glGetTexImage* glGetTexSubImage* glReadPixels​	GL_ARRAY_BUFFER glVertexAttrib*
GL_ELEMENT_ARRAY_BUFFER glDrawElements (etc)	GL_DRAW_INDIRECT_BUFFER​ glDrawArraysIndirect glDrawElementsIndirect
GL_UNIFORM_BUFFER​ glUniformBlockBinding	GL_TEXTURE_BUFFER​ glTexBuffer

In OpenGL, a buffer object is an unstructured blob of data. The above categories are various targets to which you can bind a buffer. For example, binding a buffer to GL_ARRAY_BUFFER effects subsequent calls to glVertexAttrib*. Even though it contains vertex data, you can also bind that same buffer object to GL_TEXTURE_BUFFER. Remember, buffers are just blobs!

---

Most buffers are bound using glBindBuffer. However, some targets, like GL_UNIFORM_BUFFER, have multiple binding points; these are called indexed buffers. They're bound using glBindBufferBase or glBindBufferRange instead of glBindBuffer.

TRIM6
      glEnable(GL_PRIMITIVE_RESTART);
      glPrimitiveRestartIndex(1200);
  

TRIM6
      // somewhat similar:
      GLint starts[3] = ...;
      GLint counts[3] = ...;
      glMultiDrawArrays(GL_TRIANGLE_STRIP, starts, counts, 3);
  

glDrawArrays(enum mode, int first, sizei count)
glDrawElements(enum mode, sizei count, enum type, const void *indices)

glDrawRangeElements(enum mode, uint start, uint end, sizei count, enum type, const void *indices)
glDrawArraysInstanced(enum mode, int first, sizei count, sizei primcount)
glDrawElementsInstanced(enum mode, sizei count, enum type, const void *indices, sizei primcount)
glDrawElementsBaseVertex(enum mode, sizei count, enum type, const void *indices, int basevertex)
glDrawRangeElementsBaseVertex(enum mode, uint start, uint end, sizei count, enum type, ...

glDrawArraysInstancedBaseInstance(enum mode, int first, sizei count, sizei primcount, uint baseinstance)
glDrawArraysIndirect(enum mode, const void *indirect) // GL_DRAW_INDIRECT_BUFFER

glDrawElementsInstancedBaseVertex(enum mode, sizei count, enum type, const void *indices, ...
glDrawElementsInstancedBaseInstance(enum mode, sizei count, enum type, const void *indices, ...
glDrawElementsInstancedBaseVertexBaseInstance(enum mode, sizei count, enum type, ...
glDrawElementsIndirect(enum mode, enum type, const void *indirect) // GL_DRAW_INDIRECT_BUFFER

glDrawTransformFeedback(enum mode, uint id)
glDrawTransformFeedbackStream(enum mode, uint id, uint stream)
glDrawTransformFeedbackInstanced(enum mode, uint id, sizei primcount)
glDrawTransformFeedbackStreamInstanced(enum mode, uint id, uint stream, sizei primcount)

TRIM6
      GLuint mydrawcall[] = {
          62, /* count */
          12, /* primcount */
          0,  /* first */
          0,  /* baseInstance */
      };
      
      // Get parameters from GPU memory:
      GLuint bufObj;
      glGenBuffers(1, &bufObj);
      glBindBuffer(GL_DRAW_INDIRECT_BUFFER, bufObj);
      glBufferData(GL_DRAW_INDIRECT_BUFFER, sizeof(mydrawcall), mydrawcall, GL_STATIC_DRAW);
      glDrawArraysIndirect(GL_TRIANGLES, 0);
      
      // Generate parameters from OpenCL:
      glGenBuffers(1, &bufObj);
      glBindBuffer(GL_DRAW_INDIRECT_BUFFER, bufObj);
      glBufferData(GL_DRAW_INDIRECT_BUFFER, sizeof(mydrawcall), NULL, GL_STATIC_DRAW);
      clCreateFromGLBuffer(context, CL_MEM_READ_WRITE, bufObj, &err);