box3d/samples/gfx/world_text.c
Erin Catto 3fc20f5b45
Follow cam (#107)
- follow cam in replay viewer
- world text with halo
- fixed sensor crash
- sensor visitors must now be convex
2026-07-29 22:14:26 -07:00

523 lines
16 KiB
C

// SPDX-FileCopyrightText: 2026 Erin Catto
// SPDX-License-Identifier: MIT
#if defined( _MSC_VER ) && !defined( _CRT_SECURE_NO_WARNINGS )
#define _CRT_SECURE_NO_WARNINGS
#endif
#include "gfx/world_text.h"
#include "gfx/fonts.h"
#include "gfx/text.h"
#include "world_text.glsl.h"
#define STB_TRUETYPE_IMPLEMENTATION
#include "stb_truetype.h"
#include <math.h>
#include <sokol_app.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
// Printable ASCII. Labels are numbers, ids and short type names, so this
// range covers everything the samples emit. Anything outside draws as '?'.
#define FIRST_CHAR 32
#define CHAR_COUNT 95
// Distance range carried around each outline, in pixels. The halo fades inside
// it, so this bounds how far the fade can reach.
#define SDF_PADDING 4
#define SDF_ONEDGE 128
// One transparent column and row between packed glyphs so a bilinear tap at
// a glyph edge cannot reach its neighbour.
#define GLYPH_GAP 1
#define ATLAS_DIM 512
// 1024 labels of 32 characters, matching text.c's label cap. Overflow drops
// glyphs rather than growing.
#define MAX_GLYPHS 32768
// The swap chain (color + depth) and the color-only offscreen test target.
// Mirrors overlay.c's cache.
#define TEXT_MAX_PIPELINES 2
// Pen-relative glyph box and atlas window. The box is in pixels and whole, so a
// quad placed at a whole pixel covers its atlas cell one texel to one pixel. The
// advance stays fractional: rounding every advance instead of every origin would
// drift the whole word.
typedef struct Glyph
{
float x0, y0, x1, y1; // origin at the top left of the line box, Y down
float u0, v0, u1, v1;
float advance;
} Glyph;
static struct
{
Glyph glyphs[CHAR_COUNT];
// Built from scratch inside each submit rather than accumulated across the
// frame, so a flat array beats the arena the overlay needs.
world_text_glyph_instance_t* instances;
int glyphCount;
sg_shader shader;
sg_image atlas;
sg_view atlasView;
sg_sampler atlasSampler;
sg_buffer instBuf;
sg_view instView;
struct
{
sg_pixel_format colorFormat;
sg_pixel_format depthFormat;
sg_pipeline pipeline;
} pipelines[TEXT_MAX_PIPELINES];
int pipelineCount;
float pixelHeight;
float haloPixels;
bool ready;
} s_text;
// Rasterize printable ASCII into one RG8 atlas and fill the glyph table. R is a
// coverage bitmap, G a distance field, both from the same outlines at the same
// scale so they agree on where the edge is.
//
// The bake tracks the size labels draw at, which is what buys the glyph body its
// crispness: a coverage bitmap sampled one texel to one pixel is exactly what a
// UI font renderer puts on screen, and no distance field reproduces that at 14
// pixels because it cannot grid fit. The halo has no such constraint, so it
// keeps the field, which is smooth at any size and gives a fade for free.
//
// Packing is a shelf: glyphs from a single bake size have near-uniform heights,
// so rows waste little and this stands in for a real rect packer.
static bool BakeAtlas( void )
{
int fontSize = 0;
const unsigned char* fontData = GetFontBytes( &fontSize );
stbtt_fontinfo font;
if ( stbtt_InitFont( &font, fontData, stbtt_GetFontOffsetForIndex( fontData, 0 ) ) == 0 )
{
fprintf( stderr, "[world_text] stbtt_InitFont failed on %d embedded bytes of %s\n", fontSize, GetFontName() );
return false;
}
// ScaleForPixelHeight makes ascent-to-descent exactly the label height.
const float scale = stbtt_ScaleForPixelHeight( &font, s_text.pixelHeight );
int ascent, descent, lineGap;
stbtt_GetFontVMetrics( &font, &ascent, &descent, &lineGap );
// Whole pixels, so a glyph box stays whole and lands on the pixel grid. A
// fractional baseline would put every horizontal stroke between two rows.
const float ascentPixels = floorf( (float)ascent * scale + 0.5f );
unsigned char* atlas = (unsigned char*)calloc( (size_t)ATLAS_DIM * ATLAS_DIM * 2, 1 );
if ( atlas == NULL )
{
return false;
}
const float invDim = 1.0f / (float)ATLAS_DIM;
const float distanceScale = (float)SDF_ONEDGE / (float)SDF_PADDING;
int penX = 0;
int penY = 0;
int shelfHeight = 0;
bool ok = true;
for ( int i = 0; i < CHAR_COUNT; ++i )
{
const int codepoint = FIRST_CHAR + i;
Glyph* glyph = &s_text.glyphs[i];
memset( glyph, 0, sizeof( *glyph ) );
int advance, leftBearing;
stbtt_GetCodepointHMetrics( &font, codepoint, &advance, &leftBearing );
glyph->advance = (float)advance * scale;
int w = 0, h = 0, xoff = 0, yoff = 0;
unsigned char* sdf =
stbtt_GetCodepointSDF( &font, scale, codepoint, SDF_PADDING, SDF_ONEDGE, distanceScale, &w, &h, &xoff, &yoff );
if ( sdf == NULL )
{
// Space and friends carry an advance but no outline.
continue;
}
if ( penX + w > ATLAS_DIM )
{
penX = 0;
penY += shelfHeight;
shelfHeight = 0;
}
if ( penY + h > ATLAS_DIM )
{
fprintf( stderr, "[world_text] atlas full at codepoint %d, raise ATLAS_DIM or lower the label size\n", codepoint );
stbtt_FreeSDF( sdf, NULL );
ok = false;
break;
}
for ( int row = 0; row < h; ++row )
{
unsigned char* dst = atlas + ( (size_t)( penY + row ) * ATLAS_DIM + penX ) * 2;
const unsigned char* src = sdf + (size_t)row * w;
for ( int col = 0; col < w; ++col )
{
dst[col * 2 + 1] = src[col];
}
}
// The coverage bitmap shares the cell. stb derives both boxes from the
// same glyph box and only the field pads it, so the offsets differ by
// exactly the padding, but take it from the reported corners anyway.
int bw = 0, bh = 0, bxoff = 0, byoff = 0;
unsigned char* bitmap = stbtt_GetCodepointBitmap( &font, scale, scale, codepoint, &bw, &bh, &bxoff, &byoff );
if ( bitmap != NULL )
{
const int insetX = bxoff - xoff;
const int insetY = byoff - yoff;
for ( int row = 0; row < bh; ++row )
{
const int y = insetY + row;
if ( y < 0 || y >= h )
{
continue;
}
unsigned char* dst = atlas + ( (size_t)( penY + y ) * ATLAS_DIM + penX ) * 2;
const unsigned char* src = bitmap + (size_t)row * bw;
for ( int col = 0; col < bw; ++col )
{
const int x = insetX + col;
if ( x >= 0 && x < w )
{
dst[x * 2] = src[col];
}
}
}
stbtt_FreeBitmap( bitmap, NULL );
}
// stb reports the box against the baseline with Y down. Shift it to
// the top of the line box so an anchor lands where ImGui put it, and
// existing call sites that pad with leading spaces still read right.
glyph->x0 = (float)xoff;
glyph->y0 = (float)yoff + ascentPixels;
glyph->x1 = (float)( xoff + w );
glyph->y1 = (float)yoff + ascentPixels + (float)h;
glyph->u0 = (float)penX * invDim;
glyph->v0 = (float)penY * invDim;
glyph->u1 = (float)( penX + w ) * invDim;
glyph->v1 = (float)( penY + h ) * invDim;
penX += w + GLYPH_GAP;
if ( h + GLYPH_GAP > shelfHeight )
{
shelfHeight = h + GLYPH_GAP;
}
stbtt_FreeSDF( sdf, NULL );
}
if ( ok )
{
// A resize rebakes, so drop whatever the last size produced.
if ( s_text.atlasView.id != 0 )
{
sg_destroy_view( s_text.atlasView );
s_text.atlasView.id = 0;
}
if ( s_text.atlas.id != 0 )
{
sg_destroy_image( s_text.atlas );
s_text.atlas.id = 0;
}
sg_image_desc imgDesc = { 0 };
imgDesc.width = ATLAS_DIM;
imgDesc.height = ATLAS_DIM;
imgDesc.num_mipmaps = 1;
imgDesc.pixel_format = SG_PIXELFORMAT_RG8;
imgDesc.data.mip_levels[0].ptr = atlas;
imgDesc.data.mip_levels[0].size = (size_t)ATLAS_DIM * ATLAS_DIM * 2;
imgDesc.label = "world_text_atlas";
s_text.atlas = sg_make_image( &imgDesc );
sg_view_desc viewDesc = { 0 };
viewDesc.texture.image = s_text.atlas;
viewDesc.label = "world_text_atlas_view";
s_text.atlasView = sg_make_view( &viewDesc );
if ( s_text.atlasSampler.id == 0 )
{
// Nearest would do for the body, which is sampled one texel to one
// pixel, but the field wants filtering at the cell edges.
sg_sampler_desc sampDesc = { 0 };
sampDesc.min_filter = SG_FILTER_LINEAR;
sampDesc.mag_filter = SG_FILTER_LINEAR;
sampDesc.wrap_u = SG_WRAP_CLAMP_TO_EDGE;
sampDesc.wrap_v = SG_WRAP_CLAMP_TO_EDGE;
sampDesc.label = "world_text_atlas_sampler";
s_text.atlasSampler = sg_make_sampler( &sampDesc );
}
}
free( atlas );
return ok;
}
// Lazily create (and cache) the pipeline for one output format pair, same
// scheme and same blend state as overlay.c. Depth compare is ALWAYS with
// writes off: a label is meant to be read, so it draws over whatever the
// scene put in front of it.
static bool EnsurePipeline( sg_pixel_format colorFormat, sg_pixel_format depthFormat, sg_pipeline* outPipeline )
{
for ( int i = 0; i < s_text.pipelineCount; ++i )
{
if ( s_text.pipelines[i].colorFormat == colorFormat && s_text.pipelines[i].depthFormat == depthFormat )
{
*outPipeline = s_text.pipelines[i].pipeline;
return true;
}
}
if ( s_text.pipelineCount >= TEXT_MAX_PIPELINES )
{
fprintf( stderr, "[world_text] pipeline cache exhausted (max %d format pairs)\n", TEXT_MAX_PIPELINES );
return false;
}
sg_pipeline_desc pdesc = { 0 };
pdesc.shader = s_text.shader;
// No VBO / no IBO, the VS expands six vertices per instance.
pdesc.index_type = SG_INDEXTYPE_NONE;
pdesc.cull_mode = SG_CULLMODE_NONE;
pdesc.colors[0].pixel_format = colorFormat;
pdesc.color_count = 1;
// Premultiplied-alpha blend. The FS emits premultiplied color, which is
// also what makes the halo work: alpha without color resolves to black.
pdesc.colors[0].blend.enabled = true;
pdesc.colors[0].blend.src_factor_rgb = SG_BLENDFACTOR_ONE;
pdesc.colors[0].blend.dst_factor_rgb = SG_BLENDFACTOR_ONE_MINUS_SRC_ALPHA;
pdesc.colors[0].blend.op_rgb = SG_BLENDOP_ADD;
pdesc.colors[0].blend.src_factor_alpha = SG_BLENDFACTOR_ONE;
pdesc.colors[0].blend.dst_factor_alpha = SG_BLENDFACTOR_ONE_MINUS_SRC_ALPHA;
pdesc.colors[0].blend.op_alpha = SG_BLENDOP_ADD;
pdesc.depth.pixel_format = depthFormat;
pdesc.depth.compare = SG_COMPAREFUNC_ALWAYS;
pdesc.depth.write_enabled = false;
pdesc.sample_count = 1;
pdesc.label = "world_text_pipeline";
const sg_pipeline pipeline = sg_make_pipeline( &pdesc );
s_text.pipelines[s_text.pipelineCount].colorFormat = colorFormat;
s_text.pipelines[s_text.pipelineCount].depthFormat = depthFormat;
s_text.pipelines[s_text.pipelineCount].pipeline = pipeline;
++s_text.pipelineCount;
*outPipeline = pipeline;
return true;
}
void WorldTextInit( void )
{
if ( s_text.ready )
{
return;
}
s_text.pixelHeight = floorf( 13.0f * sapp_dpi_scale() );
s_text.haloPixels = 2.0f;
if ( BakeAtlas() == false )
{
return;
}
s_text.instances = (world_text_glyph_instance_t*)malloc( (size_t)MAX_GLYPHS * sizeof( world_text_glyph_instance_t ) );
if ( s_text.instances == NULL )
{
fprintf( stderr, "[world_text] failed to allocate glyph instances\n" );
// Clean up
sg_destroy_sampler( s_text.atlasSampler );
s_text.atlasSampler.id = 0;
sg_destroy_view( s_text.atlasView );
s_text.atlasView.id = 0;
sg_destroy_image( s_text.atlas );
s_text.atlas.id = 0;
return;
}
sg_buffer_desc bufDesc = { 0 };
bufDesc.usage.storage_buffer = true;
bufDesc.usage.stream_update = true;
bufDesc.size = (size_t)MAX_GLYPHS * sizeof( world_text_glyph_instance_t );
bufDesc.label = "world_text_glyph_instances";
s_text.instBuf = sg_make_buffer( &bufDesc );
sg_view_desc instViewDesc = { 0 };
instViewDesc.storage_buffer.buffer = s_text.instBuf;
instViewDesc.label = "world_text_glyph_instances_view";
s_text.instView = sg_make_view( &instViewDesc );
s_text.shader = sg_make_shader( world_text_prog_shader_desc( sg_query_backend() ) );
s_text.ready = true;
}
void WorldTextShutdown( void )
{
if ( !s_text.ready )
{
return;
}
for ( int i = 0; i < s_text.pipelineCount; ++i )
{
sg_destroy_pipeline( s_text.pipelines[i].pipeline );
s_text.pipelines[i].pipeline.id = 0;
s_text.pipelines[i].colorFormat = SG_PIXELFORMAT_NONE;
s_text.pipelines[i].depthFormat = SG_PIXELFORMAT_NONE;
}
s_text.pipelineCount = 0;
sg_destroy_shader( s_text.shader );
s_text.shader.id = 0;
sg_destroy_view( s_text.instView );
s_text.instView.id = 0;
sg_destroy_buffer( s_text.instBuf );
s_text.instBuf.id = 0;
sg_destroy_sampler( s_text.atlasSampler );
s_text.atlasSampler.id = 0;
sg_destroy_view( s_text.atlasView );
s_text.atlasView.id = 0;
sg_destroy_image( s_text.atlas );
s_text.atlas.id = 0;
free( s_text.instances );
s_text.instances = NULL;
s_text.glyphCount = 0;
s_text.ready = false;
}
// Walk this frame's labels and lay each one out into glyph quads. Advances
// accumulate along the pen, so a label's characters share an anchor and differ
// only in their pen offset, which keeps the whole string bill-boarding as one.
// The pen accumulates fractionally and each origin rounds off it, so spacing
// stays true across a word while every glyph still starts on a whole pixel.
static void BuildGlyphs( void )
{
s_text.glyphCount = 0;
const int count = GetTextCount();
for ( int i = 0; i < count; ++i )
{
const TextEntry* entry = GetTextAt( i );
if ( entry->space != TEXT_SPACE_WORLD )
{
continue;
}
const Vec4 color = entry->color;
float pen = 0.0f;
for ( const char* p = entry->text; *p != '\0'; ++p )
{
int index = (unsigned char)*p - FIRST_CHAR;
if ( index < 0 || index >= CHAR_COUNT )
{
index = '?' - FIRST_CHAR;
}
const Glyph* glyph = &s_text.glyphs[index];
// Space has an advance but no box, and nothing else should reach
// the rasterizer with zero area either.
if ( glyph->x1 > glyph->x0 && glyph->y1 > glyph->y0 )
{
if ( s_text.glyphCount >= MAX_GLYPHS )
{
return;
}
const float originX = floorf( pen + 0.5f );
world_text_glyph_instance_t* inst = &s_text.instances[s_text.glyphCount];
inst->anchor = MakeVec4( entry->worldPos.x, entry->worldPos.y, entry->worldPos.z, 0.0f );
inst->rect = MakeVec4( originX + glyph->x0, glyph->y0, glyph->x1 - glyph->x0, glyph->y1 - glyph->y0 );
inst->uv = MakeVec4( glyph->u0, glyph->v0, glyph->u1, glyph->v1 );
inst->color = color;
s_text.glyphCount++;
}
pen += glyph->advance;
}
}
}
void WorldTextSubmit( int width, int height, const Mat4* view, const Mat4* viewInv, const Mat4* proj, const Mat4* projInv,
b3Vec3 cameraPos, float time, sg_pixel_format colorFormat, sg_pixel_format depthFormat )
{
if ( !s_text.ready )
{
return;
}
BuildGlyphs();
if ( s_text.glyphCount == 0 )
{
return;
}
sg_pipeline pipeline = { 0 };
if ( !EnsurePipeline( colorFormat, depthFormat, &pipeline ) )
{
return;
}
const Mat4 view_proj = MulMM4( *proj, *view );
// inv(P*V) = inv(V)*inv(P), see overlay.c for why both inverses arrive
// prebuilt rather than being inverted here.
const Mat4 inv_view_proj = MulMM4( *viewInv, *projInv );
const float w = (float)width;
const float h = (float)height;
world_text_ub_frame_t ub = { 0 };
ub.view = *view;
ub.proj = *proj;
ub.view_proj = view_proj;
ub.inv_view_proj = inv_view_proj;
ub.camera_pos = MakeVec4( cameraPos.x, cameraPos.y, cameraPos.z, time );
ub.viewport = MakeVec4( w, h, w > 0.0f ? 1.0f / w : 0.0f, h > 0.0f ? 1.0f / h : 0.0f );
// Halo width in pixels plus the distance one pixel spans, which the bake fixes
// since the field is rasterized at the size it draws at. The field saturates
// SDF_PADDING pixels out, so that is the ceiling on the fade.
world_text_ub_text_style_t styleUb = { 0 };
const float distancePerPixel = ( (float)SDF_ONEDGE / (float)SDF_PADDING ) / 255.0f;
styleUb.style_params = MakeVec4( s_text.haloPixels, (float)SDF_ONEDGE / 255.0f, distancePerPixel, 0.0f );
// .w is strength at the glyph edge
styleUb.halo_params = MakeVec4( 0.2f, 0.2f, 0.2f, 0.2f );
sg_range instanceRange;
instanceRange.ptr = s_text.instances;
instanceRange.size = (size_t)s_text.glyphCount * sizeof( world_text_glyph_instance_t );
sg_update_buffer( s_text.instBuf, &instanceRange );
sg_apply_pipeline( pipeline );
sg_bindings bindings = { 0 };
bindings.views[VIEW_world_text_glyph_instances] = s_text.instView;
bindings.views[VIEW_world_text_tex_sdf] = s_text.atlasView;
bindings.samplers[SMP_world_text_smp_sdf] = s_text.atlasSampler;
sg_apply_bindings( &bindings );
sg_apply_uniforms( UB_world_text_ub_frame, &SG_RANGE( ub ) );
sg_apply_uniforms( UB_world_text_ub_text_style, &SG_RANGE( styleUb ) );
sg_draw( 0, 6, s_text.glyphCount );
}