ResourceStoreInspector.cpp

#include "Inspectors.h"
 
#include "InspectorGuiHelper.h"
#include "Context.h"
#include "Resources/ResourceStore.h"
#include "Resources/ResourceStoreStorage.h"
 
#include "imgui.h"
#include <cctype>
#include <list>
 
 
void Cogs::Core::resourceStoreInspector(Context * context, bool * show)
{
  if (*show) {
    ImGui::SetNextWindowSize(ImVec2(600, 400), ImGuiCond_Once);
 
    LockGuard lock(context->resourceStore->data->cache->lock);
 
    std::list<std::string> keys;
    for (const auto & it : context->resourceStore->data->cache->resources) {
      keys.push_back(it.first);
    }
    keys.sort();
 
 
    std::string windowHeader;
    windowHeader.reserve(50);
    windowHeader.append("Resources [");
    windowHeader.append(std::to_string(keys.size()));
    windowHeader.append("]");
 
    guiBegin(windowHeader, show);
 
    for (const auto & key : keys) {
      if (ImGui::TreeNode(key.c_str())) {
        const auto & resource = context->resourceStore->data->cache->resources[key];
 
        ImGui::Text("Name: %s", resource.name.c_str());
        ImGui::Text("Path: %s", resource.path.c_str());
        ImGui::Text("Size: %zu (0x%zx) bytes", resource.bytes.size(), resource.bytes.size());
 
        if (ImGui::TreeNode("Text view")) {
          ImGui::Separator();
          const auto size = resource.bytes.size();
          const auto * data = reinterpret_cast<const char*>(resource.bytes.data());
 
          uint32_t l = 1;
          for (size_t a = 0; a < size; ) {
            // Search for line start
            for (; a < size; a++) {
              if (data[a] == '\r');
              else if (data[a] == '\n') l++;
              else break;
            }
            // Search for end of line
            auto b = a;
            for (; b < size; b++) {
              if ((data[b] == '\r') || (data[b] == '\n')) break;
            }
 
            if (a < b) {
              ImGui::Text("%4d ", l);
              ImGui::SameLine();
              ImGui::TextUnformatted(data + a, data + b);
              a = b;
            }
            else break;
          }
          ImGui::Separator();
          ImGui::TreePop();
        }
        if (ImGui::TreeNode("Hex dump")) {
          static constexpr char tab[16] = {
            '0', '1', '2', '3', '4', '5', '6', '7',
            '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'
          };
 
          char buf[10 + 3 * 16 + 1 + 16 + 1];
 
          ImGui::Separator();
 
          auto data = resource.bytes.toSpan<uint8_t>();
          const size_t size = data.size();
 
          for (size_t o = 0; o < size; o += 16) {
            std::memset(buf, ' ', sizeof(buf));
 
            for (unsigned i = 0; i < 8; i++) {
              buf[i] = tab[(o >> (24 - 4 * i)) & 0xf];
            }
            buf[8] = ':';
 
            buf[10 + 3 * 16] = '"';
            buf[10 + 3 * 16 + 1 + std::min((size - o), (size_t)16)] = '"';
            for (unsigned i = 0; i < 16; i++) {
              if (o + i < size) {
                buf[10 + 3 * i + 0] = tab[((data[o + i] >> 4) & 0xf)];
                buf[10 + 3 * i + 1] = tab[((data[o + i] >> 0) & 0xf)];
                if ((33 <= data[o + i]) && (data[o + i] <= 127)) {
                  buf[10 + 3 * 16 + 1 + i] = data[o + i];
                }
              }
            }
            ImGui::TextUnformatted(buf, buf + sizeof(buf));
          }
 
          ImGui::Separator();
          ImGui::TreePop();
        }
        ImGui::TreePop();
      }
    }
 
    guiEnd();
  }
}