Question

Every time I search on Google about OpenGL programming I found articles but it seems that all are mentioning shaders and buffers. What are those?
Can you explain some of them:

• Depth buffer
• Stencil buffer
• Pixel shader
• Frame buffer
• …?

I heard for few of them but couldn’t find whole list. What are shaders in OpenGL, and what are buffers? Can somebody provide examples when we are using them?

Answer 1

A color buffer is some piece of internal memory with a specified memory layout, but otherwise more or less opaque to you that represents an image. It holds information about the color of each pixel in the image. You draw/render into color buffers. There can be more than a single color buffer with recent versions of OpenGL on recent hardware, which you can use to make some special rendering techniques more efficient.

Depth and stencil buffers are the same as color buffers, except they hold (as the name implies) depth and stencil information rather than color. Depth and stencil are often combined into one buffer (but need not be), and you can never have more than one depth/stencil buffer at a time.
The depth buffer is normally used to resolve overdrawing ambiguity when rendering several objects in no particular order. Only the one fragment closest to “your eye” survives. The stencil buffer can be used for special effects, e.g. to mask out regions of a buffer.

A framebuffer is something you attach color buffers to and draw/render into and which is optionally visible on the screen. There is always at least one framebuffer, this is what you see on your screen, but there may be any number of them. This is managed by the framebuffer extension which is core functionality since version 3.0. A framebuffer usually has separate “front” and “back” buffers too. One will be shown to you while you render to the other. At appropriate times, the buffers are flipped, so you do not see flickering.

A shader, most generally, is a “program” that OpenGL executes on your behalf inside its pipeline at well-defined times on well-defined data to generate some desired effect. It most often runs on the graphics card, but it may also be executed partially or wholly on the CPU.
Pixel shaders, the first shaders historically available (and namegivers) are run once for every fragment. They take some defined inputs (e.g. light position, normals) and produce a single output that later goes through the depth test, and is finally is written to or blended with the color buffer.
Vertex, geometry, or tesselation shaders do not really “shade” anything (they transform and/or generate vertices and primitives, which are later turned into fragments), but they inherit the name.