From e61823b8bb69e258370503df7969e4e3c2089e2d Mon Sep 17 00:00:00 2001 From: jussi Date: Wed, 1 Nov 2023 23:36:31 +0200 Subject: LoadFontEx fix. DrawTextBoxed and DrawTextBoxedSelectable From raylib [text] example - Rectangle bounds. --- src/text.c | 184 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 181 insertions(+), 3 deletions(-) (limited to 'src/text.c') diff --git a/src/text.c b/src/text.c index 1783644..4184794 100644 --- a/src/text.c +++ b/src/text.c @@ -4,6 +4,144 @@ #include "textures.h" #include "lua_core.h" +// DrawTextBoxed and DrawTextBoxedSelectable from raylib [text] example - Rectangle bounds + +// Draw text using font inside rectangle limits with support for text selection +static void DrawTextBoxedSelectable(Font font, const char *text, Rectangle rec, float fontSize, float spacing, bool wordWrap, Color tint, int selectStart, int selectLength, Color selectTint, Color selectBackTint) +{ + int length = TextLength(text); // Total length in bytes of the text, scanned by codepoints in loop + + float textOffsetY = 0; // Offset between lines (on line break '\n') + float textOffsetX = 0.0f; // Offset X to next character to draw + + float scaleFactor = fontSize/(float)font.baseSize; // Character rectangle scaling factor + + // Word/character wrapping mechanism variables + enum { MEASURE_STATE = 0, DRAW_STATE = 1 }; + int state = wordWrap? MEASURE_STATE : DRAW_STATE; + + int startLine = -1; // Index where to begin drawing (where a line begins) + int endLine = -1; // Index where to stop drawing (where a line ends) + int lastk = -1; // Holds last value of the character position + + for (int i = 0, k = 0; i < length; i++, k++) + { + // Get next codepoint from byte string and glyph index in font + int codepointByteCount = 0; + int codepoint = GetCodepoint(&text[i], &codepointByteCount); + int index = GetGlyphIndex(font, codepoint); + + // NOTE: Normally we exit the decoding sequence as soon as a bad byte is found (and return 0x3f) + // but we need to draw all of the bad bytes using the '?' symbol moving one byte + if (codepoint == 0x3f) codepointByteCount = 1; + i += (codepointByteCount - 1); + + float glyphWidth = 0; + if (codepoint != '\n') + { + glyphWidth = (font.glyphs[index].advanceX == 0) ? font.recs[index].width*scaleFactor : font.glyphs[index].advanceX*scaleFactor; + + if (i + 1 < length) glyphWidth = glyphWidth + spacing; + } + + // NOTE: When wordWrap is ON we first measure how much of the text we can draw before going outside of the rec container + // We store this info in startLine and endLine, then we change states, draw the text between those two variables + // and change states again and again recursively until the end of the text (or until we get outside of the container). + // When wordWrap is OFF we don't need the measure state so we go to the drawing state immediately + // and begin drawing on the next line before we can get outside the container. + if (state == MEASURE_STATE) + { + // TODO: There are multiple types of spaces in UNICODE, maybe it's a good idea to add support for more + // Ref: http://jkorpela.fi/chars/spaces.html + if ((codepoint == ' ') || (codepoint == '\t') || (codepoint == '\n')) endLine = i; + + if ((textOffsetX + glyphWidth) > rec.width) + { + endLine = (endLine < 1)? i : endLine; + if (i == endLine) endLine -= codepointByteCount; + if ((startLine + codepointByteCount) == endLine) endLine = (i - codepointByteCount); + + state = !state; + } + else if ((i + 1) == length) + { + endLine = i; + state = !state; + } + else if (codepoint == '\n') state = !state; + + if (state == DRAW_STATE) + { + textOffsetX = 0; + i = startLine; + glyphWidth = 0; + + // Save character position when we switch states + int tmp = lastk; + lastk = k - 1; + k = tmp; + } + } + else + { + if (codepoint == '\n') + { + if (!wordWrap) + { + textOffsetY += (font.baseSize + font.baseSize/2)*scaleFactor; + textOffsetX = 0; + } + } + else + { + if (!wordWrap && ((textOffsetX + glyphWidth) > rec.width)) + { + textOffsetY += (font.baseSize + font.baseSize/2)*scaleFactor; + textOffsetX = 0; + } + + // When text overflows rectangle height limit, just stop drawing + if ((textOffsetY + font.baseSize*scaleFactor) > rec.height) break; + + // Draw selection background + bool isGlyphSelected = false; + if ((selectStart >= 0) && (k >= selectStart) && (k < (selectStart + selectLength))) + { + DrawRectangleRec((Rectangle){ rec.x + textOffsetX - 1, rec.y + textOffsetY, glyphWidth, (float)font.baseSize*scaleFactor }, selectBackTint); + isGlyphSelected = true; + } + + // Draw current character glyph + if ((codepoint != ' ') && (codepoint != '\t')) + { + DrawTextCodepoint(font, codepoint, (Vector2){ rec.x + textOffsetX, rec.y + textOffsetY }, fontSize, isGlyphSelected? selectTint : tint); + } + } + + if (wordWrap && (i == endLine)) + { + textOffsetY += (font.baseSize + font.baseSize/2)*scaleFactor; + textOffsetX = 0; + startLine = endLine; + endLine = -1; + glyphWidth = 0; + selectStart += lastk - k; + k = lastk; + + state = !state; + } + } + + if ((textOffsetX != 0) || (codepoint != ' ')) textOffsetX += glyphWidth; // avoid leading spaces + } +} + +// Draw text using font inside rectangle limits +static void DrawTextBoxed(Font font, const char *text, Rectangle rec, float fontSize, float spacing, bool wordWrap, Color tint) +{ + DrawTextBoxedSelectable(font, text, rec, fontSize, spacing, wordWrap, tint, 0, 0, WHITE, WHITE); +} + /* ## Text - Loading */ @@ -54,8 +192,8 @@ int ltextLoadFontEx( lua_State *L ) { if ( lua_istable( L, 3 ) ) { int glyphCount = uluaGetTableLen( L, 3 ); int fontChars[ glyphCount ]; - - int t = lua_gettop( L ); + + int t = 3; int i = 0; lua_pushnil( L ); @@ -82,7 +220,7 @@ int ltextLoadFontEx( lua_State *L ) { /* > font = RL.LoadFontFromImage( Image image, Color key, int firstChar ) -Load font from Image ( XNA style) +Load font from Image (XNA style) - Success return Font */ @@ -239,6 +377,46 @@ int ltextDrawTextCodepoints( lua_State *L ) { return 0; } +/* +> RL.DrawTextBoxed(Font font, const char *text, Rectangle rec, float fontSize, float spacing, bool wordWrap, Color tint ) + +Draw text using font inside rectangle limits. Function from raylib [text] example - Rectangle bounds +*/ +int ltextDrawTextBoxed( lua_State *L ) { + Font *font = uluaGetFont( L, 1 ); + Rectangle rec = uluaGetRectangle( L, 3 ); + float fontSize = luaL_checknumber( L, 4 ); + float spacing = luaL_checknumber( L, 5 ); + bool wordWrap = uluaGetBoolean( L, 6 ); + Color tint = uluaGetColor( L, 7 ); + + DrawTextBoxedSelectable( *font, luaL_checkstring( L, 2 ), rec, fontSize, spacing, wordWrap, tint, 0, 0, WHITE, WHITE ); + + return 0; +} + +/* +> RL.DrawTextBoxedSelectable( Font font, string text, Rectangle rec, float fontSize, float spacing, bool wordWrap, Color tint, int selectStart, int selectLength, Color selectTint, Color selectBackTint ) + +Draw text using font inside rectangle limits with support for text selection. Function from raylib [text] example - Rectangle bounds +*/ +int ltextDrawTextBoxedSelectable( lua_State *L ) { + Font *font = uluaGetFont( L, 1 ); + Rectangle rec = uluaGetRectangle( L, 3 ); + float fontSize = luaL_checknumber( L, 4 ); + float spacing = luaL_checknumber( L, 5 ); + bool wordWrap = uluaGetBoolean( L, 6 ); + Color tint = uluaGetColor( L, 7 ); + int selectStart = luaL_checkinteger( L, 8 ); + int selectLength = luaL_checkinteger( L, 9 ); + Color selectTint = uluaGetColor( L, 10 ); + Color selectBackTint = uluaGetColor( L, 11 ); + + DrawTextBoxedSelectable( *font, luaL_checkstring( L, 2 ), rec, fontSize, spacing, wordWrap, tint, selectStart, selectLength, selectTint, selectBackTint ); + + return 0; +} + /* ## Text - Font info functions */ -- cgit v1.2.3