[fix] a glitch where unloaded face(s) was crashing the entire application (must be log)

Author: mrsrina

include/ekg/draw/font_renderer.hpp

@@ -89,6 +89,7 @@ namespace ekg::draw {
     bool flag_first_time {true};
     bool font_face_changed {};
     bool font_size_changed {};
+    bool was_initialized {};
 
     ekg::gpu::allocator *p_allocator {};
     std::unordered_map<char32_t, ekg::draw::glyph_char_t> mapped_glyph_char_data {};

include/ekg/draw/typography.hpp

@@ -46,9 +46,10 @@ namespace ekg::draw {
   public:
     FT_Face ft_face {};
     FT_GlyphSlot ft_glyph_slot {};
-    std::string_view font_path {};
+    std::string font_path {};
     bool font_face_changed {};
     bool font_face_loaded {};
+    FT_Vector highest_glyph_size {};
   };
 
   bool reload_font_face(

include/ekg/ekg.hpp

@@ -64,7 +64,7 @@ namespace ekg {
 
   struct runtime_property {
   public:
-    const char *p_font_path {};
+    const char *p_font_path {""};
     const char *p_font_path_emoji {""};
     ekg::gpu::api *p_gpu_api {};
     ekg::os::platform *p_os_platform {};

include/ekg/util/io.hpp

@@ -179,6 +179,12 @@ namespace ekg {
 
     ~log() {
       ekg::log::buffer << '\n';
+      #define EKG_LOG_DEBUG
+      #ifdef EKG_LOG_DEBUG
+      ekg::log::buffered = true;
+      ekg::log::flush();
+      ekg_log("");
+      #endif
     }
 
     template<typename t>

libekg.a

@@ -52,6 +52,7 @@ ekg::stack ekg::runtime::front {};
 ekg::current_hovered_state ekg::hovered {};
 
 void ekg::runtime::update_size_changed() {
+  ekg::log() << "Refreshing layout and font sizes!";
   ekg::layout::scale_calculate();
 
   uint32_t font_size {
@@ -573,7 +574,7 @@ void ekg::runtime::prepare_ui_env() {
   this->f_renderer_small.bind_allocator(&this->gpu_allocator);
 
   this->f_renderer_normal.sampler_texture.gl_protected_active_index = true;
-  this->f_renderer_normal.set_size(0);
+  this->f_renderer_normal.set_size(18);
   this->f_renderer_normal.bind_allocator(&this->gpu_allocator);
 
   this->f_renderer_big.sampler_texture.gl_protected_active_index = true;

src/core/runtime.cpp

@@ -34,7 +34,7 @@ ekg::gpu::sampler_t *ekg::draw::font_renderer::get_sampler_texture() {
 }
 
 float ekg::draw::font_renderer::get_text_width(std::string_view text, int32_t &lines) {
-  if (text.empty()) {
+  if (text.empty() || (!this->font_face_text.font_face_loaded && !this->font_face_emoji.font_face_loaded)) {
     return 0.0f;
   }
 
@@ -101,7 +101,7 @@ float ekg::draw::font_renderer::get_text_width(std::string_view text, int32_t &l
 }
 
 float ekg::draw::font_renderer::get_text_width(std::string_view text) {
-  if (text.empty()) {
+  if (text.empty() || (!this->font_face_text.font_face_loaded && !this->font_face_emoji.font_face_loaded)) {
     return 0.0f;
   }
 
@@ -168,15 +168,15 @@ float ekg::draw::font_renderer::get_text_height() {
 }
 
 void ekg::draw::font_renderer::set_font(std::string_view path) {
-  if (this->font_face_text.font_path != path) {
+  if (!path.empty() && this->font_face_text.font_path != path) {
     this->font_face_text.font_path = path;
     this->font_face_text.font_face_changed = true;
     this->reload();
   }
 }
 
 void ekg::draw::font_renderer::set_font_emoji(std::string_view path) {
-  if (this->font_face_emoji.font_path != path) {
+  if (!path.empty() && this->font_face_emoji.font_path != path) {
     this->font_face_emoji.font_path = path;
     this->font_face_emoji.font_face_changed = true;
     this->reload();
@@ -192,24 +192,35 @@ void ekg::draw::font_renderer::set_size(uint32_t size) {
 }
 
 void ekg::draw::font_renderer::reload() {
-  if (this->font_size == 0) {
+  if (this->font_size == 0 || (this->font_face_text.font_path.empty() && this->font_face_emoji.font_path.empty())) {
     return;
   }
 
   if (
-      (!this->font_face_text.font_path.empty() && ekg::draw::reload_font_face(&this->font_face_text, this->font_size_changed, this->font_size)) ||
-      (!this->font_face_emoji.font_path.empty() && ekg::draw::reload_font_face(&this->font_face_emoji, this->font_size_changed, this->font_size))
+      (
+        !this->font_face_text.font_path.empty()
+        &&
+        ekg::draw::reload_font_face(&this->font_face_text, this->font_size_changed, this->font_size)
+      )
+      ||
+      (
+        !this->font_face_emoji.font_path.empty()
+        &&
+        ekg::draw::reload_font_face(&this->font_face_emoji, this->font_size_changed, this->font_size)
+      )
     ) {
     ekg::log() << "Failed to load font face, text: " << this->font_face_text.font_face_loaded << " , emoji: " << this->font_face_emoji.font_face_loaded;
     return;
   }
 
   this->font_size_changed = false;
 
-  /* Phase of getting bitmap texture bounds. */
   this->full_width = 0;
   this->full_height = 0;
 
+  this->font_face_text.highest_glyph_size = FT_Vector {};
+  this->font_face_emoji.highest_glyph_size = FT_Vector {};
+
   this->ft_bool_kerning = FT_HAS_KERNING(this->font_face_text.ft_face);
   this->font_face_text.ft_glyph_slot = this->font_face_text.ft_face->glyph;
 
@@ -219,22 +230,25 @@ void ekg::draw::font_renderer::reload() {
 
   FT_GlyphSlot ft_glyph_slot {};
   FT_Face ft_face {};
-
   ekg::flags flags {};
 
+  ekg::draw::font_face_t *p_font_face_picked {};
+
   for (char32_t &char32 : this->loaded_sampler_generate_list) {
     switch (char32 < 256 || !this->font_face_emoji.font_face_loaded) {
       case true: {
         ft_face = this->font_face_text.ft_face;
         ft_glyph_slot = this->font_face_text.ft_face->glyph;
         flags = FT_LOAD_RENDER;
+        p_font_face_picked = &this->font_face_text;
         break;
       }
 
       default: {
         ft_face = this->font_face_emoji.ft_face;
         ft_glyph_slot = this->font_face_emoji.ft_face->glyph;
         flags = FT_LOAD_RENDER | FT_LOAD_COLOR;
+        p_font_face_picked = &this->font_face_emoji;
         break;
       }
     }
@@ -253,7 +267,17 @@ void ekg::draw::font_renderer::reload() {
     char_data.wsize = static_cast<float>(static_cast<int32_t>(ft_glyph_slot->advance.x >> 6));
 
     this->full_width += static_cast<int32_t>(char_data.w);
-    this->full_height = std::max(this->full_height, static_cast<int32_t>(ft_glyph_slot->bitmap.rows));
+    this->full_height = ekg_min(this->full_height, static_cast<int32_t>(char_data.h));
+
+    p_font_face_picked->highest_glyph_size.x = ekg_min(
+      p_font_face_picked->highest_glyph_size.x,
+      static_cast<int32_t>(char_data.w)
+    );
+
+    p_font_face_picked->highest_glyph_size.y = ekg_min(
+      p_font_face_picked->highest_glyph_size.y,
+      static_cast<int32_t>(char_data.h)
+    );
   }
 
   this->text_height = static_cast<float>(this->font_size);
@@ -420,19 +444,27 @@ void ekg::draw::font_renderer::blit(std::string_view text, float x, float y, con
 void ekg::draw::font_renderer::flush() {
   uint64_t size {this->loaded_sampler_generate_list.size()};
   if (this->last_sampler_generate_list_size != size) {
+    ekg::log() << "Sampler updated from-to: " << this->last_sampler_generate_list_size << " " << size;
+ 
     this->reload();
     this->last_sampler_generate_list_size = size;
     ekg::ui::redraw = true;
   }
 }
 
 void ekg::draw::font_renderer::init() {
+  if (this->was_initialized) {
+    return;
+  }
+
+  this->was_initialized = true;
+
   this->loaded_sampler_generate_list.resize(256);
   for (char32_t char32 {}; char32 < 256; char32++) {
     this->loaded_sampler_generate_list[char32] = char32;
   }
 
-  ekg::log() << "Initializing 256 chars rendereable";
+  ekg::log() << "Initializing 256 default chars!";
 }
 
 void ekg::draw::font_renderer::quit() {

src/draw/font_renderer.cpp

@@ -329,13 +329,43 @@ uint64_t ekg::os::opengl::generate_font_atlas(
   std::unordered_map<char32_t, ekg::draw::glyph_char_t> &mapped_glyph_char_data,
   float &non_swizzlable_range
 ) {
-  bool is_current_opengl_version_gl_es {
-    this->opengl_version == ekg::os::opengl_version::es
+  FT_Vector highest_glyph_size {
+    (
+      p_font_face_text->highest_glyph_size.x
+      *
+      p_font_face_text->highest_glyph_size.y
+    )
+    >
+    (
+      p_font_face_emoji->highest_glyph_size.x
+      *
+      p_font_face_emoji->highest_glyph_size.y
+    )
+    ? (p_font_face_text->highest_glyph_size) : (p_font_face_emoji->highest_glyph_size)
   };
 
   GLint sub_image_format {
-    is_current_opengl_version_gl_es ? GL_RGBA : GL_RED
+    GL_RED
+  };
+
+  bool is_current_opengl_version_gl_es {
+    this->opengl_version == ekg::os::opengl_version::es
   };
+
+  std::vector<unsigned char> r8_to_r8g8b8a8_swizzled_image {};
+  unsigned char *p_current_image_buffer {};
+
+  if (is_current_opengl_version_gl_es) {
+    sub_image_format = GL_RGBA;
+
+    r8_to_r8g8b8a8_swizzled_image.resize(
+      highest_glyph_size.x
+      *
+      highest_glyph_size.y
+      *
+      4
+    );
+  }
 
   if (!p_sampler->gl_id) {
     glGenTextures(1, &p_sampler->gl_id);
@@ -366,10 +396,6 @@ uint64_t ekg::os::opengl::generate_font_atlas(
   FT_Face ft_face {};
   FT_Vector char_size {};
 
-  std::vector<unsigned char> r8_to_r8g8b8a8_swizzled_image {};
-  unsigned char *p_current_image_buffer {};
-  size_t previous_size {1};
-
   ekg::flags flags {};
   float offset {};
 
@@ -413,18 +439,6 @@ uint64_t ekg::os::opengl::generate_font_atlas(
       char_size.x = char_data.w;
       char_size.y = char_data.h;
 
-      if (r8_to_r8g8b8a8_swizzled_image.size() != previous_size) {
-        r8_to_r8g8b8a8_swizzled_image.resize(
-          static_cast<size_t>(char_size.x)
-          *
-          static_cast<size_t>(char_size.y)
-          *
-          static_cast<size_t>(4)
-        );
-
-        previous_size = r8_to_r8g8b8a8_swizzled_image.size();
-      }
-
       ekg::format_convert_result result {
         ekg::image_src_r8_convert_to_r8g8b8a8(
           char_size,

src/os/ekg_opengl.cpp

@@ -28,6 +28,8 @@
 #include "ekg/ekg.hpp"
 
 void ekg::service::input::init() {
+  ekg::log() << "Initialising input-bind system!";
+
   /**
    * Forced null termination at end due the necessary optmization,
    * when changing dynamically the special key state.

src/service/input.cpp

@@ -464,7 +464,7 @@ int32_t showcase_useless_window() {
 
   ekg::runtime_property ekg_runtime_property {
     .p_font_path = "comic-mono.ttf",
-    .p_font_path_emoji = "twemoji.ttf",
+    //.p_font_path_emoji = "twemoji.ttf",
     .p_gpu_api = new ekg::os::opengl("#version 300 es \nprecision highp float;"),
     //.p_gpu_api = new ekg::os::opengl("#version 450"),
     .p_os_platform = new ekg::os::sdl(app.p_sdl_win)
@@ -1044,9 +1044,9 @@ void test_out_of_context_uis() {
 int32_t laboratory_testing() {
   SDL_Init(SDL_INIT_VIDEO);
 
-  SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE);
-  SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 4);
-  SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 4);
+  SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_ES);
+  SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3);
+  SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 0);
   SDL_GL_SetSwapInterval((app.vsync = true));
 
   app.p_sdl_win = {
@@ -1066,10 +1066,14 @@ int32_t laboratory_testing() {
   glewExperimental = GL_TRUE;
   glewInit();
 
+  ekg::ui::auto_scale = false;
+  ekg::ui::scale = {1280, 800};
+
   ekg::runtime_property ekg_runtime_property {
-    .p_font_path = "whitneybook.otf",
-    .p_font_path_emoji = "twemoji.ttf",
-    .p_gpu_api = new ekg::os::opengl("#version 450"),
+    //.p_font_path = "comic-mono.ttf",
+    //.p_font_path_emoji = "twemoji.ttf",
+    .p_gpu_api = new ekg::os::opengl("#version 300 es \nprecision highp float;"),
+    //.p_gpu_api = new ekg::os::opengl("#version 450"),
     .p_os_platform = new ekg::os::sdl(app.p_sdl_win)
   };
 
@@ -1612,6 +1616,7 @@ int32_t laboratory_testing() {
   };
 
   ekg::label("meow", ekg::dock::fill | ekg::dock::next)->set_scaled_height(6);
+  ekg::textbox("oi", "idk", ekg::dock::fill | ekg::dock::next);
 
   /*
   ekg::gpu::sampler_t meow_sampler {};
@@ -1676,5 +1681,5 @@ int32_t laboratory_testing() {
 }
 
 int32_t main(int32_t, char**) {
-  return showcase_useless_window();
+  return laboratory_testing();
 }