SDL3: When Font is NULL, use `SDL_RenderDebugText()`

[RobLoach]

Allow using SDL3 renderer without a loaded font? Use SDL_RenderDebugText

[sleeptightAnsiC]

I'm not entirely sure what "when Font is NULL" exactly means here, like passing NULL as nk_user_font to nk_init? I guess it is possible. Implementing this depends on your drawing loop and how it handles the fonts. demo/sdl3_renderer already partially supports something similar with nk_sdl_style_set_debug_font(). You can enable it by flipping #if 0 on this line

There are basically two ways:

Option 1: If you're using the vertex API (aka NK_INCLUDE_VERTEX_BUFFER_OUTPUT, nk_convert, nk_draw_foreach, etc...) take a look here:

Nuklear/demo/sdl3_renderer/nuklear_sdl3_renderer.h

Lines 596 to 716 in 0dbc52f

	/* Debug Font Width/Height of internal texture atlas
	* This is a result of: ceil(sqrt('~' - ' '))
	* There is a sanity check for this value in nk_sdl_style_set_debug_font */
	#define NK_SDL_DFWH (10)
	NK_INTERN float
	nk_sdl_query_debug_font_width(nk_handle handle, float height,
	const char *text, int len)
	{
	NK_UNUSED(handle);
	return nk_utf_len(text, len) * height;
	}
	NK_INTERN void
	nk_sdl_query_debug_font_glypth(nk_handle handle, float height,
	struct nk_user_font_glyph *glyph,
	nk_rune codepoint, nk_rune next_codepoint)
	{
	char ascii;
	int idx, x, y;
	NK_UNUSED(next_codepoint);
	NK_UNUSED(handle);
	/* replace non-ASCII characters with question mark */
	ascii = (codepoint < (nk_rune)' ' || codepoint > (nk_rune)'~')
	? '?' : (char)codepoint;
	NK_ASSERT(ascii >= ' ' && ascii <= '~');
	idx = (int)(ascii - ' ');
	x = idx / NK_SDL_DFWH;
	y = idx % NK_SDL_DFWH;
	NK_ASSERT(x >= 0 && x < NK_SDL_DFWH);
	NK_ASSERT(y >= 0 && y < NK_SDL_DFWH);
	glyph->height = height;
	glyph->width = height;
	glyph->xadvance = height;
	glyph->uv[0].x = (float)(x + 0) / NK_SDL_DFWH;
	glyph->uv[0].y = (float)(y + 0) / NK_SDL_DFWH;
	glyph->uv[1].x = (float)(x + 1) / NK_SDL_DFWH;
	glyph->uv[1].y = (float)(y + 1) / NK_SDL_DFWH;
	glyph->offset.x = 0.0f;
	glyph->offset.y = 0.0f;
	}
	NK_API void
	nk_sdl_style_set_debug_font(struct nk_context* ctx)
	{
	struct nk_user_font* font;
	struct nk_sdl* sdl;
	SDL_Surface *surface;
	SDL_Renderer *renderer;
	char buf[2];
	int x, y;
	bool success;
	NK_ASSERT(ctx);
	sdl = (struct nk_sdl*)ctx->userdata.ptr;
	NK_ASSERT(sdl);
	if (sdl->debug_font) {
	sdl->allocator.free(sdl->allocator.userdata, sdl->debug_font);
	sdl->debug_font = 0;
	}
	/* sanity check: formal proof of NK_SDL_DFWH value (which is 10) */
	NK_ASSERT(SDL_ceil(SDL_sqrt('~' - ' ')) == NK_SDL_DFWH);
	/* We use another Software Renderer just to make sure
	* that we won't mutate any state in the main Renderer. */
	surface = SDL_CreateSurface(
	NK_SDL_DFWH * SDL_DEBUG_TEXT_FONT_CHARACTER_SIZE,
	NK_SDL_DFWH * SDL_DEBUG_TEXT_FONT_CHARACTER_SIZE,
	SDL_PIXELFORMAT_RGBA32);
	NK_ASSERT(surface);
	renderer = SDL_CreateSoftwareRenderer(surface);
	NK_ASSERT(renderer);
	success = SDL_SetRenderDrawColor(renderer, 0xFF, 0xFF, 0xFF, 0xFF);
	NK_ASSERT(success);
	/* SPACE is the first printable ASCII character */
	NK_MEMCPY(buf, " ", sizeof(buf));
	for (x = 0; x < NK_SDL_DFWH; x++)
	{
	for (y = 0; y < NK_SDL_DFWH; y++)
	{
	success = SDL_RenderDebugText(
	renderer,
	(float)(x * SDL_DEBUG_TEXT_FONT_CHARACTER_SIZE),
	(float)(y * SDL_DEBUG_TEXT_FONT_CHARACTER_SIZE),
	buf);
	NK_ASSERT(success);
	buf[0]++;
	/* TILDE is the last printable ASCII character */
	if (buf[0] > '~')
	break;
	}
	}
	success = SDL_RenderPresent(renderer);
	NK_ASSERT(success);
	font = (struct nk_user_font*)sdl->allocator.alloc(sdl->allocator.userdata, 0, sizeof(*font));
	NK_ASSERT(font);
	font->userdata.ptr = sdl;
	font->height = SDL_DEBUG_TEXT_FONT_CHARACTER_SIZE;
	font->width = &nk_sdl_query_debug_font_width;
	font->query = &nk_sdl_query_debug_font_glypth;
	/* HACK: nk_sdl_device_upload_atlas turns pixels into SDL_Texture
	* and sets said Texture into sdl->ogl.font_tex
	* then nk_sdl_render expects same Texture at font->texture */
	nk_sdl_device_upload_atlas(ctx, surface->pixels, surface->w, surface->h);
	font->texture.ptr = sdl->ogl.font_tex;
	sdl->debug_font = font;
	nk_style_set_font(ctx, font);
	SDL_DestroyRenderer(renderer);
	SDL_DestroySurface(surface);
	}

^ this code renders the glyphs to the texture and treats it like font atlas with hardcoded values. I don't believe there is a any better way to achieve it in this specific case.

Option 2: If you're using high level drawing commands (aka nk_command, nk_foreach, nk_command_text, etc...) then you can even call SDL_RenderDebugText directly. You just need to reuse nk_sdl_query_debug_font_width from above, and use something like this:

case NK_COMMAND_TEXT: {
    const struct nk_command_text *c = (const struct nk_command_text*)cmd;
    SDL_SetRenderDrawColor(your_renderer,
                           c->foreground.r,
                           c->foreground.g,
                           c->foreground.b,
                           c->foreground.a);
    SDL_RenderDebugText(your_renderer,
                        (float)c->x,
                        (float)c->y,
                        c->string);
} break;

^ IIRC, this ignores some nk_command_text fields and may not handle foreground.a correctly (you may need to turn on blending, don't really remember all the details now)

[sleeptightAnsiC]

You can enable it by flipping #if 0 on this line

this is how it looks like with demo/sdl3_renderer:

CLICK ME

and this is how it looks like in my personal project:

CLICK ME

(my version uses shadow behind glyphs for better readability)

[sleeptightAnsiC]

I remember there were few bugs in the library that were making Option 2 (and all custom font handling in general) pain to deal with. Maybe I'll enter some Issues later.

[RobLoach]

Oh, that nk_sdl_style_set_debug_font() is nice. Didn't see that one before 👍

[sleeptightAnsiC]

@RobLoach

Out of curiosity, does nk_sdl_style_set_debug_font() work well for your use case? I wrote that function back when I wasn't aware of all Nuklear caveats, and I'm not so proud of how it does few things.

I have a better version in my personal project but I'm hesitant to upstream it, because (a) I've never seen anyone being interested in that function before, and (b) there are some bugs/problems in Nuklear which become obvious when using it.

[RobLoach]

It would be handy for cases where you don't have a font, and don't wanna bake the Nuklear one because your kitchen is on fire.

In my case, it was for a small demo application, and I didn't wanna eat the memory on a font when SDL already provided one.

Feel free to push up any clean up, I'd be happy to take a look.