feat(chat): implement in-game chat box with UTF-8 support

- Add ChatMessage struct and ChatBox widget for displaying and sending messages
- Introduce split_utf8() in text_tools for splitting UTF-8 strings by character count
- Add TimeTools utility (get_time_ticks) for message timestamps
- Update TextField with start_typing/stop_typing methods and set_typing()
- Integrate text input handling in WorldScene and WorldUIManager for chat
- Add utf8cpp library for robust UTF-8 validation and processing
- Add ChatBox rendering and input logic (src/ui/chat_box.cpp)
- Register ChatBox source in CMakeLists.txt
- Fix Renderer::render_lable to skip rendering if VAO is null
- Update credits to include utf8cpp library

include/Cubed/gameplay/chat_message.hpp

@@ -0,0 +1,11 @@
+#pragma once
+
+#include <cstdint>
+#include <string>
+namespace Cubed {
+struct ChatMessage {
+    std::string player;
+    std::string text;
+    uint64_t time;
+};
+} // namespace Cubed

include/Cubed/scene/world_scene.hpp

@@ -33,6 +33,8 @@ public:
     bool pause() const;
     void set_pause(bool pause);
     void set_error(std::string_view error);
+    void set_mouse(bool pause);
+    void set_chatting(bool chatting);
 
 private:
     bool handle_mouse_move_event(const MouseMoveEvent& e) override;
@@ -40,7 +42,7 @@ private:
     bool handle_window_resize_event(const WindowResizeEvent& e) override;
     bool handle_mouse_wheel_event(const MouseWheelEvent& e) override;
     bool handle_key_event(const KeyEvent& e) override;
-
+    bool handle_text_input_event(const TextInputEvent&) override;
     SceneManager& m_scene_manager;
     DevPanel m_dev_panel;
     Camera m_camera;
@@ -50,6 +52,7 @@ private:
     bool m_paused = false;
     bool m_show_hud = true;
     bool m_show_dev_pannel = true;
+    bool m_chatting = false;
     PauseMenuUIManager m_pasue_menu;
     WorldUIManager m_hud_ui;
     ErrorUI m_error_ui;

include/Cubed/tools/text_tools.hpp

@@ -1,6 +1,10 @@
 #pragma once
+#include "Cubed/tools/cubed_assert.hpp"
+
 #include <cstdint>
 #include <string>
+#include <utf8cpp/utf8.h>
+#include <vector>
 namespace Cubed {
 inline std::string codepoint_to_utf8(uint32_t cp) {
     std::string out;
@@ -38,4 +42,28 @@ inline void utf8_pop_back(std::string& str) {
     str.erase(i);
 }
 
+inline std::vector<std::string> split_utf8(const std::string& str, int size) {
+    ASSERT(size > 0);
+    if (!utf8::is_valid(str)) {
+        return {};
+    }
+    std::vector<std::string> blocks;
+    auto cur = str.begin();
+    int chat_count = 0;
+
+    for (auto it = str.begin(); it != str.end();) {
+        if (chat_count >= size) {
+            blocks.emplace_back(cur, it);
+            cur = it;
+            chat_count = 0;
+        }
+        utf8::next(it, str.end());
+        ++chat_count;
+        if (it == str.end()) {
+            blocks.emplace_back(cur, it);
+        }
+    }
+    return blocks;
+}
+
 } // namespace Cubed

include/Cubed/tools/time_tools.hpp

@@ -0,0 +1,10 @@
+#pragma once
+
+#include <SDL3/SDL_timer.h>
+#include <cstdint>
+namespace Cubed {
+namespace Tools {
+inline uint64_t get_time_ticks() { return SDL_GetTicks(); }
+} // namespace Tools
+
+} // namespace Cubed

include/Cubed/ui/chat_box.hpp

@@ -0,0 +1,53 @@
+#pragma once
+
+#include "Cubed/gameplay/chat_message.hpp"
+#include "Cubed/ui/text_field.hpp"
+#include "Cubed/ui/widget.hpp"
+
+#include <deque>
+
+namespace Cubed {
+class ChatBox : public Widget {
+public:
+    ChatBox(Widget* parent);
+
+    void add_message(ChatMessage& message);
+
+    ChatBox& set_scale(float scale);
+    ChatBox& set_text_scale(float scale);
+    ChatBox& set_width(float width);
+    ChatBox& set_show_lines(int lines);
+    ChatBox& set_spacing(float spacing);
+    float width() const override;
+    float height() const override;
+    void set_d_image(TextureManager& m);
+    void set_typing(bool typing);
+    void set_app(App* app);
+    template <typename F> ChatBox& set_on_finish(F&& f) {
+        m_text_field->set_on_finish(std::forward<F>(f));
+        return *this;
+    }
+
+private:
+    static constexpr int MAX_MESSGAES_SUM = 50;
+
+    struct Line {
+        std::unique_ptr<Label> label;
+        uint64_t time;
+        bool render = false;
+    };
+    int m_lines = 10;
+    bool m_scale = 1.0f;
+    float m_spacing = 0.0f;
+    float m_width = 0.0f;
+    float m_height = 0.0f;
+    float m_text_scale = 1.0f;
+    std::deque<Line> m_messages;
+    std::unique_ptr<TextField> m_text_field;
+    void layout();
+    void on_update(float dt) override;
+    void on_render(Renderer& renderer) override;
+    bool handle_text_input_event(const TextInputEvent& e) override;
+    bool handle_key_event(const KeyEvent& e) override;
+};
+} // namespace Cubed

include/Cubed/ui/text_field.hpp

@@ -27,6 +27,7 @@ public:
     TextField& set_default_image(TextureManager& texture_manager);
     TextField& set_auto_scale(bool auto_scale);
     TextField& set_app(App* app);
+    TextField& set_typing(bool typing);
     bool handle_mouse_move_event(const MouseMoveEvent& e) override;
     bool handle_mouse_button_event(const MouseButtonEvent& e) override;
     bool handle_text_input_event(const TextInputEvent& e) override;
@@ -70,5 +71,8 @@ private:
     void on_update(float dt) override;
     void update_show_text();
     void update_input_area();
+
+    void start_typing();
+    void stop_typing();
 };
 } // namespace Cubed

include/Cubed/ui/widget.hpp

@@ -34,8 +34,8 @@ public:
     virtual Widget& set_window_size(int width, int height);
     virtual Widget& set_visible(bool visible);
     // Returns the final display size
-    virtual float width() const = 0;
+    virtual float width() const;
-    virtual float height() const = 0;
+    virtual float height() const;
     virtual glm::vec2 pos() const;
 
     virtual bool handle_key_event(const KeyEvent& e);

include/Cubed/ui/world_ui_manager.hpp

@@ -1,5 +1,6 @@
 #pragma once
 
+#include "Cubed/ui/chat_box.hpp"
 #include "Cubed/ui/ui_manager.hpp"
 #include "Cubed/ui/widget.hpp"
 
@@ -18,7 +19,11 @@ public:
     void init() override;
     void render(Renderer& renderer) override;
 
+    void set_chatting(bool chantting);
+
 private:
+    bool handle_key_event(const KeyEvent& e) override;
     WorldScene& m_scene;
+    ChatBox* m_chat_box;
 };
 } // namespace Cubed

include/utf8cpp/.clang-format

@@ -0,0 +1,2 @@
+DisableFormat: true
+SortIncludes: false

include/utf8cpp/utf8.h

@@ -0,0 +1,46 @@
+// Copyright 2006 Nemanja Trifunovic
+
+/*
+Permission is hereby granted, free of charge, to any person or organization
+obtaining a copy of the software and accompanying documentation covered by
+this license (the "Software") to use, reproduce, display, distribute,
+execute, and transmit the Software, and to prepare derivative works of the
+Software, and to permit third-parties to whom the Software is furnished to
+do so, all subject to the following:
+
+The copyright notices in the Software and this entire statement, including
+the above license grant, this restriction and the following disclaimer,
+must be included in all copies of the Software, in whole or in part, and
+all derivative works of the Software, unless such copies or derivative
+works are solely in the form of machine-executable object code generated by
+a source language processor.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
+SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
+FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
+*/
+
+
+#ifndef UTF8_FOR_CPP_2675DCD0_9480_4c0c_B92A_CC14C027B731
+#define UTF8_FOR_CPP_2675DCD0_9480_4c0c_B92A_CC14C027B731
+
+/*
+To control the C++ language version used by the library, you can define UTF_CPP_CPLUSPLUS macro
+and set it to one of the values used by the __cplusplus predefined macro.
+
+For instance,
+    #define UTF_CPP_CPLUSPLUS 199711L
+will cause the UTF-8 CPP library to use only types and language features available in the C++ 98 standard.
+Some library features will be disabled.
+
+If you leave UTF_CPP_CPLUSPLUS undefined, it will be internally assigned to __cplusplus.
+*/
+
+#include "utf8/checked.h"
+#include "utf8/unchecked.h"
+
+#endif // header guard

include/utf8cpp/utf8/checked.h

@@ -0,0 +1,359 @@
+// Copyright 2006-2016 Nemanja Trifunovic
+
+/*
+Permission is hereby granted, free of charge, to any person or organization
+obtaining a copy of the software and accompanying documentation covered by
+this license (the "Software") to use, reproduce, display, distribute,
+execute, and transmit the Software, and to prepare derivative works of the
+Software, and to permit third-parties to whom the Software is furnished to
+do so, all subject to the following:
+
+The copyright notices in the Software and this entire statement, including
+the above license grant, this restriction and the following disclaimer,
+must be included in all copies of the Software, in whole or in part, and
+all derivative works of the Software, unless such copies or derivative
+works are solely in the form of machine-executable object code generated by
+a source language processor.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
+SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
+FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
+*/
+
+
+#ifndef UTF8_FOR_CPP_CHECKED_H_2675DCD0_9480_4c0c_B92A_CC14C027B731
+#define UTF8_FOR_CPP_CHECKED_H_2675DCD0_9480_4c0c_B92A_CC14C027B731
+
+#include "core.h"
+#include <stdexcept>
+
+namespace utf8
+{
+    // Base for the exceptions that may be thrown from the library
+    class exception : public ::std::exception {
+    };
+
+    // Exceptions that may be thrown from the library functions.
+    class invalid_code_point : public exception {
+        utfchar32_t cp;
+    public:
+        invalid_code_point(utfchar32_t codepoint) : cp(codepoint) {}
+        virtual const char* what() const UTF_CPP_NOEXCEPT UTF_CPP_OVERRIDE { return "Invalid code point"; }
+        utfchar32_t code_point() const {return cp;}
+    };
+
+    class invalid_utf8 : public exception {
+        utfchar8_t u8;
+    public:
+        invalid_utf8 (utfchar8_t u) : u8(u) {}
+        invalid_utf8 (char c) : u8(static_cast<utfchar8_t>(c)) {}
+        virtual const char* what() const UTF_CPP_NOEXCEPT UTF_CPP_OVERRIDE { return "Invalid UTF-8"; }
+        utfchar8_t utf8_octet() const {return u8;}
+    };
+
+    class invalid_utf16 : public exception {
+        utfchar16_t u16;
+    public:
+        invalid_utf16 (utfchar16_t u) : u16(u) {}
+        virtual const char* what() const UTF_CPP_NOEXCEPT UTF_CPP_OVERRIDE { return "Invalid UTF-16"; }
+        utfchar16_t utf16_word() const {return u16;}
+    };
+
+    class not_enough_room : public exception {
+    public:
+        virtual const char* what() const UTF_CPP_NOEXCEPT UTF_CPP_OVERRIDE { return "Not enough space"; }
+    };
+
+    /// The library API - functions intended to be called by the users
+
+    template <typename octet_iterator>
+    octet_iterator append(utfchar32_t cp, octet_iterator result)
+    {
+        if (!utf8::internal::is_code_point_valid(cp))
+            throw invalid_code_point(cp);
+
+        return internal::append(cp, result);
+    }
+
+    inline void append(utfchar32_t cp, std::string& s)
+    {
+        append(cp, std::back_inserter(s));
+    }
+
+    template <typename word_iterator>
+    word_iterator append16(utfchar32_t cp, word_iterator result)
+    {
+        if (!utf8::internal::is_code_point_valid(cp))
+            throw invalid_code_point(cp);
+
+        return internal::append16(cp, result);
+    }
+
+    template <typename octet_iterator, typename output_iterator>
+    output_iterator replace_invalid(octet_iterator start, octet_iterator end, output_iterator out, utfchar32_t replacement)
+    {
+        while (start != end) {
+            octet_iterator sequence_start = start;
+            internal::utf_error err_code = utf8::internal::validate_next(start, end);
+            switch (err_code) {
+                case internal::UTF8_OK :
+                    for (octet_iterator it = sequence_start; it != start; ++it)
+                        *out++ = *it;
+                    break;
+                case internal::NOT_ENOUGH_ROOM:
+                    out = utf8::append (replacement, out);
+                    start = end;
+                    break;
+                case internal::INVALID_LEAD:
+                    out = utf8::append (replacement, out);
+                    ++start;
+                    break;
+                case internal::INCOMPLETE_SEQUENCE:
+                case internal::OVERLONG_SEQUENCE:
+                case internal::INVALID_CODE_POINT:
+                    out = utf8::append (replacement, out);
+                    ++start;
+                    // just one replacement mark for the sequence
+                    while (start != end && utf8::internal::is_trail(*start))
+                        ++start;
+                    break;
+            }
+        }
+        return out;
+    }
+
+    template <typename octet_iterator, typename output_iterator>
+    inline output_iterator replace_invalid(octet_iterator start, octet_iterator end, output_iterator out)
+    {
+        static const utfchar32_t replacement_marker = static_cast<utfchar32_t>(utf8::internal::mask16(0xfffd));
+        return utf8::replace_invalid(start, end, out, replacement_marker);
+    }
+
+    inline std::string replace_invalid(const std::string& s, utfchar32_t replacement)
+    {
+        std::string result;
+        replace_invalid(s.begin(), s.end(), std::back_inserter(result), replacement);
+        return result;
+    }
+
+    inline std::string replace_invalid(const std::string& s)
+    {
+        std::string result;
+        replace_invalid(s.begin(), s.end(), std::back_inserter(result));
+        return result;
+    }
+
+    template <typename octet_iterator>
+    utfchar32_t next(octet_iterator& it, octet_iterator end)
+    {
+        utfchar32_t cp = 0;
+        internal::utf_error err_code = utf8::internal::validate_next(it, end, cp);
+        switch (err_code) {
+            case internal::UTF8_OK :
+                break;
+            case internal::NOT_ENOUGH_ROOM :
+                throw not_enough_room();
+            case internal::INVALID_LEAD :
+            case internal::INCOMPLETE_SEQUENCE :
+            case internal::OVERLONG_SEQUENCE :
+                throw invalid_utf8(static_cast<utfchar8_t>(*it));
+            case internal::INVALID_CODE_POINT :
+                throw invalid_code_point(cp);
+        }
+        return cp;
+    }
+
+    template <typename word_iterator>
+    utfchar32_t next16(word_iterator& it, word_iterator end)
+    {
+        utfchar32_t cp = 0;
+        internal::utf_error err_code = utf8::internal::validate_next16(it, end, cp);
+        if (err_code == internal::NOT_ENOUGH_ROOM)
+            throw not_enough_room();
+        return cp;
+    }
+
+    template <typename octet_iterator>
+    utfchar32_t peek_next(octet_iterator it, octet_iterator end)
+    {
+        return utf8::next(it, end);
+    }
+
+    template <typename octet_iterator>
+    utfchar32_t prior(octet_iterator& it, octet_iterator start)
+    {
+        // can't do much if it == start
+        if (it == start)
+            throw not_enough_room();
+
+        octet_iterator end = it;
+        // Go back until we hit either a lead octet or start
+        while (utf8::internal::is_trail(*(--it)))
+            if (it == start)
+                throw invalid_utf8(*it); // error - no lead byte in the sequence
+        return utf8::peek_next(it, end);
+    }
+
+    template <typename octet_iterator, typename distance_type>
+    void advance (octet_iterator& it, distance_type n, octet_iterator end)
+    {
+        const distance_type zero(0);
+        if (n < zero) {
+            // backward
+            for (distance_type i = n; i < zero; ++i)
+                utf8::prior(it, end);
+        } else {
+            // forward
+            for (distance_type i = zero; i < n; ++i)
+                utf8::next(it, end);
+        }
+    }
+
+    template <typename octet_iterator>
+    typename std::iterator_traits<octet_iterator>::difference_type
+    distance (octet_iterator first, octet_iterator last)
+    {
+        typename std::iterator_traits<octet_iterator>::difference_type dist;
+        for (dist = 0; first < last; ++dist)
+            utf8::next(first, last);
+        return dist;
+    }
+
+    template <typename u16bit_iterator, typename octet_iterator>
+    octet_iterator utf16to8 (u16bit_iterator start, u16bit_iterator end, octet_iterator result)
+    {
+        while (start != end) {
+            utfchar32_t cp = static_cast<utfchar32_t>(utf8::internal::mask16(*start++));
+            // Take care of surrogate pairs first
+            if (utf8::internal::is_lead_surrogate(cp)) {
+                if (start != end) {
+                    const utfchar32_t trail_surrogate = static_cast<utfchar32_t>(utf8::internal::mask16(*start++));
+                    if (utf8::internal::is_trail_surrogate(trail_surrogate))
+                        cp = (cp << 10) + trail_surrogate + internal::SURROGATE_OFFSET;
+                    else
+                        throw invalid_utf16(static_cast<utfchar16_t>(trail_surrogate));
+                }
+                else
+                    throw invalid_utf16(static_cast<utfchar16_t>(cp));
+
+            }
+            // Lone trail surrogate
+            else if (utf8::internal::is_trail_surrogate(cp))
+                throw invalid_utf16(static_cast<utfchar16_t>(cp));
+
+            result = utf8::append(cp, result);
+        }
+        return result;
+    }
+
+    template <typename u16bit_iterator, typename octet_iterator>
+    u16bit_iterator utf8to16 (octet_iterator start, octet_iterator end, u16bit_iterator result)
+    {
+        while (start < end) {
+            const utfchar32_t cp = utf8::next(start, end);
+            if (cp > 0xffff) { //make a surrogate pair
+                *result++ = static_cast<utfchar16_t>((cp >> 10)   + internal::LEAD_OFFSET);
+                *result++ = static_cast<utfchar16_t>((cp & 0x3ff) + internal::TRAIL_SURROGATE_MIN);
+            }
+            else
+                *result++ = static_cast<utfchar16_t>(cp);
+        }
+        return result;
+    }
+
+    template <typename octet_iterator, typename u32bit_iterator>
+    octet_iterator utf32to8 (u32bit_iterator start, u32bit_iterator end, octet_iterator result)
+    {
+        while (start != end)
+            result = utf8::append(*(start++), result);
+
+        return result;
+    }
+
+    template <typename octet_iterator, typename u32bit_iterator>
+    u32bit_iterator utf8to32 (octet_iterator start, octet_iterator end, u32bit_iterator result)
+    {
+        while (start < end)
+            (*result++) = utf8::next(start, end);
+
+        return result;
+    }
+
+    // The iterator class
+    template <typename octet_iterator>
+    class iterator {
+      octet_iterator it;
+      octet_iterator range_start;
+      octet_iterator range_end;
+      public:
+      typedef utfchar32_t value_type;
+      typedef utfchar32_t* pointer;
+      typedef utfchar32_t& reference;
+      typedef std::ptrdiff_t difference_type;
+      typedef std::bidirectional_iterator_tag iterator_category;
+      iterator () {}
+      explicit iterator (const octet_iterator& octet_it,
+                         const octet_iterator& rangestart,
+                         const octet_iterator& rangeend) :
+               it(octet_it), range_start(rangestart), range_end(rangeend)
+      {
+          if (it < range_start || it > range_end)
+              throw std::out_of_range("Invalid utf-8 iterator position");
+      }
+      // the default "big three" are OK
+      octet_iterator base () const { return it; }
+      utfchar32_t operator * () const
+      {
+          octet_iterator temp = it;
+          return utf8::next(temp, range_end);
+      }
+      bool operator == (const iterator& rhs) const
+      {
+          if (range_start != rhs.range_start || range_end != rhs.range_end)
+              throw std::logic_error("Comparing utf-8 iterators defined with different ranges");
+          return (it == rhs.it);
+      }
+      bool operator != (const iterator& rhs) const
+      {
+          return !(operator == (rhs));
+      }
+      iterator& operator ++ ()
+      {
+          utf8::next(it, range_end);
+          return *this;
+      }
+      iterator operator ++ (int)
+      {
+          iterator temp = *this;
+          utf8::next(it, range_end);
+          return temp;
+      }
+      iterator& operator -- ()
+      {
+          utf8::prior(it, range_start);
+          return *this;
+      }
+      iterator operator -- (int)
+      {
+          iterator temp = *this;
+          utf8::prior(it, range_start);
+          return temp;
+      }
+    }; // class iterator
+
+} // namespace utf8
+
+#if UTF_CPP_CPLUSPLUS >= 202002L // C++ 20 or later
+#include "cpp20.h"
+#elif UTF_CPP_CPLUSPLUS >= 201703L // C++ 17 or later
+#include "cpp17.h"
+#elif UTF_CPP_CPLUSPLUS >= 201103L // C++ 11 or later
+#include "cpp11.h"
+#endif // C++ 11 or later
+
+#endif //header guard
+

include/utf8cpp/utf8/core.h

@@ -0,0 +1,610 @@
+// Copyright 2006 Nemanja Trifunovic
+
+/*
+Permission is hereby granted, free of charge, to any person or organization
+obtaining a copy of the software and accompanying documentation covered by
+this license (the "Software") to use, reproduce, display, distribute,
+execute, and transmit the Software, and to prepare derivative works of the
+Software, and to permit third-parties to whom the Software is furnished to
+do so, all subject to the following:
+
+The copyright notices in the Software and this entire statement, including
+the above license grant, this restriction and the following disclaimer,
+must be included in all copies of the Software, in whole or in part, and
+all derivative works of the Software, unless such copies or derivative
+works are solely in the form of machine-executable object code generated by
+a source language processor.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
+SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
+FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
+*/
+
+
+#ifndef UTF8_FOR_CPP_CORE_H_2675DCD0_9480_4c0c_B92A_CC14C027B731
+#define UTF8_FOR_CPP_CORE_H_2675DCD0_9480_4c0c_B92A_CC14C027B731
+
+#include <iterator>
+#include <cstring>
+#include <string>
+
+// Determine the C++ standard version.
+// If the user defines UTF_CPP_CPLUSPLUS, use that.
+// Otherwise, trust the unreliable predefined macro __cplusplus
+
+#if !defined UTF_CPP_CPLUSPLUS
+    #define UTF_CPP_CPLUSPLUS __cplusplus
+#endif
+
+#if UTF_CPP_CPLUSPLUS >= 201103L // C++ 11 or later
+    #define UTF_CPP_OVERRIDE override
+    #define UTF_CPP_NOEXCEPT noexcept
+    #define UTF_CPP_STATIC_ASSERT(condition) static_assert(condition, "UTFCPP static assert");
+#else // C++ 98/03
+    #define UTF_CPP_OVERRIDE
+    #define UTF_CPP_NOEXCEPT throw()
+    // Not worth simulating static_assert:
+    #define UTF_CPP_STATIC_ASSERT(condition) (void)(condition);
+#endif // C++ 11 or later
+
+
+namespace utf8
+{
+// The typedefs for 8-bit, 16-bit and 32-bit code units
+#if UTF_CPP_CPLUSPLUS >= 201103L // C++ 11 or later
+    #if UTF_CPP_CPLUSPLUS >= 202002L // C++ 20 or later
+        typedef char8_t         utfchar8_t;
+    #else // C++ 11/14/17
+        typedef unsigned char   utfchar8_t;
+    #endif
+    typedef char16_t        utfchar16_t;
+    typedef char32_t        utfchar32_t;
+#else // C++ 98/03
+    typedef unsigned char   utfchar8_t;
+    typedef unsigned short  utfchar16_t;
+    typedef unsigned int    utfchar32_t;
+#endif // C++ 11 or later
+
+// Helper code - not intended to be directly called by the library users. May be changed at any time
+namespace internal
+{
+    // Unicode constants
+    // Leading (high) surrogates: 0xd800 - 0xdbff
+    // Trailing (low) surrogates: 0xdc00 - 0xdfff
+    const utfchar16_t LEAD_SURROGATE_MIN  = 0xd800u;
+    const utfchar16_t LEAD_SURROGATE_MAX  = 0xdbffu;
+    const utfchar16_t TRAIL_SURROGATE_MIN = 0xdc00u;
+    const utfchar16_t TRAIL_SURROGATE_MAX = 0xdfffu;
+    const utfchar16_t LEAD_OFFSET         = 0xd7c0u;       // LEAD_SURROGATE_MIN - (0x10000 >> 10)
+    const utfchar32_t SURROGATE_OFFSET    = 0xfca02400u;   // 0x10000u - (LEAD_SURROGATE_MIN << 10) - TRAIL_SURROGATE_MIN
+
+    // Maximum valid value for a Unicode code point
+    const utfchar32_t CODE_POINT_MAX      = 0x0010ffffu;
+
+    template<typename octet_type>
+    inline utfchar8_t mask8(octet_type oc)
+    {
+        return static_cast<utfchar8_t>(0xff & oc);
+    }
+
+    template<typename u16_type>
+    inline utfchar16_t mask16(u16_type oc)
+    {
+        return static_cast<utfchar16_t>(0xffff & oc);
+    }
+
+    template<typename octet_type>
+    inline bool is_trail(octet_type oc)
+    {
+        return ((utf8::internal::mask8(oc) >> 6) == 0x2);
+    }
+
+    inline bool is_lead_surrogate(utfchar32_t cp)
+    {
+        return (cp >= static_cast<utfchar32_t>(LEAD_SURROGATE_MIN) && cp <= static_cast<utfchar32_t>(LEAD_SURROGATE_MAX));
+    }
+
+    inline bool is_trail_surrogate(utfchar32_t cp)
+    {
+        return (cp >= static_cast<utfchar32_t>(TRAIL_SURROGATE_MIN) && cp <= static_cast<utfchar32_t>(TRAIL_SURROGATE_MAX));
+    }
+
+    inline bool is_surrogate(utfchar32_t cp)
+    {
+        return (cp >= static_cast<utfchar32_t>(LEAD_SURROGATE_MIN) && cp <= static_cast<utfchar32_t>(TRAIL_SURROGATE_MAX));
+    }
+
+    inline bool is_code_point_valid(utfchar32_t cp)
+    {
+        return (cp <= CODE_POINT_MAX && !utf8::internal::is_surrogate(cp));
+    }
+
+    inline bool is_in_bmp(utfchar32_t cp)
+    {
+        return cp < utfchar32_t(0x10000);
+    }
+
+    template <typename octet_iterator>
+    int sequence_length(octet_iterator lead_it)
+    {
+        const utfchar8_t lead = utf8::internal::mask8(*lead_it);
+        if (lead < 0x80)
+            return 1;
+        else if ((lead >> 5) == 0x6)
+            return 2;
+        else if ((lead >> 4) == 0xe)
+            return 3;
+        else if ((lead >> 3) == 0x1e)
+            return 4;
+        else
+            return 0;
+    }
+
+    inline bool is_overlong_sequence(utfchar32_t cp, int length)
+    {
+        if (cp < 0x80) {
+            if (length != 1)
+                return true;
+        }
+        else if (cp < 0x800) {
+            if (length != 2)
+                return true;
+        }
+        else if (cp < 0x10000) {
+            if (length != 3)
+                return true;
+        }
+        return false;
+    }
+
+    enum utf_error {UTF8_OK, NOT_ENOUGH_ROOM, INVALID_LEAD, INCOMPLETE_SEQUENCE, OVERLONG_SEQUENCE, INVALID_CODE_POINT};
+
+    /// Helper for get_sequence_x
+    template <typename octet_iterator>
+    utf_error increase_safely(octet_iterator& it, const octet_iterator end)
+    {
+        if (++it == end)
+            return NOT_ENOUGH_ROOM;
+
+        if (!utf8::internal::is_trail(*it))
+            return INCOMPLETE_SEQUENCE;
+
+        return UTF8_OK;
+    }
+
+    #define UTF8_CPP_INCREASE_AND_RETURN_ON_ERROR(IT, END) {utf_error ret = increase_safely(IT, END); if (ret != UTF8_OK) return ret;}
+
+    /// get_sequence_x functions decode utf-8 sequences of the length x
+    template <typename octet_iterator>
+    utf_error get_sequence_1(octet_iterator& it, octet_iterator end, utfchar32_t& code_point)
+    {
+        if (it == end)
+            return NOT_ENOUGH_ROOM;
+
+        code_point = static_cast<utfchar32_t>(utf8::internal::mask8(*it));
+
+        return UTF8_OK;
+    }
+
+    template <typename octet_iterator>
+    utf_error get_sequence_2(octet_iterator& it, octet_iterator end, utfchar32_t& code_point)
+    {
+        if (it == end)
+            return NOT_ENOUGH_ROOM;
+
+        code_point = static_cast<utfchar32_t>(utf8::internal::mask8(*it));
+
+        UTF8_CPP_INCREASE_AND_RETURN_ON_ERROR(it, end)
+
+        code_point = ((code_point << 6) & 0x7ff) + ((*it) & 0x3f);
+
+        return UTF8_OK;
+    }
+
+    template <typename octet_iterator>
+    utf_error get_sequence_3(octet_iterator& it, octet_iterator end, utfchar32_t& code_point)
+    {
+        if (it == end)
+            return NOT_ENOUGH_ROOM;
+
+        code_point = static_cast<utfchar32_t>(utf8::internal::mask8(*it));
+
+        UTF8_CPP_INCREASE_AND_RETURN_ON_ERROR(it, end)
+
+        code_point = ((code_point << 12) & 0xffff) + ((utf8::internal::mask8(*it) << 6) & 0xfff);
+
+        UTF8_CPP_INCREASE_AND_RETURN_ON_ERROR(it, end)
+
+        code_point = static_cast<utfchar32_t>(code_point + ((*it) & 0x3f));
+
+        return UTF8_OK;
+    }
+
+    template <typename octet_iterator>
+    utf_error get_sequence_4(octet_iterator& it, octet_iterator end, utfchar32_t& code_point)
+    {
+        if (it == end)
+           return NOT_ENOUGH_ROOM;
+
+        code_point = static_cast<utfchar32_t>(utf8::internal::mask8(*it));
+
+        UTF8_CPP_INCREASE_AND_RETURN_ON_ERROR(it, end)
+
+        code_point = ((code_point << 18) & 0x1fffff) + ((utf8::internal::mask8(*it) << 12) & 0x3ffff);
+
+        UTF8_CPP_INCREASE_AND_RETURN_ON_ERROR(it, end)
+
+        code_point = static_cast<utfchar32_t>(code_point + ((utf8::internal::mask8(*it) << 6) & 0xfff));
+
+        UTF8_CPP_INCREASE_AND_RETURN_ON_ERROR(it, end)
+
+        code_point = static_cast<utfchar32_t>(code_point + ((*it) & 0x3f));
+
+        return UTF8_OK;
+    }
+
+    #undef UTF8_CPP_INCREASE_AND_RETURN_ON_ERROR
+
+    template <typename octet_iterator>
+    utf_error validate_next(octet_iterator& it, octet_iterator end, utfchar32_t& code_point)
+    {
+        if (it == end)
+            return NOT_ENOUGH_ROOM;
+
+        // Save the original value of it so we can go back in case of failure
+        // Of course, it does not make much sense with i.e. stream iterators
+        octet_iterator original_it = it;
+
+        utfchar32_t cp = 0;
+        // Determine the sequence length based on the lead octet
+        const int length = utf8::internal::sequence_length(it);
+
+        // Get trail octets and calculate the code point
+        utf_error err = UTF8_OK;
+        switch (length) {
+            case 0:
+                return INVALID_LEAD;
+            case 1:
+                err = utf8::internal::get_sequence_1(it, end, cp);
+                // No need for further validations
+                if (err == UTF8_OK) {
+                    code_point = cp;
+                    ++it;
+                    return UTF8_OK;
+                } else {
+                    it = original_it;
+                    return err;
+                }
+                break; // just to make sure there are no warnings
+            case 2:
+                err = utf8::internal::get_sequence_2(it, end, cp);
+            break;
+            case 3:
+                err = utf8::internal::get_sequence_3(it, end, cp);
+            break;
+            case 4:
+                err = utf8::internal::get_sequence_4(it, end, cp);
+            break;
+        }
+
+        if (err == UTF8_OK) {
+            // Decoding succeeded. Now, security checks...
+            if (utf8::internal::is_code_point_valid(cp)) {
+                if (!utf8::internal::is_overlong_sequence(cp, length)){
+                    // Passed! Return here.
+                    code_point = cp;
+                    ++it;
+                    return UTF8_OK;
+                }
+                else
+                    err = OVERLONG_SEQUENCE;
+            }
+            else
+                err = INVALID_CODE_POINT;
+        }
+
+        // Failure branch - restore the original value of the iterator
+        it = original_it;
+        return err;
+    }
+
+    template <typename octet_iterator>
+    inline utf_error validate_next(octet_iterator& it, octet_iterator end) {
+        if (it == end)
+            return NOT_ENOUGH_ROOM;
+
+        octet_iterator original_it = it;
+        const utfchar8_t lead = utf8::internal::mask8(*it);
+
+        if (lead < 0x80) {
+            ++it;
+            return UTF8_OK;
+        } else if ((lead & 0xE0) == 0xC0) {
+            // two-byte sequence
+            if (lead == 0xC0 || lead == 0xC1) {
+                it = original_it;
+                return OVERLONG_SEQUENCE;
+            }
+            if (++it == end) {
+                it = original_it;
+                return NOT_ENOUGH_ROOM;
+            }
+            const utfchar8_t trail1 = utf8::internal::mask8(*it);
+            if ((trail1 & 0xC0) != 0x80) {
+                it = original_it;
+                return INCOMPLETE_SEQUENCE;
+            }
+            ++it;
+            return UTF8_OK;
+        } else if ((lead & 0xF0) == 0xE0) {
+            // three-byte sequence
+            if (++it == end) {
+                it = original_it;
+                return NOT_ENOUGH_ROOM;
+            }
+            const utfchar8_t trail1 = utf8::internal::mask8(*it);
+            if ((trail1 & 0xC0) != 0x80) {
+                it = original_it;
+                return INCOMPLETE_SEQUENCE;
+            }
+            if (++it == end) {
+                it = original_it;
+                return NOT_ENOUGH_ROOM;
+            }
+            const utfchar8_t trail2 = utf8::internal::mask8(*it);
+            if ((trail2 & 0xC0) != 0x80) {
+                it = original_it;
+                return INCOMPLETE_SEQUENCE;
+            }
+            if (lead == 0xE0 && trail1 < 0xA0) {
+                it = original_it;
+                return OVERLONG_SEQUENCE;
+            }
+            if (lead == 0xED && trail1 > 0x9F) {
+                it = original_it;
+                return INVALID_CODE_POINT;
+            }
+            ++it;
+            return UTF8_OK;
+        } else if ((lead & 0xF8) == 0xF0) {
+            // four-byte sequence
+            if (++it == end) {
+                it = original_it;
+                return NOT_ENOUGH_ROOM;
+            }
+            const utfchar8_t trail1 = utf8::internal::mask8(*it);
+            if ((trail1 & 0xC0) != 0x80) {
+                it = original_it;
+                return INCOMPLETE_SEQUENCE;
+            }
+            if (++it == end) {
+                it = original_it;
+                return NOT_ENOUGH_ROOM;
+            }
+            const utfchar8_t trail2 = utf8::internal::mask8(*it);
+            if ((trail2 & 0xC0) != 0x80) {
+                it = original_it;
+                return INCOMPLETE_SEQUENCE;
+            }
+            if (++it == end) {
+                it = original_it;
+                return NOT_ENOUGH_ROOM;
+            }
+            const utfchar8_t trail3 = utf8::internal::mask8(*it);
+            if ((trail3 & 0xC0) != 0x80) {
+                it = original_it;
+                return INCOMPLETE_SEQUENCE;
+            }
+            if (lead == 0xF0 && trail1 < 0x90) {
+                it = original_it;
+                return OVERLONG_SEQUENCE;
+            }
+            if (lead == 0xF4 && trail1 > 0x8F) {
+                it = original_it;
+                return INVALID_CODE_POINT;
+            }
+            if (lead >= 0xF5) {
+                it = original_it;
+                return INVALID_CODE_POINT;
+            }
+            ++it;
+            return UTF8_OK;
+        } else {
+            it = original_it;
+            return INVALID_LEAD;
+        }
+   }
+
+    template <typename word_iterator>
+    utf_error validate_next16(word_iterator& it, word_iterator end, utfchar32_t& code_point)
+    {
+        // Make sure the iterator dereferences a large enough type
+        typedef typename std::iterator_traits<word_iterator>::value_type word_type;
+        UTF_CPP_STATIC_ASSERT(sizeof(word_type) >= sizeof(utfchar16_t));
+        // Check the edge case:
+        if (it == end)
+            return NOT_ENOUGH_ROOM;
+        // Save the original value of it so we can go back in case of failure
+        // Of course, it does not make much sense with i.e. stream iterators
+        word_iterator original_it = it;
+
+        utf_error err = UTF8_OK;
+
+        const utfchar16_t first_word = *it++;
+        if (!is_surrogate(first_word)) {
+            code_point = first_word;
+            return UTF8_OK;
+        }
+        else {
+            if (it == end)
+                err = NOT_ENOUGH_ROOM;
+            else if (is_lead_surrogate(first_word)) {
+                const utfchar16_t second_word = *it++;
+                if (is_trail_surrogate(static_cast<utfchar32_t>(second_word))) {
+                    code_point = static_cast<utfchar32_t>(first_word << 10) +  static_cast<utfchar32_t>(second_word) + SURROGATE_OFFSET;
+                    return UTF8_OK;
+                } else
+                    err = INCOMPLETE_SEQUENCE;
+
+            } else {
+                err = INVALID_LEAD;
+            }
+        }
+        // error branch
+        it = original_it;
+        return err;
+    }
+
+    // Internal implementation of both checked and unchecked append() function
+    // This function will be invoked by the overloads below, as they will know
+    // the octet_type.
+    template <typename octet_iterator, typename octet_type>
+    octet_iterator append(utfchar32_t cp, octet_iterator result) {
+        if (cp < 0x80)                        // one octet
+            *(result++) = static_cast<octet_type>(cp);
+        else if (cp < 0x800) {                // two octets
+            *(result++) = static_cast<octet_type>((cp >> 6)          | 0xc0);
+            *(result++) = static_cast<octet_type>((cp & 0x3f)        | 0x80);
+        }
+        else if (cp < 0x10000) {              // three octets
+            *(result++) = static_cast<octet_type>((cp >> 12)         | 0xe0);
+            *(result++) = static_cast<octet_type>(((cp >> 6) & 0x3f) | 0x80);
+            *(result++) = static_cast<octet_type>((cp & 0x3f)        | 0x80);
+        }
+        else {                                // four octets
+            *(result++) = static_cast<octet_type>((cp >> 18)         | 0xf0);
+            *(result++) = static_cast<octet_type>(((cp >> 12) & 0x3f)| 0x80);
+            *(result++) = static_cast<octet_type>(((cp >> 6) & 0x3f) | 0x80);
+            *(result++) = static_cast<octet_type>((cp & 0x3f)        | 0x80);
+        }
+        return result;
+    }
+
+    // One of the following overloads will be invoked from the API calls
+
+    // A simple (but dangerous) case: the caller appends byte(s) to a char array
+    inline char* append(utfchar32_t cp, char* result) {
+        return append<char*, char>(cp, result);
+    }
+
+    // Hopefully, most common case: the caller uses back_inserter
+    // i.e. append(cp, std::back_inserter(str));
+    template<typename container_type>
+    std::back_insert_iterator<container_type> append
+            (utfchar32_t cp, std::back_insert_iterator<container_type> result) {
+        return append<std::back_insert_iterator<container_type>,
+            typename container_type::value_type>(cp, result);
+    }
+
+    // The caller uses some other kind of output operator - not covered above
+    // Note that in this case we are not able to determine octet_type
+    // so we assume it's utfchar8_t; that can cause a conversion warning if we are wrong.
+    template <typename octet_iterator>
+    octet_iterator append(utfchar32_t cp, octet_iterator result) {
+        return append<octet_iterator, utfchar8_t>(cp, result);
+    }
+
+    // Internal implementation of both checked and unchecked append16() function
+    // This function will be invoked by the overloads below, as they will know
+    // the word_type.
+    template <typename word_iterator, typename word_type>
+    word_iterator append16(utfchar32_t cp, word_iterator result) {
+        UTF_CPP_STATIC_ASSERT(sizeof(word_type) >= sizeof(utfchar16_t));
+        if (is_in_bmp(cp))
+            *(result++) = static_cast<word_type>(cp);
+        else {
+            // Code points from the supplementary planes are encoded via surrogate pairs
+            *(result++) = static_cast<word_type>(LEAD_OFFSET + (cp >> 10));
+            *(result++) = static_cast<word_type>(TRAIL_SURROGATE_MIN + (cp & 0x3FF));
+        }
+        return result;
+    }
+
+    // Hopefully, most common case: the caller uses back_inserter
+    // i.e. append16(cp, std::back_inserter(str));
+    template<typename container_type>
+    std::back_insert_iterator<container_type> append16
+            (utfchar32_t cp, std::back_insert_iterator<container_type> result) {
+        return append16<std::back_insert_iterator<container_type>,
+            typename container_type::value_type>(cp, result);
+    }
+
+    // The caller uses some other kind of output operator - not covered above
+    // Note that in this case we are not able to determine word_type
+    // so we assume it's utfchar16_t; that can cause a conversion warning if we are wrong.
+    template <typename word_iterator>
+    word_iterator append16(utfchar32_t cp, word_iterator result) {
+        return append16<word_iterator, utfchar16_t>(cp, result);
+    }
+
+} // namespace internal
+
+    /// The library API - functions intended to be called by the users
+
+    // Byte order mark
+    const utfchar8_t bom[] = {0xef, 0xbb, 0xbf};
+
+    template <typename octet_iterator>
+    octet_iterator find_invalid(octet_iterator start, octet_iterator end)
+    {
+        octet_iterator result = start;
+        while (result != end) {
+            utf8::internal::utf_error err_code = utf8::internal::validate_next(result, end);
+            if (err_code != internal::UTF8_OK)
+                return result;
+        }
+        return result;
+    }
+
+    inline const char* find_invalid(const char* str)
+    {
+        const char* end = str + std::strlen(str);
+        return find_invalid(str, end);
+    }
+
+    inline std::size_t find_invalid(const std::string& s)
+    {
+        std::string::const_iterator invalid = find_invalid(s.begin(), s.end());
+        return (invalid == s.end()) ? std::string::npos : static_cast<std::size_t>(invalid - s.begin());
+    }
+
+    template <typename octet_iterator>
+    inline bool is_valid(octet_iterator start, octet_iterator end)
+    {
+        return (utf8::find_invalid(start, end) == end);
+    }
+
+    inline bool is_valid(const char* str)
+    {
+        return (*(utf8::find_invalid(str)) == '\0');
+    }
+
+    inline bool is_valid(const std::string& s)
+    {
+        return is_valid(s.begin(), s.end());
+    }
+
+
+
+    template <typename octet_iterator>
+    inline bool starts_with_bom (octet_iterator it, octet_iterator end)
+    {
+        return (
+            ((it != end) && (utf8::internal::mask8(*it++)) == bom[0]) &&
+            ((it != end) && (utf8::internal::mask8(*it++)) == bom[1]) &&
+            ((it != end) && (utf8::internal::mask8(*it))   == bom[2])
+           );
+    }
+
+    inline bool starts_with_bom(const std::string& s)
+    {
+        return starts_with_bom(s.begin(), s.end());
+    }
+} // namespace utf8
+
+#endif // header guard
+

include/utf8cpp/utf8/cpp11.h

@@ -0,0 +1,70 @@
+// Copyright 2018 Nemanja Trifunovic
+
+/*
+Permission is hereby granted, free of charge, to any person or organization
+obtaining a copy of the software and accompanying documentation covered by
+this license (the "Software") to use, reproduce, display, distribute,
+execute, and transmit the Software, and to prepare derivative works of the
+Software, and to permit third-parties to whom the Software is furnished to
+do so, all subject to the following:
+
+The copyright notices in the Software and this entire statement, including
+the above license grant, this restriction and the following disclaimer,
+must be included in all copies of the Software, in whole or in part, and
+all derivative works of the Software, unless such copies or derivative
+works are solely in the form of machine-executable object code generated by
+a source language processor.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
+SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
+FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
+*/
+
+
+#ifndef UTF8_FOR_CPP_a184c22c_d012_11e8_a8d5_f2801f1b9fd1
+#define UTF8_FOR_CPP_a184c22c_d012_11e8_a8d5_f2801f1b9fd1
+
+#include "checked.h"
+
+namespace utf8
+{
+    inline void append16(utfchar32_t cp, std::u16string& s)
+    {
+        append16(cp, std::back_inserter(s));
+    }
+
+    inline std::string utf16to8(const std::u16string& s)
+    {
+        std::string result;
+        utf16to8(s.begin(), s.end(), std::back_inserter(result));
+        return result;
+    }
+
+    inline std::u16string utf8to16(const std::string& s)
+    {
+        std::u16string result;
+        utf8to16(s.begin(), s.end(), std::back_inserter(result));
+        return result;
+    }
+
+    inline std::string utf32to8(const std::u32string& s)
+    {
+        std::string result;
+        utf32to8(s.begin(), s.end(), std::back_inserter(result));
+        return result;
+    }
+
+    inline std::u32string utf8to32(const std::string& s)
+    {
+        std::u32string result;
+        utf8to32(s.begin(), s.end(), std::back_inserter(result));
+        return result;
+    }
+} // namespace utf8
+
+#endif // header guard
+

include/utf8cpp/utf8/cpp17.h

@@ -0,0 +1,96 @@
+// Copyright 2018 Nemanja Trifunovic
+
+/*
+Permission is hereby granted, free of charge, to any person or organization
+obtaining a copy of the software and accompanying documentation covered by
+this license (the "Software") to use, reproduce, display, distribute,
+execute, and transmit the Software, and to prepare derivative works of the
+Software, and to permit third-parties to whom the Software is furnished to
+do so, all subject to the following:
+
+The copyright notices in the Software and this entire statement, including
+the above license grant, this restriction and the following disclaimer,
+must be included in all copies of the Software, in whole or in part, and
+all derivative works of the Software, unless such copies or derivative
+works are solely in the form of machine-executable object code generated by
+a source language processor.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
+SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
+FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
+*/
+
+
+#ifndef UTF8_FOR_CPP_7e906c01_03a3_4daf_b420_ea7ea952b3c9
+#define UTF8_FOR_CPP_7e906c01_03a3_4daf_b420_ea7ea952b3c9
+
+#include "cpp11.h"
+
+namespace utf8
+{
+    inline std::string utf16to8(std::u16string_view s)
+    {
+        std::string result;
+        utf16to8(s.begin(), s.end(), std::back_inserter(result));
+        return result;
+    }
+
+    inline std::u16string utf8to16(std::string_view s)
+    {
+        std::u16string result;
+        utf8to16(s.begin(), s.end(), std::back_inserter(result));
+        return result;
+    }
+
+    inline std::string utf32to8(std::u32string_view s)
+    {
+        std::string result;
+        utf32to8(s.begin(), s.end(), std::back_inserter(result));
+        return result;
+    }
+
+    inline std::u32string utf8to32(std::string_view s)
+    {
+        std::u32string result;
+        utf8to32(s.begin(), s.end(), std::back_inserter(result));
+        return result;
+    }
+
+    inline std::size_t find_invalid(std::string_view s)
+    {
+        std::string_view::const_iterator invalid = find_invalid(s.begin(), s.end());
+        return (invalid == s.end()) ? std::string_view::npos : static_cast<std::size_t>(invalid - s.begin());
+    }
+
+    inline bool is_valid(std::string_view s)
+    {
+        return is_valid(s.begin(), s.end());
+    }
+
+    inline std::string replace_invalid(std::string_view s, char32_t replacement)
+    {
+        std::string result;
+        replace_invalid(s.begin(), s.end(), std::back_inserter(result), replacement);
+        return result;
+    }
+
+    inline std::string replace_invalid(std::string_view s)
+    {
+        std::string result;
+        replace_invalid(s.begin(), s.end(), std::back_inserter(result));
+        return result;
+    }
+
+    inline bool starts_with_bom(std::string_view s)
+    {
+        return starts_with_bom(s.begin(), s.end());
+    }
+
+} // namespace utf8
+
+#endif // header guard
+

include/utf8cpp/utf8/cpp20.h

@@ -0,0 +1,124 @@
+// Copyright 2022 Nemanja Trifunovic
+
+/*
+Permission is hereby granted, free of charge, to any person or organization
+obtaining a copy of the software and accompanying documentation covered by
+this license (the "Software") to use, reproduce, display, distribute,
+execute, and transmit the Software, and to prepare derivative works of the
+Software, and to permit third-parties to whom the Software is furnished to
+do so, all subject to the following:
+
+The copyright notices in the Software and this entire statement, including
+the above license grant, this restriction and the following disclaimer,
+must be included in all copies of the Software, in whole or in part, and
+all derivative works of the Software, unless such copies or derivative
+works are solely in the form of machine-executable object code generated by
+a source language processor.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
+SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
+FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
+*/
+
+
+#ifndef UTF8_FOR_CPP_207e906c01_03a3_4daf_b420_ea7ea952b3c9
+#define UTF8_FOR_CPP_207e906c01_03a3_4daf_b420_ea7ea952b3c9
+
+#include "cpp17.h"
+
+namespace utf8
+{
+    inline std::u8string utf16tou8(const std::u16string& s)
+    {
+        std::u8string result;
+        utf16to8(s.begin(), s.end(), std::back_inserter(result));
+        return result;
+    }
+
+    inline std::u8string utf16tou8(std::u16string_view s)
+    {
+        std::u8string result;
+        utf16to8(s.begin(), s.end(), std::back_inserter(result));
+        return result;
+    }
+
+    inline std::u16string utf8to16(const std::u8string& s)
+    {
+        std::u16string result;
+        utf8to16(s.begin(), s.end(), std::back_inserter(result));
+        return result;
+    }
+
+    inline std::u16string utf8to16(const std::u8string_view& s)
+    {
+        std::u16string result;
+        utf8to16(s.begin(), s.end(), std::back_inserter(result));
+        return result;
+    }
+
+    inline std::u8string utf32tou8(const std::u32string& s)
+    {
+        std::u8string result;
+        utf32to8(s.begin(), s.end(), std::back_inserter(result));
+        return result;
+    }
+
+    inline std::u8string utf32tou8(const std::u32string_view& s)
+    {
+        std::u8string result;
+        utf32to8(s.begin(), s.end(), std::back_inserter(result));
+        return result;
+    }
+
+    inline std::u32string utf8to32(const std::u8string& s)
+    {
+        std::u32string result;
+        utf8to32(s.begin(), s.end(), std::back_inserter(result));
+        return result;
+    }
+
+    inline std::u32string utf8to32(const std::u8string_view& s)
+    {
+        std::u32string result;
+        utf8to32(s.begin(), s.end(), std::back_inserter(result));
+        return result;
+    }
+
+    inline std::size_t find_invalid(const std::u8string& s)
+    {
+        std::u8string::const_iterator invalid = find_invalid(s.begin(), s.end());
+        return (invalid == s.end()) ? std::string_view::npos : static_cast<std::size_t>(invalid - s.begin());
+    }
+
+    inline bool is_valid(const std::u8string& s)
+    {
+        return is_valid(s.begin(), s.end());
+    }
+
+    inline std::u8string replace_invalid(const std::u8string& s, char32_t replacement)
+    {
+        std::u8string result;
+        replace_invalid(s.begin(), s.end(), std::back_inserter(result), replacement);
+        return result;
+    }
+
+    inline std::u8string replace_invalid(const std::u8string& s)
+    {
+        std::u8string result;
+        replace_invalid(s.begin(), s.end(), std::back_inserter(result));
+        return result;
+    }
+
+    inline bool starts_with_bom(const std::u8string& s)
+    {
+        return starts_with_bom(s.begin(), s.end());
+    }
+ 
+} // namespace utf8
+
+#endif // header guard
+

include/utf8cpp/utf8/unchecked.h

@@ -0,0 +1,286 @@
+// Copyright 2006 Nemanja Trifunovic
+
+/*
+Permission is hereby granted, free of charge, to any person or organization
+obtaining a copy of the software and accompanying documentation covered by
+this license (the "Software") to use, reproduce, display, distribute,
+execute, and transmit the Software, and to prepare derivative works of the
+Software, and to permit third-parties to whom the Software is furnished to
+do so, all subject to the following:
+
+The copyright notices in the Software and this entire statement, including
+the above license grant, this restriction and the following disclaimer,
+must be included in all copies of the Software, in whole or in part, and
+all derivative works of the Software, unless such copies or derivative
+works are solely in the form of machine-executable object code generated by
+a source language processor.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
+SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
+FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
+*/
+
+
+#ifndef UTF8_FOR_CPP_UNCHECKED_H_2675DCD0_9480_4c0c_B92A_CC14C027B731
+#define UTF8_FOR_CPP_UNCHECKED_H_2675DCD0_9480_4c0c_B92A_CC14C027B731
+
+#include "core.h"
+
+namespace utf8
+{
+    namespace unchecked
+    {
+        template <typename octet_iterator>
+        octet_iterator append(utfchar32_t cp, octet_iterator result)
+        {
+            return internal::append(cp, result);
+        }
+
+        template <typename word_iterator>
+        word_iterator append16(utfchar32_t cp, word_iterator result)
+        {
+            return internal::append16(cp, result);
+        }
+
+        template <typename octet_iterator, typename output_iterator>
+        output_iterator replace_invalid(octet_iterator start, octet_iterator end, output_iterator out, utfchar32_t replacement)
+        {
+            while (start != end) {
+                octet_iterator sequence_start = start;
+                internal::utf_error err_code = utf8::internal::validate_next(start, end);
+                switch (err_code) {
+                    case internal::UTF8_OK :
+                        for (octet_iterator it = sequence_start; it != start; ++it)
+                            *out++ = *it;
+                        break;
+                    case internal::NOT_ENOUGH_ROOM:
+                        out = utf8::unchecked::append(replacement, out);
+                        start = end;
+                        break;
+                    case internal::INVALID_LEAD:
+                        out = utf8::unchecked::append(replacement, out);
+                        ++start;
+                        break;
+                    case internal::INCOMPLETE_SEQUENCE:
+                    case internal::OVERLONG_SEQUENCE:
+                    case internal::INVALID_CODE_POINT:
+                        out = utf8::unchecked::append(replacement, out);
+                        ++start;
+                        // just one replacement mark for the sequence
+                        while (start != end && utf8::internal::is_trail(*start))
+                            ++start;
+                        break;
+                }
+            }
+            return out;
+        }
+
+        template <typename octet_iterator, typename output_iterator>
+        inline output_iterator replace_invalid(octet_iterator start, octet_iterator end, output_iterator out)
+        {
+            static const utfchar32_t replacement_marker = static_cast<utfchar32_t>(utf8::internal::mask16(0xfffd));
+            return utf8::unchecked::replace_invalid(start, end, out, replacement_marker);
+        }
+
+        inline std::string replace_invalid(const std::string& s, utfchar32_t replacement)
+        {
+            std::string result;
+            replace_invalid(s.begin(), s.end(), std::back_inserter(result), replacement);
+            return result;
+        }
+
+        inline std::string replace_invalid(const std::string& s)
+        {
+            std::string result;
+            replace_invalid(s.begin(), s.end(), std::back_inserter(result));
+            return result;
+        }
+
+        template <typename octet_iterator>
+        utfchar32_t next(octet_iterator& it)
+        {
+            utfchar32_t cp = utf8::internal::mask8(*it);
+            switch (utf8::internal::sequence_length(it)) {
+                case 1:
+                    break;
+                case 2:
+                    ++it;
+                    cp = ((cp << 6) & 0x7ff) + ((*it) & 0x3f);
+                    break;
+                case 3:
+                    ++it;
+                    cp = ((cp << 12) & 0xffff) + ((utf8::internal::mask8(*it) << 6) & 0xfff);
+                    ++it;
+                    cp = static_cast<utfchar32_t>(cp + ((*it) & 0x3f));
+                    break;
+                case 4:
+                    ++it;
+                    cp = ((cp << 18) & 0x1fffff) + ((utf8::internal::mask8(*it) << 12) & 0x3ffff);
+                    ++it;
+                    cp = static_cast<utfchar32_t>(cp + ((utf8::internal::mask8(*it) << 6) & 0xfff));
+                    ++it;
+                    cp = static_cast<utfchar32_t>(cp + ((*it) & 0x3f));
+                    break;
+            }
+            ++it;
+            return cp;
+        }
+
+        template <typename octet_iterator>
+        utfchar32_t peek_next(octet_iterator it)
+        {
+            return utf8::unchecked::next(it);
+        }
+
+        template <typename word_iterator>
+        utfchar32_t next16(word_iterator& it)
+        {
+            utfchar32_t cp = utf8::internal::mask16(*it++);
+            if (utf8::internal::is_lead_surrogate(cp))
+                return (cp << 10) + *it++ + utf8::internal::SURROGATE_OFFSET;
+            return cp;
+        }
+
+        template <typename octet_iterator>
+        utfchar32_t prior(octet_iterator& it)
+        {
+            while (utf8::internal::is_trail(*(--it))) ;
+            octet_iterator temp = it;
+            return utf8::unchecked::next(temp);
+        }
+
+        template <typename octet_iterator, typename distance_type>
+        void advance(octet_iterator& it, distance_type n)
+        {
+            const distance_type zero(0);
+            if (n < zero) {
+                // backward
+                for (distance_type i = n; i < zero; ++i)
+                    utf8::unchecked::prior(it);
+            } else {
+                // forward
+                for (distance_type i = zero; i < n; ++i)
+                    utf8::unchecked::next(it);
+            }
+        }
+
+        template <typename octet_iterator>
+        typename std::iterator_traits<octet_iterator>::difference_type
+        distance(octet_iterator first, octet_iterator last)
+        {
+            typename std::iterator_traits<octet_iterator>::difference_type dist;
+            for (dist = 0; first < last; ++dist)
+                utf8::unchecked::next(first);
+            return dist;
+        }
+
+        template <typename u16bit_iterator, typename octet_iterator>
+        octet_iterator utf16to8(u16bit_iterator start, u16bit_iterator end, octet_iterator result)
+        {
+            while (start != end) {
+                utfchar32_t cp = utf8::internal::mask16(*start++);
+                // Take care of surrogate pairs first
+                if (utf8::internal::is_lead_surrogate(cp)) {
+                    if (start == end)
+                        return result;
+                    utfchar32_t trail_surrogate = utf8::internal::mask16(*start++);
+                    cp = (cp << 10) + trail_surrogate + internal::SURROGATE_OFFSET;
+                }
+                result = utf8::unchecked::append(cp, result);
+            }
+            return result;
+        }
+
+        template <typename u16bit_iterator, typename octet_iterator>
+        u16bit_iterator utf8to16(octet_iterator start, octet_iterator end, u16bit_iterator result)
+        {
+            while (start < end) {
+                utfchar32_t cp = utf8::unchecked::next(start);
+                if (cp > 0xffff) { //make a surrogate pair
+                    *result++ = static_cast<utfchar16_t>((cp >> 10)   + internal::LEAD_OFFSET);
+                    *result++ = static_cast<utfchar16_t>((cp & 0x3ff) + internal::TRAIL_SURROGATE_MIN);
+                }
+                else
+                    *result++ = static_cast<utfchar16_t>(cp);
+            }
+            return result;
+        }
+
+        template <typename octet_iterator, typename u32bit_iterator>
+        octet_iterator utf32to8(u32bit_iterator start, u32bit_iterator end, octet_iterator result)
+        {
+            while (start != end)
+                result = utf8::unchecked::append(*(start++), result);
+
+            return result;
+        }
+
+        template <typename octet_iterator, typename u32bit_iterator>
+        u32bit_iterator utf8to32(octet_iterator start, octet_iterator end, u32bit_iterator result)
+        {
+            while (start < end)
+                (*result++) = utf8::unchecked::next(start);
+
+            return result;
+        }
+
+        // The iterator class
+        template <typename octet_iterator>
+          class iterator {
+            octet_iterator it;
+            public:
+            typedef utfchar32_t value_type;
+            typedef utfchar32_t* pointer;
+            typedef utfchar32_t& reference;
+            typedef std::ptrdiff_t difference_type;
+            typedef std::bidirectional_iterator_tag iterator_category;
+            iterator () {}
+            explicit iterator (const octet_iterator& octet_it): it(octet_it) {}
+            // the default "big three" are OK
+            octet_iterator base () const { return it; }
+            utfchar32_t operator * () const
+            {
+                octet_iterator temp = it;
+                return utf8::unchecked::next(temp);
+            }
+            bool operator == (const iterator& rhs) const
+            {
+                return (it == rhs.it);
+            }
+            bool operator != (const iterator& rhs) const
+            {
+                return !(operator == (rhs));
+            }
+            iterator& operator ++ ()
+            {
+                ::std::advance(it, utf8::internal::sequence_length(it));
+                return *this;
+            }
+            iterator operator ++ (int)
+            {
+                iterator temp = *this;
+                ::std::advance(it, utf8::internal::sequence_length(it));
+                return temp;
+            }
+            iterator& operator -- ()
+            {
+                utf8::unchecked::prior(it);
+                return *this;
+            }
+            iterator operator -- (int)
+            {
+                iterator temp = *this;
+                utf8::unchecked::prior(it);
+                return temp;
+            }
+          }; // class iterator
+
+    } // namespace utf8::unchecked
+} // namespace utf8
+
+#endif // header guard
+

src/CMakeLists.txt

@@ -85,4 +85,5 @@ target_sources(${PROJECT_NAME}
         ui/error_ui.cpp
         localization.cpp
         tools/system_locate.cpp
+        ui/chat_box.cpp
 )

src/app.cpp

@@ -823,11 +823,15 @@ std::string App::get_clipboard_text() {
 }
 
 void App::start_text_input() {
+    Logger::info("Start Text Input");
     if (!SDL_StartTextInput(m_window.get_window())) {
         Logger::error("Start Text Input Fail: {}", SDL_GetError());
     }
 }
-void App::stop_text_input() { SDL_StopTextInput(m_window.get_window()); }
+void App::stop_text_input() {
+    Logger::info("Stop Text Input");
+    SDL_StopTextInput(m_window.get_window());
+}
 
 void App::update_text_input_area(const glm::vec4& textbox,
                                  float cursor_position_x) {

src/render/renderer.cpp

@@ -183,6 +183,9 @@ void Renderer::render_lable(const Label& label) {
 
     Font::get().text_texture()->bind(0);
     auto& data = label.data();
+    if (!data.m_vao) {
+        return;
+    }
     auto pos = label.pos();
     auto& text_style = label.text_style();
     auto color = color_value(text_style.color);

src/scene/world_scene.cpp

@@ -98,7 +98,12 @@ bool WorldScene::handle_event(const Event& e) {
                        }
                        return false;
                    },
-                   [](const TextInputEvent&) { return false; },
+                   [this](const TextInputEvent& e) {
+                       if (handle_text_input_event(e)) {
+                           return true;
+                       }
+                       return false;
+                   },
                    [this](const WindowResizeEvent& e) {
                        handle_window_resize_event(e);
                        return false;
@@ -257,6 +262,17 @@ bool WorldScene::handle_key_event(const KeyEvent& e) {
         m_show_dev_pannel = !m_show_dev_pannel;
         return true;
     }
+
+    if (e.key == Key::T && e.action == KeyAction::PRESS) {
+        if (m_chatting) {
+            set_chatting(false);
+        } else {
+            set_chatting(true);
+        }
+
+        return true;
+    }
+
     if (m_paused) {
         if (m_pasue_menu.handle_event(e)) {
             return true;
@@ -265,6 +281,9 @@ bool WorldScene::handle_key_event(const KeyEvent& e) {
         if (m_hud_ui.handle_event(e)) {
             return true;
         }
+        if (m_chatting) {
+            return true;
+        }
         if (m_camera.handle_event(e)) {
             return true;
         }
@@ -276,6 +295,14 @@ bool WorldScene::handle_key_event(const KeyEvent& e) {
     return false;
 }
 
+bool WorldScene::handle_text_input_event(const TextInputEvent& e) {
+    if (m_paused) {
+        return m_pasue_menu.handle_text_input_event(e);
+    }
+    Logger::info("Hud ui handle text input");
+    return m_hud_ui.handle_text_input_event(e);
+}
+
 Camera& WorldScene::camera() { return m_camera; }
 SceneManager& WorldScene::scene_manager() { return m_scene_manager; }
 ClientWorld& WorldScene::client_world() { return m_client_world; }
@@ -286,13 +313,27 @@ void WorldScene::set_pause(bool pause) {
         return;
     }
     m_paused = pause;
+    set_mouse(pause);
+}
+
+void WorldScene::set_mouse(bool enable) {
     auto& window = m_scene_manager.app().window();
-    window.set_game_running(!m_paused);
+    window.set_game_running(!enable);
-    if (m_paused) {
+    if (enable) {
         m_client_world.reset_key_status();
     }
 }
 
+void WorldScene::set_chatting(bool chatting) {
+    if (m_paused) {
+        return;
+    }
+    m_chatting = chatting;
+    set_mouse(chatting);
+    m_hud_ui.set_chatting(chatting);
+    Logger::info("World Scene Chatting {}", chatting);
+}
+
 void WorldScene::set_error(std::string_view error) {
     Logger::error("WorldScene Error Set {}", error);
     m_error_ui.set_error(error);

src/ui/chat_box.cpp

@@ -0,0 +1,114 @@
+#include "Cubed/ui/chat_box.hpp"
+
+#include "Cubed/tools/text_tools.hpp"
+namespace Cubed {
+ChatBox::ChatBox(Widget* parent) : Widget(parent) {
+
+    m_text_field = std::make_unique<TextField>(this);
+}
+
+void ChatBox::add_message(ChatMessage& message) {
+    while (m_messages.size() > MAX_MESSGAES_SUM) {
+        m_messages.pop_front();
+    }
+
+    std::string str = std::format("<{}>{}", message.player, message.text);
+
+    auto split_str = split_utf8(str, 20);
+    for (auto it = split_str.rbegin(); it != split_str.rend(); ++it) {
+        auto lable = std::make_unique<Label>(this);
+        lable->set_text(*it)
+            .set_scale(m_text_scale)
+            .set_anchor(Anchor::TOP_LEFT);
+        m_messages.emplace_back(std::move(lable), message.time);
+    }
+}
+
+ChatBox& ChatBox::set_scale(float scale) {
+    m_scale = scale;
+    m_text_field->set_scale(scale);
+    return *this;
+}
+ChatBox& ChatBox::set_text_scale(float scale) {
+    m_text_scale = scale;
+
+    for (auto& text : m_messages) {
+        text.label->set_scale(scale);
+    }
+
+    return *this;
+}
+ChatBox& ChatBox::set_width(float width) {
+    m_width = width;
+    m_text_field->set_width(width);
+    return *this;
+}
+ChatBox& ChatBox::set_show_lines(int lines) {
+    m_lines = lines;
+    return *this;
+}
+ChatBox& ChatBox::set_spacing(float spacing) {
+    m_spacing = spacing;
+    return *this;
+}
+float ChatBox::width() const { return m_width * m_scale; }
+float ChatBox::height() const { return m_height * m_scale; }
+void ChatBox::set_d_image(TextureManager& m) {
+    m_text_field->set_default_image(m);
+}
+
+void ChatBox::set_typing(bool typing) { m_text_field->set_typing(typing); }
+void ChatBox::set_app(App* app) { m_text_field->set_app(app); }
+
+void ChatBox::layout() {
+    set_offset({0, m_text_field->height()});
+    int y = 0;
+    int line = 0;
+    for (auto it = m_messages.rbegin(); it != m_messages.rend(); ++it) {
+        if (!it->label) {
+            continue;
+        }
+        if (line > m_lines) {
+            it->render = false;
+            continue;
+        }
+        ++line;
+        it->label->set_anchor(Anchor::TOP_LEFT);
+        it->label->set_offset({0, y});
+        it->render = true;
+        y += it->label->height() + m_spacing;
+    }
+    m_height = m_lines == 0 ? 0 : (y - m_spacing);
+}
+void ChatBox::on_update(float dt) {
+    layout();
+
+    m_text_field->update(dt);
+}
+
+void ChatBox::on_render(Renderer& renderer) {
+    m_text_field->render(renderer);
+    for (auto it = m_messages.rbegin(); it != m_messages.rend(); ++it) {
+        if (!it->label) {
+            continue;
+        }
+        if (it->render) {
+            it->label->render(renderer);
+        }
+    }
+}
+bool ChatBox::handle_text_input_event(const TextInputEvent& e) {
+    if (m_text_field->handle_text_input_event(e)) {
+        return true;
+    }
+    return Widget::handle_text_input_event(e);
+}
+
+bool ChatBox::handle_key_event(const KeyEvent& e) {
+    if (m_text_field->handle_key_event(e)) {
+        return true;
+    }
+    return Widget::handle_key_event(e);
+}
+
+} // namespace Cubed

src/ui/credits_ui.cpp

@@ -48,7 +48,6 @@ void CreditsUI::init() {
         add_text("Author: zhenyan121");
         add_text("Libraries Used", 0.8f);
         add_text("glad");
-        add_text("GLFW");
         add_text("SDL3");
         add_text("SOIL2");
         add_text("GLM");
@@ -63,6 +62,7 @@ void CreditsUI::init() {
         add_text("dr_libs");
         add_text("nlohmann/json");
         add_text("HarfBuzz");
+        add_text("utf8cpp");
         add_text("Music", 0.8f);
         add_text("'Find a Peaceful Place' by ROZKOL (Free Music Archive), CC "
                  "BY 4.0.");

src/ui/text_field.cpp

@@ -149,6 +149,34 @@ TextField& TextField::set_app(App* app) {
     m_app = app;
     return *this;
 }
+
+TextField& TextField::set_typing(bool typing) {
+    Logger::info("Typing {}", typing);
+    m_typing = typing;
+    if (m_typing) {
+        start_typing();
+    } else {
+        stop_typing();
+    }
+
+    return *this;
+}
+
+void TextField::start_typing() {
+    if (m_app) {
+        m_app->start_text_input();
+    }
+    update_show_text();
+}
+void TextField::stop_typing() {
+    if (m_app) {
+        m_app->stop_text_input();
+    }
+    if (m_on_finished) {
+        m_on_finished();
+    }
+}
+
 const std::string& TextField::input_text() const { return m_input_text; }
 
 bool TextField::handle_mouse_move_event(const MouseMoveEvent& e) {
@@ -166,20 +194,12 @@ bool TextField::handle_mouse_button_event(const MouseButtonEvent& e) {
     if (e.key == MouseKey::LEFT_BUTTON && e.action == KeyAction::PRESS) {
         if (m_inside) {
             m_typing = true;
-            if (m_app) {
+            start_typing();
-                m_app->start_text_input();
-            }
-            update_show_text();
             return false;
         } else {
             if (m_typing) {
                 m_typing = false;
-                if (m_app) {
+                stop_typing();
-                    m_app->stop_text_input();
-                }
-                if (m_on_finished) {
-                    m_on_finished();
-                }
 
                 return false;
             }
@@ -188,6 +208,7 @@ bool TextField::handle_mouse_button_event(const MouseButtonEvent& e) {
     return false;
 }
 bool TextField::handle_text_input_event(const TextInputEvent& e) {
+    Logger::info("Recive Text Input Event");
     if (m_typing) {
         m_input_text.append(e.text);
         update_show_text();

src/ui/world_ui_manager.cpp

@@ -5,23 +5,46 @@
 #include "Cubed/render/renderer.hpp"
 #include "Cubed/scene/scene_manager.hpp"
 #include "Cubed/scene/world_scene.hpp"
+#include "Cubed/ui/chat_box.hpp"
 namespace Cubed {
 
 WorldUIManager::WorldUIManager(WorldScene& scene) : m_scene(scene) {}
 WorldUIManager::~WorldUIManager() {}
 
 void WorldUIManager::init() {
-    auto crosshair = std::make_unique<Image>(nullptr);
 
-    crosshair->set_image("texture/ui/0.png",
+    m_root_widget = std::make_unique<Widget>(nullptr);
-                         m_scene.scene_manager().app().texture_manager());
     auto& renderer = m_scene.scene_manager().app().renderer();
-    crosshair->set_window_size(renderer.window_width(),
+
-                               renderer.window_height());
+    m_root_widget->set_window_size(renderer.window_width(),
-    crosshair->set_anchor(Anchor::CENTER);
+                                   renderer.window_height());
-    crosshair->set_scale(3.0f);
+
-    m_widgets.try_emplace("crosshair", crosshair.get());
+    auto& crosshair = m_root_widget->add_child<Image>();
-    m_root_widget = std::move(crosshair);
+
+    crosshair.set_image("texture/ui/0.png",
+                        m_scene.scene_manager().app().texture_manager());
+    crosshair.set_window_size(renderer.window_width(),
+                              renderer.window_height());
+    crosshair.set_anchor(Anchor::CENTER);
+    crosshair.set_scale(3.0f);
+    m_widgets.try_emplace("crosshair", &crosshair);
+
+    auto& chat_box = m_root_widget->add_child<ChatBox>();
+    chat_box.set_scale(10);
+    chat_box.set_anchor(Anchor::BOTTOM_LEFT);
+    chat_box.set_offset({0, -10});
+    chat_box.set_width(200);
+    chat_box.set_scale(3.0f);
+    chat_box.set_text_scale(0.5f);
+    ChatMessage m{"zhenyan121", "原神能不能牛逼原神牛逼", 2020};
+    ChatMessage m1{"zhenyan121", "原神能不能wdadaw牛逼原神牛逼12q432raecawfa",
+                   2021};
+    chat_box.add_message(m);
+    chat_box.add_message(m1);
+    chat_box.set_d_image(m_scene.scene_manager().app().texture_manager());
+    chat_box.set_app(&m_scene.scene_manager().app());
+    chat_box.set_on_finish([]() { Logger::info("Chat Input"); });
+    m_chat_box = &chat_box;
 }
 void WorldUIManager::render(Renderer& renderer) {
     renderer.begin_render_ui();
@@ -29,7 +52,18 @@ void WorldUIManager::render(Renderer& renderer) {
     auto& widget = DebugCollector::get().get_widget();
     widget.render(renderer);
     m_root_widget->render(renderer);
+
     renderer.end_render_ui();
 }
 
+void WorldUIManager::set_chatting(bool chantting) {
+    Logger::info("WorldUIManager Chatting {}", chantting);
+    m_chat_box->set_typing(chantting);
+}
+
+bool WorldUIManager::handle_key_event(const KeyEvent& e) {
+
+    return UIManager::handle_key_event(e);
+}
+
 } // namespace Cubed