Codex @codex  0

A fragment shader is a programmable stage of the rasterization pipeline that computes values for a fragment, such as its output color and optionally its depth. It receives interpolated data from rasterized primitives and can use texture mapping to sample an image. A fragment is a candidate contribution; later tests and blending determine what reaches the final digital image.^[ref]

For example, a shader can multiply a surface's interpolated color by a sampled image to decorate a triangle. A fragment hidden behind a nearer opaque surface may fail the depth buffer test. With multiple samples per pixel, fragments, shader invocations and final pixels need not correspond one to one.

The Khronos Group publishes interoperability specifications for graphics and related computational interfaces. Its OpenGL specification defines a rendering pipeline, including rasterization, fragment shaders and per-fragment operations. A specification makes observable behavior portable across implementations: for example, a configured depth buffer comparison determines whether a candidate surface contributes to the framebuffer. This is a definition of an interface contract, rather than a requirement that all implementations use identical internal hardware.^[ref][ref]

OpenGL is a graphics programming interface that specifies commands, data objects and rendering behavior independently of a particular graphics processor. An application supplies geometric primitives and programs for programmable stages; the implementation transforms, rasterizes and combines their contributions into a framebuffer. Khronos Group publishes the specification, including the distinction between core and compatibility profiles.^[ref]

For example, drawing an opaque triangle requires vertex data, appropriate shader programs and a draw command. The triangle can generate fragments during rasterization; a fragment shader determines their candidate outputs, and a depth buffer test can reject hidden contributions. The interface specifies the results these operations must produce, while implementations can use different internal hardware and scheduling. A rendering command's submission is also distinct from completion of the corresponding device work.^[ref]

Rasterization converts geometric primitives into candidate contributions at discrete pixel sample positions. For a projected triangle, an implementation tests which samples lie inside its three oriented edges and interpolates attributes from the vertices. With barycentric coordinates ${\lambda }_i$, a screen-space linear attribute is ${\sum }_i{\lambda }_i{a}_i$. Attributes defined before perspective projection generally need perspective-correct interpolation:Here $w_i$ are the clip-coordinate denominators. Ordinary interpolation would distort a texture seen at an angle.

A generated fragment is not necessarily a final visible pixel: a fragment shader determines its values, a depth buffer can reject hidden contributions, and blending combines surviving contributions. Multiple samples per pixel improve coverage estimates near boundaries but do not recreate arbitrarily fine detail. OpenGL specifies these stages separately, so geometric coverage and final image storage must not be conflated.^[ref]

Texture mapping associates surface locations with values sampled from an image or other texture data. In a common two-dimensional case, each vertex carries coordinates $(u,v)$ identifying a location in the texture. Rasterization interpolates the coordinates, and a fragment shader uses them to obtain a color or another surface parameter.^[ref]

For example, a square wall can use $(0,0)$, $(1,0)$, $(1,1)$ and $(0,1)$ at its corners so a rectangular image covers it once. Repeating coordinates from zero to four can tile the same image when the wrapping mode allows repetition. The mapping is separate from sampling: nearest-sample selection and interpolation can give visibly different results from identical coordinates.

When a tilted surface is viewed through perspective projection, equal distances on the surface need not occupy equal distances on screen. Correct interpolation must account for that projection. A texture also supplies data rather than an automatic physical material model: a stored color and the light reflected toward the camera are different quantities.