View source for Default Framebuffer

The '''Default Framebuffer''' is the framebuffer that OpenGL is created with. It is created along with the OpenGL Context. Like [[Framebuffer Object]]s, the default framebuffer is a series of images. Unlike FBOs, one of these images usually represents what you actually see on some part of your screen.

== Creation ==

The default framebuffer is created at the time the [[OpenGL context]] is constructed. The desired properties of the default framebuffer are given to the context creation functions, which will take these into consideration when creating the context. The construction of a context is platform-specific, so exactly how you specify your desired properties is platform-specific.

The default framebuffer contains a number of images, based on how it was created. All default framebuffer images are automatically resized to the size of the output window, as it is resized.

== Color buffers ==

The default framebuffer contains up to 4 color buffers, named {{enum|GL_FRONT_LEFT}}, {{enum|GL_BACK_LEFT}}, {{enum|GL_FRONT_RIGHT}}, and {{enum|GL_BACK_RIGHT}}. The left and right buffers are used for [http://en.wikipedia.org/wiki/Stereoscopy stereoscopic rendering]. Most consumer graphics cards cannot use these for doing stereoscopic 3D visualization.

If stereo rendering is not being done, then only the left buffers will be active. Attempts to read from or draw to the right buffers would fail.

=== Multiple buffer aliases ===

The default framebuffer's set of 4 color images have certain aliases that represent multiple buffers. These names are {{enum|GL_LEFT}}, {{enum|GL_RIGHT}}, {{enum|GL_FRONT}}, {{enum|GL_BACK}}, and {{enum|GL_FRONT_AND_BACK}}; they represent the left, right, front, back, or all four buffers. These are only allowed in {{apifunc|glDrawBuffer}} (not {{apifunc|glDrawBuffers}}; note the "s") and {{apifunc|glReadBuffer}}.

When used for rendering outputs, multiple buffer aliases mean that all of the specified buffers get the same colors. When used for reading operations, the multiple buffer aliases specify a single buffer. The rule is that it specifies the frontmost, leftmost buffer of the ones that it covers. In tabular form:

{| class="wikitable"
! Alias
! Real Image
|-
|{{enum|GL_LEFT}}
|{{enum|GL_FRONT_LEFT}}
|-
|{{enum|GL_RIGHT}}
|{{enum|GL_FRONT_RIGHT}}
|-
|{{enum|GL_FRONT}}
|{{enum|GL_FRONT_LEFT}}
|-
|{{enum|GL_BACK}}
|{{enum|GL_BACK_LEFT}}
|-
|{{enum|GL_FRONT_AND_BACK}}
|{{enum|GL_FRONT_LEFT}}
|}
=== Double buffering ===

The front and back buffers represent a double-buffered framebuffer. The front buffer is, more or less, what you see on the screen. The back buffer is the image that is typically rendered to. When the user wants the rendered image to become visible, they call a platform-specific buffer swapping command. This effectively transfers the back buffer data into the front buffer.

Rendering into, or reading from, the front buffer is not advisable.

The buffer swap does not have to be a true swap. In a true swap, the back buffer becomes the front buffer and vice-versa. If you were to read from the back buffer after a true swap, it would hold the ''previous'' contents of the front buffer.

That being said, OpenGL does not ''require'' true swapping. All that is required is that the contents of the back buffer find their way into the front buffer. This could be via a true swap, or it could be via a copy from the back buffer into the front.

Stereo rendering has two back buffers and two front buffers. Swapping performs the switch on both.

== Depth buffer ==

The default framebuffer can have a [[Depth Buffer]], which can be used for depth testing. The precision of the depth buffer is generally one of the parameters passed to the context creation functions. The name of the default framebuffer's depth buffer (for query purposes) is {{enum|GL_DEPTH}}.

Stereo rendering still uses ''one'' depth buffer. It must be shared among the left and right buffers, so a clear may need to be issued between rendering to the left and right buffers.

== Stencil buffer ==

The default framebuffer can have a [[Stencil Test|stencil buffer for doing stencil tests.]] The number of stencil bits is generally one of the parameters passed to context creation functions. The name of the default framebuffer's stencil buffer (for query purposes) is {{enum|GL_STENCIL}}.

Stereo rendering still uses ''one'' stencil buffer. It must be shared among the left and right buffers, so a clear may need to be issued between rendering to the left and right buffers.

== Pixel ownership test ==

If part or all of the OpenGL window is not visible on the screen, the non-visible pixels in the default framebuffer are said to no longer be owned by OpenGL. They fail the pixel ownership test.

Pixels that fail this test have undefined values. Any operations that attempt to change these pixel values may or may not succeed. Reading from unowned pixels may return anything.

Note that the pixel ownership test only matters for the default framebuffer. All [[Framebuffer Object]] pixels pass the pixel ownership test.

== Multisample framebuffer ==

The default framebuffer can be [[Multisample|multisampled]] as well. Again, the number of samples is usually specified as a context creation parameter.

== Removed buffer images ==
{{deprecated|section=}}

In compatibility contexts or OpenGL 3.0 and below, the default framebuffer can contain a plethora of other image buffers. It can contain a number of auxiliary color images; these are simply off-screen color buffers of the same size as the window. They can be rendered to and blitted from just like any other image. These are named {{enum|GL_AUX''i''}}, where ''i'' is a number from 0 to the number of auxiliary buffers.

The default framebuffer can also contain an accumulation buffer, which can be used to perform certain computations when rendering.

[[Category:Framebuffer]]