blob: 673fe7e0d97a1c481910b17ce18653031679dd38 [file] [log] [blame]
Name
NV_framebuffer_mixed_samples
Name Strings
GL_NV_framebuffer_mixed_samples
GL_EXT_raster_multisample
Contact
Jeff Bolz, NVIDIA Corporation (jbolz 'at' nvidia.com)
Contributors
Pat Brown, NVIDIA
Mathias Heyer, NVIDIA
Mark Kilgard, NVIDIA
Chris Dalton, NVIDIA
Rui Bastros, NVIDIA
Status
Shipping
Version
Last Modified Date: February 15, 2017
Revision: 3
Number
OpenGL Extension #469
OpenGL ES Extension #231
Dependencies
This extension is written against the OpenGL 4.3
(Compatibility Profile) and OpenGL ES 3.0.3 (December 18, 2013)
specification.
This extension is written as a superset of EXT_raster_multisample, since
so many of the edits overlap each other and it is not expected for an
implementation to support NV_framebuffer_mixed_samples but not
EXT_raster_multisample.
This extension interacts with NV_fragment_coverage_to_color.
This extension interacts with EXT_depth_bounds_test.
This extension interacts with OES_sample_shading
This extension interacts with OES_sample_variables
This extension interacts with NV_framebuffer_multisample
This extension interacts with the OpenGL ES 3.1 specification.
This extension interacts with ARB_blend_func_extended
Overview
This extension allows multisample rendering with a raster and
depth/stencil sample count that is larger than the color sample count.
Rasterization and the results of the depth and stencil tests together
determine the portion of a pixel that is "covered". It can be useful to
evaluate coverage at a higher frequency than color samples are stored.
This coverage is then "reduced" to a collection of covered color samples,
each having an opacity value corresponding to the fraction of the color
sample covered. The opacity can optionally be blended into individual
color samples.
In the current hardware incarnation both depth and stencil testing are
supported with mixed samples, although the API accommodates supporting
only one or the other.
Rendering with fewer color samples than depth/stencil samples can greatly
reduce the amount of memory and bandwidth consumed by the color buffer.
However, converting the coverage values into opacity can introduce
artifacts where triangles share edges and may not be suitable for normal
triangle mesh rendering.
One expected use case for this functionality is Stencil-then-Cover path
rendering (NV_path_rendering). The stencil step determines the coverage
(in the stencil buffer) for an entire path at the higher sample frequency,
and then the cover step can draw the path into the lower frequency color
buffer using the coverage information to antialias path edges. With this
two-step process, internal edges are fully covered when antialiasing is
applied and there is no corruption on these edges.
The key features of this extension are:
- It allows a framebuffer object to be considered complete when its depth
or stencil samples are a multiple of the number of color samples.
- It redefines SAMPLES to be the number of depth/stencil samples (if any);
otherwise, it uses the number of color samples. SAMPLE_BUFFERS is one if
there are multisample depth/stencil attachments. Multisample
rasterization and multisample fragment ops are allowed if SAMPLE_BUFFERS
is one.
- It replaces several error checks involving SAMPLE_BUFFERS by error
checks directly referencing the number of samples in the relevant
attachments.
- A coverage reduction step is added to Per-Fragment Operations which
converts a set of covered raster/depth/stencil samples to a set of
covered color samples. The coverage reduction step also includes an
optional coverage modulation step, multiplying color values by a
fractional opacity corresponding to the number of associated
raster/depth/stencil samples covered.
New Procedures and Functions
void RasterSamplesEXT(uint samples, boolean fixedsamplelocations);
void CoverageModulationTableNV(sizei n, const float *v);
void GetCoverageModulationTableNV(sizei bufsize, float *v);
void CoverageModulationNV(enum components);
New Tokens
Accepted by the <cap> parameter of Enable, Disable, IsEnabled:
RASTER_MULTISAMPLE_EXT 0x9327
COVERAGE_MODULATION_TABLE_NV 0x9331
Accepted by the <pname> parameter of GetBooleanv, GetDoublev,
GetIntegerv, and GetFloatv:
RASTER_SAMPLES_EXT 0x9328
MAX_RASTER_SAMPLES_EXT 0x9329
RASTER_FIXED_SAMPLE_LOCATIONS_EXT 0x932A
MULTISAMPLE_RASTERIZATION_ALLOWED_EXT 0x932B
EFFECTIVE_RASTER_SAMPLES_EXT 0x932C
// COLOR_SAMPLES_NV is shared with NV_multisample_coverage
COLOR_SAMPLES_NV 0x8E20
DEPTH_SAMPLES_NV 0x932D
STENCIL_SAMPLES_NV 0x932E
MIXED_DEPTH_SAMPLES_SUPPORTED_NV 0x932F
MIXED_STENCIL_SAMPLES_SUPPORTED_NV 0x9330
COVERAGE_MODULATION_NV 0x9332
COVERAGE_MODULATION_TABLE_SIZE_NV 0x9333
Additions to Chapter 8 of the OpenGL 4.3 (Compatibility Profile) Specification
(Textures and Samplers)
Modify the error list for CopyTex(Sub)Image in Section 8.6 (Alternate
Texture Image Specification Commands), p. 228. [This language redefines
one error condition in terms of the sample count of the targeted color
buffer instead of SAMPLE_BUFFERS.]
An INVALID_OPERATION error is generated by CopyTexSubImage3D,
CopyTexImage2D, CopyTexSubImage2D, CopyTexImage1D, or CopyTexSubImage1D
if
* the value of READ_BUFFER is NONE.
* the value of READ_FRAMEBUFFER_BINDING is non-zero, and
- the read buffer selects an attachment that has no image attached,
or
- the number of samples in the read buffer is greater than one.
Additions to Chapter 9 of the OpenGL 4.3 (Compatibility Profile) Specification
(Framebuffers and Framebuffer Objects)
Edit Section 9.4.2 (Whole Framebuffer Completeness), p. 314
- The number of samples in an attached image is determined by the value of
RENDERBUFFER_SAMPLES for renderbuffer images, and by the value of
TEXTURE_SAMPLES for texture images. All attached color images must have
the same number of samples. If the depth and stencil attachments are both
populated, those two images must have the same number of samples. If any
color attachments are populated and either the depth or stencil
attachments are populated, the following rules apply. If there is an
image attached to the depth (stencil) attachment, it must have the same
number of samples as the color attachments if the value of
MIXED_DEPTH_SAMPLES_SUPPORTED_NV (MIXED_STENCIL_SAMPLES_SUPPORTED_NV) is
FALSE. If the value of MIXED_DEPTH_SAMPLES_SUPPORTED_NV
(MIXED_STENCIL_SAMPLES_SUPPORTED_NV) is TRUE, then the number of samples
in the depth (stencil) image must be an integer multiple of the number
of samples in the color attachments.
{ FRAMEBUFFER_INCOMPLETE_MULTISAMPLE }
...
The values of SAMPLE_BUFFERS, SAMPLES, COLOR_SAMPLES_NV, DEPTH_SAMPLES_NV,
and STENCIL_SAMPLES_NV are derived from the attachments of the currently
bound draw framebuffer object. If the current DRAW_FRAMEBUFFER_BINDING is
not framebuffer complete, then all these values are undefined. Otherwise,
COLOR_SAMPLES_NV is equal to the value of RENDERBUFFER_SAMPLES or
TEXTURE_SAMPLES (depending on the type of the attached images) of the
attached color images, which must all have the same value. DEPTH_SAMPLES_NV
and STENCIL_SAMPLES_NV are equal to the number of samples in the
corresponding attached images. If there are no corresponding attachments,
these values are equal to zero. SAMPLES is equal to the first non-zero
value from the list of STENCIL_SAMPLES_NV, DEPTH_SAMPLES_NV, and
COLOR_SAMPLES_NV. SAMPLE_BUFFERS is one if any attachment has more than one
sample. Otherwise, SAMPLE_BUFFERS is zero.
Additions to Chapter 14 of the OpenGL 4.3 (Compatibility Profile) Specification
(Rasterization)
Modify Section 14.3.1 (Multisampling), p. 478
(replace the introductory language at the beginning of the section to
account for the new ability to use multisample rasterization without
having multisample storage)
Multisampling is a mechanism to antialias all GL primitives: points,
lines, polygons, bitmaps, and images. The technique is to sample all
primitives multiple times at each pixel. The color sample values are
resolved to a single, displayable color. For window system-provided
framebuffers, this occurs each time a pixel is updated, so the
antialiasing appears to be automatic at the application level. For
application-created framebuffers, this must be requested by calling
the BlitFramebuffer command (see section 18.3.1). Because each sample
includes color, depth, and stencil information, the color (including
texture operation), depth, and stencil functions perform
equivalently to the single-sample mode.
When the framebuffer includes a multisample buffer, separate color, depth,
and stencil values are stored in this buffer for each sample location.
Samples contain separate color values for each fragment color.
Framebuffers including a multisample buffer do not include non-multisample
depth or stencil buffers, even if the multisample buffer does not store
depth or stencil values. Color buffers do coexist with the multisample
buffer, however.
The color sample values are resolved to a single, displayable color each
time a pixel is updated, so the antialiasing appears to be automatic at
the application level. Because each sample includes color, depth, and
stencil information, the color (including texture operation), depth, and
stencil functions perform equivalently to the single-sample mode.
Multisample antialiasing is most valuable for rendering polygons, because
it requires no sorting for hidden surface elimination, and it correctly
handles adjacent polygons, object silhouettes, and even intersecting
polygons. If only points or lines are being rendered, the "smooth"
antialiasing mechanism provided by the base GL may result in a higher
quality image. This mechanism is designed to allow multisample and smooth
antialiasing techniques to be alternated during the rendering of a single
scene.
If the value of MULTISAMPLE_RASTERIZATION_ALLOWED_EXT is TRUE, the
rasterization of all primitives is changed, and is referred to as
multisample rasterization. Otherwise, primitive rasterization is
referred to as single-sample rasterization. The value of MULTISAMPLE-
_RASTERIZATION_ALLOWED_EXT is queried by calling GetIntegerv
with pname set to MULTISAMPLE_RASTERIZATION_ALLOWED_EXT.
During multisample rendering the contents of a pixel fragment are changed
in two ways. First, each fragment includes a coverage value with
EFFECTIVE_RASTER_SAMPLES_EXT bits. The value of EFFECTIVE_RASTER_-
SAMPLES_EXT is an implementation-dependent constant, and
is queried by calling GetIntegerv with pname set to EFFECTIVE_RASTER-
_SAMPLES_EXT.
Multisample rasterization may also be enabled without introducing
additional storage for the multisample buffer, by calling Enable with a
<target> of RASTER_MULTISAMPLE_EXT. The command:
void RasterSamplesEXT(uint samples, boolean fixedsamplelocations);
selects the number of samples to be used for rasterization. <samples>
represents a request for a desired minimum number of samples. Since
different implementations may support different sample counts, the actual
sample pattern used is implementation-dependent. However, the resulting
value for RASTER_SAMPLES_EXT is guaranteed to be greater than or equal to
<samples> and no more than the next larger sample count supported by the
implementation. If <fixedsamplelocations> is TRUE, identical sample
locations will be used for all pixels. The sample locations chosen are a
function of only the parameters to RasterSamplesEXT and not of any other
state.
If RASTER_MULTISAMPLE_EXT is enabled, then the sample pattern chosen by
RasterSamplesEXT will be used instead of sampling at the center of the
pixel. The sample locations can be queried with GetMultisamplefv with a
<pname> of SAMPLE_POSITION, similar to normal multisample sample locations.
The value MULTISAMPLE_RASTERIZATION_ALLOWED_EXT is TRUE if SAMPLE_BUFFERS
is one or if RASTER_MULTISAMPLE_EXT is enabled. The value
EFFECTIVE_RASTER_SAMPLES_EXT is equal to RASTER_SAMPLES_EXT if
RASTER_MULTISAMPLE_EXT is enabled, otherwise is equal to SAMPLES.
Explicit multisample rasterization is not allowed if the raster sample
count is less than the color sample count, or if the raster sample count
does not match the depth or stencil sample counts when depth or stencil
testing is performed. If RASTER_MULTISAMPLE_EXT is enabled, the error
INVALID_OPERATION will be generated by Draw, Bitmap, DrawPixels, and
CopyPixels commands if
- the value of RASTER_SAMPLES_EXT is zero;
- the value of RASTER_SAMPLES_EXT is less than the value of
COLOR_SAMPLES_NV;
- the depth or depth bounds test is enabled, the draw framebuffer
includes a depth buffer, and the value of RASTER_SAMPLES_EXT does not
equal the value of DEPTH_SAMPLES_NV; or
- the stencil test is enabled, the draw framebuffer includes a stencil
buffer, and the value of RASTER_SAMPLES_EXT does not equal the value
of STENCIL_SAMPLES_NV;
Errors
- An INVALID_VALUE error is generated if <samples> is greater than the
value of MAX_RASTER_SAMPLES_EXT.
Add to the end of Section 14.3.1.1 (Sample Shading), p. 479
If RASTER_MULTISAMPLE_EXT is enabled, the number of unique samples to
process is implementation-dependent and need not be more than one.
If RASTER_MULTISAMPLE_EXT is disabled but the value of SAMPLES is
greater than the value of COLOR_SAMPLES, the number of unique samples
to process is implementation-dependent and need not be more than one.
Modify Section 14.4.3 (Point Multisample Rasterization)
If MULTISAMPLE is enabled and MULTISAMPLE_RASTERIZATION_ALLOWED_EXT is
TRUE, then points are rasterized using the following algorithm, regardless
of whether point antialiasing (POINT_SMOOTH) is enabled or disabled.
Modify Section 14.5.4 (Line Multisample Rasterization)
If MULTISAMPLE is enabled and MULTISAMPLE_RASTERIZATION_ALLOWED_EXT is
TRUE, then lines are rasterized using the following algorithm, regardless
of whether line antialiasing (LINE_SMOOTH) is enabled or disabled.
Modify Section 14.6.6 (Polygon Multisample Rasterization)
If MULTISAMPLE is enabled and MULTISAMPLE_RASTERIZATION_ALLOWED_EXT is
TRUE, then polygons are rasterized using the following algorithm,
regardless of whether polygon antialiasing (POLYGON_SMOOTH) is enabled or
disabled.
Modify Section 14.8.0.1 (Bitmap Multisample Rasterization)
If MULTISAMPLE is enabled and MULTISAMPLE_RASTERIZATION_ALLOWED_EXT is
TRUE, then bitmaps are rasterized using the following algorithm.
Additions to Chapter 15 of the OpenGL 4.3 (Compatibility Profile) Specification
(Programmable Fragment Processing)
Modify Section 15.2.2 (Shader Inputs), p. 512
The built-in variable gl_SampleMaskIn is an integer array holding bitfields
indicating the set of fragment samples covered by the primitive
corresponding to the fragment shader invocation. The number of elements in
the array is
ceil(s/32),
where <s> is the maximum number of color or raster samples supported by the
implementation. Bit <n> of element <w> in the array is set if and only if
the raster sample numbered 32<w> + <n> is considered covered for this
fragment shader invocation.
Modify Section 15.2.3 (Shader Outputs), p. 513
The built-in integer array gl_SampleMask can be used to change the sample
coverage for a fragment from within the shader. The number of elements in
the array is
ceil(s/32),
where <s> is the maximum number of color or raster samples supported by the
implementation.
Additions to Chapter 17 of the OpenGL 4.3 (Compatibility Profile) Specification
(Writing Fragments and Samples to the Framebuffer)
Modify Figure 17.1 (Per-fragment operations)
Add a new stage called "Coverage Reduction" between "Occlusion Query" and
"Blending".
(note: If NV_fragment_coverage_to_color is supported, the "Coverage
Reduction" stage is after the "Fragment coverage to color" stage.)
Modify Section 17.3.3 (Multisample Fragment Operations)
First paragraph:
...No changes to the fragment alpha or coverage values are made at this
step if MULTISAMPLE is disabled or MULTISAMPLE_RASTERIZATION_ALLOWED_EXT is
FALSE.
...
If SAMPLE_ALPHA_TO_COVERAGE is enabled, a temporary coverage value is
generated where each bit is determined by the alpha value at the
corresponding sample location. The coverage value has
EFFECTIVE_RASTER_SAMPLES_EXT bits.
Modify Section 17.3.7 (Occlusion Queries), p.538
When an occlusion query is started with target SAMPLES_PASSED, the samples-
passed count maintained by the GL is set to zero. When an occlusion query
is active, the samples-passed count is incremented for each fragment that
passes the depth test. If MULTISAMPLE_RASTERIZATION_ALLOWED_EXT is FALSE,
then the samples-passed count is incremented by 1 for each fragment. If
MULTISAMPLE_RASTERIZATION_ALLOWED_EXT is TRUE, then the samples-passed
count is incremented by the number of samples whose coverage bit is set.
However, implementations, at their discretion, may instead increase the
samples-passed count by the value of EFFECTIVE_RASTER_SAMPLES_EXT if any
sample in the fragment is covered. Additionally, if
RASTER_MULTISAMPLE_EXT is enabled, implementations may instead increase
the samples-passed count by one for the entire fragment if any sample
is covered.
Add a new Section 17.3.Y (Coverage Reduction) after 17.3.7.
If the value of EFFECTIVE_RASTER_SAMPLES_EXT is greater than the value of
COLOR_SAMPLES_NV, a fragment's coverage is reduced from
EFFECTIVE_RASTER_SAMPLES_EXT bits to COLOR_SAMPLES_NV bits. There is an
implementation-dependent association of raster samples to color samples.
The reduced "color coverage" is computed such that the coverage bit for
each color sample is 1 if any of the associated bits in the fragment's
coverage is on, and 0 otherwise. Blending and writes to the framebuffer
are not performed on samples whose color coverage bit is zero.
For each color sample, the associated bits of the fragment's coverage are
counted and divided by the number of associated bits to produce a
modulation factor R in the range (0,1] (a value of zero would have been
killed due to a color coverage of 0). Specifically:
N = value of EFFECTIVE_RASTER_SAMPLES_EXT;
M = value of COLOR_SAMPLES_NV;
R = popcount(associated coverage bits) / (N / M);
If COVERAGE_MODULATION_TABLE_NV is enabled, the value R is mapped
through a programmable lookup table to produce another value. The lookup
table has a fixed, implementation-dependent, size according to the value
of COVERAGE_MODULATION_TABLE_SIZE_NV.
S = value of COVERAGE_MODULATION_TABLE_SIZE_NV
I = max(1, int(R*S));
R = table[I-1];
Note that the table does not have an entry for R=0, because such samples
would have been killed. The table is controlled by the command:
CoverageModulationTableNV(sizei n, const float *v);
where <v> contains S floating point values. The values are rounded on use
to an implementation dependent precision, which is at least as fine as
1 / N, and clamped to [0,1]. Initially, COVERAGE_MODULATION_TABLE_NV is
disabled, and the table is initialized with entry i = ((i+1) / S). An
INVALID_VALUE error is generated if <n> is not equal to
COVERAGE_MODULATION_TABLE_SIZE_NV. The command
GetCoverageModulationTableNV(sizei bufsize, float *v);
obtains the coverage modulation table. min(bufsize/sizeof(float),S)
floating point values are written to <v>, in order.
For each draw buffer with a floating point or normalized color format, the
fragment's color value and second source color [for ARB_blend_func_extended]
is replicated to M values which may each be modulated (multiplied) by
that color sample's associated value of R. This modulation is controlled
by the function:
CoverageModulationNV(enum components);
<components> may be RGB, RGBA, ALPHA, or NONE. If <components> is RGB or
RGBA, the red, green, and blue components are modulated. If components is
RGBA or ALPHA, the alpha component is modulated. The initial value of
COVERAGE_MODULATION_NV is NONE.
Each sample's color value is then blended and written to the framebuffer
independently.
Additions to Chapter 18 of the OpenGL 4.3 (Compatibility Profile) Specification
(Drawing, Reading, and Copying Pixels)
Modify Section 18.1.3 (Pixel Rectangle Multisample Rasterization)
If MULTISAMPLE is enabled and MULTISAMPLE_RASTERIZATION_ALLOWED_EXT is TRUE,
then pixel rectangles are rasterized using the following algorithm.
Modify Section 18.2 (Reading Pixels)
Replace the error check for ReadPixels, redefining one error condition in
terms of the sample count of the targeted color buffer instead of
SAMPLE_BUFFERS:
An INVALID_OPERATION error is generated if the value of READ_-
FRAMEBUFFER_BINDING (see section 9) is non-zero, the read framebuffer is
framebuffer complete, and the number of samples in the read buffer is
greater than one.
Modify Section 18.3 (Copying Pixels)
Replace the second error check for CopyPixels, redefining one error
condition in terms of the sample count of the targeted color buffer
instead of SAMPLE_BUFFERS:
An INVALID_OPERATION error is generated if the object bound to
READ_FRAMEBUFFER_BINDING is framebuffer complete and the number of samples
in the read buffer is greater than one.
An INVALID_OPERATION error is generated if the value of READ_-
FRAMEBUFFER_BINDING (see section 9) is non-zero, the read framebuffer is
framebuffer complete, and the number of samples in the read buffer is
greater than one.
Modify Section 18.3.1 (Blitting Pixel Rectangles), p. 580
(redefine various language in terms of sample counts in individual buffers
instead of SAMPLE_BUFFERS)
If the number of samples in the source buffer is greater than one and the
number of samples in the destination buffers is equal to one, the samples
corresponding to each pixel location in the source are converted to a
single sample before being written to the destination.
If the number of samples in the source buffer is one and the number of
samples in the destination buffers are greater than one, the value of the
source sample is replicated in each of the destination samples.
If the number of samples in the source buffer or in any of the destination
buffers is greater than one, no copy is performed and an INVALID_OPERATION
error is generated if the dimensions of the source and destination
rectangles provided to BlitFramebuffer are not identical, or if the formats
of the read and draw framebuffers are not identical.
If the number of samples in the source and destination buffers are equal
and greater than zero, the samples are copied without modification from the
read framebuffer to the draw framebuffer. Otherwise, no copy is performed
and an INVALID_OPERATION error is generated.
New Implementation Dependent State
Minimum
Get Value Type Get Command Value Description Sec.
--------- ------- ----------- ------- ------------------------ ------
MAX_RASTER_SAMPLES_EXT Z+ GetIntegerv 2 Maximum number of raster 14.3.1
samples
MIXED_DEPTH_SAMPLES_- B GetBooleanv FALSE(*)Support for number of depth 9.4.2
SUPPORTED_NV samples not equal to number
of color samples
MIXED_STENCIL_SAMPLES_- B GetBooleanv FALSE(*)Support for number of depth 9.4.2
SUPPORTED_NV samples not equal to number
of color samples
COVERAGE_MODULATION_TABLE_- Z+ GetIntegerv 2(**) Number of entries in the table 17.3.Y
SIZE_NV
(*) footnote: Either MIXED_DEPTH_SAMPLES_SUPPORTED_NV or
MIXED_STENCIL_SAMPLES_SUPPORTED_NV must be TRUE for this extension to be
useful.
(**) Must be at least as large as MAX_RASTER_SAMPLES_EXT.
New State
Get Value Get Command Type Initial Value Description Sec. Attribute
--------- ----------- ---- ------------- ----------- ---- ---------
RASTER_MULTISAMPLE_EXT IsEnabled B FALSE Multisample Rasterization 14.3.1 enable/multisample
without multiple color
samples
RASTER_SAMPLES_EXT GetIntegerv Z+ 0 Number of raster samples 14.3.1 multisample
RASTER_FIXED_SAMPLE_- GetBooleanv B FALSE Require same sample 14.3.1 multisample
LOCATIONS_EXT locations
MULTISAMPLE_RASTERIZATION_- GetBooleanv B FALSE Whether MS rasterization 14.3.1 -
ALLOWED_EXT can be used
EFFECTIVE_RASTER_SAMPLES_EXT GetIntegerv Z+ 0 How many samples are used 14.3.1 -
for rasterization and
fragment operations
COLOR_SAMPLES_NV GetIntegerv Z+ 0 Number of color samples 9.4.2 -
DEPTH_SAMPLES_NV GetIntegerv Z+ 0 Number of depth samples 9.4.2 -
STENCIL_SAMPLES_NV GetIntegerv Z+ 0 Number of stencil samples 9.4.2 -
<blank> GetCoverage- R^k[0,1] (i+1)/S Lookup table for coverage 17.3.Y -
ModulationTableNV values
COVERAGE_MODULATION_TABLE_NV IsEnabled B FALSE Enable lookup table for 17.3.Y -
coverage values
COVERAGE_MODULATION_NV GetIntegerv E NONE Which components are 17.3.Y -
multiplied by coverage
fraction
Additions to the AGL/GLX/WGL Specifications
None.
GLX Protocol
None.
Modifications to the OpenGL Shading Language Specification, Version 4.30
Modify Section 7.1 (Built-In Language Variables), p. 118
For both the input array gl_SampleMaskIn[] and the output array
gl_SampleMask[], bit B of mask M (gl_SampleMaskIn[M] or gl_SampleMask[M])
corresponds to sample 32*M+B. These arrays have ceil(s/32) elements, where
s is the maximum number of color or raster samples supported by the
implementation.
Interactions with OpenGL ES 3.0
For OpenGL ES, remove references to images, bitmaps and GetDoublev.
Disregard references to POINT_SMOOTH, LINE_SMOOTH and POLYGON_SMOOTH.
Omit changes to Section 14.8.0.1 (Bitmap Multisample Rasterization).
Also, omit changes to Section 18.1.3 (Pixel Rectangle Multisample
Rasterization) and Section 18.3 (Copying Pixels).
Since OpenGL ES does not support enabling/disabling MULTISAMPLE
rasterization via MULTISAMPLE, read all occurrences of MULTISAMPLE
as if it was enabled.
Interactions with OpenGL ES 3.1
If this extension is implemented on OpenGL ES and OpenGL ES 3.1 is
not supported, remove any language referring to TEXTURE_SAMPLES.
Dependencies on ARB_blend_func_extended
If this extension is not supported, remove the phrase "and second
source color [for ARB_blend_func_extended]" from the new Section 17.3.Y
(Coverage Reduction).
Dependencies on NV_framebuffer_multisample
If this extension is implemented on OpenGL ES and NV_framebuffer_multisample
is not supported, disregard changes to BlitFramebuffer where the
number of samples in the draw framebuffer is greater than one.
Dependencies on OES_sample_shading
If this extension is implemented on OpenGL ES and if
OES_sample_shading is not supported, omit changes to Section 14.3.3.1
(Sample Shading).
Dependencies on OES_sample_variables
If this extension is implemented on OpenGL ES and if
OES_sample_variables is not supported, omit changes to Section 3.9.2
(Shader Inputs; Shader Outputs).
Dependencies on EXT_depth_bounds_test
If EXT_depth_bounds_test is not supported, remove the error check when
DBT is enabled.
Errors
Various errors prohibiting read/copy operations involving multisample
color buffers are redefined to refer to the sample count of the targeted
color buffer instead of a whole-framebuffer RASTER_SAMPLES. This
extension allows a single-sample color buffer to be combined with a
multisample depth/stencil buffer and defines RASTER_SAMPLES to be 1 in
that case.
The error INVALID_OPERATION is be generated by Draw, Bitmap, DrawPixels,
and CopyPixels commands if RASTER_MULTISAMPLE_EXT is enabled, and any of
the following is true:
- the value of RASTER_SAMPLES_EXT is zero;
- the value of RASTER_SAMPLES_EXT is less than the value of
COLOR_SAMPLES_NV;
- the depth or depth bounds test is enabled, the draw framebuffer
includes a depth buffer, and the value of RASTER_SAMPLES_EXT does not
equal the value of DEPTH_SAMPLES_NV; or
- the stencil test is enabled, the draw framebuffer includes a stencil
buffer, and the value of RASTER_SAMPLES_EXT does not equal the value
of STENCIL_SAMPLES_NV.
The error INVALID_VALUE is generated by RasterSamplesEXT if <samples> is
greater than the value of MAX_RASTER_SAMPLES_EXT.
The error INVALID_VALUE is generated by CoverageModulationTableNV if <n>
is not equal to COVERAGE_MODULATION_TABLE_SIZE_NV.
NVIDIA Implementation Details
NVIDIA GPUs before the Maxwell 2 generation do not support this
extension. This includes GM10x GPUs from the first Maxwell
generation.
GM20x-based GPUs (GeForce 9xx series, Quadro M6000, Tegra X1, etc.)
and later GPUs support the following mixtures of samples:
Color samples Stencil samples Depth samples
============= =============== =============
1 1 1
1 2 2
1 4 4
1 8 8
1 16 0
------------- --------------- -------------
2 2 2
2 4 4
2 8 8
2 16 0
------------- --------------- -------------
4 4 4
4 8 8
4 16 0
------------- --------------- -------------
8 8 8
8 16 0
A non-zero stencil or depth sample count can always be made zero.
For example, 4 color samples with 8 stencil samples but no depth
samples is supported.
If you have a non-zero number of 24-bit fixed-point depth samples,
the corresponding storage for the sample number of stencil samples
is allocated even if zero samples are requested.
When there are zero depth samples but non-zero stencil samples, GM20x
benefits from stencil bandwidth mitigation technology. So rendering
performance (e.g. path rendering) is significantly better when an
application can use the stencil buffer without allocating a depth
buffer.
As the table indicates, rendering with 16 stencil samples requires
no depth samples.
NVIDIA's implementation-dependent behavior when sample shading enabled
when the number of effective raster samples is not equal to the number
of color samples shades at the pixel rate, effectively ignoring the
per-sample shading (as allowed by the language in section 14.3.3.1).
Issues
(1) How is coverage modulation intended to be used?
RESOLVED: Coverage modulation allows the coverage to be converted to
"opacity", which can then be blended into the color buffer to accomplish
antialiasing. This is similar to the intent of POLYGON_SMOOTH. For example,
if non-premultiplied alpha colors are in use (common OpenGL usage):
glCoverageModulationNV(GL_ALPHA);
glEnable(GL_BLEND);
glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA,
GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
or if using pre-multiplied alpha colors (common in 2D rendering):
glCoverageModulationNV(GL_RGBA);
glEnable(GL_BLEND);
glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
(2) How is the coverage modulation table intended to be used?
RESOLVED: It could be used to accomplish the coverage modulation
"downsample" in a modified color space (akin to an sRGB downsample). It
could also be used (in conjunction with blending) to kill any partially
covered color samples.
Note that for lower ratios of N/M, the table's entries are used sparsely.
For example, if N=16, M=4, and S=16, the initial calculation of R would
produce values of 0.25, 0.5, 0.75, and 1. Then I = 4, 8, 12, or 16, and
entries 3, 7, 11, and 15 would be used. The intent is that the table
should be treated like a function from (0,1] to [0,1].
(3) What combinations of AA modes are supported?
RESOLVED: Depth/stencil samples being an integer multiple of color samples
is a necessary condition, but is not sufficient. There may be other
implementation-dependent limitations that cause certain combinations not
to be supported and report as an incomplete framebuffer.
(4) What errors should be generated when RasterSamples and depth/stencil
sample counts mismatch?
RESOLVED: Commands that do any sort of rasterization, including Draw,
Bitmap, DrawPixels, and CopyPixels, should have errors if the depth/stencil
buffer may be touched (depth test, stencil test, depth bounds test
enabled). Clear does not rasterize, so should not have any such errors.
(5) When using both NV_fragment_coverage_to_color and EXT_raster_multisample
or NV_framebuffer_mixed_samples, how do these features interact?
RESOLVED: Both may be used simultaneously, and the coverage_to_color
functionality is applied before coverage reduction in the pipeline. This
means the full raster sample mask will be written to the color buffer, not
the reduced color sample mask.
(6) How do EXT_raster_multisample and NV_framebuffer_mixed_samples
interact? Why are there two extensions?
RESOLVED: The functionality in EXT_raster_multisample is equivalent to
"Target-Independent Rasterization" in Direct3D 11.1, and is expected to be
supportable today by other hardware vendors. It allows using multiple
raster samples with a single color sample, as long as depth and stencil
tests are disabled, with the number of raster samples controlled by a
piece of state.
NV_framebuffer_mixed_samples is an extension/enhancement of this feature
with a few key improvements:
- Multiple color samples are allowed, with the requirement that the number
of raster samples must be a multiple of the number of color samples.
- Depth and stencil buffers and tests are supported, with the requirement
that the number of raster/depth/stencil samples must all be equal for
any of the three that are in use.
- The addition of the coverage modulation feature, which allows the
multisample coverage information to accomplish blended antialiasing.
Using mixed samples does not require enabling RASTER_MULTISAMPLE_EXT; the
number of raster samples can be inferred from the depth/stencil
attachments. But if it is enabled, RASTER_SAMPLES_EXT must equal the
number of depth/stencil samples.
(7) How do ARB_blend_func_extended (dual-source blending) interact
with this extension?
RESOLVED: Coverage modulation affects both the source color and the
source factor color (GL_SRC1_COLOR, etc.).
(8) How does ARB_sample_shading (per-sample shading) interact with
this extension?
RESOLVED: Implementations have the option of shading just a single
sample when the number of raster samples doesn't match the number
of color samples, be that because RASTER_MULTISAMPLE_EXT is enabled
or the number of depth and/or stencil samples is greater than the
number of color samples.
See the language added to the end of Section 14.3.1.1 (Sample
Shading).
(9) Why does the antialiasing quality look "ropey" even with 8 or
even 16 raster samples?
Because of the color values on typical displays (e.g. devices
displaying color values encoded in the sRGB color space) do not have
a perceptually-linear color response, antialiasing quality based on
fractional coverage is best achieved on such sRGB displays by
enabling sRGB framebuffer blending (i.e. GL_FRAMEBUFFER_SRGB).
Otherwise antialiased edges rendered with coverage modulation may
have a "ropey" appearance.
The benefit of enabling sRGB framebuffer blending is a more noticable
improvement in edge antialiasing quality than moving from 4 to 8 or
8 to 16 samples.
If you are going to use 8 or 16 (or even 4) raster samples with
blended coverage modulation, you are well-advised to use sRGB
framebuffer blending for best quality.
Revision History
Revision 3, 2017/02/15 (not merged to Khronos earlier)
- ARB_blend_func_extended interaction specified
- Mixed samples may not work with sample shading, NVIDIA
- Added implementation Details, sRGB advice.
Revision 2, 2015/03/27
- Add ES interactions
Revision 1
- Internal revisions.