stb VS basis_universal

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.

The author of the OP also develops Basis, which is designed to take advantage of GPU texture compression formats. GPU formats have a fixed bitrate which makes them efficient to sample but not the most efficient to transmit, so Basis layers on a second level of compression that unpacks into a GPU texture.

https://github.com/BinomialLLC/basis_universal

You might find https://github.com/BinomialLLC/basis_universal interesting :)

Erm, aren't both WebP and PNG rather useless for games? How do you convert those formats into one of the hardware-compressed texture formats consumed by the GPU (like BCx, ETC or ASTC)? Without those you're wasting a ton of GPU memory bandwidth when sampling textures.

(there are some alternatives, like https://github.com/BinomialLLC/basis_universal, or http://www.radgametools.com/oodletexture.htm)

In addition to this, texture compression is optimized for random access and has to use a fixed amount of bytes per each block, but there is a possibility to further compress this during the delivery. This is called the supercompression and Basis Universal is a good example of this. JPEG XL is also based on tiles for parallel decoding, but those tiles are too large (128x128 minimum, compare with 12x12 maximum of ASTC) so it is not yet suitable for GPU as it stands.

Im interested to see what image format specific compressors go gpu. JpegXL, AVIF, WebP... who wants to show up & throw down? Or even just fastpng?

Meanwhile we dont really hear or regard many of the gpu-oriented compression techs. TIL Basis/KTX2 is itself zstd compressed (formerly LZ apparently?). https://github.com/BinomialLLC/basis_universal

You could check out Binomial's basis_universal. After Google bought them, they open sourced it and allowed use for free.

Another alternative you should consider is https://github.com/BinomialLLC/basis_universal

Simple, open-source, standardized and supports every GPU-oriented format around. And, built-in library support for https://github.com/BinomialLLC/basis_universal

Yep. That lib is great. And, similarly https://github.com/nfrechette/acl and https://github.com/BinomialLLC/basis_universal