ImguiRenderer.cpp

#include "ImguiRenderer.h"
 
#include "../../Context.h"
#include "../../ViewContext.h"
 
#include "Input/KeyboardMapping.h"
#include "Renderer/IRenderer.h"
#include "Resources/ResourceStore.h"
 
#include "Rendering/IGraphicsDevice.h"
#include "Rendering/IContext.h"
#include "Rendering/IBuffers.h"
#include "Rendering/ITextures.h"
#include "Rendering/IEffects.h"
#include "Rendering/IRenderTargets.h"
#include "Rendering/ICapabilities.h"
#include "Rendering/CommandGroupAnnotation.h"
#include "Services/DPIService.h"
 
#include "Foundation/Logging/Logger.h"
#include "Foundation/Platform/Keyboard.h"
#include "Foundation/Platform/Mouse.h"
 
#include <set>
#include "imgui.h"
#include "imgui_internal.h"
 
#include <glm/mat4x4.hpp>
#include <glm/ext/matrix_projection.hpp>
 
#include <algorithm>
#include <iterator>
 
namespace
{
  const Cogs::Logging::Log      logger = Cogs::Logging::getLogger("ImguiRenderer");
  std::set<ImGuiContext*> guiContexts;
 
  struct ImguiConstants
  {
    glm::mat4 projectionMatrix;
    int showAlpha;
    int texMode;
    int offset;
    int output_sRGB;
  };
 
  void dummyRenderCallback(const ImDrawList* /*parent_list*/, const ImDrawCmd* /*cmd*/)
  {
    LOG_WARNING(logger, "Calling dummyRenderCallback");
  }
 
  ImGuiKey CogsKeyToImGuiKey(Cogs::Key key) {
    switch (key) {
      case Cogs::Key::A:                return ImGuiKey_A;
      case Cogs::Key::B:                return ImGuiKey_B;
      case Cogs::Key::C:                return ImGuiKey_C;
      case Cogs::Key::D:                return ImGuiKey_D;
      case Cogs::Key::E:                return ImGuiKey_E;
      case Cogs::Key::F:                return ImGuiKey_F;
      case Cogs::Key::G:                return ImGuiKey_G;
      case Cogs::Key::H:                return ImGuiKey_H;
      case Cogs::Key::I:                return ImGuiKey_I;
      case Cogs::Key::J:                return ImGuiKey_J;
      case Cogs::Key::K:                return ImGuiKey_K;
      case Cogs::Key::L:                return ImGuiKey_L;
      case Cogs::Key::M:                return ImGuiKey_M;
      case Cogs::Key::N:                return ImGuiKey_N;
      case Cogs::Key::O:                return ImGuiKey_O;
      case Cogs::Key::P:                return ImGuiKey_P;
      case Cogs::Key::Q:                return ImGuiKey_Q;
      case Cogs::Key::R:                return ImGuiKey_R;
      case Cogs::Key::S:                return ImGuiKey_S;
      case Cogs::Key::T:                return ImGuiKey_T;
      case Cogs::Key::U:                return ImGuiKey_U;
      case Cogs::Key::V:                return ImGuiKey_V;
      case Cogs::Key::W:                return ImGuiKey_W;
      case Cogs::Key::X:                return ImGuiKey_X;
      case Cogs::Key::Y:                return ImGuiKey_Y;
      case Cogs::Key::Z:                return ImGuiKey_Z;
      case Cogs::Key::Zero:             return ImGuiKey_0;
      case Cogs::Key::One:              return ImGuiKey_1;
      case Cogs::Key::Two:              return ImGuiKey_2;
      case Cogs::Key::Three:            return ImGuiKey_3;
      case Cogs::Key::Four:             return ImGuiKey_4;
      case Cogs::Key::Five:             return ImGuiKey_5;
      case Cogs::Key::Six:              return ImGuiKey_6;
      case Cogs::Key::Seven:            return ImGuiKey_7;
      case Cogs::Key::Eight:            return ImGuiKey_8;
      case Cogs::Key::Nine:             return ImGuiKey_9;
      case Cogs::Key::Left:             return ImGuiKey_LeftArrow;
      case Cogs::Key::Right:            return ImGuiKey_RightArrow;
      case Cogs::Key::Up:               return ImGuiKey_UpArrow;
      case Cogs::Key::Down:             return ImGuiKey_DownArrow;
      case Cogs::Key::Shift:
      case Cogs::Key::LeftShift:
      case Cogs::Key::RightShift:       return ImGuiMod_Shift;
      case Cogs::Key::Control:
      case Cogs::Key::LeftControl:
      case Cogs::Key::RightControl:     return ImGuiMod_Ctrl;
      case Cogs::Key::Alt:
      case Cogs::Key::LeftAlt:
      case Cogs::Key::RightAlt:         return ImGuiMod_Alt;
      case Cogs::Key::CapsLock:         return ImGuiKey_CapsLock;
      case Cogs::Key::Tab:              return ImGuiKey_Tab;
      case Cogs::Key::Escape:           return ImGuiKey_Escape;
      case Cogs::Key::Enter:            return ImGuiKey_Enter;
      case Cogs::Key::Space:            return ImGuiKey_Space;
      case Cogs::Key::Insert:           return ImGuiKey_Insert;
      case Cogs::Key::Delete:           return ImGuiKey_Delete;
      case Cogs::Key::Backspace:        return ImGuiKey_Backspace;
      case Cogs::Key::Home:             return ImGuiKey_Home;
      case Cogs::Key::End:              return ImGuiKey_End;
      case Cogs::Key::PageUp:           return ImGuiKey_PageUp;
      case Cogs::Key::PageDown:         return ImGuiKey_PageDown;
      case Cogs::Key::F1:               return ImGuiKey_F1;
      case Cogs::Key::F2:               return ImGuiKey_F2;
      case Cogs::Key::F3:               return ImGuiKey_F3;
      case Cogs::Key::F4:               return ImGuiKey_F4;
      case Cogs::Key::F5:               return ImGuiKey_F5;
      case Cogs::Key::F6:               return ImGuiKey_F6;
      case Cogs::Key::F7:               return ImGuiKey_F7;
      case Cogs::Key::F8:               return ImGuiKey_F8;
      case Cogs::Key::F9:               return ImGuiKey_F9;
      case Cogs::Key::F10:              return ImGuiKey_F10;
      case Cogs::Key::F11:              return ImGuiKey_F11;
      case Cogs::Key::F12:              return ImGuiKey_F12;
      default:                          return ImGuiKey_None;
    }
  }
 
}
 
GetClipboardTextFn Cogs::Core::ImguiRenderer::getClipboardTextFn = nullptr;
SetClipboardTextFn Cogs::Core::ImguiRenderer::setClipboardTextFn = nullptr;
 
ImDrawCallback Cogs::Core::setGuiMode = dummyRenderCallback;
 
bool Cogs::Core::ImguiRenderer::initialize(Cogs::Core::Context * context)
{
  auto & defaultFont = fontRegistry.fonts[0];
  fontRegistry.defaultFont = &defaultFont;
 
  float scaleFactor = context->getDefaultView()->dpiService->getScaleFactor();
 
  this->context = context;
  this->device = context->device;
 
  imguiContext = createGuiContext();
  ImGui::SetCurrentContext(imguiContext);
 
  // Default initialize font glyph cache to default font
  ImGuiIO& io = ImGui::GetIO();
  fontGlyphBuilder = ImFontGlyphRangesBuilder();
  // Add at least the default Glyph range so western characters are displayed
  fontGlyphBuilder.AddRanges(io.Fonts->GetGlyphRangesDefault());
  fontGlyphBuilder.BuildRanges(&loadedRanges);
 
#ifdef __EMSCRIPTEN__
  defaultFont.load(context, "Fonts/SourceSansPro-Regular.ttf", 20 * scaleFactor, loadedRanges.Data);
#elif defined(_WIN32)
  defaultFont.load(context, "C:/Windows/Fonts/segoeui.ttf", 16 * scaleFactor, loadedRanges.Data);
#elif defined(__linux__)
  defaultFont.load(context, "/usr/share/fonts/truetype/freefont/FreeSans.ttf", 16 * scaleFactor, loadedRanges.Data);
#elif defined(__APPLE__)
  defaultFont.load(context, "/System/Library/Fonts/SFNS.ttf", 16 * scaleFactor, loadedRanges.Data);
#else
  assert(false); // TODO
#endif
 
  timer = Timer::startNew();
 
  createResources();
 
  return true;
}
 
void Cogs::Core::ImguiRenderer::cleanup()
{
  if (imguiContext) {
    ImGui::SetCurrentContext(imguiContext);
 
    ImGui::GetIO().Fonts = nullptr;
 
    fontRegistry.fonts.clear();
    fontRegistry.defaultFont = nullptr;
 
    deleteGuiContext(imguiContext);
    imguiContext = nullptr;
 
    fontGlyphBuilder.Clear();
  }
}
 
ImGuiContext* Cogs::Core::ImguiRenderer::createGuiContext() {
  ImGuiContext*   guiContext = ImGui::CreateContext(&fontRegistry.defaultFont->fontAtlas);
 
  guiContexts.insert(guiContext);
  ImGui::SetCurrentContext(guiContext);
 
  ImGuiPlatformIO platformIO = ImGui::GetPlatformIO();
 
  // NOTE:  This is not technically correct.  The old clipboard functions take
  // a void* as their first argument which is meant to be user defined data.
  // The new clipboard functions take an ImGuiContext instead (from which the
  // user data can be retrieved).  Cogs never used the user data anyway, so
  // while this should be perfectly safe it is still nevertheless very wrong.
  if (getClipboardTextFn) {
    platformIO.Platform_GetClipboardTextFn = reinterpret_cast<const char*(*)(ImGuiContext*)>(getClipboardTextFn);
  }
  if (setClipboardTextFn) {
    platformIO.Platform_SetClipboardTextFn = reinterpret_cast<void(*)(ImGuiContext*, const char*)>(setClipboardTextFn);
  }
 
  ImGui::GetStyle().ScaleAllSizes(context->getDefaultView()->dpiService->getScaleFactor());
 
  return guiContext;
}
 
void Cogs::Core::ImguiRenderer::deleteGuiContext(ImGuiContext* guiContext) {
  auto i = guiContexts.find(guiContext);
 
  if (i != guiContexts.end()) {
    guiContexts.erase(i);
  }
 
  ImGui::SetCurrentContext(guiContext);
  ImGui::DestroyContext(guiContext);
}
 
bool Cogs::Core::ImguiRenderer::isUsingMouse() {
  bool  active = false;
 
  for (ImGuiContext* context : guiContexts) {
    active |= context->IO.WantCaptureMouse;
  }
  return active;
}
 
bool Cogs::Core::ImguiRenderer::isUsingKeyboard() {
  bool  active = false;
 
  for (ImGuiContext* context : guiContexts) {
    active |= context->IO.WantCaptureKeyboard;
  }
  return active;
}
 
void Cogs::Core::ImguiRenderer::setClipboardCallbacks(GetClipboardTextFn getter, SetClipboardTextFn setter) {
  getClipboardTextFn = getter;
  setClipboardTextFn = setter;
 
  ImGuiContext* currentContext = ImGui::GetCurrentContext();
 
  for (ImGuiContext* context : guiContexts) {
    ImGui::SetCurrentContext(context);
 
    ImGuiPlatformIO&  platformIO = ImGui::GetPlatformIO();
 
    // NOTE:  This is not technically correct.  The old clipboard functions take
    // a void* as their first argument which is meant to be user defined data.
    // The new clipboard functions take an ImGuiContext instead (from which the
    // user data can be retrieved).  Cogs never used the user data anyway, so
    // while this should be perfectly safe it is still nevertheless very wrong.
    platformIO.Platform_GetClipboardTextFn = reinterpret_cast<const char*(*)(ImGuiContext*)>(getClipboardTextFn);
    platformIO.Platform_SetClipboardTextFn = reinterpret_cast<void(*)(ImGuiContext*, const char*)>(setClipboardTextFn);
  }
  ImGui::SetCurrentContext(currentContext);
}
 
void Cogs::Core::ImguiRenderer::updateConstantBuffer(IContext * deviceContext, uint32_t mode)
{
  this->mode = mode;
  const float L = 0.0f;
  const float R = ImGui::GetIO().DisplaySize.x;
  const float B = ImGui::GetIO().DisplaySize.y;
  const float T = 0.0f;
 
  auto M = glm::ortho(L, R, B, T);
 
  int texMode = 0;
  int offset = 0;
  switch (mode & GUI_MODE_TEX_TYPE_MASK)
  {
  case GUI_MODE_TEX_TYPE_2D:
    texMode = 0;
    break;
  case GUI_MODE_TEX_TYPE_ARRAY:
    texMode = 1;
    offset = mode & GUI_MODE_TEX_OFFSET_MASK;
    break;
  case GUI_MODE_TEX_TYPE_CUBE:
    texMode = 2;
    offset = mode & GUI_MODE_TEX_OFFSET_MASK;
    break;
  case GUI_MODE_TEX_TYPE_2DMS:
    texMode = 3;
    break;
  default:
    assert(false);
    break;
  }
 
  int showAlpha = 0;
  switch (mode & GUI_MODE_TEX_CHANNELS_MASK) {
  case GUI_MODE_TEX_CHANNELS_RGB:
    showAlpha = 0;
    break;
  case GUI_MODE_TEX_CHANNELS_ALPHA:
    showAlpha = 1;
    break;
  case GUI_MODE_TEX_CHANNELS_RED:
    showAlpha = 2;
    break;
  case GUI_MODE_TEX_CHANNELS_111R:
    showAlpha = 3;
    break;
  case GUI_MODE_TEX_CHANNELS_111INVR:
    showAlpha = 4;
    break;
  default:
    assert(false);
    break;
  }
 
  int output_sRGB = 0;
  if (context->renderer->getSettings().defaultRenderTargetExpectsSRGB) {
    output_sRGB = 1;
  }
 
  if (HandleIsValid(constantBuffer)) {
    {
      MappedBuffer<ImguiConstants> constants(deviceContext, constantBuffer, MapMode::WriteDiscard);
 
      if (constants) {
        constants->projectionMatrix = M;
        constants->showAlpha = showAlpha;
        constants->texMode = texMode;
        constants->offset = offset;
        constants->output_sRGB = output_sRGB;
      }
    }
    deviceContext->setConstantBuffer("ImguiBuffer", constantBuffer);
  }
  else {
    assert(false);
  }
}
 
void Cogs::Core::ImguiRenderer::frame(ImGuiContext* guiContext, ViewContext& view, bool updateio)
{
  ImGui::SetCurrentContext(guiContext);
 
  ImGuiIO&        io = ImGui::GetIO();
  const Keyboard& keyboard = view.refKeyboard();
 
  if (updateio) {
    const Cogs::Mouse::State&         mouseState = view.refMouse().getState();
    const std::vector<Cogs::Gesture>& gestures = view.refGestures().getGestures();
    Cogs::PointerType                 pointerType = view.refGestures().getPointerType();
 
    std::memset(io.MouseDown, 0, sizeof(io.MouseDown));
 
    if (pointerType == Cogs::PointerType::Touch) { // We don't want to interfere with mouse devices
      view.refGestures().hoverEnable = true;
      for (const Cogs::Gesture& gesture : gestures) {
        if (gesture.kind == Cogs::Gesture::Kind::Press) {
          touchPointerPosition.x = gesture.press.coord.x;
          touchPointerPosition.y = gesture.press.coord.y;
          touchPointerHeld = true;
        }
        else if (gesture.kind == Cogs::Gesture::Kind::Tap) {
          touchPointerPosition.x = gesture.tap.coord.x;
          touchPointerPosition.y = gesture.tap.coord.y;
          touchPointerHeld = false;
        }
        else if (gesture.kind == Cogs::Gesture::Kind::Drag) {
          touchPointerPosition.x = gesture.drag.currCoord.x;
          touchPointerPosition.y = gesture.drag.currCoord.y;
          touchPointerHeld = true;
        }
        else if (gesture.kind == Cogs::Gesture::Kind::Hover) {
          touchPointerPosition.x = gesture.hover.coord.x;
          touchPointerPosition.y = gesture.hover.coord.y;
        }
      }
    }
 
    io.MouseDown[0] = mouseState.buttonDown[MouseButton::Left] || touchPointerHeld; // We can only left click with touch pointer
    io.MouseDown[1] = mouseState.buttonDown[MouseButton::Right];
    io.MouseDown[2] = mouseState.buttonDown[MouseButton::Middle];
    
    if (pointerType == Cogs::PointerType::Touch) {
      io.MousePos.x = touchPointerPosition.x;
      io.MousePos.y = touchPointerPosition.y;
    }
    else {
      io.MousePos.x = mouseState.position.x;
      io.MousePos.y = mouseState.position.y;
    }
    
    io.MouseWheel = mouseState.wheel != 0 ? (mouseState.wheel > 0 ? 1.0f : -1.0f) : 0;
 
    for (const Keyboard::Event& e: keyboard.getEvents()) {
      if ((e.type == Keyboard::Event::Type::Press) || (e.type == Keyboard::Event::Type::Release)) {
        io.AddKeyEvent(CogsKeyToImGuiKey(std::get<Key>(e.data)), e.type == Keyboard::Event::Type::Press);
      }
    }
    io.AddInputCharactersUTF8(keyboard.getState().chars.c_str());
  }
  else {
    for (const Keyboard::Event& e: keyboard.getEvents()) {
      if (e.type == Keyboard::Event::Type::Release) {
        io.AddKeyEvent(CogsKeyToImGuiKey(std::get<Key>(e.data)), false);
      }
    }
  }
  io.DisplaySize = view.getSize();
 
  // Ensure time since last render positive.
  io.DeltaTime = std::max(static_cast<float>(timer.elapsedSeconds()), 0.000001f);
  timer.start();
 
  if (updateLoadedRanges) {
    ImVector<ImWchar> requiredRanges;
 
    fontGlyphBuilder.BuildRanges(&requiredRanges);
 
    if (!std::equal(loadedRanges.begin(), loadedRanges.end(), requiredRanges.begin(), requiredRanges.end())) {
      for (auto& [_, font] : fontRegistry.fonts) {
        font.reloadWithNewGlyphs(context, requiredRanges.Data);
      }
      loadedRanges = requiredRanges;
    }
    updateLoadedRanges = false;
  }
 
  ImGui::NewFrame();
}
 
void Cogs::Core::ImguiRenderer::render()
{
  Cogs::IEffects* effects = device->getEffects();
  Cogs::ResourceStatus status = HandleIsValid(effect) ? effects->checkEffect(effect) : Cogs::ResourceStatus::Error;
 
  if (status == Cogs::ResourceStatus::Ready && effectStatus != Cogs::ResourceStatus::Ready) {
    inputLayout = device->getBuffers()->loadInputLayout(&format, 1, effect);
  }
 
  if (status == Cogs::ResourceStatus::Error && effectStatus != Cogs::ResourceStatus::Error) {
    LOG_ERROR(logger, "ImguiRenderer: Invalid imgui effect handle.");
  }
 
  effectStatus = status;
 
  auto deviceContext = device->getImmediateContext();
 
  CommandGroupAnnotation commandGroup(deviceContext, "Imgui::Render");
 
  // ImGui::Render() must be called every frame that NewFrame() was called, regardless of
  // effect readiness, otherwise ImGui asserts on the next NewFrame().
  ImGui::Render();
 
  if (effectStatus != Cogs::ResourceStatus::Ready) {
    return;
  }
 
  auto drawData = ImGui::GetDrawData();
 
  auto buffers = device->getBuffers();
 
  // Create and grow vertex/index buffers if needed
  if (!HandleIsValid(vertexBuffer) || vertexBufferSize < drawData->TotalVtxCount) {
    if (HandleIsValid(vertexBuffer)) { buffers->releaseVertexBuffer(vertexBuffer); vertexBuffer = VertexBufferHandle::NoHandle; }
    vertexBufferSize = drawData->TotalVtxCount + 5000;
 
    vertexBuffer = buffers->loadVertexBuffer(nullptr, vertexBufferSize, format);
  }
 
  if (!HandleIsValid(indexBuffer) || indexBufferSize < drawData->TotalIdxCount) {
    if (HandleIsValid(indexBuffer)) { buffers->releaseIndexBuffer(indexBuffer); indexBuffer = IndexBufferHandle::NoHandle; }
    indexBufferSize = drawData->TotalIdxCount + 10000;
 
    indexBuffer = buffers->loadIndexBuffer(nullptr, indexBufferSize, sizeof(ImDrawIdx));
  }
 
  if (device->getType() == GraphicsDeviceType::OpenGLES30) {
 
    // Use updateSubBuffer since emscripten doesn't support memory mapping without faking it
    // through an extra buffer. Avoid that copy.
 
    size_t vtx_offset = 0;
    for (int n = 0; n < drawData->CmdListsCount; n++) {
      const ImDrawList* commandList = drawData->CmdLists[n];
      deviceContext->updateSubBuffer(vertexBuffer, vtx_offset, sizeof(ImDrawVert) * commandList->VtxBuffer.size(), &commandList->VtxBuffer[0]);
      vtx_offset += sizeof(ImDrawVert) * commandList->VtxBuffer.size();
    }
 
    size_t idx_offset = 0;
    for (int n = 0; n < drawData->CmdListsCount; n++) {
      const ImDrawList* commandList = drawData->CmdLists[n];
      deviceContext->updateSubBuffer(indexBuffer, idx_offset, sizeof(ImDrawIdx) * commandList->IdxBuffer.size(), &commandList->IdxBuffer[0]);
      idx_offset += sizeof(ImDrawIdx) * commandList->IdxBuffer.size();
    }
 
  }
  else {
    ImDrawVert* vtx_dst = (ImDrawVert*)deviceContext->map(vertexBuffer, MapMode::WriteDiscard);
    ImDrawIdx* idx_dst = (ImDrawIdx*)deviceContext->map(indexBuffer, MapMode::WriteDiscard);
 
    if (vtx_dst && idx_dst) {
      for (int n = 0; n < drawData->CmdListsCount; n++) {
        const auto commandList = drawData->CmdLists[n];
 
        memcpy(vtx_dst, &commandList->VtxBuffer[0], commandList->VtxBuffer.size() * sizeof(ImDrawVert));
        memcpy(idx_dst, &commandList->IdxBuffer[0], commandList->IdxBuffer.size() * sizeof(ImDrawIdx));
 
        vtx_dst += commandList->VtxBuffer.size();
        idx_dst += commandList->IdxBuffer.size();
      }
    }
    deviceContext->unmap(vertexBuffer);
    deviceContext->unmap(indexBuffer);
  }
 
  deviceContext->setViewport(0, 0, ImGui::GetIO().DisplaySize.x, ImGui::GetIO().DisplaySize.y);
  deviceContext->clearDepth(context->renderer->getClearDepth());
 
  deviceContext->setEffect(effect);
  const uint32_t strides[] = { sizeof(ImDrawVert) };
  deviceContext->setVertexBuffers(&vertexBuffer, 1, strides, nullptr);
  deviceContext->setIndexBuffer(indexBuffer, sizeof(ImDrawIdx));
  if (HandleIsValid(inputLayout)) deviceContext->setInputLayout(inputLayout);
  updateConstantBuffer(deviceContext, GUI_MODE_DEFAULT);
 
  deviceContext->setBlendState(blendState);
  deviceContext->setRasterizerState(rasterizerState);
  deviceContext->setDepthStencilState(depthState);
 
  deviceContext->setTexture("texture0", 0, dummyTex2D);
  deviceContext->setSamplerState("texture0Sampler", 0, sampler);
 
  deviceContext->setTexture("texturems", 1, dummyTex2DMS);
  deviceContext->setSamplerState("texture0Sampler", 1, sampler);
 
  deviceContext->setTexture("texcube", 2, dummyTexCube);
  deviceContext->setSamplerState("texture0Sampler", 2, sampler);
 
  deviceContext->setTexture("texarray", 3, dummyTex2DArray);
  deviceContext->setSamplerState("texarraySampler", 3, sampler);
 
  // Render command lists
  int baseVertex = 0;
  int baseIndex = 0;
 
  for (int n = 0; n < drawData->CmdListsCount; n++) {
    const ImDrawList* commandList = drawData->CmdLists[n];
 
    for (int commandIndex = 0; commandIndex < commandList->CmdBuffer.size(); commandIndex++) {
      const ImDrawCmd* pcmd = &commandList->CmdBuffer[commandIndex];
 
      if (pcmd->UserCallback == setGuiMode) {
        updateConstantBuffer(deviceContext, (uint32_t)(uint64_t)pcmd->UserCallbackData);
      }
      else {
        if (pcmd->UserCallback) {
          pcmd->UserCallback(commandList, pcmd);
        } else {
          switch (device->getType()) {
          case GraphicsDeviceType::OpenGL20:
          case GraphicsDeviceType::OpenGLES30:
            deviceContext->setScissor(int(pcmd->ClipRect.x),
                                      int(ImGui::GetIO().DisplaySize.y) - int(pcmd->ClipRect.w),
                                      int(pcmd->ClipRect.z) - int(pcmd->ClipRect.x),
                                      int(pcmd->ClipRect.w) - int(pcmd->ClipRect.y));
 
            break;
 
          default:
            deviceContext->setScissor(int(pcmd->ClipRect.x),
                                      int(pcmd->ClipRect.y),
                                      int(pcmd->ClipRect.z),
                                      int(pcmd->ClipRect.w));
            break;
          }
 
          Cogs::TextureHandle textureHandle(pcmd->GetTexID());
 
          deviceContext->setBlendState(blendState);
 
          assert(pcmd->ElemCount > 0);
          switch (mode & GUI_MODE_TEX_TYPE_MASK)
          {
            case GUI_MODE_TEX_TYPE_2D:
              deviceContext->setTexture("texture0", 0, textureHandle);
              deviceContext->setSamplerState("texture0Sampler", 0, sampler);
              break;
            case GUI_MODE_TEX_TYPE_ARRAY:
              deviceContext->setTexture("texarray", 3, textureHandle);
              deviceContext->setSamplerState("texture0Sampler", 3, sampler);
              break;
            case GUI_MODE_TEX_TYPE_CUBE:
              deviceContext->setTexture("texcube", 2, textureHandle);
              deviceContext->setSamplerState("texture0Sampler", 2, sampler);
              break;
            case GUI_MODE_TEX_TYPE_2DMS:
              deviceContext->setTexture("texturems", 1, textureHandle);
              deviceContext->setSamplerState("texture0Sampler", 1, sampler);
              break;
            default:
              assert(false);
              break;
          }
          deviceContext->drawIndexed(PrimitiveType::TriangleList, baseIndex, pcmd->ElemCount, baseVertex);
        }
      }
 
      baseIndex += pcmd->ElemCount;
    }
 
    baseVertex += commandList->VtxBuffer.size();
  }
 
  auto & io = ImGui::GetIO();
 
  io.ClearInputCharacters();
}
 
void Cogs::Core::ImguiRenderer::addTextToGlyphBuilder(const char* text)
{
  if (text) {
    fontGlyphBuilder.AddText(text);
    updateLoadedRanges = true;
  }
}
 
void Cogs::Core::ImguiRenderer::addRangeToGlyphBuilder(const ImWchar* ranges)
{
  fontGlyphBuilder.AddRanges(ranges);
  updateLoadedRanges = true;
}
 
void Cogs::Core::ImguiRenderer::style()
{
  // FIXME: those should become parameters to the function
  float satMult = 0.0f;
  static int hue = 146;
  static float col_main_sat = satMult * 180.f / 255.f;
  static float col_main_val = 161.f / 255.f;
  static float col_area_sat = satMult * 124.f / 255.f;
  static float col_area_val = 100.f / 255.f;
  static float col_back_sat = satMult * 59.f / 255.f;
  static float col_back_val = 40.f / 255.f;
 
  ImGuiStyle & style = ImGui::GetStyle();
 
  ImVec4 col_text = ImColor::HSV(hue / 255.f, 20.f / 255.f, 255.f / 255.f);
  ImVec4 col_main = ImColor::HSV(hue / 255.f, col_main_sat, col_main_val);
  ImVec4 col_back = ImColor::HSV(hue / 255.f, col_back_sat, col_back_val);
  ImVec4 col_dark = ImColor::HSV(hue / 255.f, col_back_sat, 55 / 255.f);
  ImVec4 col_area = ImColor::HSV(hue / 255.f, col_area_sat, col_area_val);
 
  style.Colors[ImGuiCol_Text] = ImVec4(col_text.x, col_text.y, col_text.z, 1.00f);
  style.Colors[ImGuiCol_TextDisabled] = ImVec4(col_text.x, col_text.y, col_text.z, 0.58f);
  style.Colors[ImGuiCol_WindowBg] = ImVec4(col_back.x, col_back.y, col_back.z, 1.00f);
  style.Colors[ImGuiCol_Border] = ImVec4(col_text.x, col_text.y, col_text.z, 0.30f);
  style.Colors[ImGuiCol_BorderShadow] = ImVec4(0.00f, 0.00f, 0.00f, 0.00f);
  style.Colors[ImGuiCol_FrameBg] = ImVec4(col_area.x, col_area.y, col_area.z, 1.00f);
  style.Colors[ImGuiCol_FrameBgHovered] = ImVec4(col_main.x, col_main.y, col_main.z, 0.68f);
  style.Colors[ImGuiCol_FrameBgActive] = ImVec4(col_main.x, col_main.y, col_main.z, 1.00f);
  style.Colors[ImGuiCol_TitleBg] = ImVec4(col_main.x, col_main.y, col_main.z, 0.45f);
  style.Colors[ImGuiCol_TitleBgCollapsed] = ImVec4(col_main.x, col_main.y, col_main.z, 0.35f);
  style.Colors[ImGuiCol_TitleBgActive] = ImVec4(col_main.x, col_main.y, col_main.z, 0.78f);
  style.Colors[ImGuiCol_MenuBarBg] = ImVec4(col_back.x, col_back.y, col_back.z, 1.00f);
  style.Colors[ImGuiCol_ScrollbarBg] = ImVec4(col_area.x, col_area.y, col_area.z, 1.00f);
  style.Colors[ImGuiCol_ScrollbarGrab] = ImVec4(col_main.x, col_main.y, col_main.z, 0.31f);
  style.Colors[ImGuiCol_ScrollbarGrabHovered] = ImVec4(col_main.x, col_main.y, col_main.z, 0.78f);
  style.Colors[ImGuiCol_ScrollbarGrabActive] = ImVec4(col_main.x, col_main.y, col_main.z, 1.00f);
  style.Colors[ImGuiCol_CheckMark] = ImVec4(col_main.x, col_main.y, col_main.z, 0.80f);
  style.Colors[ImGuiCol_SliderGrab] = ImVec4(col_main.x, col_main.y, col_main.z, 0.24f);
  style.Colors[ImGuiCol_SliderGrabActive] = ImVec4(col_main.x, col_main.y, col_main.z, 1.00f);
  style.Colors[ImGuiCol_Button] = ImVec4(col_main.x, col_main.y, col_main.z, 0.44f);
  style.Colors[ImGuiCol_ButtonHovered] = ImVec4(col_main.x, col_main.y, col_main.z, 0.86f);
  style.Colors[ImGuiCol_ButtonActive] = ImVec4(col_main.x, col_main.y, col_main.z, 1.00f);
  style.Colors[ImGuiCol_Header] = ImVec4(col_main.x, col_main.y, col_main.z, 0.76f);
  style.Colors[ImGuiCol_HeaderHovered] = ImVec4(col_dark.x, col_dark.y, col_dark.z, 0.86f);
  style.Colors[ImGuiCol_HeaderActive] = ImVec4(col_main.x, col_main.y, col_main.z, 1.00f);
  style.Colors[ImGuiCol_ResizeGrip] = ImVec4(col_main.x, col_main.y, col_main.z, 0.20f);
  style.Colors[ImGuiCol_ResizeGripHovered] = ImVec4(col_main.x, col_main.y, col_main.z, 0.78f);
  style.Colors[ImGuiCol_ResizeGripActive] = ImVec4(col_main.x, col_main.y, col_main.z, 1.00f);
  style.Colors[ImGuiCol_PlotLines] = ImVec4(col_text.x, col_text.y, col_text.z, 0.63f);
  style.Colors[ImGuiCol_PlotLinesHovered] = ImVec4(col_main.x, col_main.y, col_main.z, 1.00f);
  style.Colors[ImGuiCol_PlotHistogram] = ImVec4(col_text.x, col_text.y, col_text.z, 0.63f);
  style.Colors[ImGuiCol_PlotHistogramHovered] = ImVec4(col_main.x, col_main.y, col_main.z, 1.00f);
  style.Colors[ImGuiCol_TextSelectedBg] = ImVec4(col_main.x, col_main.y, col_main.z, 0.43f);
  style.Colors[ImGuiCol_PopupBg] = ImVec4(col_back.x, col_back.y, col_back.z, 0.99f);
  style.Colors[ImGuiCol_ModalWindowDimBg] = ImVec4(0.20f, 0.20f, 0.20f, 0.35f);
 
  style.WindowRounding = 2.0f;
  style.WindowBorderSize = 0.0f;
}
 
void Cogs::Core::ImguiRenderer::createSampler()
{
  SamplerState fs = {};
  fs.addressModeS = SamplerState::Clamp;
  fs.addressModeT = SamplerState::Clamp;
  fs.filter = SamplerState::MinMagMipLinear;
  sampler = device->getTextures()->loadSamplerState(fs);
}
 
bool Cogs::Core::ImguiRenderer::createResources()
{
  VertexElement elements[] = {
    { 0, DataFormat::X32Y32_FLOAT, ElementSemantic::Position, 0, InputType::VertexData, 0 },
    { 2 * sizeof(float), DataFormat::X32Y32_FLOAT, ElementSemantic::TextureCoordinate, 0, InputType::VertexData, 0 },
    { 4 * sizeof(float), DataFormat::R8G8B8A8_UNORM, ElementSemantic::Color, 0, InputType::VertexData, 0 }
  };
  format = device->getBuffers()->createVertexFormat(elements, std::size(elements));
 
  Cogs::EffectDescription desc;
  desc.name = "ImguiEffect";
  desc.type = EffectDescriptionType::File;
 
  switch (device->getType()) {
 
  case GraphicsDeviceType::WebGPU:
    desc.vertexShader = "Engine/ImguiVS.wgsl";
    desc.pixelShader = "Engine/ImguiPS.wgsl";
    desc.vsEntryPoint = "vs_main";
    desc.psEntryPoint = "fs_main";
    desc.flags = static_cast<EffectFlags::EEffectFlags>(desc.flags | EffectFlags::WGSL);
 
    desc.definitions.push_back(Cogs::PreprocessorDefinition("COGS_SRGB_CONVERSION_FAST", "1"));
    desc.definitions.push_back(Cogs::PreprocessorDefinition("COGS_SRGB_CONVERSION_APPROX", "2"));
    desc.definitions.push_back(Cogs::PreprocessorDefinition("COGS_SRGB_CONVERSION_EXACT", "3"));
    break;
 
  case GraphicsDeviceType::OpenGLES30:
    desc.vertexShader = "Engine/ImguiVS.es30.glsl";
    desc.pixelShader = "Engine/ImguiPS.es30.glsl";
    desc.flags = static_cast<EffectFlags::EEffectFlags>(desc.flags | EffectFlags::GLSL);
    break;
 
  default:
    desc.vertexShader = "Engine/ImguiVS.hlsl";
    desc.pixelShader = "Engine/ImguiPS.hlsl";
    break;
  }
  effect = device->getEffects()->loadEffect(desc);
 
  constantBuffer = device->getBuffers()->loadBuffer(nullptr, sizeof(ImguiConstants), Usage::Dynamic, AccessMode::Write, BindFlags::ConstantBuffer);
  device->getBuffers()->annotate(constantBuffer, "ImGui");
 
  BlendState bs = {};
  bs.enabled = true;
  bs.sourceBlend = BlendState::Blend::SourceAlpha;
  bs.destinationBlend = BlendState::Blend::InverseSourceAlpha;
  bs.operation = BlendState::BlendOperation::Add;
 
  blendState = device->getRenderTargets()->loadBlendState(bs);
 
  RasterizerState rs = {};
  rs.cullMode = RasterizerState::None;
  rs.frontCounterClockwise = false;
  rs.wireFrame = false;
  rs.scissor = true;
 
  rasterizerState = device->getRenderTargets()->loadRasterizerState(rs);
 
  DepthStencilState ds = {};
  ds.depthEnabled = false;
  ds.depthFunction = DepthStencilState::Always;
 
  depthState = device->getRenderTargets()->loadDepthStencilState(ds);
 
  Cogs::ITextures* textures = device->getTextures();
  assert(textures);
 
  uint32_t width = 2;
  uint32_t height = 2;
  const unsigned char data[2 * 2 * 4] = {
    0xffu, 0xffu, 0xffu, 0xffu,
    0x88u, 0x88u, 0x88u, 0x88u,
    0x88u, 0x88u, 0x88u, 0x88u,
    0xffu, 0xffu, 0xffu, 0xffu,
  };
  const unsigned char* dataPtrs[6] = { data, data, data, data, data, data };
 
  dummyTex2D = textures->loadTexture(data, width, height, TextureFormat::R8G8B8A8_UNORM_SRGB);
  dummyTex2DMS = textures->loadTexture(nullptr, width, height, TextureFormat::R8G8B8A8_UNORM_SRGB, 4, TextureFlags::RenderTarget);
  dummyTex2DArray = textures->loadTextureArray(dataPtrs, 1, 1, &width, &height, TextureFormat::R8G8B8A8_UNORM_SRGB);
  dummyTexCube = textures->loadCubeMap(dataPtrs, 1, 1, &width, &height, TextureFormat::R8G8B8A8_UNORM_SRGB);
 
  createSampler();
 
  return true;
}
 
void Cogs::Core::GuiFont::load(const Context * context, const std::string& name, float size, const ImWchar* glyphRanges)
{
  path = name;
  auto fontBytes = context->resourceStore->getResourceContents(name);
  if (fontBytes.empty()) {
    static const std::string fallbackFont = "Fonts/Inconsolata-Regular.ttf";
    path = fallbackFont;
    LOG_WARNING(logger, "Failed to read font %.*s, trying %s", StringViewFormat(name), fallbackFont.c_str());
    fontBytes = context->resourceStore->getResourceContents(fallbackFont);
  }
 
  ImFontConfig    config;
  unsigned char*  pixels;
  int             width;
  int             height;
 
  config.FontDataOwnedByAtlas = false;
  initialSize = size;
  fontAtlas.Clear();
 
  for (int i = 0; i < cNoOfFontSizes; ++i, size += initialSize) {
    font[i] = fontAtlas.AddFontFromMemoryTTF(fontBytes.data(), static_cast<int>(fontBytes.size()), size, &config, glyphRanges);
  }
  fontAtlas.GetTexDataAsRGBA32(&pixels, &width, &height);
  fontAtlas.TexID = context->device->getTextures()->loadTexture(pixels, width, height, TextureFormat::R8G8B8A8_UNORM_SRGB, 0).handle;
}
 
void Cogs::Core::GuiFont::reloadWithNewGlyphs(const Context* context, const ImWchar* glyphRanges) {
  load(context, path, initialSize, glyphRanges);
}
 
ImFont* Cogs::Core::GuiFont::find(float size, float& scale) const {
  int idx = 0;
  float fontSize = initialSize;
 
  for (; idx < (cNoOfFontSizes - 1); ++idx, fontSize += initialSize) {
    if (size <= (fontSize + (fontSize * 0.3f))) {
      break;
    }
  }
  scale = size / fontSize;
  return font[idx];
}