在具有多重采样的 GLSL 4.1 片段着色器中使用“丢弃”

Question

I'm attempting depth peeling with multisampling enabled, and having some issues with incorrect data ending up in my transparent layers. I use the following to check if a sample (originally a fragment) is valid for this pass:

float depth = texelFetch(depthMinima, ivec2(gl_FragCoord.xy), gl_SampleID).r;
if (gl_FragCoord.z <= depth)
{
    discard;
}

Where depthMinima is defined as

uniform sampler2DMS depthMinima;

I have enabled GL_SAMPLE_SHADING which, if I understand correctly, should result in the fragment shader being called on a per-sample basis. If this isn't the case, is there a way I can get this to happen?

The result is that the first layer or two look right, but beneath that (and I'm doing 8 layers) I start getting junk values - mostly plain blue, sometimes values from previous layers.

This works fine for single-sampled buffers, but not for multi-sampled buffers. Does the discard keyword still discard the entire fragment?

Answer 1

I have enabled GL_SAMPLE_SHADING which, if I understand correctly, should result in the fragment shader being called on a per-sample basis.

It's not enough to only enable GL_SAMPLE_SHADING . You also need to set:

glMinSampleShading(1.0f)

A value of 1.0 indicates that each sample in the framebuffer should be indpendently shaded. A value of 0.0 effectively allows the GL to ignore sample rate shading. Any value between 0.0 and 1.0 allows the GL to shade only a subset of the total samples within each covered fragment. Which samples are shaded and the algorithm used to select that subset of the fragment's samples is implementation dependent.

– glMinSampleShading

In other words 1.0 tells it to shade all samples. 0.5 tells it to shade at least half the samples.

// Check the current value
GLfloat value;
glGetFloatv(GL_MIN_SAMPLE_SHADING_VALUE, &value);

If either GL_MULTISAMPLE or GL_SAMPLE_SHADING is disabled then sample shading has no effect.

There'll be multiple fragment shader invocations for each fragment, to which each sample is a subset of the fragment. In other words. Sample shading specifies the minimum number of samples to process for each fragment.

If GL_MIN_SAMPLE_SHADING_VALUE is set to 1.0 then there'll be issued a fragment shader invocation for each sample (within the primitive). If its set to 0.5 then there'll be a shader invocation for every second sample.

max(ceil(MIN_SAMPLE_SHADING_VALUE * SAMPLES), 1)

Each being evaluated at their sample location ( gl_SamplePosition ). With gl_SampleID being the index of the sample that is currently being processed.

Should discard work on a per-sample basis, or does it still only work per-fragment?

With or without sample shading discard still only terminate a single invocation of the shader.

Resources:

• ARB_sample_shading
• Fragment Shader
• Per-Sample Processing

Answer 2

I faced a similar problem when using depth_peeling on a multi-sample buffer.

Some artifacts appears due to the depth_test error when using a multi_sample depth texture from the previous peel and the current fragment depth.

vec4 previous_peel_depth_tex = texelFetch(previous_peel_depth, coord, 0);

the third argument is the sample you want to use for your comparison which will give a different value from the fragment center. Like the author said you can use gl_SampleID

vec4 previous_peel_depth_tex = texelFetch(previous_peel_depth, ivec2(gl_FragCoord.xy), gl_SampleID);

This solved my problem but with a huge performance drop, if you have 4 samples you will run your fragment shader 4 times, if 4 have peels it means 4x4 calls. You don't need to set the opengl flags if atleast glEnable(GL_MULTISAMPLE); is on

Any static use of [gl_SampleID] in a fragment shader causes the entire shader to be evaluated per-sample

I decided to use a different approach and to add a bias when doing the depth comparison

float previous_linearized = linearize_depth(previous_peel_depth_tex.r, near, far);
float current_linearized = linearize_depth(gl_FragCoord.z, near, far);

float bias_meter = 0.05;
bool belong_to_previous_peel = delta_depth < bias_meter;

This solve my problem but some artifacts might still appears and you need to adjust your bias in your eye_space units (meter, cm, ...)