[Из песочницы] Модифицированный алгоритм Geometry Buffer Anti-Aliasing08.08.2016 17:18

struct VsIn
{
    float3 Position0 : Position0;
    float3 Position1 : Position1;
};

struct PsIn
{
    float4 Position : SV_Position;
    // The parameters are constant across the line so use the nointerpolation attribute.
    // This is not necessarily required, but using this we can make the vertex shader slightly shorter.
    nointerpolation float4 KMF : KMF;
};

float4x4 ViewProj;
float4 ScaleBias;

PsIn main(VsIn In)
{
    PsIn Out;
    float4 pos0 = mul(ViewProj, float4(In.Position0, 1.0));
    float4 pos1 = mul(ViewProj, float4(In.Position1, 1.0));
    Out.Position = pos0;
    // Compute screen-space position and direction of line
    float2 pos = (pos0.xy / pos0.w) * ScaleBias.xy + ScaleBias.zw;
    float2 dir = (pos1.xy / pos1.w) * ScaleBias.xy + ScaleBias.zw - pos;
    // Select between mostly horizontal or vertical
    bool x_gt_y = abs(dir.x) > abs(dir.y);
    // Pass down the screen-space line equation
    if (x_gt_y)
    {
        float k = dir.y / dir.x;
        Out.KMF.xy = float2(k, -1);
    }
    else
    {
        float k = dir.x / dir.y;
        Out.KMF.xy = float2(-1, k);
    }
    Out.KMF.z = -dot(pos.xy, Out.KMF.xy);
    Out.KMF.w = asfloat(x_gt_y);
    return Out;
}

Texture2D BackBuffer;
SamplerState Filter;
float2 PixelSize;

float4 main(PsIn In) : SV_Target
{
    // Compute the difference between geometric line and sample position
    float diff = dot(In.KMF.xy, In.Position.xy) + In.KMF.z;
    // Compute the coverage of the neighboring surface
    float coverage = 0.5f - abs(diff);
    float2 offset = 0;
    if (coverage > 0)
    {
        // Select direction to sample a neighbor pixel
        float off = diff >= 0 ? 1 : -1;
        if (asuint(In.KMF.w))
            offset.y = off;
        else
            offset.x = off;
    }
    // Blend pixel with neighbor pixel using texture filtering and shifting the coordinate appropriately.
    return BackBuffer.Sample(Filter, (In.Position.xy + coverage * offset.xy) * PixelSize);
}

struct PsIn
{
    float4 Position : SV_Position;
    float2 TexCoord : TexCoord;
};

[Vertex shader]

PsIn main(uint VertexID : SV_VertexID)
{
    // Produce a fullscreen triangle
    PsIn Out;
    Out.Position.x = (VertexID == 0)? 3.0f : -1.0f;
    Out.Position.y = (VertexID == 2)? 3.0f : -1.0f;
    Out.Position.zw = 1.0f;
    Out.TexCoord = Out.Position.xy * float2(0.5f, -0.5f) + 0.5f;
    return Out;
}

[Fragment shader]

Texture2D BackBuffer;
Texture2D  GeometryBuffer;
SamplerState Linear;
SamplerState Point;

float2 PixelSize;

float4 main(PsIn In) : SV_Target
{
    float2 offset = GeometryBuffer.Sample(Point, In.TexCoord);
    // Check geometry buffer for an edge cutting through the pixel.
    [flatten]
    if (min(abs(offset.x), abs(offset.y)) >= 0.5f)
    {
        // If no edge was found we look in neighboring pixels' geometry information. This is necessary because
        // relevant geometry information may only be available on one side of an edge, such as on silhouette edges,
        // where a background pixel adjacent to the edge will have the background's geometry information, and not
        // the foreground's geometric edge that we need to antialias against. Doing this step covers up gaps in the
        // geometry information.
        offset = 0.5f;
        // We only need to check the component on neighbor samples that point towards us
        float offset_x0 = GeometryBuffer.Sample(Point, In.TexCoord, int2(-1,  0)).x;
        float offset_x1 = GeometryBuffer.Sample(Point, In.TexCoord, int2( 1,  0)).x;
        float offset_y0 = GeometryBuffer.Sample(Point, In.TexCoord, int2( 0, -1)).y;
        float offset_y1 = GeometryBuffer.Sample(Point, In.TexCoord, int2( 0,  1)).y;
        // Check range of neighbor pixels' distance and use if edge cuts this pixel.
        if (abs(offset_x0 - 0.75f) < 0.25f) offset = float2(offset_x0 - 1.0f, 0.5f); // Left  x-offset [ 0.5 ..  1.0] cuts this pixel
        if (abs(offset_x1 + 0.75f) < 0.25f) offset = float2(offset_x1 + 1.0f, 0.5f); // Right x-offset [-1.0 .. -0.5] cuts this pixel
        if (abs(offset_y0 - 0.75f) < 0.25f) offset = float2(0.5f, offset_y0 - 1.0f); // Up    y-offset [ 0.5 ..  1.0] cuts this pixel
        if (abs(offset_y1 + 0.75f) < 0.25f) offset = float2(0.5f, offset_y1 + 1.0f); // Down  y-offset [-1.0 .. -0.5] cuts this pixel
    }
    // Convert distance to texture coordinate shift
    float2 off = (offset >= float2(0, 0))? float2(0.5f, 0.5f) : float2(-0.5f, -0.5f);
    offset = off - offset;
    // Blend pixel with neighbor pixel using texture filtering and shifting the coordinate appropriately.
    return BackBuffer.Sample(Linear, In.TexCoord + offset * PixelSize);
}

struct PsIn
{
    float4 Position : SV_Position;
    float2 TexCoord : TexCoord;
};

[Vertex shader]

PsIn main(uint VertexID : SV_VertexID)
{
    // Produce a fullscreen triangle
    PsIn Out;
    Out.Position.x = (VertexID == 0)? 3.0f : -1.0f;
    Out.Position.y = (VertexID == 2)? 3.0f : -1.0f;
    Out.Position.zw = 1.0f;
    Out.TexCoord = Out.Position.xy * float2(0.5f, -0.5f) + 0.5f;
    return Out;
}

[Fragment shader]

Texture2D BackBuffer;
Texture2D  GeometryBuffer;
Texture2D  InvGeometryBuffer;
SamplerState Linear;
SamplerState Point;

float2 PixelSize;
int Tweak;
int ShowEdges;

void check_opposite_neighbor(float2 tex_coord, inout float2 offset)
{
    // Select major offset
    float2 off;
    bool x_major = abs(offset.x) < abs(offset.y);
    if (x_major)
        off = float2(sign(offset.x), 0);
    else
        off = float2(0, sign(offset.y));
    // Select neighbor's offset
    float2 opp_offset = GeometryBuffer.Sample(Point, tex_coord + off*PixelSize);
    // Make sure it is valid
    bool apply_offset = true;
    if (min(abs(opp_offset.x), abs(opp_offset.y)) < 0.5f)
    {
        // Make sure it points towards current sample
        // if so - don't apply texture coordinate offset
        if (x_major)
        {
            if (sign(offset.x)!=sign(opp_offset.x) && abs(opp_offset.x) < 0.5f)
                offset = 0.5f;
        }
        else
        {
            if (sign(offset.y)!=sign(opp_offset.y) && abs(opp_offset.y) < 0.5f)
                offset = 0.5f;
        }
    }
}

float4 main(PsIn In) : SV_Target
{
    float2 offset = GeometryBuffer.Sample(Point, In.TexCoord);
    bool edge_found = false;
    bool triple_coverage = false;
    float4 result;
    // Check geometry buffer for an edge cutting through the pixel.
    [flatten]
    if (min(abs(offset.x), abs(offset.y)) >= 0.5f)
    {
        // If no edge was found we look in neighboring pixels' geometry information. This is necessary because
        // relevant geometry information may only be available on one side of an edge, such as on silhouette edges,
        // where a background pixel adjacent to the edge will have the background's geometry information, and not
        // the foreground's geometric edge that we need to antialias against. Doing this step covers up gaps in the
        // geometry information.
        offset = 0.5f;
        // We only need to check the component on neighbor samples that point towards us
        float offset_x0 = GeometryBuffer.Sample(Point, In.TexCoord, int2(-1,  0)).x;
        float offset_x1 = GeometryBuffer.Sample(Point, In.TexCoord, int2( 1,  0)).x;
        float offset_y0 = GeometryBuffer.Sample(Point, In.TexCoord, int2( 0, -1)).y;
        float offset_y1 = GeometryBuffer.Sample(Point, In.TexCoord, int2( 0,  1)).y;

        // Check range of neighbor pixels' distance and use if edge cuts this pixel.
        if (abs(offset_x0 - 0.75f) < 0.25f)
        {
            edge_found = true;
            offset = float2(offset_x0 - 1.0f, 0.5f); // Left  x-offset [ 0.5 ..  1.0] cuts this pixel
        }
        if (abs(offset_x1 + 0.75f) < 0.25f)
        {
            edge_found = true;
            offset = float2(offset_x1 + 1.0f, 0.5f); // Right x-offset [-1.0 .. -0.5] cuts this pixel
        }
        if (abs(offset_y0 - 0.75f) < 0.25f)
        {
            edge_found = true;
            offset = float2(0.5f, offset_y0 - 1.0f); // Up    y-offset [ 0.5 ..  1.0] cuts this pixel
        }
        if (abs(offset_y1 + 0.75f) < 0.25f)
        {
            edge_found = true;
            offset = float2(0.5f, offset_y1 + 1.0f); // Down  y-offset [-1.0 .. -0.5] cuts this pixel
        }
    }
    else
    {
        edge_found = true;
        if (Tweak)
        {
            float inv_offset = InvGeometryBuffer.Sample(Point, In.TexCoord);
            if (inv_offset != 0.0f)
            {
                triple_coverage = true;
                
                // Sample two neighbors
                float maj_offset;
                float2 off = 0;
                if (abs(offset.x) < abs(offset.y))
                {
                    off.x = -sign(inv_offset);
                    maj_offset = offset.x;
                }
                else
                {
                    off.y = -sign(inv_offset);
                    maj_offset = offset.y;
                }                
                float4 n1 = BackBuffer.Sample(Point, In.TexCoord + off*PixelSize);
                float4 n2 = BackBuffer.Sample(Point, In.TexCoord - off*PixelSize);
                
                // Calculate coverage for this sample (b) and two neighbors (a, c)
                float alpha = 0.5f-abs(maj_offset); // a (n1)
                float gamma = 0.5f-abs(inv_offset); // c (n2)
                float beta = 1-alpha-gamma; // b (this)

                // Blend final color
                result = alpha*n1 + beta*BackBuffer.Sample(Point, In.TexCoord) + gamma*n2;
            }
            else
                check_opposite_neighbor(In.TexCoord, offset);
        }
    }
    if (ShowEdges && edge_found)
        result = float4(1, 0, 0, 1);
    else if (!triple_coverage)
    {
        // Convert distance to texture coordinate shift
        float2 off = (offset >= float2(0, 0))? float2(0.5f, 0.5f) : float2(-0.5f, -0.5f);
        offset = off - offset;
        // Blend pixel with neighbor pixel using texture filtering and shifting the coordinate appropriately.
        result = BackBuffer.Sample(Linear, In.TexCoord + offset * PixelSize);
    }
    return result;
}