| 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. |