/*
 * Copyright 2011-2026 Branimir Karadzic. All rights reserved.
 * License: https://github.com/bkaradzic/bgfx/blob/master/LICENSE
 */

// GPU font rendering using the Slug algorithm.
// 
// Slug reference shaders by Eric Lengyel (MIT License).
// https://github.com/EricLengyel/Slug?tab=readme-ov-file#slug
//
// For more information see:
// https://sluglibrary.com/

#include "common.h"
#include "bgfx_utils.h"
#include "imgui/imgui.h"
#include "font/utf8.h"

#include <bx/math.h>
#include <bx/easing.h>
#include <bx/sort.h>
#include <bx/string.h>

#include <tinystl/unordered_map.h>
#include <tinystl/vector.h>
namespace stl = tinystl;

#include <stb/stb_truetype.h>

namespace
{

static constexpr uint16_t kTexWidth = 4096;
static constexpr uint8_t  kMaxBands = 8;

struct Curve
{
	float p1x, p1y;
	float p2x, p2y;
	float p3x, p3y;
};

struct Rect
{
	float minX;
	float minY;
	float maxX;
	float maxY;
};

struct SlugGlyph
{
	int32_t  glyphIndex;
	int32_t  advance;
	int32_t  bearingX;
	int32_t  bearingY;
	int32_t  width;
	int32_t  height;

	Rect     rect;

	int32_t  curveStart;
	int32_t  curveCount;

	uint16_t glyphLocX;
	uint16_t glyphLocY;
	uint8_t  bandMaxX;
	uint8_t  bandMaxY;

	float    bandScaleX;
	float    bandScaleY;
	float    bandOffsetX;
	float    bandOffsetY;
};

struct FontVertex
{
	float m_x;           // pos.xy = object-space vertex coordinates.
	float m_y;           //
	float m_nx;          // pos.zw = object-space normal vector.
	float m_ny;          //

	float m_u;           // tex.xy = em-space sample coordinates.
	float m_v;           //
	float m_glyphLoc;    // tex.z = location of glyph data in band texture / Bit-packed: (glyphLocY << 16) | glyphLocX, reinterpreted as float.
	float m_bandMax;     // tex.w = max band indexes and flags             / Bit-packed: (bandMaxY  << 16) | bandMaxX,  reinterpreted as float.

	float m_bandScaleX;  // banding
	float m_bandScaleY;
	float m_bandOffsetX;
	float m_bandOffsetY;

	static void init()
	{
		ms_layout.begin()
			.add(bgfx::Attrib::Position,  4, bgfx::AttribType::Float) // pos.xy = object-space vertex coordinates.
			                                                          // pos.zw = object-space normal vector.
			.add(bgfx::Attrib::TexCoord0, 4, bgfx::AttribType::Float) // tex.xy = em-space sample coordinates.
			                                                          // tex.z = location of glyph data in band texture (interpreted as integer):
			                                                          // tex.w = max band indexes and flags (interpreted as integer): 
			.add(bgfx::Attrib::TexCoord1, 4, bgfx::AttribType::Float) // banding
			.end();
	}

	static bgfx::VertexLayout ms_layout;
};

bgfx::VertexLayout FontVertex::ms_layout;

class SlugFont
{
public:
	float worldSize;

	SlugFont(const uint8_t* _fontData, float _worldSize)
		: worldSize(_worldSize)
		, m_curveTex(BGFX_INVALID_HANDLE)
		, m_bandTex(BGFX_INVALID_HANDLE)
		, m_vbh(BGFX_INVALID_HANDLE)
		, m_ibh(BGFX_INVALID_HANDLE)
	{
		if (!stbtt_InitFont(&m_fontInfo, _fontData, stbtt_GetFontOffsetForIndex(_fontData, 0) ) )
		{
			return;
		}

		float scale1px = stbtt_ScaleForMappingEmToPixels(&m_fontInfo, 1.0f);
		m_emSize = 1.0f / scale1px;
	
		buildGlyph(0, 0); // Undefined glyph at index 0.

		for (uint32_t codePoint = 32; codePoint < 128; ++codePoint)
		{
			const int32_t glyphIdx = stbtt_FindGlyphIndex(&m_fontInfo, codePoint);

			if (0 != glyphIdx)
			{
				buildGlyph(codePoint, glyphIdx);
			}

		}

		uploadTextures();
	}

	~SlugFont()
	{
		if (bgfx::isValid(m_curveTex) )
		{
			bgfx::destroy(m_curveTex);
			m_curveTex = BGFX_INVALID_HANDLE;
		}

		if (bgfx::isValid(m_bandTex) )
		{
			bgfx::destroy(m_bandTex);
			m_bandTex = BGFX_INVALID_HANDLE;
		}

		destroyMesh();
	}

	void destroyMesh()
	{
		if (bgfx::isValid(m_vbh) )
		{
			bgfx::destroy(m_vbh);
			m_vbh = BGFX_INVALID_HANDLE;
		}

		if (bgfx::isValid(m_ibh) )
		{
			bgfx::destroy(m_ibh);
			m_ibh = BGFX_INVALID_HANDLE;
		}
	}

	void prepareGlyphsForText(const bx::StringView& _text)
	{
		bool changed = false;

		uint32_t state = 0;

		for (const char* textIt = _text.getPtr(); textIt != _text.getTerm(); ++textIt)
		{
			uint32_t codePoint;
			if (0 != utf8_decode(&state, &codePoint, *textIt) )
			{
				continue;
			}

			if ('\r' == codePoint
			||  '\n' == codePoint)
			{
				continue;
			}

			if (m_glyphs.find(codePoint) != m_glyphs.end() )
			{
				continue;
			}

			const int32_t glyphIdx = stbtt_FindGlyphIndex(&m_fontInfo, codePoint);
			if (0 != glyphIdx)
			{
				buildGlyph(codePoint, glyphIdx);
				changed = true;
			}
		}

		BX_ASSERT(state == UTF8_ACCEPT, "The string is not well-formed");

		if (changed)
		{
			uploadTextures();
		}
	}

	void buildMesh(float _x, float _y, const bx::StringView& _text)
	{
		destroyMesh();

		float originalX = _x;

		stl::vector<FontVertex> vertices;
		stl::vector<uint32_t>   indices;

		uint32_t state = 0;

		int32_t previous = 0;
		for (const char* textIt = _text.getPtr(); textIt != _text.getTerm(); ++textIt)
		{
			uint32_t codePoint;
			if (0 != utf8_decode(&state, &codePoint, *textIt) )
			{
				continue;
			}

			if ('\r' == codePoint)
			{
				continue;
			}

			if ('\n' == codePoint)
			{
				_x = originalX;
				int32_t ascent, descent, lineGap;
				stbtt_GetFontVMetrics(&m_fontInfo, &ascent, &descent, &lineGap);
				float lineHeight = (float)(ascent - descent + lineGap) / m_emSize * worldSize;
				_y -= lineHeight;
				continue;
			}

			auto glyphIt = m_glyphs.find(codePoint);
			SlugGlyph& glyph = (glyphIt == m_glyphs.end() ) ? m_glyphs[0] : glyphIt->second;

			if (previous != 0 && glyph.glyphIndex != 0)
			{
				int32_t kern = stbtt_GetGlyphKernAdvance(&m_fontInfo, previous, glyph.glyphIndex);
				_x += (float)kern / m_emSize * worldSize;
			}

			if (glyph.curveCount > 0)
			{
				const float u0 = glyph.rect.minX;
				const float v0 = glyph.rect.minY;
				const float u1 = glyph.rect.maxX;
				const float v1 = glyph.rect.maxY;

				const float x0 = _x + u0 * worldSize;
				const float y0 = _y + v0 * worldSize;
				const float x1 = _x + u1 * worldSize;
				const float y1 = _y + v1 * worldSize;

				static constexpr float kN = 1.0f;

				uint32_t base = (uint32_t)vertices.size();

				FontVertex vert;
				vert.m_bandScaleX  = glyph.bandScaleX;
				vert.m_bandScaleY  = glyph.bandScaleY;
				vert.m_bandOffsetX = glyph.bandOffsetX;
				vert.m_bandOffsetY = glyph.bandOffsetY;
				{
					uint32_t loc = (uint32_t(glyph.glyphLocY) << 16) | uint32_t(glyph.glyphLocX);
					uint32_t bm  = (uint32_t(glyph.bandMaxY)  << 16) | uint32_t(glyph.bandMaxX);
					bx::memCopy(&vert.m_glyphLoc, &loc, sizeof(float));
					bx::memCopy(&vert.m_bandMax,  &bm,  sizeof(float));
				}

				vert.m_x  =  x0;
				vert.m_y  =  y0;
				vert.m_u  =  u0;
				vert.m_v  =  v0;
				vert.m_nx = -kN;
				vert.m_ny = -kN;
				vertices.push_back(vert);

				vert.m_x  =  x1;
				vert.m_y  =  y0;
				vert.m_u  =  u1;
				vert.m_v  =  v0;
				vert.m_nx = +kN;
				vert.m_ny = -kN;
				vertices.push_back(vert);

				vert.m_x  =  x1;
				vert.m_y  =  y1;
				vert.m_u  =  u1;
				vert.m_v  =  v1;
				vert.m_nx = +kN;
				vert.m_ny = +kN;
				vertices.push_back(vert);

				vert.m_x  =  x0;
				vert.m_y  =  y1;
				vert.m_u  =  u0;
				vert.m_v  =  v1;
				vert.m_nx = -kN;
				vert.m_ny = +kN;
				vertices.push_back(vert);

				indices.push_back(base + 0);
				indices.push_back(base + 1);
				indices.push_back(base + 2);
				indices.push_back(base + 2);
				indices.push_back(base + 3);
				indices.push_back(base + 0);
			}

			_x += float(glyph.advance) / m_emSize * worldSize;
			previous = glyph.glyphIndex;
		}

		BX_ASSERT(state == UTF8_ACCEPT, "The string is not well-formed");

		if (!indices.empty() )
		{
			const bgfx::Memory* vmem = bgfx::alloc( (uint32_t)(vertices.size() * sizeof(FontVertex)) );
			bx::memCopy(vmem->data, vertices.data(), vmem->size);

			const bgfx::Memory* imem = bgfx::alloc( (uint32_t)(indices.size() * sizeof(uint32_t)) );
			bx::memCopy(imem->data, indices.data(), imem->size);

			m_vbh = bgfx::createVertexBuffer(vmem, FontVertex::ms_layout);
			m_ibh = bgfx::createIndexBuffer(imem, BGFX_BUFFER_INDEX32);
		}
	}

	void submit(
		  bgfx::ViewId _view
		, bgfx::ProgramHandle _program
		, bgfx::UniformHandle _curveSampler
		, bgfx::UniformHandle _bandSampler
		, bgfx::UniformHandle _paramsUniform
		)
	{
		const float params[] =
		{
			bx::bitCast<float>(0xffffffff),
			bx::bitCast<float>(0x303030ff),
			worldSize,
			1.0f / worldSize,
		};

		bgfx::setVertexBuffer(0, m_vbh);
		bgfx::setIndexBuffer(m_ibh);

		bgfx::setTexture(0, _curveSampler, m_curveTex);
		bgfx::setTexture(1, _bandSampler,  m_bandTex);

		bgfx::setUniform(_paramsUniform, params);

		bgfx::setState(0
			| BGFX_STATE_WRITE_RGB
			| BGFX_STATE_WRITE_A
			| BGFX_STATE_DEPTH_TEST_ALWAYS
			| BGFX_STATE_BLEND_FUNC(BGFX_STATE_BLEND_SRC_ALPHA, BGFX_STATE_BLEND_INV_SRC_ALPHA)
			);

		bgfx::submit(_view, _program);
	}

	Rect measure(float _x, float _y, const bx::StringView& _text)
	{
		Rect bb;
		bb.minX = bx::max<float>();
		bb.minY = bx::max<float>();
		bb.maxX = bx::min<float>();
		bb.maxY = bx::min<float>();

		float originalX = _x;

		uint32_t state = 0;
		int32_t previous = 0;
		for (const char* textIt = _text.getPtr(); textIt != _text.getTerm(); ++textIt)
		{
			uint32_t codePoint;
			if (0 != utf8_decode(&state, &codePoint, *textIt) )
			{
				continue;
			}

			if (codePoint == '\r')
			{
				continue;
			}

			if (codePoint == '\n')
			{
				_x = originalX;
				int32_t ascent, descent, lineGap;
				stbtt_GetFontVMetrics(&m_fontInfo, &ascent, &descent, &lineGap);
				const float lineHeight = float(ascent - descent + lineGap) / m_emSize * worldSize;
				_y -= lineHeight;
				continue;
			}

			auto glyphIt = m_glyphs.find(codePoint);
			SlugGlyph& glyph = (glyphIt == m_glyphs.end() ) ? m_glyphs[0] : glyphIt->second;

			if (0 != previous
			&&  0 != glyph.glyphIndex)
			{
				const int32_t kern = stbtt_GetGlyphKernAdvance(&m_fontInfo, previous, glyph.glyphIndex);
				_x += float(kern) / m_emSize * worldSize;
			}

			const float x0 = _x + glyph.rect.minX * worldSize;
			const float y0 = _y + glyph.rect.minY * worldSize;
			const float x1 = _x + glyph.rect.maxX * worldSize;
			const float y1 = _y + glyph.rect.maxY * worldSize;

			bb.minX = bx::min(bb.minX, x0);
			bb.minY = bx::min(bb.minY, y0);
			bb.maxX = bx::max(bb.maxX, x1);
			bb.maxY = bx::max(bb.maxY, y1);

			_x += (float)glyph.advance / m_emSize * worldSize;
			previous = glyph.glyphIndex;
		}

		return bb;
	}

private:
	void buildGlyph(uint32_t _charcode, int32_t _glyphIndex)
	{
		SlugGlyph glyph;
		glyph.glyphIndex = _glyphIndex;
		glyph.curveStart = (int32_t)m_curves.size();

		stbtt_vertex* stbVerts = NULL;
		int32_t numVerts = stbtt_GetGlyphShape(&m_fontInfo, _glyphIndex, &stbVerts);

		if (0 < numVerts)
		{
			convertOutline(stbVerts, numVerts);
			stbtt_FreeShape(&m_fontInfo, stbVerts);
		}

		glyph.curveCount = int32_t(m_curves.size() ) - glyph.curveStart;

		int32_t advanceWidth, leftSideBearing;
		stbtt_GetGlyphHMetrics(&m_fontInfo, _glyphIndex, &advanceWidth, &leftSideBearing);
		glyph.advance = advanceWidth;

		int32_t x0, y0, x1, y1;
		if (!stbtt_GetGlyphBox(&m_fontInfo, _glyphIndex, &x0, &y0, &x1, &y1) )
		{
			x0 = y0 = x1 = y1 = 0;
		}

		glyph.bearingX = x0;
		glyph.bearingY = y1;
		glyph.width    = x1 - x0;
		glyph.height   = y1 - y0;

		glyph.rect.minX = float(x0 / m_emSize);
		glyph.rect.minY = float(y0 / m_emSize);
		glyph.rect.maxX = float(x1 / m_emSize);
		glyph.rect.maxY = float(y1 / m_emSize);

		glyph.glyphLocX   = 0;
		glyph.glyphLocY   = 0;
		glyph.bandMaxX    = 0;
		glyph.bandMaxY    = 0;
		glyph.bandScaleX  = 0.0f;
		glyph.bandScaleY  = 0.0f;
		glyph.bandOffsetX = 0.0f;
		glyph.bandOffsetY = 0.0f;

		m_glyphs[_charcode] = glyph;
	}

	void convertOutline(const stbtt_vertex* _vertices, int32_t _numVertices)
	{
		const float emSize = m_emSize;

		float cx = 0.0f, cy = 0.0f;

		for (int32_t ii = 0; ii < _numVertices; ++ii)
		{
			const stbtt_vertex& v = _vertices[ii];

			switch (v.type)
			{
			case STBTT_vmove:
				cx = float(v.x)/emSize;
				cy = float(v.y)/emSize;
				break;

			case STBTT_vline:
				{
					Curve c;
					c.p1x = cx;
					c.p1y = cy;
					c.p3x = float(v.x)/emSize;
					c.p3y = float(v.y)/emSize;
					c.p2x = 0.5f * (c.p1x + c.p3x);
					c.p2y = 0.5f * (c.p1y + c.p3y);
					m_curves.push_back(c);

					cx = c.p3x;
					cy = c.p3y;
				}
				break;

			case STBTT_vcurve:
				{
					Curve c;
					c.p1x = cx;
					c.p1y = cy;
					c.p2x = float(v.cx)/emSize;
					c.p2y = float(v.cy)/emSize;
					c.p3x = float(v.x )/emSize;
					c.p3y = float(v.y )/emSize;
					m_curves.push_back(c);

					cx = c.p3x;
					cy = c.p3y;
				}
				break;

			case STBTT_vcubic:
				{
					const float b1x = float(v.cx )/emSize;
					const float b1y = float(v.cy )/emSize;
					const float b2x = float(v.cx1)/emSize;
					const float b2y = float(v.cy1)/emSize;
					const float b3x = float(v.x  )/emSize;
					const float b3y = float(v.y  )/emSize;

					const float c0x = cx  + (b1x - cx ) * 0.75f;
					const float c0y = cy  + (b1y - cy ) * 0.75f;
					const float c1x = b3x + (b2x - b3x) * 0.75f;
					const float c1y = b3y + (b2y - b3y) * 0.75f;
					const float dx  = 0.5f * (c0x + c1x);
					const float dy  = 0.5f * (c0y + c1y);

					Curve q1;
					q1.p1x = cx;  q1.p1y = cy;
					q1.p2x = c0x; q1.p2y = c0y;
					q1.p3x = dx;  q1.p3y = dy;
					m_curves.push_back(q1);

					Curve q2;
					q2.p1x = dx;  q2.p1y = dy;
					q2.p2x = c1x; q2.p2y = c1y;
					q2.p3x = b3x; q2.p3y = b3y;
					m_curves.push_back(q2);

					cx = b3x;
					cy = b3y;
				}
				break;
			}
		}
	}

	struct CurveRef
	{
		int32_t index;
		float   sortKey;
	};

	static int32_t compareCurveRefDescending(const void* _lhs, const void* _rhs)
	{
		const float lk = static_cast<const CurveRef*>(_lhs)->sortKey;
		const float rk = static_cast<const CurveRef*>(_rhs)->sortKey;
		return (lk > rk) ? -1 : (lk < rk) ? 1 : 0;
	}

	static void collectHBand(
		  const stl::vector<Curve>& _curves
		, int32_t _start
		, int32_t _count
		, float _bandMinY
		, float _bandMaxY
		, stl::vector<int32_t>& _outResult
		)
	{
		stl::vector<CurveRef> refs;

		for (int32_t ii = 0; ii < _count; ++ii)
		{
			const Curve& curve = _curves[_start + ii];
			const float  cMinY = bx::min(curve.p1y, curve.p2y, curve.p3y);
			const float  cMaxY = bx::max(curve.p1y, curve.p2y, curve.p3y);

			if (cMaxY >= _bandMinY
			&&  cMinY <= _bandMaxY)
			{
				CurveRef ref = { _start + ii, bx::max(curve.p1x, curve.p2x, curve.p3x) };
				refs.push_back(ref);
			}
		}

		if (!refs.empty() )
		{
			bx::quickSort(refs.data(), (uint32_t)refs.size(), compareCurveRefDescending);
		}

		for (const CurveRef& ref : refs)
		{
			_outResult.push_back(ref.index);
		}
	}

	static void collectVBand(
		  const stl::vector<Curve>& _curves
		, int32_t _start
		, int32_t _count
		, float _bandMinX
		, float _bandMaxX
		, stl::vector<int32_t>& _outResult
		)
	{
		stl::vector<CurveRef> refs;

		for (int32_t ii = 0; ii < _count; ++ii)
		{
			const Curve& curve = _curves[_start + ii];
			const float  cMinX = bx::min(curve.p1x, curve.p2x, curve.p3x);
			const float  cMaxX = bx::max(curve.p1x, curve.p2x, curve.p3x);

			if (cMaxX >= _bandMinX
			&&  cMinX <= _bandMaxX)
			{
				CurveRef ref = { _start + ii, bx::max(curve.p1y, curve.p2y, curve.p3y) };
				refs.push_back(ref);
			}
		}

		if (!refs.empty() )
		{
			bx::quickSort(refs.data(), (uint32_t)refs.size(), compareCurveRefDescending);
		}

		for (const CurveRef& ref : refs)
		{
			_outResult.push_back(ref.index);
		}
	}

	void uploadTextures()
	{
		uint32_t numCurves = (uint32_t)m_curves.size();

		stl::vector<uint32_t> curveTexelIndex(numCurves);
		uint32_t curveTexels = 0;

		for (uint32_t ii = 0; ii < numCurves; ++ii)
		{
			const uint32_t row0 = curveTexels / kTexWidth;
			const uint32_t row1 = (curveTexels + 1) / kTexWidth;

			if (row0 != row1)
			{
				curveTexels = row1 * kTexWidth;
			}

			curveTexelIndex[ii] = curveTexels;
			curveTexels += 2;
		}

		uint16_t curveTexH = (uint16_t)( (curveTexels + kTexWidth - 1) / kTexWidth);
		curveTexH = bx::max<uint16_t>(1, curveTexH);

		struct BandEntry
		{
			uint32_t count;
			uint32_t offset;
		};

		struct GlyphBandData
		{
			BandEntry hbands[kMaxBands];
			BandEntry vbands[kMaxBands];
			uint8_t   numHBands;
			uint8_t   numVBands;
			stl::vector<uint32_t>  curveLocList;
		};

		stl::vector<GlyphBandData> allGlyphBands;
		allGlyphBands.reserve(m_glyphs.size() );

		uint32_t bandTexRow = 0;

		for (auto& kv : m_glyphs)
		{
			SlugGlyph& glyph = kv.second;

			GlyphBandData gbd;

			if (glyph.curveCount == 0)
			{
				glyph.glyphLocX   = 0;
				glyph.glyphLocY   = uint16_t(bandTexRow);
				glyph.bandMaxX    = 0;
				glyph.bandMaxY    = 0;
				glyph.bandScaleX  = 0.0f;
				glyph.bandScaleY  = 0.0f;
				glyph.bandOffsetX = 0.0f;
				glyph.bandOffsetY = 0.0f;

				gbd.hbands[0] = {0, 0};
				gbd.vbands[0] = {0, 0};
				gbd.numHBands = 1;
				gbd.numVBands = 1;
				allGlyphBands.push_back(gbd);

				bandTexRow++;
				continue;
			}

			float bbW = glyph.rect.maxX - glyph.rect.minX;
			float bbH = glyph.rect.maxY - glyph.rect.minY;

			const uint8_t numHBands = bx::clamp(uint8_t(glyph.curveCount / 2), 1, kMaxBands);
			const uint8_t numVBands = bx::clamp(uint8_t(glyph.curveCount / 2), 1, kMaxBands);

			glyph.bandMaxX = numVBands - 1;
			glyph.bandMaxY = numHBands - 1;

			if (bbH > 0.0f)
			{
				glyph.bandScaleY  = float(numHBands) / bbH;
				glyph.bandOffsetY = -glyph.rect.minY * glyph.bandScaleY;
			}
			else
			{
				glyph.bandScaleY  = 0.0f;
				glyph.bandOffsetY = 0.0f;
			}

			if (bbW > 0.0f)
			{
				glyph.bandScaleX  = float(numVBands) / bbW;
				glyph.bandOffsetX = -glyph.rect.minX * glyph.bandScaleX;
			}
			else
			{
				glyph.bandScaleX  = 0.0f;
				glyph.bandOffsetX = 0.0f;
			}

			glyph.glyphLocX = 0;
			glyph.glyphLocY = uint16_t(bandTexRow);

			gbd.numHBands = numHBands;

			const float bandH = bbH / (float)numHBands;

			for (int32_t bb = 0; bb < numHBands; ++bb)
			{
				const float bMinY = glyph.rect.minY + float(bb    ) * bandH;
				const float bMaxY = glyph.rect.minY + float(bb + 1) * bandH;

				stl::vector<int32_t> curvesInBand;
				collectHBand(m_curves, glyph.curveStart, glyph.curveCount, bMinY, bMaxY, curvesInBand);

				gbd.hbands[bb].count  = (uint32_t)curvesInBand.size();
				gbd.hbands[bb].offset = (uint32_t)gbd.curveLocList.size();

				for (int32_t ci : curvesInBand)
				{
					uint32_t texIdx = curveTexelIndex[ci];
					gbd.curveLocList.push_back(texIdx % kTexWidth);
					gbd.curveLocList.push_back(texIdx / kTexWidth);
				}
			}

			gbd.numVBands = numVBands;

			const float bandW = bbW / (float)numVBands;

			for (int32_t bb = 0; bb < numVBands; ++bb)
			{
				const float bMinX = glyph.rect.minX + float(bb    ) * bandW;
				const float bMaxX = glyph.rect.minX + float(bb + 1) * bandW;

				stl::vector<int32_t> curvesInBand;
				collectVBand(m_curves, glyph.curveStart, glyph.curveCount, bMinX, bMaxX, curvesInBand);

				gbd.vbands[bb].count  = (uint32_t)curvesInBand.size();
				gbd.vbands[bb].offset = (uint32_t)gbd.curveLocList.size();

				for (int32_t ci : curvesInBand)
				{
					uint32_t texIdx = curveTexelIndex[ci];
					gbd.curveLocList.push_back(texIdx % kTexWidth);
					gbd.curveLocList.push_back(texIdx / kTexWidth);
				}
			}

			allGlyphBands.push_back(gbd);
			bandTexRow++;
		}

		{
			uint32_t glyphIdx = 0;
			for (auto& kv : m_glyphs)
			{
				BX_UNUSED(kv);
				GlyphBandData& gbd = allGlyphBands[glyphIdx];

				const int32_t  numHBands  = gbd.numHBands;
				const int32_t  numVBands  = gbd.numVBands;
				const uint32_t headerSize = uint32_t(numHBands + numVBands);

				for (int32_t bb = 0; bb < numHBands; ++bb)
				{
					gbd.hbands[bb].offset = headerSize + gbd.hbands[bb].offset / 2;
				}

				for (int32_t bb = 0; bb < numVBands; ++bb)
				{
					gbd.vbands[bb].offset = headerSize + gbd.vbands[bb].offset / 2;
				}

				glyphIdx++;
			}
		}

		{
			if (bgfx::isValid(m_curveTex) )
			{
				bgfx::destroy(m_curveTex);
			}

			const bgfx::Memory* mem = bgfx::alloc(kTexWidth * curveTexH * 4 * sizeof(float) );
			bx::memSet(mem->data, 0, mem->size);
			float* dst = (float*)mem->data;

			for (uint32_t ii = 0; ii < numCurves; ++ii)
			{
				const Curve& curve = m_curves[ii];
				const uint32_t texIdx = curveTexelIndex[ii];

				uint32_t off0 = texIdx * 4;
				dst[off0 + 0] = curve.p1x;
				dst[off0 + 1] = curve.p1y;
				dst[off0 + 2] = curve.p2x;
				dst[off0 + 3] = curve.p2y;

				uint32_t off1 = (texIdx + 1) * 4;
				dst[off1 + 0] = curve.p3x;
				dst[off1 + 1] = curve.p3y;
				dst[off1 + 2] = 0.0f;
				dst[off1 + 3] = 0.0f;
			}

			m_curveTex = bgfx::createTexture2D(
				  kTexWidth
				, curveTexH
				, false
				, 1
				, bgfx::TextureFormat::RGBA32F
				, BGFX_SAMPLER_POINT | BGFX_SAMPLER_UVW_CLAMP
				, mem
				);
		}

		{
			if (bgfx::isValid(m_bandTex) )
			{
				bgfx::destroy(m_bandTex);
			}

			uint16_t bandTexH = uint16_t(bandTexRow);

			const bgfx::Memory* mem = bgfx::alloc(kTexWidth * bandTexH * 4 * sizeof(float) );
			bx::memSet(mem->data, 0, mem->size);
			float* dst = (float*)mem->data;

			uint32_t glyphIdx = 0;
			for (auto& kv : m_glyphs)
			{
				SlugGlyph&   glyph = kv.second;
				GlyphBandData& gbd = allGlyphBands[glyphIdx];

				uint32_t rowBase = (uint32_t)glyph.glyphLocY * kTexWidth;

				const int32_t numHBands = gbd.numHBands;
				const int32_t numVBands = gbd.numVBands;

				for (int32_t bb = 0; bb < numHBands; ++bb)
				{
					uint32_t col = (uint32_t)(glyph.glyphLocX + bb);
					uint32_t off = (rowBase + col) * 4;
					dst[off + 0] = (float)gbd.hbands[bb].count;
					dst[off + 1] = (float)gbd.hbands[bb].offset;
					dst[off + 2] = 0.0f;
					dst[off + 3] = 0.0f;
				}

				for (int32_t bb = 0; bb < numVBands; ++bb)
				{
					uint32_t col = (uint32_t)(glyph.glyphLocX + numHBands + bb);
					uint32_t off = (rowBase + col) * 4;
					dst[off + 0] = (float)gbd.vbands[bb].count;
					dst[off + 1] = (float)gbd.vbands[bb].offset;
					dst[off + 2] = 0.0f;
					dst[off + 3] = 0.0f;
				}

				const uint32_t headerSize = (uint32_t)(numHBands + numVBands);
				const uint32_t numLocPairs = (uint32_t)(gbd.curveLocList.size() / 2);

				for (uint32_t ll = 0; ll < numLocPairs; ++ll)
				{
					uint32_t col = glyph.glyphLocX + headerSize + ll;
					uint32_t off = (rowBase + col) * 4;
					dst[off + 0] = (float)gbd.curveLocList[ll * 2 + 0];
					dst[off + 1] = (float)gbd.curveLocList[ll * 2 + 1];
					dst[off + 2] = 0.0f;
					dst[off + 3] = 0.0f;
				}

				glyphIdx++;
			}

			m_bandTex = bgfx::createTexture2D(
				  kTexWidth
				, bandTexH
				, false
				, 1
				, bgfx::TextureFormat::RGBA32F
				, BGFX_SAMPLER_POINT | BGFX_SAMPLER_UVW_CLAMP
				, mem
				);
		}
	}

	stbtt_fontinfo m_fontInfo;
	float m_emSize;

	stl::vector<Curve> m_curves;
	stl::unordered_map<uint32_t, SlugGlyph> m_glyphs;

	bgfx::TextureHandle m_curveTex;
	bgfx::TextureHandle m_bandTex;

	bgfx::VertexBufferHandle m_vbh;
	bgfx::IndexBufferHandle  m_ibh;
};

class ExampleGpuFont : public entry::AppI
{
public:
	ExampleGpuFont(const char* _name, const char* _description, const char* _url)
		: entry::AppI(_name, _description, _url)
		, m_fontData(NULL)
		, m_mainFont(NULL)
		, m_fontProgram(BGFX_INVALID_HANDLE)
		, m_curveSampler(BGFX_INVALID_HANDLE)
		, m_bandSampler(BGFX_INVALID_HANDLE)
		, m_paramsUniform(BGFX_INVALID_HANDLE)
		, m_animate(true)
		, m_scrollSpeed(0.25f)
		, m_scrollOffset(0.0f)
		, m_scrollDirection(1.0f)
	{
	}

	void init(int32_t _argc, const char* const* _argv, uint32_t _width, uint32_t _height) override
	{
		Args args(_argc, _argv);

		m_width  = _width;
		m_height = _height;
		m_debug  = BGFX_DEBUG_NONE;
		m_reset  = BGFX_RESET_VSYNC;

		bgfx::Init init;
		init.type     = args.m_type;
		init.vendorId = args.m_pciId;
		init.platformData.nwh  = entry::getNativeWindowHandle(entry::kDefaultWindowHandle);
		init.platformData.ndt  = entry::getNativeDisplayHandle();
		init.platformData.type = entry::getNativeWindowHandleType();
		init.resolution.width  = m_width;
		init.resolution.height = m_height;
		init.resolution.reset  = m_reset;
		bgfx::init(init);

		bgfx::setDebug(m_debug);

		bgfx::setViewClear(0
			, BGFX_CLEAR_COLOR
			, 0x303030ff
			, 1.0f
			, 0
			);

		FontVertex::init();

		m_curveSampler  = bgfx::createUniform("s_curveData", bgfx::UniformType::Sampler);
		m_bandSampler   = bgfx::createUniform("s_bandData",  bgfx::UniformType::Sampler);
		m_paramsUniform = bgfx::createUniform("u_params",    bgfx::UniformType::Vec4);

		m_fontProgram = loadProgram("vs_slug", "fs_slug");

		imguiCreate();

		{
			uint32_t txtSize = 0;
			void* txtData = load("text/sherlock_holmes_a_scandal_in_bohemia_arthur_conan_doyle.txt", &txtSize);
			BX_ASSERT(NULL != txtData, "Text file not found!");

			const bx::StringView text = bx::StringView( (const char*)txtData, txtSize);

			uint32_t fontDataSize = 0;
			m_fontData = (uint8_t*)load("font/roboto-regular.ttf", &fontDataSize);
			m_mainFont = new SlugFont(m_fontData, 0.05f);
			m_mainFont->prepareGlyphsForText(text);
			m_bb = m_mainFont->measure(0.0f, 0.0f, text);

			const float cx = 0.5f * (m_bb.minX + m_bb.maxX);
			const float cy = m_bb.maxY;
			m_mainFont->buildMesh(-cx, -cy, text);

			unload(txtData);
			txtData = NULL;
		}

		{
			const float textW  = m_bb.maxX - m_bb.minX;
			const float aspect = float(m_width) / float(m_height);
			const float halfFovRad = 30.0f * bx::kPi / 180.0f; // half of 60° vertical FOV
			m_distance = (textW * 0.5f) / (bx::tan(halfFovRad) * aspect) * 1.1f;
		}

		m_posX = 0.0f;
		m_posY = 0.0f;
		m_rotX = 0.0f;
		m_rotY = 0.0f;
		m_rotZ = 0.0f;
		m_lastMouseX = 0;
		m_lastMouseY = 0;
		m_lastMz = 0;
		m_dragging = false;

		m_frameTime.reset();
		m_animTimeOffset = bx::toSeconds<float>(m_frameTime.getDurationTime() );
		m_animReset = true;
	}

	virtual int32_t shutdown() override
	{
		delete m_mainFont;
		m_mainFont = NULL;

		if (m_fontData != NULL)
		{
			unload(m_fontData);
			m_fontData = NULL;
		}

		imguiDestroy();

		bgfx::destroy(m_curveSampler);
		bgfx::destroy(m_bandSampler);
		bgfx::destroy(m_paramsUniform);
		bgfx::destroy(m_fontProgram);

		bgfx::shutdown();

		return 0;
	}

	bool update() override
	{
		if (!entry::processEvents(m_width, m_height, m_debug, m_reset, &m_mouseState) )
		{
			m_frameTime.frame();

			const float time = bx::toSeconds<float>(m_frameTime.getDurationTime() );

			imguiBeginFrame(m_mouseState.m_mx
				,  m_mouseState.m_my
				, (m_mouseState.m_buttons[entry::MouseButton::Left  ] ? IMGUI_MBUT_LEFT   : 0)
				| (m_mouseState.m_buttons[entry::MouseButton::Right ] ? IMGUI_MBUT_RIGHT  : 0)
				| (m_mouseState.m_buttons[entry::MouseButton::Middle] ? IMGUI_MBUT_MIDDLE : 0)
				,  m_mouseState.m_mz
				, uint16_t(m_width)
				, uint16_t(m_height)
				);

			showExampleDialog(this);

			ImGui::SetNextWindowPos(
				  ImVec2(m_width - m_width / 5.0f - 10.0f, 10.0f)
				, ImGuiCond_FirstUseEver
				);
			ImGui::SetNextWindowSize(
				  ImVec2(m_width / 5.0f, m_height / 3.0f)
				, ImGuiCond_FirstUseEver
				);
			ImGui::Begin("Settings", NULL, 0);

			ImGui::Checkbox("Animate", &m_animate);
			ImGui::SliderFloat("Scroll Speed", &m_scrollSpeed, 0.0f, 2.0f);

			if (ImGui::Button("Reset View") )
			{
				const float textW  = m_bb.maxX - m_bb.minX;
				const float aspect = float(m_width) / float(m_height);
				const float halfFovRad = 30.0f * bx::kPi / 180.0f;
				m_distance = (textW * 0.5f) / (bx::tan(halfFovRad) * aspect) * 1.1f;
				m_posX = 0.0f;
				m_posY = 0.0f;
				m_rotX = 0.0f;
				m_rotY = 0.0f;
				m_scrollOffset = 0.0f;
				m_scrollDirection = 1.0f;
			}

			ImGui::End();

			if (!ImGui::GetIO().WantCaptureMouse)
			{
				if (m_mouseState.m_buttons[entry::MouseButton::Right])
				{
					if (!m_dragging)
					{
						m_dragging = true;
						m_lastMouseX = m_mouseState.m_mx;
						m_lastMouseY = m_mouseState.m_my;
					}

					const float deltaX = (float)(m_mouseState.m_mx - m_lastMouseX);
					const float deltaY = (float)(m_mouseState.m_my - m_lastMouseY);
					m_lastMouseX = m_mouseState.m_mx;
					m_lastMouseY = m_mouseState.m_my;

					m_posX += deltaX * m_distance * 0.001f;
					m_posY -= deltaY * m_distance * 0.001f;
				}
				else if (m_mouseState.m_buttons[entry::MouseButton::Left])
				{
					if (!m_dragging)
					{
						m_dragging = true;
						m_lastMouseX = m_mouseState.m_mx;
						m_lastMouseY = m_mouseState.m_my;
					}

					const float deltaX = (float)(m_mouseState.m_mx - m_lastMouseX);
					const float deltaY = (float)(m_mouseState.m_my - m_lastMouseY);
					m_lastMouseX = m_mouseState.m_mx;
					m_lastMouseY = m_mouseState.m_my;

					const float size = bx::min((float)m_width, (float)m_height);
					m_rotY -= deltaX / size * bx::kPi;
					m_rotX -= deltaY / size * bx::kPi;
				}
				else if (m_mouseState.m_buttons[entry::MouseButton::Middle])
				{
					if (!m_dragging)
					{
						m_dragging = true;
						m_lastMouseX = m_mouseState.m_mx;
						m_lastMouseY = m_mouseState.m_my;
					}

					const float deltaX = (float)(m_mouseState.m_mx - m_lastMouseX);
					const float deltaY = (float)(m_mouseState.m_my - m_lastMouseY);
					m_lastMouseX = m_mouseState.m_mx;
					m_lastMouseY = m_mouseState.m_my;

					const float size = bx::min((float)m_width, (float)m_height);
					m_rotZ -= (deltaX + deltaY) / size * bx::kPi;
				}
				else
				{
					m_dragging = false;
				}

				bool resetAnimation = m_dragging;

				{
					const int32_t deltaZ = m_mouseState.m_mz - m_lastMz;
					m_lastMz = m_mouseState.m_mz;
					if (deltaZ != 0)
					{
						float factor = bx::clamp(1.0f - (float)deltaZ / 40.0f, 0.1f, 1.9f);
						m_distance = bx::clamp(m_distance * factor, 0.01f, 10.0f);
						resetAnimation = true;
					}
				}

				if (resetAnimation)
				{
					m_animTimeOffset = time + 3.0f;
				}
			}

			if (m_animate)
			{
				const float dt = bx::toMilliseconds<float>(m_frameTime.getDeltaTime() );
				m_scrollOffset += m_scrollDirection * m_scrollSpeed/1000.0f * dt;

				const float textHeight = m_bb.maxY - m_bb.minY;

				if (m_scrollOffset > textHeight)
				{
					m_scrollOffset    = textHeight;
					m_scrollDirection = -1.0f;
				}
				else if (m_scrollOffset < 0.0f)
				{
					m_scrollOffset    = 0.0f;
					m_scrollDirection = 1.0f;
				}
			}

			if (time > m_animTimeOffset)
			{
				struct Frame
				{
					float px, py, pz;
					float rx, ry, rz;
				};

				struct AnimFrame
				{
					Frame frame;
					float animTime;
					float duration;
				};

				static const AnimFrame animFrame[] =
				{
					{ {  0.0f,   0.0f,  2.00f,   0.0f,   0.0f, bx::kPiHalf }, 1.0f, 2.0f },
					{ {  0.0f,   0.0f,  3.00f,   0.0f,   0.0f, bx::kPiHalf }, 3.0f, 4.0f },
					{ {  0.0f,   0.0f, 10.00f,   0.0f,   0.0f, bx::kPiHalf }, 1.0f, 5.0f },
					{ {  0.0f,   0.0f,   0.5f,   0.0f,   0.0f,        0.0f }, 6.0f, 8.0f },
					{ {  0.0f,   0.0f,   0.5f,   0.0f,   0.0f,        1.0f }, 1.0f, 3.0f },
					{ { 0.42f,  0.05f,  0.69f,  0.79f, -0.55f,        0.0f }, 1.0f, 5.0f },
					{ { 0.07f, -0.31f,  0.59f, -0.50f, -0.00f,       -0.3f }, 1.0f, 5.0f },
					{ { 0.07f, -0.31f,  0.59f, -0.50f, -0.00f,        0.3f }, 1.0f, 5.0f },
					{ { 0.00f,  0.00f,  0.85f,  1.35f, -0.01f,        0.0f }, 1.0f, 5.0f },
				};

				static uint32_t currIdx = 0;
				static float timeOffset = time;
				static Frame prev;

				if (m_animReset)
				{
					currIdx = 0;
					timeOffset = time;

					prev =
					{
						.px = m_posX,
						.py = m_posY,
						.pz = m_distance,
						.rx = m_rotX,
						.ry = m_rotY,
						.rz = m_rotZ,
					};

					m_animReset = false;
				}

				float animFrameTime = time - timeOffset;
				if (animFrameTime >= animFrame[currIdx].duration)
				{
					timeOffset = time;
					animFrameTime -= animFrame[currIdx].duration;
					prev = animFrame[currIdx].frame;
					currIdx = (currIdx + 1) % BX_COUNTOF(animFrame);
				}

				const float animTime = bx::min(animFrameTime, animFrame[currIdx].animTime) / animFrame[currIdx].animTime;
				const Frame& curr = animFrame[currIdx].frame;
				const float tt = bx::easeInOutQuad(animTime);

				Frame frame =
				{
					.px = bx::lerp(prev.px, curr.px, tt),
					.py = bx::lerp(prev.py, curr.py, tt),
					.pz = bx::lerp(prev.pz, curr.pz, tt),
					.rx = bx::lerp(prev.rx, curr.rx, tt),
					.ry = bx::lerp(prev.ry, curr.ry, tt),
					.rz = bx::lerp(prev.rz, curr.rz, tt),
				};

				m_posX = frame.px;
				m_posY = frame.py;
				m_distance = frame.pz;
				m_rotX     = frame.rx;
				m_rotY     = frame.ry;
				m_rotZ     = frame.rz;
			}
			else
			{
				m_animReset = true;
			}

			imguiEndFrame();

			bgfx::touch(0);
			bgfx::setViewRect(0, 0, 0, uint16_t(m_width), uint16_t(m_height) );

			const float aspect = float(m_width) / float(m_height);

			float view[16];
			{
				float eye[16];
				bx::mtxLookAt(eye
					, { 0.0f, 0.0f, m_distance }
					, { 0.0f, 0.0f, 0.0f }
					, { 0.0f, 1.0f, 0.0f }
					, bx::Handedness::Right
					);

				float rotation[16];
				bx::mtxRotateXYZ(rotation, m_rotX, m_rotY, m_rotZ);

				float translation[16];
				bx::mtxTranslate(translation, m_posX, m_posY, 0.0f);

				float tmp[16];
				bx::mtxMul(tmp, rotation, translation);
				bx::mtxMul(view, tmp, eye);
			}

			float proj[16];
			bx::mtxProj(proj
				, 60.0f
				, aspect
				, 0.002f
				, 12.0f
				, bgfx::getCaps()->homogeneousDepth
				, bx::Handedness::Right
				);

			bgfx::setViewTransform(0, view, proj);

			float mtxScroll[16];
			bx::mtxTranslate(mtxScroll, 0.0f, m_scrollOffset, 0.0f);
			bgfx::setTransform(mtxScroll);

			m_mainFont->submit(0
				, m_fontProgram
				, m_curveSampler
				, m_bandSampler
				, m_paramsUniform
				);

			bgfx::frame();

			return true;
		}

		return false;
	}

	entry::MouseState m_mouseState;

	uint32_t m_width;
	uint32_t m_height;
	uint32_t m_debug;
	uint32_t m_reset;

	float m_animTimeOffset;
	bool  m_animReset = true;

	FrameTime m_frameTime;

	uint8_t*  m_fontData;
	SlugFont* m_mainFont;
	Rect m_bb;

	bgfx::ProgramHandle m_fontProgram;
	bgfx::UniformHandle m_curveSampler;
	bgfx::UniformHandle m_bandSampler;
	bgfx::UniformHandle m_paramsUniform;

	bool     m_animate;
	float    m_scrollSpeed;
	float    m_scrollOffset;
	float    m_scrollDirection;

	float    m_distance;
	float    m_posX;
	float    m_posY;
	float    m_rotX;
	float    m_rotY;
	float    m_rotZ;
	int32_t  m_lastMouseX;
	int32_t  m_lastMouseY;
	int32_t  m_lastMz;
	bool     m_dragging;
};

} // namespace

ENTRY_IMPLEMENT_MAIN(
	  ExampleGpuFont
	, "51-gpu-font"
	, "GPU Font Rendering (Slug Algorithm)"
	, "https://bkaradzic.github.io/bgfx/examples.html#gpu-font"
	);