RoundedRectangle.hlsl

matrix orthoProjMatrix;
float4 elemSize;
float4 strokeWidth;
float4 rectParams;

struct VertexShaderInput
{
    float3 position : POSITION0;
    float4 color : COLOR0;
    float2 texCoord : TEXCOORD0;
};

struct PixelShaderInput
{
    float4 position : POSITION0;
    float2 texCoord : TEXCOORD0;
    float4 color : TEXCOORD1;
};

void VertexMain(in VertexShaderInput vsInput, out PixelShaderInput output)
{
    output = (PixelShaderInput)0;

    output.position = mul(float4(vsInput.position, 1), orthoProjMatrix);
    output.texCoord = vsInput.texCoord;
    output.color = vsInput.color;
}

float getEllipseRadius(float x, float y)
{
    float phi = atan2(y, x);
    float a2 = rectParams.x * rectParams.x;
    float b2 = rectParams.y * rectParams.y;
    float ab = rectParams.x * rectParams.y;
    float sin2 = sin(phi) * sin(phi);
    float cos2 = cos(phi) * cos(phi);

    return (ab) / sqrt(a2 * sin2 + b2 * cos2);
}

float4 sinusInterpolate(float4 src, float4 dest, float pct)
{
    float sinval = sin(pct * 3.1415926 / 2.0f);
    return sinval * src + (1 - sinval) * dest;
}

// Returns:
// 0 -> top left
// 1 -> bottom left
// 2 -> top right
// 3 -> bottom right
// -2 -> "anti alias area"
// -1 -> inside the solid area
int getBorderQuad(float2 pos)
{
    if(pos.x <= rectParams.x + 3 && pos.y <= rectParams.y + 3)
        return 0;
    else if(pos.x <= rectParams.x + 3 && (elemSize.y - pos.y) < rectParams.y + 3)
        return 1;
    else if((elemSize.x - pos.x) < rectParams.x + 3 && pos.y < rectParams.y + 3)
        return 2;
    else if((elemSize.x - pos.x) < rectParams.x + 3 && (elemSize.y - pos.y) < rectParams.y + 3)
        return 3;

    if(pos.x < 3 || pos.y < 3 || (elemSize.x - pos.x) < 3 || (elemSize.y - pos.y) < 3)
        return -2;

    return -1;
}

float4 getColorFill(float4 color, float2 pos, bool fill)
{
    int quad = getBorderQuad(pos);

    if(quad == -2)
    {
        float pct = 0.0f;
        if(pos.x < 3)
            pct = (3 - pos.x) / 3.0f;
        else if(pos.x > (elemSize.x - 3))
            pct = (pos.x - elemSize.x + 3) / 3.0f;
        else if(pos.y < 3)
            pct = (3 - pos.y) / 3.0f;
        else if(pos.y > (elemSize.y - 3))
            pct = (pos.y - elemSize.y + 3) / 3.0f;

        return sinusInterpolate(color, float4(0, 0, 0, 0), 1 - pct);
    }

    if(quad == -1)
    {
        if(fill)
            return color;

        float stroke = strokeWidth.x;
        if(pos.x - 3 < stroke)
            return color;
        else if(pos.y - 3 < stroke)
            return color;
        else if((elemSize.x - 3 - pos.x) < stroke)
            return color;
        else if((elemSize.y - 3 - pos.y) < stroke)
            return color;

        float pct = 0.0f;
        if(pos.x < 6)
            pct = (3 - pos.x + 3) / 3.0f;
        else if(pos.y < 6)
            pct = (3 - pos.y + 3) / 3.0f;
        else if((elemSize.x - pos.x) < 6)
            pct = (elemSize.x - 3 - pos.x) / 3.0f;
        else if((elemSize.y - pos.y) < 6)
            pct = (elemSize.y - 3 - pos.y) / 3.0f;

        return sinusInterpolate(color, float4(0, 0, 0, 0), 1 - pct);
    }

    float2 midPoint;
    if(quad == 0)
        midPoint = float2(rectParams.x + 3, rectParams.y + 3);
    else if(quad == 1)
        midPoint = float2(rectParams.x + 3, elemSize.y - rectParams.y - 3);
    else if(quad == 2)
        midPoint = float2(elemSize.x - rectParams.x - 3, rectParams.y + 3);
    else if(quad == 3)
        midPoint = float2(elemSize.x - rectParams.x - 3, elemSize.y - rectParams.y - 3);

    float x = pos.x - midPoint.x;
    float y = pos.y - midPoint.y;

    float radius = getEllipseRadius(x, y);
    float radiusCoord = sqrt(x * x + y * y);
    if(fill)
    {
        if(radiusCoord <= radius)
            color = color;
        else
        {
            float diff = radiusCoord - radius;
            if(diff > 2)
                color = float4(0, 0, 0, 0);
            else
                color = sinusInterpolate(color, float4(0, 0, 0, 0), 1.0f - diff / 2.0f);
        }

        return color;
    }
    else
    {
        if(radiusCoord <= radius)
        {
            if((radius - radiusCoord) <= strokeWidth.x)
                color = color;
            else
            {
                float diff = (radius - radiusCoord) - strokeWidth.x;
                if(diff > 2)
                    color = float4(0, 0, 0, 0);
                else
                    color = sinusInterpolate(color, float4(0, 0, 0, 0), 1.0f - diff / 2.0f);
            }
        }
        else
        {
            float diff = radiusCoord - radius;
            if(diff > 2)
                color = float4(0, 0, 0, 0);
            else
                color = sinusInterpolate(color, float4(0, 0, 0, 0), 1.0f - diff / 2.0f);
        }

        return color;
    }
}

void PixelMainFill(in PixelShaderInput input, out float4 color : COLOR0)
{
    float elemX = (-elemSize.x / 2.0f) + elemSize.x * input.texCoord.x;
    float elemY = (-elemSize.y / 2.0f) + elemSize.y * input.texCoord.y;

    color = getColorFill(input.color, float2(elemSize.x * input.texCoord.x, elemSize.y * input.texCoord.y), true);
}

void PixelMainDraw(in PixelShaderInput input, out float4 color : COLOR0)
{
    float elemX = (-elemSize.x / 2.0f) + elemSize.x * input.texCoord.x;
    float elemY = (-elemSize.y / 2.0f) + elemSize.y * input.texCoord.y;

    color = getColorFill(input.color, float2(elemX, elemY), false);
}