Name

    INTEL_conservative_rasterization

Name Strings

    GL_INTEL_conservative_rasterization

Contact

    Slawomir Grajewski, Intel Corporation (slawomir.grajewski 'at' intel.com)

Contributors

    Petrik Clarberg, Intel Corporation
    Jon Kennedy, Intel Corporation
    Slawomir Cygan, Intel Corporation

Status

    Draft.

Version

    Last Modified Date:         11/2/2016
    Intel Revision:             2

Number

    OpenGL Extension #491
    OpenGL ES Extension #265

Dependencies

    This extension is written against the OpenGL 4.5 (Core Profile)
    Specification (May 28, 2015)

    This extension is written against Version 4.50.5 of the OpenGL Shading
    Language Specification.

    OpenGL 4.2 and GLSL 4.2 are required.

    This extension is written against the OpenGL ES 3.2 Specification
    (August 10, 2015)

    This extension is written against Version 3.20.2 of the OpenGL ES Shading
    Language Specification (August 6, 2015)

    This extension interacts with ARB_post_depth_coverage.

Overview

    Regular rasterization includes fragments with at least one
    sample covered by a polygon. Conservative rasterization includes all
    fragments that are at least partially covered by the polygon.

    In some use cases, it is also important to know if a fragment is fully
    covered by a polygon, i.e. if all parts of the fragment are within the
    polygon. An application may, for example, want to process fully covered
    fragments different from the "edge" pixels. This extension adds an option
    for the fragment shader to receive this information via gl_SampleMaskIn[].

    This extension affects only polygons in FILL mode and specifically does not
    imply any changes in processing of lines or points.

    Conservative rasterization automatically disables polygon antialiasing
    rasterization if enabled by POLYGON_SMOOTH.

New Procedures and Functions

    None.

New Tokens

    Accepted by the <target> parameter of Enable, Disable, IsEnabled:

        CONSERVATIVE_RASTERIZATION_INTEL  0x83FE

Additions to Chapter 14.6, Polygons of the OpenGL 4.5 Specification

    Modify Section 14.6.1, Basic Polygon Rasterization

    (insert before the paragraph starting with "As for the data associated...")

    The determination of which fragments are produced by polygon rasterization
    can be modified by the conservative rasterization option (as described in
    section 14.6.4).

    Modify Section 14.6.3, Antialiasing

    (add a new paragraph to the end of the section)

    Conservative rasterization automatically disables polygon antialiasing
    rasterization if enabled by POLYGON_SMOOTH.

    Modify Section 14.6.4, Options Controlling Polygon Rasterization

    (add a new paragraph to the end of the section)

    The determination of which fragments are produced as a result of polygon
    rasterization in FILL state can be modified by enabling the conservative
    rasterization option. Conservative rasterization is enabled or disabled
    with the generic Enable and Disable commands using the symbolic constant
    CONSERVATIVE_RASTERIZATION_INTEL. When disabled, the fragments are
    determined as described in section 14.6.1. When enabled the polygon
    rasterization produces all fragments for which any part of their squares
    are inside the polygon, after expanding the polygon by 1/512th of a pixel
    in both x and y dimensions. Polygons with an area of zero do generate
    fragments.

    The conservative rasterization option applies only to polygons with
    PolygonMode state set to FILL. Draw requests for polygons with different
    PolygonMode setting or for other primitive types (points/lines) generate
    INVALID_OPERATION error.

    Modify Section 14.6.6, Polygon Multisample Rasterization

    (modify the first paragraph)

    If MULTISAMPLE is enabled, and the value of SAMPLE_BUFFERS is one, then
    polygons are rasterized using the following algorithm, regardless of
    whether polygon antialiasing (POLYGON_SMOOTH) is enabled or disabled. When
    conservative rasterization is disabled as described in section 14.6.4,
    polygon rasterization produces a fragment for each framebuffer pixel with
    one or more sample points that satisfy the point sampling criteria
    described in section 14.6.1. When conservative rasterization is
    enabled, polygon rasterization produces exactly the same fragments as with
    MULTISAMPLE disabled and the value of SAMPLE_BUFFERS set to zero. If a
    polygon is culled, based on its orientation and the CullFace mode, then no
    fragments are produced during rasterization. When conservative
    rasterization is disabled, coverage bits that correspond to sample points
    that satisfy the point sampling criteria are 1, other coverage bits are
    0. When conservative rasterization is enabled all sample coverage bits for
    fragments produced by rasterization are 1, other coverage bits are 0.

Additions to Chapter 15.2.2, Shader Inputs of the OpenGL 4.5 Specification

    (replace the sentence starting with "Bit<n> of element<w> in the array...")

    Bit <n> of element <w> in the array is set if and only if the sample
    numbered <32w + n> is considered covered for this fragment shader
    invocation. If the fragment shader specifies the "early_fragment_tests" and
    "post_depth_coverage" layout qualifiers, then the sample is considered
    covered if and only if the sample is covered by the primitive and the
    sample passes the early fragment tests (as described in Section 15.2.4). If
    these layout qualifiers are not specified, then the sample is considered
    covered if the sample is covered by the primitive, regardless of the result
    of the fragment tests. If the fragment shader specifies the
    "inner_coverage" layout qualifier the sample is considered covered only if
    the sample is covered by the primitive and passes the inner coverage
    test. Layout qualifier "inner_coverage" is in effect only if conservative
    is enabled and is mutually exclusive with "post_depth_coverage".

    During the conservative rasterization process (section 14.6.4) for the
    purpose of the inner coverage test the determination is made if the
    fragment is entirely contained within the polygon. This determination is
    made by shrinking the polygon by 1/512th of pixel along the x and y
    dimensions. The result of the inner coverage test is available in
    gl_SampleMaskIn if "inner_coverage" layout qualifier is present.

    (replace the paragraph starting with "When per-sample shading is active due
    to the use of a fragment input qualified...")

    In the case of per-sample shading the information delivered via
    gl_SampleMaskIn depends on the conservative rasterization state and
    possibly on the layout qualifier. Regardless of the conservative
    rasterization state, samples killed due to SAMPLE_COVERAGE or SAMPLE_MASK
    are never reported in gl_SampleMaskIn regardless of the qualifier.

    With conservative rasterization disabled, when per-sample shading is active
    due to the use of a fragment input qualified by sample or due to the use of
    the gl_SampleID or gl_SamplePosition variables, only the bit for the
    current sample is set in gl_SampleMaskIn. When state specifies multiple
    fragment shader invocations for a given fragment, the sample mask for any
    single fragment shader invocation may specify a subset of the covered
    samples for the fragment. In this case, the bit corresponding to each
    covered sample will be set in exactly one fragment shader invocation.

    With conservative rasterization enabled, regardless of whether per-sample
    shading is active due to fragment input qualified by sample or by state,
    the meaning of the gl_SampleMaskIn depends on layout qualifier and is the
    same for both per-sample triggering conditions. Moreover as a consequence
    of rasterization rules described in section 14.6.6, when conservative
    rasterization is enabled and MULITISAMPLE is enabled and the value of
    SAMPLE_BUFFERS is one, either all samples of a given fragment are covered,
    or none.

    * No layout qualifier present:
      The sample mask for any single fragment shader invocation specifies all
      samples covered by a conservatively rasterized fragment.

    * Layout qualifier "inner_coverage":
      The sample mask for any single fragment shader invocation specifies all
      samples covered by a conservatively rasterized fragment that passed inner
      coverage test.

    * Layout qualifier "post_depth_coverage":
      The sample mask for any single fragment shader invocation specifies all
      samples covered by a conservatively rasterized fragment that passed early
      depth/stencil tests if enforced by early_fragment_tests layout qualifier
      as described in section 15.2.4.

    If MULTISAMPLE is enabled and the value of SAMPLE_BUFFERS is one, and per
    sample shading is not active, the meaning of gl_SampleMaskIn[] and its
    modifications due to layout qualifier are exactly the same as described
    above.

Additions to the OpenGL Shading Language Specification, version 4.50.5

    Including the following line in a shader can be used to control the
    language features described in this extension:

      #extension GL_INTEL_conservative_rasterization : <behavior>

    where <behavior> is as specified in section 3.3.

    A new preprocessor #define is added to the OpenGL Shading Language:

      #define GL_INTEL_conservative_rasterization 1

    Modify section 4.4.1.3, Fragment Shader Inputs

    (replace the discussion of early_fragment_tests)

    Fragment shaders also allow the following layout qualifiers on "in" only (not
    with variable declarations)

        layout-qualifier-id
            early_fragment_tests
            post_depth_coverage
            inner_coverage

    For example,

        layout(early_fragment_tests) in;
        layout(post_depth_coverage) in;
        layout(inner_coverage) in;

    "early_fragment_tests" requests that fragment tests be performed before
    fragment shader execution, as described in section 15.2.4 "Early Fragment
    Tests" of the OpenGL Specification. If neither this nor post_depth_coverage
    are declared, per-fragment tests will be performed after fragment shader
    execution.

    "post_depth_coverage" requests that the built-in "gl_SampleMaskIn[]" will
    reflect the result of the early fragment tests, as described in section
    15.2.2 "Shader Inputs" of the OpenGL Specification. Use of this
    qualifier implicitly requests that fragment tests be performed before
    fragment shader execution.

    "inner_coverage" requests that the built-in "gl_SampleMaskIn[]" will
    reflect the result of the inner coverage test as described in section
    15.2.2 "Shader Inputs" of the OpenGL Specification. It has an effect on
    "gl_SampleMaskIn[]" only if conservative rasterization is enabled.

    "post_depth_coverage" and "inner_coverage" are mutually
    exclusive. Declaring both for fragment shader will result in compile or
    link error.

    Only one fragment shader (compilation unit) need declare these, though
    more than one can. If at least one fragment shader declares one of these,
    then it is enabled.

Additions to Chapter 13.7, Polygons of the OpenGL ES 3.2 Specification

    Modify Section 13.7.1, Basic Polygon Rasterization

    (insert before the paragraph starting with "As for the data associated...")

    The determination of which fragments are produced by polygon rasterization
    can be modified by the conservative rasterization option (as described in
    section 13.7.1).

    Modify Section 13.7.1, Basic Polygon Rasterization

    (add at the end)

    The determination of which fragments are produced as a result of polygon
    rasterization can be modified by enabling the conservative rasterization
    option. Conservative rasterization is enabled or disabled with the generic
    Enable and Disable commands using the symbolic constant
    CONSERVATIVE_RASTERIZATION_INTEL. When disabled, the fragments are
    determined as described in this section. When enabled the polygon
    rasterization produces all fragments for which any part of their squares
    are inside the polygon, after expanding the polygon by 1/512th of pixel in
    both x and y dimensions. Polygons with an area of zero do generate
    fragments.

    The conservative rasterization option applies only to polygons. Draw
    requests for other primitive types (points/lines) generate
    INVALID_OPERATION error.

    Modify Section 13.7.3, Polygon Multisample Rasterization

    (modify the first paragraph)

    If the value of SAMPLE_BUFFERS is one, then polygons are rasterized using
    the following algorithm. When conservative rasterization is disabled,
    polygon rasterization produces a fragment for each framebuffer pixel with
    one or more sample points that satisfy the point sampling criteria
    described in section 13.7.1. If a polygon is culled, based on its
    orientation and the CullFace mode, then no fragments are produced during
    rasterization.

    If conservative rasterization is enabled, polygon rasterization produces
    exactly the same fragments as with the value of SAMPLE_BUFFERS set to
    zero. Also, all sample coverage bits for fragments produced by
    rasterization are 1, other coverage bits are 0. If a polygon is culled,
    based on its orientation and the CullFace mode, then no fragments are
    produced during rasterization.


Additions to Chapter 14.2.2, Shader Inputs of the OpenGL ES 3.2 Specification

    (replace the sentence starting with "Bit<n> of element<w> in the array...")

    Bit <n> of element <w> in the array is set if and only if the sample
    numbered <32w + n> is considered covered for this fragment shader
    invocation. If the fragment shader specifies the "early_fragment_tests" and
    "post_depth_coverage" layout qualifiers, then the sample is considered
    covered if and only if the sample is covered by the primitive and the
    sample passes the early fragment tests (as described in Section 15.2.4). If
    these layout qualifiers are not specified, then the sample is considered
    covered if the sample is covered by the primitive, regardless of the result
    of the fragment tests. If the fragment shader specifies the
    "inner_coverage" layout qualifier the sample is considered covered only if
    the sample is covered by the primitive and passes the inner coverage
    test. Layout qualifier "inner_coverage" is in effect only if conservative
    is enabled and is mutually exclusive with "post_depth_coverage".

    During the conservative rasterization process (section 13.7.2) for the
    purpose of the inner coverage test the determination is made if the
    fragment is entirely contained within the polygon. This determination is
    made by shrinking the polygon by 1/512th of pixel along the x and y
    dimensions. The result of the inner coverage test is available in
    gl_SampleMaskIn if "inner_coverage" layout qualifier is present.

    (replace the paragraph starting with "When per-sample shading is active due
    to the use of a fragment input qualified...")

    In the case of per-sample shading the information delivered via
    gl_SampleMaskIn depends on the conservative rasterization state and
    possibly on the layout qualifier. Regardless of the conservative
    rasterization state, samples killed due to SAMPLE_COVERAGE or SAMPLE_MASK
    are never reported in gl_SampleMaskIn regardless of the qualifier.

    With conservative rasterization disabled, when per-sample shading is active
    due to the use of a fragment input qualified by sample or due to the use of
    the gl_SampleID or gl_SamplePosition variables, only the bit for the
    current sample is set in gl_SampleMaskIn. When state specifies multiple
    fragment shader invocations for a given fragment, the sample mask for any
    single fragment shader invocation may specify a subset of the covered
    samples for the fragment. In this case, the bit corresponding to each
    covered sample will be set in exactly one fragment shader invocation.

    With conservative rasterization enabled, regardless of whether per-sample
    shading is active due to fragment input qualified by sample or by state,
    the meaning of the gl_SampleMaskIn depends on layout qualifier and is the
    same for both per-sample triggering conditions. Moreover as a consequence
    of rasterization rules described in section 13.7.3, when conservative
    rasterization is enabled and MULITISAMPLE is enabled and the value of
    SAMPLE_BUFFERS is one, either all samples of a given fragment are covered, or
    none.

    * No layout qualifier present:
      The sample mask for any single fragment shader invocation specifies all
      samples covered by a conservatively rasterized fragment.

    * Layout qualifier "inner_coverage":
      The sample mask for any single fragment shader invocation specifies all
      samples covered by a conservatively rasterized fragment that passed inner
      coverage test.

    * Layout qualifier "post_depth_coverage":
      The sample mask for any single fragment shader invocation specifies all
      samples covered by a conservatively rasterized fragment that passed early
      depth/stencil tests if enforced by early_fragment_tests layout qualifier.

    If the value of SAMPLE_BUFFERS is one, and per sample shading is not
    active, the meaning of gl_SampleMaskIn[] and its modifications due to
    layout qualifier are exactly the same as described above.


Additions to the OpenGL ES Shading Language Specification, version 3.20.2

    Including the following line in a shader can be used to control the
    language features described in this extension:

      #extension GL_INTEL_conservative_rasterization : <behavior>

    where <behavior> is as specified in section 3.3.

    A new preprocessor #define is added to the OpenGL Shading Language:

      #define GL_INTEL_conservative_rasterization 1

    Modify section 4.4.1.3, Fragment Shader Inputs

    (replace the discussion of early_fragment_tests)

    Fragment shaders also allow the following layout qualifiers on "in" only (not
    with variable declarations)

        layout-qualifier-id
            early_fragment_tests
            post_depth_coverage
            inner_coverage

    For example,

        layout(early_fragment_tests) in;
        layout(post_depth_coverage) in;
        layout(inner_coverage) in;

    "early_fragment_tests" requests that fragment tests be performed before
    fragment shader execution, as described in section 13.8 "Early Fragment
    Tests" of the OpenGL ES Specification. If neither this nor post_depth_coverage
    are declared, per-fragment tests will be performed after fragment shader
    execution.

    "post_depth_coverage" requests that the built-in "gl_SampleMaskIn[]" will
    reflect the result of the early fragment tests, as described in section
    14.2.2 "Shader Inputs" of the OpenGL ES 3.2 Specification. Use of this
    qualifier implicitly requests that fragment tests be performed before
    fragment shader execution.

    "inner_coverage" requests that the built-in
    "gl_SampleMaskIn[]" will reflect the result of the inner coverage test
    as described in section 14.2.2 "Shader Inputs" of the OpenGL ES 3.2
    Specification. It has an effect on "gl_SampleMaskIn[]" only if conservative
    rasterization is enabled.

    "post_depth_coverage" and "inner_coverage" are mutually
    exclusive. Declaring both for a fragment shader will result in compile or
    link error.

Additions to the AGL/GLX/WGL Specifications

    None.

GLX Protocol

    None.

Interactions with ARB_post_depth_coverage

    This extension is a fully compatible superset of ARB_post_depth_coverage
    extension. Implementations supporting INTEL_conservative_rasterization may
    or may not advertise ARB_post_depth_coverage without any changes in
    functionality.

Errors

    None.

New State in OpenGL 4.5 Core Profile

    (add new row to the Table 23.10, Rasterization (cont.)

                                     Initial
    Get Value      Type  Get Command  Value  Description                 Sec.
    -------------  ----  ----------- ------- -------------------------   ------
    CONSERVATIVE_  B     IsEnabled()  FALSE  Conservative Rasterization  14.6.4
    RASTERIZATION_                           setting
    INTEL

New State in OpenGL ES 3.2

    (add new row to the Table 21.7, Rasterization)

                                     Initial
    Get Value      Type  Get Command  Value  Description                 Sec.
    -------------  ----  ----------- ------- -------------------------   ------
    CONSERVATIVE_  B     IsEnabled()  FALSE  Conservative Rasterization  3.6
    RASTERIZATION_                           setting
    INTEL

Issues

    (1) Why in per-sample shading case, when conservative rasterization is
        disabled, each sample is reported exactly once in gl_SampleMaskIn
        across all invocations of fragment shader for given fragment, while
        when conservative rasterization is enabled, all eligible samples from
        the given fragment are reported for each fragment shader invocation for
        this fragment?

        Resolved. The former behavior is enforced by existing OpenGL
        spec. The latter, provided by this extension, gives more information to
        the user about neighboring samples. In the extended version, the
        information about current sample can be obtained in the
        gl_SampleMaskIn[] as indicated by gl_SampleID.


Revision History

    Rev.     Date       Author       Changes
    ----  ----------  ----------  -----------------------------------------
      2    11/2/2016  sgrajewski  Updated to OpenGL 4.5 and OpenGL ES 3.2.
                                  Aligned with ARB_post_dept_coverage extension.

      1    10/1/2013  sgrajewski  Initial revision.