stb_truetype SDF Texture attlas rendering issues

[cNori]

provided SDF function for generaction seems to be flipped upside down
glyphs seems to not be allined (idk how to solve it),
has wirde indexing for a pixels,
so i coppyed the implemntacion and edited it

now im kinda stuck idk why the . is rendered at the top insted of the bottom
render output

code

Font Content::Import::Font(const String& InFilePath, byte InQuality)
{
    auto fp = String::Format("[0]\\[1].ttf", Application::GetDataPath(), InFilePath);
    auto block = FileSystem::ReadFile(fp);

    ::Font f;
    stbtt_fontinfo info;

    if (!stbtt_InitFont(&info, block, 0))
    {
        Logger::Warning(String::Format("failed to import font [0]", InFilePath));
        return f;
    }
    int ascent, descent, lineGap;
    stbtt_GetFontVMetrics(&info, &ascent, &descent, &lineGap);

    uint64 glyphsSize = 16ull * InQuality;
    f.ImportFontSize = glyphsSize;

    auto scale = stbtt_ScaleForPixelHeight(&info, glyphsSize);
    float cascent = ascent * scale;
    auto ch = 0;
    struct Map
    {
        int ID;
        int Unicode;
        Map() = default;
        Map(int id, int unicode) : ID(id), Unicode(unicode)
        {}
    };

    Array<Map> Glyphs;
    Glyphs.Add(Map(0, 0));
    for (size_t i = 0; i < info.numGlyphs; i++)
    {
        auto id = stbtt_FindGlyphIndex(&info, i);
        if (id == 0)
        {
            continue;
        }
        else
        {
            Glyphs.Add(Map(id, i));
        }
    }
    uint64 r = 0;
    while ((r * r) < Glyphs.GetLength())
    {
        r++;
    }
    uint64 TextureSize = (r * glyphsSize);
    f.Atlas = ::Texture(TextureSize, TextureSize, Texture::Format::Grayscale,Texture::Filter::Bilinear);

    uint64 ofx = 0;
    uint64 ofy = 0;
    uint64 charsperrow = TextureSize / glyphsSize;

    for (size_t i = 0; i < Glyphs.GetLength(); i++)
    {
        FontGlyph glyph;
        glyph.Unicode = Glyphs[i].Unicode;
        Rect r;
        int xoff = 0;
        int yoff = 0;
        int w = 0;
        int h = 0;
        int advance = 0;
        int leftSideBearing = 0;
        uint64 ox = ofx * glyphsSize;
        uint64 oy = ofy * glyphsSize;
        RasterizeGlyphSDF(f.Atlas, glyphsSize, ox, oy,&info, scale, Glyphs[i].ID, InQuality, r);
        r.Location.X = ox;
        r.Location.Y = oy;
        r.Size.Y = glyphsSize;
        //r.Size.X = glyphsSize;
        stbtt_GetCodepointHMetrics(&info, ch, &advance, &leftSideBearing);

        glyph.AdvanceWidth = advance * scale;
        glyph.LeftSideBearing = leftSideBearing * scale;
        FontAddGlyph(f, r, glyph);

        ofx++;
        if (ofx == charsperrow)
        {
            ofx = 0;
            ofy++;
            if ((ofy + 1) * glyphsSize > TextureSize)
                break;
        }
    }
    return f;
}`

modyfaied SDF funcion for generating a Glyph

    void RasterizeGlyphSDF(Texture& RefTexture, uint64 size, uint64 ox, uint64 oy ,const stbtt_fontinfo* info, float scale, int glyph, int padding,Rect& bounds)
    {
        float scale_x = scale, scale_y = scale;
        int ix0, iy0, ix1, iy1;
        if (scale == 0) return;

        stbtt_GetGlyphBitmapBoxSubpixel(info, glyph, scale, scale, 0.0f, 0.0f, &ix0, &iy0, &ix1, &iy1);

        // if empty, return NULL
        if (ix0 == ix1 || iy0 == iy1)
            return;

        auto p = padding;
        auto kx0 = ix0 - p;
        auto ky0 = iy0 - p;
        auto kx1 = ix1 + p + p;
        auto ky1 = iy1 + p + p;

        bounds.SetMin(ix0, iy0);
        bounds.SetMax(ix1 + padding, iy1 + padding);

        // invert for y-downwards bitmaps
        scale_y = -scale_y;

        {
            // distance from singular values (in the same units as the pixel grid)
            const float eps = 1. / 1024, eps2 = eps * eps;
            int x, y, i, j;
            float* precompute;
            stbtt_vertex* verts;
            int num_verts = stbtt_GetGlyphShape(info, glyph, &verts);
            precompute = (float*)STBTT_malloc(num_verts * sizeof(float), info->userdata);

            for (i = 0, j = num_verts - 1; i < num_verts; j = i++) {
                if (verts[i].type == STBTT_vline) {
                    float x0 = verts[i].x * scale_x, y0 = verts[i].y * scale_y;
                    float x1 = verts[j].x * scale_x, y1 = verts[j].y * scale_y;
                    float dist = (float)STBTT_sqrt((x1 - x0) * (x1 - x0) + (y1 - y0) * (y1 - y0));
                    precompute[i] = (dist < eps) ? 0.0f : 1.0f / dist;
                }
                else if (verts[i].type == STBTT_vcurve) {
                    float x2 = verts[j].x * scale_x, y2 = verts[j].y * scale_y;
                    float x1 = verts[i].cx * scale_x, y1 = verts[i].cy * scale_y;
                    float x0 = verts[i].x * scale_x, y0 = verts[i].y * scale_y;
                    float bx = x0 - 2 * x1 + x2, by = y0 - 2 * y1 + y2;
                    float len2 = bx * bx + by * by;
                    if (len2 >= eps2)
                        precompute[i] = 1.0f / len2;
                    else
                        precompute[i] = 0.0f;
                }
                else
                    precompute[i] = 0.0f;
            }

            for (y = ky0; y < ky1; ++y) {
                for (x = kx0; x < kx1; ++x) {
                    float val = 0;
                    float min_dist = 999999.0f;
                    float sx = (float)x + 0.5f - p;
                    float sy = (float)y + 0.5f - p;
                    float x_gspace = (sx / scale_x);
                    float y_gspace = (sy / scale_y);

                    int winding = stbtt__compute_crossings_x(x_gspace, y_gspace, num_verts, verts); // @OPTIMIZE: this could just be a rasterization, but needs to be line vs. non-tesselated curves so a new path

                    for (i = 0; i < num_verts; ++i) {
                        float x0 = verts[i].x * scale_x, y0 = verts[i].y * scale_y;

                        if (verts[i].type == STBTT_vline && precompute[i] != 0.0f) {
                            float x1 = verts[i - 1].x * scale_x, y1 = verts[i - 1].y * scale_y;

                            float dist, dist2 = (x0 - sx) * (x0 - sx) + (y0 - sy) * (y0 - sy);
                            if (dist2 < min_dist * min_dist)
                                min_dist = (float)STBTT_sqrt(dist2);

                            // coarse culling against bbox
                            //if (sx > STBTT_min(x0,x1)-min_dist && sx < STBTT_max(x0,x1)+min_dist &&
                            //    sy > STBTT_min(y0,y1)-min_dist && sy < STBTT_max(y0,y1)+min_dist)
                            dist = (float)STBTT_fabs((x1 - x0) * (y0 - sy) - (y1 - y0) * (x0 - sx)) * precompute[i];
                            STBTT_assert(i != 0);
                            if (dist < min_dist) {
                                // check position along line
                                // x' = x0 + t*(x1-x0), y' = y0 + t*(y1-y0)
                                // minimize (x'-sx)*(x'-sx)+(y'-sy)*(y'-sy)
                                float dx = x1 - x0, dy = y1 - y0;
                                float px = x0 - sx, py = y0 - sy;
                                // minimize (px+t*dx)^2 + (py+t*dy)^2 = px*px + 2*px*dx*t + t^2*dx*dx + py*py + 2*py*dy*t + t^2*dy*dy
                                // derivative: 2*px*dx + 2*py*dy + (2*dx*dx+2*dy*dy)*t, set to 0 and solve
                                float t = -(px * dx + py * dy) / (dx * dx + dy * dy);
                                if (t >= 0.0f && t <= 1.0f)
                                    min_dist = dist;
                            }
                        }
                        else if (verts[i].type == STBTT_vcurve) {
                            float x2 = verts[i - 1].x * scale_x, y2 = verts[i - 1].y * scale_y;
                            float x1 = verts[i].cx * scale_x, y1 = verts[i].cy * scale_y;
                            float box_x0 = STBTT_min(STBTT_min(x0, x1), x2);
                            float box_y0 = STBTT_min(STBTT_min(y0, y1), y2);
                            float box_x1 = STBTT_max(STBTT_max(x0, x1), x2);
                            float box_y1 = STBTT_max(STBTT_max(y0, y1), y2);
                            // coarse culling against bbox to avoid computing cubic unnecessarily
                            if (sx > box_x0 - min_dist && sx < box_x1 + min_dist && sy > box_y0 - min_dist && sy < box_y1 + min_dist) {
                                int num = 0;
                                float ax = x1 - x0, ay = y1 - y0;
                                float bx = x0 - 2 * x1 + x2, by = y0 - 2 * y1 + y2;
                                float mx = x0 - sx, my = y0 - sy;
                                float res[3] = { 0.f,0.f,0.f };
                                float px, py, t, it, dist2;
                                float a_inv = precompute[i];
                                if (a_inv == 0.0) { // if a_inv is 0, it's 2nd degree so use quadratic formula
                                    float a = 3 * (ax * bx + ay * by);
                                    float b = 2 * (ax * ax + ay * ay) + (mx * bx + my * by);
                                    float c = mx * ax + my * ay;
                                    if (STBTT_fabs(a) < eps2) { // if a is 0, it's linear
                                        if (STBTT_fabs(b) >= eps2) {
                                            res[num++] = -c / b;
                                        }
                                    }
                                    else {
                                        float discriminant = b * b - 4 * a * c;
                                        if (discriminant < 0)
                                            num = 0;
                                        else {
                                            float root = (float)STBTT_sqrt(discriminant);
                                            res[0] = (-b - root) / (2 * a);
                                            res[1] = (-b + root) / (2 * a);
                                            num = 2; // don't bother distinguishing 1-solution case, as code below will still work
                                        }
                                    }
                                }
                                else {
                                    float b = 3 * (ax * bx + ay * by) * a_inv; // could precompute this as it doesn't depend on sample point
                                    float c = (2 * (ax * ax + ay * ay) + (mx * bx + my * by)) * a_inv;
                                    float d = (mx * ax + my * ay) * a_inv;
                                    num = stbtt__solve_cubic(b, c, d, res);
                                }
                                dist2 = (x0 - sx) * (x0 - sx) + (y0 - sy) * (y0 - sy);
                                if (dist2 < min_dist * min_dist)
                                    min_dist = (float)STBTT_sqrt(dist2);

                                if (num >= 1 && res[0] >= 0.0f && res[0] <= 1.0f) {
                                    t = res[0], it = 1.0f - t;
                                    px = it * it * x0 + 2 * t * it * x1 + t * t * x2;
                                    py = it * it * y0 + 2 * t * it * y1 + t * t * y2;
                                    dist2 = (px - sx) * (px - sx) + (py - sy) * (py - sy);
                                    if (dist2 < min_dist * min_dist)
                                        min_dist = (float)STBTT_sqrt(dist2);
                                }
                                if (num >= 2 && res[1] >= 0.0f && res[1] <= 1.0f) {
                                    t = res[1], it = 1.0f - t;
                                    px = it * it * x0 + 2 * t * it * x1 + t * t * x2;
                                    py = it * it * y0 + 2 * t * it * y1 + t * t * y2;
                                    dist2 = (px - sx) * (px - sx) + (py - sy) * (py - sy);
                                    if (dist2 < min_dist * min_dist)
                                        min_dist = (float)STBTT_sqrt(dist2);
                                }
                                if (num >= 3 && res[2] >= 0.0f && res[2] <= 1.0f) {
                                    t = res[2], it = 1.0f - t;
                                    px = it * it * x0 + 2 * t * it * x1 + t * t * x2;
                                    py = it * it * y0 + 2 * t * it * y1 + t * t * y2;
                                    dist2 = (px - sx) * (px - sx) + (py - sy) * (py - sy);
                                    if (dist2 < min_dist * min_dist)
                                        min_dist = (float)STBTT_sqrt(dist2);
                                }
                            }
                        }
                    }

                    val = min_dist / p;
                    if (winding == 0)
                    {
                        val = 0.5 - val;
                    }
                    else
                    {
                        val += 0.5;
                    }
                    val = Math::Saturate(val);
                    RefTexture.SetPixel(
                        (ox + (static_cast<unsigned long long>(x) - ix0)),
                        RefTexture.GetHeight() - (oy + (static_cast<unsigned long long>(y) - iy0)),
                        val);
                }
            }
            STBTT_free(precompute, info->userdata);
            STBTT_free(verts, info->userdata);
        }
    }
    ```

[nothings]

Nothing is upside down or wrong.

https://github.com/nothings/stb/blob/master/stb_truetype.h#L161

[nothings]

I don't understand your problem. Have you never worked with computer graphics before? The definition of what direction coordinate axes extend in is arbitrary. Some systems use cartesian coordinates where positive Y is up. Some systems use "classical graphics" coordinates where positive Y is down.

Glyph bitmaps are just defined in some coordinate space, and it's up to you to map that source coordinate space to the display coordinate space, the same as anything. stb_truetype doesn't display glyphs so there's no default mapping between spaces that is wrong. There is just the glyph bitmap coordinate space. There are many possible systems you could display on, and some of them use positive Y up, some use positive Y down. It's not possible for stb_truetype glyphs to be "correct" because there is no correct, since there is no single universal convention.

[nothings]

also some glyphs are offsets in a way where the Y offset is just lost i tried some stuff but i cant get the Y offset on the render to be in correct spot i used the baseline but some glyphs are not aligned on Y still

Are you applying the *yoff return value?

[nothings]

I see that in your version of the function, it seems like you removed the *xoff and *yoff functionality. If you're going to go changing the code so it can't possibly work anymore because you don't understand it, there's really no reason for me to help you. Good luck.

[cNori]

ok i figred out why i cant get Glyphs to render in correct spot there are fliped araund the "center" of a glyph
not araund the orgin (ascent - descent)
(render from my slow rasterizer with is doing it the correct fliping and offseting)

[cNori]

also some glyphs are offsets in a way where the Y offset is just lost i tried some stuff but i cant get the Y offset on the render to be in correct spot i used the baseline but some glyphs are not aligned on Y still

Are you applying the *yoff return value?

yes i was using it
to get the AABB displaying
but the Y/X value on some glyphs is just off
i did not get it working at the end the AABB seems to be off