nanovg VS stb

I use nanovg for my projects and it works surprisingly well for its size. It integration is pretty simple .... if you know a little bit of OpenGL, otherwise there is a slight learning curve.

The "engine" is built on top of amazing https://www.lwjgl.org/ and https://github.com/bkaradzic/bgfx/, and UI system is baked by https://github.com/memononen/nanovg and https://github.com/facebook/yoga

It's a library for drawing vector shapes, sort of like SVG - https://github.com/memononen/nanovg The old way in the SDK was with GDI+, but the benefit of a vector format is scalability to higher resolutions and better GPU usage. The workaround potentially costs some frames, but its better than bust panels for now.

If you are a beginner in computer graphics, I strongly suggest you to look at the nanovg library: it contains all the primitives you might want to render (circles, lines, filled polygons, text, images, ...). Integrating it in existing codebase is not that hard, since the library is rather small.

NanoVG is the closest thing I came across when I had a similar quesiton: https://github.com/memononen/NanoVG

unfortunately it doesn't seem like it's getting steady updates now unlike the last time I checked. But I imagine it's pretty mature at this point. There also seem to be ports in Metal/DX11 if you didn't want to be stuck in OpenGL.

Also there's NanoVG if you really want a vector api in C, but don't need anti-aliased clipping.

Getting sufficient antialiasing quality for 2D graphics is difficult on GPUs. https://github.com/memononen/nanovg accomplishes this with GL2/GLES2 level hardware for most of the stuff one would want to render as part of a GUI. My project https://github.com/styluslabs/nanovgXC supports rendering arbitrary paths with exact coverage antialiasing, but requires GLES3.1 or GL4 level hardware for reasonable performance.

> to learn the 'nuts and bolts' of rendering

These nuts and bolts are very different between CPU and GPU. CPU-based libraries are painting pixels in bitmaps in system memory. Most GPU-based libraries are uploading indexed triangle meshes, and rendering them with weird shaders.

Worse, there're no good open source implementations of GPU-based ones. Microsoft ships an implementation as a part of OS (Direct2D) but it's not open source. Linux simply doesn't have an equivalent.

At least for initial versions, consider C interop with this https://github.com/memononen/nanovg It cuts a few corners (no cleartype for text, CPU overhead for repeated rendering of same static paths) but it's still good overall, simple, and easy to use.

> My only concern with C# is the cross compatibility

Works well on Linux, Windows and OSX, including ARM CPUs. Not sure about Android and iOS, never tested.

My largest concern with C# would be performance. Technically the language allows to code in any style, but most guides and examples are using OO-heavy one.

Have you considered not using an engine at all, in favor of libraries? There are many amazing libraries I've used for game development - all in C/C++ - that you can piece together:

* General: [stb](https://github.com/nothings/stb)

Great to see more accessible references on font internals. I have dabbled on this a bit last year and managed to have a parser and render the points of a glyph's contour (I stopped before Bezier and shape filling stuff). I still have not considered hinting, so it's nice that it's covered. What helped me was an article from the Handmade Network [1] and the source of stb_truetype [2] (also used in Dear ImGUI).

[1] https://handmade.network/forums/articles/t/7330-implementing....

[2] https://github.com/nothings/stb/blob/master/stb_truetype.h

So I read through the materials on mesh shaders and work graphs and looked at sample code. These won't really work (see below). As I implied previously, it's best to research/discuss these sort of matters with professional graphics programmers who have experience actually using the technologies under consideration.

So for the sake of future web searchers who discover this thread: there are only two proven ways to efficiently draw thousands of unique textures of different sizes with a single draw call that are actually used by experienced graphics programmers in production code as of 2023.

Proven method #1: Pack these thousands of textures into a texture atlas.

Proven method #2: Use bindless resources, which is still fairly bleeding edge, and will require fallback to atlases if targeting the PC instead of only high end console (Xbox Series S|X...).

Mesh shaders by themselves won't work: These have similar texture access limitations to the old geometry/tessellation stage they improve upon. A limited, fixed number of textures still must be bound before each draw call (say, 16 or 32 textures, not 1000s), unless bindless resources are used. So mesh shaders must be used with an atlas or with bindless resources.

Work graphs by themselves won't work: This feature is bleeding edge shader model 6.8 whereas bindless resources are SM 6.6. (Xbox Series X|S might top out at SM 6.7, I can't find an authoritative answer.) It looks like work graphs might only work well on nVidia GPUs and won't work well on Intel GPUs anytime soon (but, again, I'm not knowledgeable enough to say this authoritatively). Furthermore, this feature may have a hard dependency on using bindless to begin with. That is, I can't tell if one is allowed to execute a work graph that binds and unbinds individual texture resources. And if one could do such a thing, it would certainly be slower than using bindless. The cost of bindless is paid "up front" when the textures are uploaded.

Some programmers use Texture2DArray/GL_TEXTURE_2D_ARRAY as an alternative to atlases but two limitations are (1) the max array length (e.g. GL_MAX_ARRAY_TEXTURE_LAYERS) might only be 256 (e.g. for OpenGL 3.0), (2) all textures must be the same size.

Finally, for the sake of any web searcher who lands on this thread in the years to come, to pack an atlas well a good packing algorithm is needed. It's harder to pack triangles than rectangles but triangles use atlas memory more efficiently and a good triangle packing will outperform the fancy new bindless rendering. Some open source starting points for packing:

https://github.com/nothings/stb/blob/master/stb_rect_pack.h

https://github.com/ands/trianglepacker

The STB headers are mostly built like that: https://github.com/nothings/stb

You could also add an optional 'convenience API' over the lower-level flexible-but-inconvenient core API, as long as core library can be compiled on its own.

In essence it's just a way to decouple the actually important library code from runtime environment details which might be better implemented outside the C/C++ stdlib.

It's already as simple as the stdlib IO functions not being asynchrononous while many operating systems provide more modern alternatives. For a specific type of library (such an image decoder) it's often better to delegate such details to the library user instead of circumventing the stdlib and talking directly to OS APIs.

My stuff for instance:

https://github.com/floooh/sokol

...inspired by:

https://github.com/nothings/stb

But it's not so much about the build system, but requiring a separate C/C++ compiler toolchain (Rust needs this, Zig currently does not - unless the proposal is implemented).

STB Libraries: https://github.com/nothings/stb

stb_ds is also very popular.