Slug Font Rendering

#include "slug.hlsl"#include "curve.hlsl"

// Line segment: p0, p1// Quadratic Bézier: p0, p1 (control), p2
struct CurveRecord{    float2 p0;   // Start point    float2 p1;   // Control point (or end point for lines)    float2 p2;   // End point (unused for lines — flagged via type)    // Type/flags encoded separately or in padding};

// Inputs from vertex shaderstruct PS_Input{    float4 position  : SV_Position;    float2 glyphCoord : TEXCOORD0;  // Position in glyph/font units    // Band index or precomputed band data    nointerpolation uint bandOffset : TEXCOORD1;    nointerpolation uint curveCount : TEXCOORD2;};
// Glyph curve data bufferStructuredBuffer<float4> CurveBuffer : register(t0);
float4 PS_Slug(PS_Input input) : SV_Target{    float coverage = ComputeGlyphCoverage(        input.glyphCoord,        CurveBuffer,        input.bandOffset,        input.curveCount    );
    // Premultiplied alpha output    float4 color = float4(textColor.rgb * coverage, coverage);    return color;}

// Evaluate whether a quadratic bezier contributes to coverage at point p// p0: start, p1: control, p2: end// Returns signed coverage contributionfloat QuadraticBezierCoverage(float2 p, float2 p0, float2 p1, float2 p2){    // Transform to canonical space    float2 a = p1 - p0;    float2 b = p0 - 2.0 * p1 + p2;
    // Find t values where bezier Y == p.y    float2 delta = p - p0;        float A = b.y;    float B = a.y;    float C = p0.y - p.y;
    float coverage = 0.0;
    if (abs(A) > 1e-6)    {        float disc = B * B - A * C;        if (disc >= 0.0)        {            float sqrtDisc = sqrt(disc);            float t0 = (-B - sqrtDisc) / A;            float t1 = (-B + sqrtDisc) / A;
            // For each valid t in [0,1], compute x and check winding            if (t0 >= 0.0 && t0 <= 1.0)            {                float x = (A * t0 + 2.0 * B) * t0 + p0.x + delta.x;                // ... accumulate signed coverage            }            if (t1 >= 0.0 && t1 <= 1.0)            {                float x = (A * t1 + 2.0 * B) * t1 + p0.x + delta.x;                // ... accumulate signed coverage            }        }    }    else    {        // Degenerate to linear case        float t = -C / (2.0 * B);        if (t >= 0.0 && t <= 1.0)        {            float x = 2.0 * a.x * t + p0.x;            // ... accumulate signed coverage        }    }
    return coverage;}

// Signed coverage contribution of a line segment from p0 to p1float LineCoverage(float2 p, float2 p0, float2 p1){    // Check Y range    float minY = min(p0.y, p1.y);    float maxY = max(p0.y, p1.y);
    if (p.y < minY || p.y >= maxY)        return 0.0;
    // Interpolate X at p.y    float t = (p.y - p0.y) / (p1.y - p0.y);    float x = lerp(p0.x, p1.x, t);
    // Winding: +1 if p is to the left (inside), -1 if right    float dir = (p1.y > p0.y) ? 1.0 : -1.0;    return (p.x <= x) ? dir : 0.0;}

// Compute AA coverage using partial pixel coverage// windingNumber: integer winding from coverage pass// distToEdge: signed distance to nearest curve (in pixels)float AntiAliasedCoverage(int windingNumber, float distToEdge){    // Non-zero winding rule    bool inside = (windingNumber != 0);        // Smooth transition at edges using clamp    float edgeCoverage = clamp(distToEdge + 0.5, 0.0, 1.0);        return inside ? edgeCoverage : (1.0 - edgeCoverage);}

struct VS_Input{    float2 position   : POSITION;     // Glyph quad corner in screen/world space    float2 glyphCoord : TEXCOORD0;    // Corresponding glyph-space coordinate    uint   bandOffset : TEXCOORD1;    // Offset into curve buffer for this glyph    uint   curveCount : TEXCOORD2;    // Number of curves in band};
struct VS_Output{    float4 position   : SV_Position;    float2 glyphCoord : TEXCOORD0;    nointerpolation uint bandOffset : TEXCOORD1;    nointerpolation uint curveCount : TEXCOORD2;};
VS_Output VS_Slug(VS_Input input){    VS_Output output;    output.position   = mul(float4(input.position, 0.0, 1.0), WorldViewProjection);    output.glyphCoord = input.glyphCoord;    output.bandOffset = input.bandOffset;    output.curveCount = input.curveCount;    return output;}

// Blend state: premultiplied alphaBlendState SlugBlend{    BlendEnable    = TRUE;    SrcBlend       = ONE;           // Premultiplied    DestBlend      = INV_SRC_ALPHA;    BlendOp        = ADD;    SrcBlendAlpha  = ONE;    DestBlendAlpha = INV_SRC_ALPHA;    BlendOpAlpha   = ADD;};
// Depth: typically write disabled for text overlayDepthStencilState SlugDepth{    DepthEnable    = FALSE;    DepthWriteMask = ZERO;};
// Rasterizer: no backface culling (glyph quads are 2D)RasterizerState SlugRaster{    CullMode = NONE;    FillMode = SOLID;};