-glspec44.compatibility
...
2.6.2 Buffer Objects
The GL uses many types of data supplied by the client. Some of this data must be
stored in server memory, and it is desirable to store other types of frequently used
client data, such as vertex array and pixel data, in server memory for performance
reasons, even if the option to store it in client memory exists.
Buffer objects contain a data store holding a fixed-sized allocation of server
memory, and provide a mechanism to allocate, initialize, read from, and write to
such memory. Under certain circumstances, the data store of a buffer object may
be shared between the client and server and accessed simultaneously by both.
Buffer objects may be shared. They are described in detail in chapter 6.
2.6.3 Shader Objects
The source and/or binary code representing part or all of a shader program that is
executed by one of the programmable stages defined by the GL (such as a vertex
or fragment shader) is encapsulated in one or more shader objects.
Shader objects may be shared. They are described in detail in chapter 7.
2.6.4 Program Objects
Shader objects that are to be used by one or more of the programmable stages of
the GL are linked together to form a program object. The shader programs that
are executed by these programmable stages are called executables. All information
necessary for defining each executable is encapsulated in a program object.
Program objects may be shared. They are described in detail in chapter 7.
2.6.5 Program Pipeline Objects
Program pipeline objects contain a separate program object binding point for each
programmable stage. They allow a primitive to be processed by independent programs
in each programmable stage, instead of requiring a single program object
for each combination of shader operations. They allow greater flexibility when
combining different shaders in various ways, without requiring a program object
for each such combination.
Program pipeline objects are container objects including references to program2.6.6 Texture Objects
objects, and are not shared. They are described in detail in chapter 7.
Texture objects or textures include a collection of texture images built from arrays
of image elements referred to as texels. There are many types of texture objects
varying by dimensionality and structure; the different texture types are described
in detail in the introduction to chapter 8.
Texture objects also include state describing the image parameters of the texture
images, and state describing how sampling is performed when a shader accesses
a texture.
Shaders may sample a texture at a location indicated by specified texture coordinates,
with details of sampling determined by the sampler state of the texture.
The resulting texture samples are typically used to modify a fragment’s color, in
order to map an image onto a geometric primitive being drawn, but may be used
for any purpose in a shader.
Texture objects may be shared. They are described in detail in chapter 8.
2.6.7 Sampler Objects
Sampler objects contain the subset of texture object state controlling how sampling
is performed when a shader accesses a texture. Sampler and texture objects may be
bound together so that the sampler object state is used by shaders when sampling
the texture, overriding equivalent state in the texture object. Separating texture
image data from the method of sampling that data allows reuse of the same sampler
state with many different textures without needing to set the sampler state in each
texture.
Sampler objects may be shared. They are described in detail in chapter 8.
2.6.8 Renderbuffer Objects
Renderbuffer objects contain a single image in a format which can be rendered
to. Renderbuffer objects are attached to framebuffer objects (see below) when
performing off-screen rendering.
Renderbuffer objects may be shared. They are described in detail in chapter 9.
2.6.9 Framebuffer Objects
Framebuffer objects encapsulate the state of a framebuffer, including a collection of
color, depth, and stencil buffers. Each such buffer is represented by a renderbuffer
object or texture object attached to the framebuffer object.
Framebuffer objects are container objects including references to renderbuffer
and/or texture objects, and are not shared5. They are described in detail in chapter
9.
2.6.10 Vertex Array Objects
Vertex array objects represent a collection of sets of vertex attributes. Each set
is stored as an array in a buffer object data store, with each element of the array
having a specified format and component count. The attributes of the currently
bound vertex array object are used as inputs to the vertex shader when executing
drawing commands.
Vertex array objects are container objects including references to buffer objects,
and are not shared. They are described in detail in chapter 10.
2.6.11 Transform Feedback Objects
Transform feedback objects are used to capture attributes of the vertices of transformed primitives passed to the transform feedback stage when transform feedback mode is active. They include state required for transform feedback together with references to buffer objects in which attributes are captured.
Transform feedback objects are container objects including references to buffer
objects, and are not shared. They are described in detail in section 13.2.1.
2.6.12 Query Objects
Query objects return information about the processing of a sequence of GL commands,
such as the number of primitives processed by drawing commands; the
number of primitives written to transform feedback buffers; the number of samples
that pass the depth test during fragment processing; and the amount of time
required to process commands.
Query objects are not shared. They are described in detail in section 4.2.
No comments:
Post a Comment