Revision control
Copy as Markdown
// Copyright (C) 2019 Klaralvdalens Datakonsult AB (KDAB).
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
/*
*
*
*/
#include "imguirenderer_p.h"
#include <renderview_p.h>
#include <rendercommand_p.h>
#include <renderer_p.h>
#include <submissioncontext_p.h>
#include <Qt3DRender/private/geometryrenderermanager_p.h>
#include <QDateTime>
#include <QGuiApplication>
#include <QMouseEvent>
#include <QClipboard>
#include <QCursor>
#include <QOpenGLExtraFunctions>
#include "imgui.h"
#ifndef GL_VERTEX_ARRAY_BINDING
// just for building on some platforms, won't run anyway as this requires GL/ES > 2
#define GL_VERTEX_ARRAY_BINDING 0x85B5
#endif
QT_BEGIN_NAMESPACE
namespace Qt3DRR = Qt3DRender::Render;
namespace Qt3DRRD = Qt3DRR::Debug;
namespace {
const QHash<int, ImGuiKey> keyMap = {
{ Qt::Key_Tab, ImGuiKey_Tab },
{ Qt::Key_Left, ImGuiKey_LeftArrow },
{ Qt::Key_Right, ImGuiKey_RightArrow },
{ Qt::Key_Up, ImGuiKey_UpArrow },
{ Qt::Key_Down, ImGuiKey_DownArrow },
{ Qt::Key_PageUp, ImGuiKey_PageUp },
{ Qt::Key_PageDown, ImGuiKey_PageDown },
{ Qt::Key_Home, ImGuiKey_Home },
{ Qt::Key_End, ImGuiKey_End },
{ Qt::Key_Delete, ImGuiKey_Delete },
{ Qt::Key_Backspace, ImGuiKey_Backspace },
{ Qt::Key_Enter, ImGuiKey_Enter },
{ Qt::Key_Escape, ImGuiKey_Escape },
{ Qt::Key_A, ImGuiKey_A },
{ Qt::Key_C, ImGuiKey_C },
{ Qt::Key_V, ImGuiKey_V },
{ Qt::Key_X, ImGuiKey_X },
{ Qt::Key_Y, ImGuiKey_Y },
{ Qt::Key_Z, ImGuiKey_Z },
};
QByteArray g_currentClipboardText;
// doesn't handle primitive restart when using indexes
int vertexToPrimitiveCount(Qt3DRender::QGeometryRenderer::PrimitiveType primitiveType, int numVertices) {
int nPrimitives = 0;
switch (primitiveType) {
case Qt3DRender::QGeometryRenderer::Points:
case Qt3DRender::QGeometryRenderer::LineLoop:
nPrimitives += numVertices;
break;
case Qt3DRender::QGeometryRenderer::Triangles:
nPrimitives += numVertices / 3;
break;
case Qt3DRender::QGeometryRenderer::Lines:
nPrimitives += numVertices / 2;
break;
case Qt3DRender::QGeometryRenderer::TriangleFan:
case Qt3DRender::QGeometryRenderer::TriangleStrip:
case Qt3DRender::QGeometryRenderer::LineStrip:
nPrimitives += numVertices - 1;
break;
case Qt3DRender::QGeometryRenderer::TrianglesAdjacency:
nPrimitives += numVertices / 6;
break;
case Qt3DRender::QGeometryRenderer::TriangleStripAdjacency:
case Qt3DRender::QGeometryRenderer::LineStripAdjacency:
nPrimitives += numVertices / 2 - 1;
break;
case Qt3DRender::QGeometryRenderer::LinesAdjacency:
nPrimitives += numVertices / 4;
break;
case Qt3DRender::QGeometryRenderer::Patches:
nPrimitives += 1;
}
return nPrimitives;
}
const char *primitiveTypeName(Qt3DRender::QGeometryRenderer::PrimitiveType primitiveType) {
switch (primitiveType) {
case Qt3DRender::QGeometryRenderer::Points:
return "Points";
case Qt3DRender::QGeometryRenderer::LineLoop:
return "LineLoop";
case Qt3DRender::QGeometryRenderer::Triangles:
return "Triangles";
case Qt3DRender::QGeometryRenderer::TrianglesAdjacency:
return "TriangleAdjacency";
case Qt3DRender::QGeometryRenderer::TriangleFan:
return "TriangleFan";
case Qt3DRender::QGeometryRenderer::TriangleStrip:
return "TriangleStrip";
case Qt3DRender::QGeometryRenderer::TriangleStripAdjacency:
return "TriangleStringAdjacency";
case Qt3DRender::QGeometryRenderer::LineStrip:
return "LineStrip";
case Qt3DRender::QGeometryRenderer::LineStripAdjacency:
return "LineStripAdjacency";
case Qt3DRender::QGeometryRenderer::Lines:
return "Lines";
case Qt3DRender::QGeometryRenderer::LinesAdjacency:
return "LinesAdjacency";
case Qt3DRender::QGeometryRenderer::Patches:
return "Patches";
}
return "";
}
}
Qt3DRRD::ImGuiRenderer::ImGuiRenderer(Qt3DRR::OpenGL::Renderer *renderer)
: m_renderer(renderer)
{
ImGui::CreateContext();
ImGuiIO &io = ImGui::GetIO();
auto imGuiPath = qgetenv("QT3D_IMGUI_PATH");
if (!imGuiPath.isEmpty()) {
io.IniFilename = QByteArray{imGuiPath + QByteArray{"/imgui.ini"}}.constData();
} else {
io.IniFilename = nullptr;
}
#ifndef QT_NO_CLIPBOARD
io.SetClipboardTextFn = [](void *user_data, const char *text) {
Q_UNUSED(user_data);
QGuiApplication::clipboard()->setText(QString::fromLatin1(text));
};
io.GetClipboardTextFn = [](void *user_data) {
Q_UNUSED(user_data);
g_currentClipboardText = QGuiApplication::clipboard()->text().toUtf8();
return static_cast<const char *>(g_currentClipboardText.data());
};
#endif
std::fill(std::begin(m_fpsLog), std::end(m_fpsLog), 0.f);
std::fill(std::begin(m_jobsLog), std::end(m_jobsLog), 0.f);
m_fpsRange.first = m_fpsRange.second = 0.f;
m_jobsRange.first = m_jobsRange.second = 0.f;
}
Qt3DRRD::ImGuiRenderer::~ImGuiRenderer() = default;
void Qt3DRRD::ImGuiRenderer::renderDebugOverlay(const std::vector<Qt3DRR::OpenGL::RenderView *> &renderViews, const Qt3DRR::OpenGL::RenderView *renderView, int jobsInLastFrame)
{
if (!newFrame(renderView))
return;
const int renderViewsCount = int(renderViews.size());
int logIndex = qMin(IMGUI_PERF_LOG_SIZE - 1, ImGui::GetFrameCount());
if (logIndex == IMGUI_PERF_LOG_SIZE - 1) {
std::rotate(std::begin(m_fpsLog), std::begin(m_fpsLog) + 1, std::end(m_fpsLog));
std::rotate(std::begin(m_jobsLog), std::begin(m_jobsLog) + 1, std::end(m_jobsLog));
}
m_fpsLog[logIndex] = ImGui::GetIO().Framerate;
m_fpsRange.first = m_fpsRange.second = 0.f;
for (float v: m_fpsLog) {
m_fpsRange.first = qMin(m_fpsRange.first, qMax(v - 5.f, 0.f));
m_fpsRange.second = qMax(m_fpsRange.second, v + 2.f);
}
m_jobsLog[logIndex] = jobsInLastFrame;
m_jobsRange.first = m_jobsRange.second = 0.f;
for (float v: m_jobsLog) {
m_jobsRange.first = qMin(m_jobsRange.first, qMax(v - 5.f, 0.f));
m_jobsRange.second = qMax(m_jobsRange.second, v + 2.f);
}
{
ImGui::Begin("Qt3D Profiling");
char caption[50];
snprintf(caption, sizeof(caption), "Avg %.3f ms/frame (%.1f FPS)", static_cast<double>(1000.0f / ImGui::GetIO().Framerate), static_cast<double>(ImGui::GetIO().Framerate));
ImGui::PlotLines("FPS", m_fpsLog, logIndex + 1, 0, caption, m_fpsRange.first, m_fpsRange.second, ImVec2(0, 80));
ImGui::PlotHistogram("Jobs", m_jobsLog, logIndex + 1, 0, nullptr, m_jobsRange.first, m_jobsRange.second, ImVec2(0, 80));
int nCommands = 0;
int nVertices = 0;
int nPrimitives = 0;
QSet<HGeometryRenderer> inUseGeometries;
QSet<Qt3DCore::QNodeId> inUseTextures;
for (int j=0; j<renderViewsCount; j++) {
Qt3DRR::OpenGL::RenderView *rv = renderViews.at(j);
nCommands += rv->commandCount();
rv->forEachCommand([&](const Qt3DRR::OpenGL::RenderCommand &command) {
if (command.m_type != Qt3DRR::OpenGL::RenderCommand::Draw)
return;
nVertices += command.m_primitiveCount;
nPrimitives += vertexToPrimitiveCount(command.m_primitiveType, command.m_primitiveCount);
inUseGeometries.insert(command.m_geometryRenderer);
const auto &textures = command.m_parameterPack.textures();
for (const auto &ns: textures)
inUseTextures.insert(ns.nodeId);
});
}
auto columnNumber = [](int i) {
if (i == 0)
ImGui::Text("--");
else
ImGui::Text(" %d", i);
ImGui::NextColumn();
};
auto column2Numbers = [](int i, int of) {
if (of == 0)
ImGui::Text("--");
else
ImGui::Text(" %d of %d", i, of);
ImGui::NextColumn();
};
ImGui::Columns(5);
ImGui::Separator();
for (auto s: {"Jobs", "RV", "Cmds", "Verts", "Prims"}) {
ImGui::Text("#%s", s);
ImGui::NextColumn();
}
for (auto s: {jobsInLastFrame, renderViewsCount, nCommands, nVertices, nPrimitives})
columnNumber(s);
ImGui::Columns(3);
ImGui::Separator();
for (auto s: {"Entities", "Geometries", "Textures"}) {
ImGui::Text("#%s", s);
ImGui::NextColumn();
}
columnNumber(m_renderer->nodeManagers()->renderNodesManager()->count());
column2Numbers(inUseGeometries.size(), m_renderer->nodeManagers()->geometryRendererManager()->count());
column2Numbers(inUseTextures.size(), m_renderer->nodeManagers()->textureManager()->count());
ImGui::Columns(1);
ImGui::Separator();
bool pj = m_renderer->services()->systemInformation()->isTraceEnabled();
ImGui::AlignTextToFramePadding();
ImGui::Text("Profiling: ");
ImGui::SameLine();
if (ImGui::Checkbox("Jobs", &pj))
QMetaObject::invokeMethod(m_renderer->services()->systemInformation(), "setTraceEnabled", Qt::QueuedConnection, Q_ARG(bool, pj));
ImGui::SameLine();
if (ImGui::Button("Reveal"))
QMetaObject::invokeMethod(m_renderer->services()->systemInformation(), "revealLogFolder", Qt::QueuedConnection);
ImGui::AlignTextToFramePadding();
ImGui::Text("Show:");
ImGui::SameLine();
if (ImGui::Button("GL Info"))
m_showGLInfoWindow = !m_showGLInfoWindow;
ImGui::SameLine();
if (ImGui::Button("Render Views"))
m_showRenderDetailsWindow = !m_showRenderDetailsWindow;
ImGui::AlignTextToFramePadding();
ImGui::Text("Dump:");
ImGui::SameLine();
if (ImGui::Button("SceneGraph##1"))
QMetaObject::invokeMethod(m_renderer->services()->systemInformation(), "dumpCommand",
Qt::QueuedConnection, Q_ARG(QString, QLatin1String("render scenegraph")));
ImGui::SameLine();
if (ImGui::Button("FrameGraph##1"))
QMetaObject::invokeMethod(m_renderer->services()->systemInformation(), "dumpCommand",
Qt::QueuedConnection, Q_ARG(QString, QLatin1String("render framegraph")));
ImGui::SameLine();
if (ImGui::Button("Render Views##1"))
QMetaObject::invokeMethod(m_renderer->services()->systemInformation(), "dumpCommand",
Qt::QueuedConnection, Q_ARG(QString, QLatin1String("render framepaths")));
ImGui::AlignTextToFramePadding();
ImGui::Text(" ");
ImGui::SameLine();
if (ImGui::Button("Filter State##1"))
QMetaObject::invokeMethod(m_renderer->services()->systemInformation(), "dumpCommand",
Qt::QueuedConnection, Q_ARG(QString, QLatin1String("render filterstates")));
ImGui::SameLine();
if (ImGui::Button("JobsGraph##1"))
QMetaObject::invokeMethod(m_renderer->services()->systemInformation(), "dumpCommand",
Qt::QueuedConnection, Q_ARG(QString, QLatin1String("dump jobs")));
ImGui::End();
if (m_showGLInfoWindow)
showGLInfo();
if (m_showRenderDetailsWindow)
showRenderDetails(renderViews);
}
ImGui::Render();
renderDrawList(ImGui::GetDrawData());
}
void Qt3DRRD::ImGuiRenderer::setCapabilities(const QString &capabilities)
{
m_capabilities = capabilities.toLatin1();
}
void Qt3DRRD::ImGuiRenderer::showGLInfo()
{
ImGui::Begin("Open GL Details", &m_showGLInfoWindow);
ImGui::Text("%s", m_capabilities.data());
ImGui::End();
}
void Qt3DRRD::ImGuiRenderer::showRenderDetails(const std::vector<Qt3DRR::OpenGL::RenderView *> &renderViews)
{
ImGui::Begin("Render Views", &m_showRenderDetailsWindow);
int i = 1;
for (const Qt3DRR::OpenGL::RenderView *view : renderViews) {
QString label(QLatin1String("View ") + QString::number(i++));
if (ImGui::TreeNode(label.toLatin1().data())) {
ImGui::Text("Viewport: (%.1f, %.1f, %.1f, %.1f)", view->viewport().x(), view->viewport().y(),
view->viewport().width(), view->viewport().height());
ImGui::Text("Surface Size: (%d, %d)", view->surfaceSize().width(), view->surfaceSize().height());
ImGui::Text("Pixel Ratio: %.1f", view->devicePixelRatio());
ImGui::Text("No Draw: %s", view->noDraw() ? "TRUE" : "FALSE");
ImGui::Text("Frustum Culling: %s", view->frustumCulling() ? "TRUE" : "FALSE");
ImGui::Text("Compute: %s", view->isCompute() ? "TRUE" : "FALSE");
ImGui::Text("Clear Depth Value: %f", static_cast<double>(view->clearDepthValue()));
ImGui::Text("Clear Stencil Value: %d", view->clearStencilValue());
int j = 1;
view->forEachCommand([&](const Qt3DRR::OpenGL::RenderCommand &command) {
GeometryRenderer *rGeometryRenderer = m_renderer->nodeManagers()->data<GeometryRenderer, GeometryRendererManager>(command.m_geometryRenderer);
QString label = QString(QLatin1String("Command %1 {%2}")).arg(QString::number(j++), QString::number(rGeometryRenderer->peerId().id()));
if (ImGui::TreeNode(label.toLatin1().data())) {
ImGui::Text("Primitive Type: %s %s", primitiveTypeName(command.m_primitiveType),
command.m_drawIndexed ? "(indexed)" : "");
ImGui::Text("# Vertices: %d", command.m_primitiveCount);
ImGui::Text("# Primitives: %d", vertexToPrimitiveCount(command.m_primitiveType, command.m_primitiveCount));
ImGui::Text("# Instances: %d", command.m_instanceCount);
ImGui::TreePop();
}
});
ImGui::TreePop();
ImGui::Separator();
}
}
if (ImGui::Button("Dump"))
QMetaObject::invokeMethod(m_renderer->services()->systemInformation(), "dumpCommand",
Qt::QueuedConnection, Q_ARG(QString, QLatin1String("render rendercommands")));
ImGui::End();
}
void Qt3DRRD::ImGuiRenderer::renderDrawList(ImDrawData *draw_data)
{
// Avoid rendering when minimized, scale coordinates for retina displays (screen coordinates != framebuffer coordinates)
ImGuiIO& io = ImGui::GetIO();
int fb_width = int(io.DisplaySize.x * io.DisplayFramebufferScale.x);
int fb_height = int(io.DisplaySize.y * io.DisplayFramebufferScale.y);
if (fb_width == 0 || fb_height == 0)
return;
draw_data->ScaleClipRects(io.DisplayFramebufferScale);
// Backup GL state
GLint last_active_texture; m_funcs->glGetIntegerv(GL_ACTIVE_TEXTURE, &last_active_texture);
m_funcs->glActiveTexture(GL_TEXTURE0);
GLint last_program; m_funcs->glGetIntegerv(GL_CURRENT_PROGRAM, &last_program);
GLint last_texture; m_funcs->glGetIntegerv(GL_TEXTURE_BINDING_2D, &last_texture);
GLint last_array_buffer; m_funcs->glGetIntegerv(GL_ARRAY_BUFFER_BINDING, &last_array_buffer);
GLint last_element_array_buffer; m_funcs->glGetIntegerv(GL_ELEMENT_ARRAY_BUFFER_BINDING, &last_element_array_buffer);
GLint last_vertex_array; m_funcs->glGetIntegerv(GL_VERTEX_ARRAY_BINDING, &last_vertex_array);
GLint last_blend_src_rgb; m_funcs->glGetIntegerv(GL_BLEND_SRC_RGB, &last_blend_src_rgb);
GLint last_blend_dst_rgb; m_funcs->glGetIntegerv(GL_BLEND_DST_RGB, &last_blend_dst_rgb);
GLint last_blend_src_alpha; m_funcs->glGetIntegerv(GL_BLEND_SRC_ALPHA, &last_blend_src_alpha);
GLint last_blend_dst_alpha; m_funcs->glGetIntegerv(GL_BLEND_DST_ALPHA, &last_blend_dst_alpha);
GLint last_blend_equation_rgb; m_funcs->glGetIntegerv(GL_BLEND_EQUATION_RGB, &last_blend_equation_rgb);
GLint last_blend_equation_alpha; m_funcs->glGetIntegerv(GL_BLEND_EQUATION_ALPHA, &last_blend_equation_alpha);
GLint last_viewport[4]; m_funcs->glGetIntegerv(GL_VIEWPORT, last_viewport);
GLint last_scissor_box[4]; m_funcs->glGetIntegerv(GL_SCISSOR_BOX, last_scissor_box);
GLboolean last_enable_blend = m_funcs->glIsEnabled(GL_BLEND);
GLboolean last_enable_cull_face = m_funcs->glIsEnabled(GL_CULL_FACE);
GLboolean last_enable_depth_test = m_funcs->glIsEnabled(GL_DEPTH_TEST);
GLboolean last_enable_scissor_test = m_funcs->glIsEnabled(GL_SCISSOR_TEST);
// Setup render state: alpha-blending enabled, no face culling, no depth testing, scissor enabled
m_funcs->glEnable(GL_BLEND);
m_funcs->glBlendEquation(GL_FUNC_ADD);
m_funcs->glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
m_funcs->glDisable(GL_CULL_FACE);
m_funcs->glDisable(GL_DEPTH_TEST);
m_funcs->glEnable(GL_SCISSOR_TEST);
// Setup viewport, orthographic projection matrix
m_funcs->glViewport(0, 0, static_cast<GLsizei>(fb_width), static_cast<GLsizei>(fb_height));
const float ortho_projection[4][4] = {
{ 2.0f/io.DisplaySize.x, 0.0f, 0.0f, 0.0f },
{ 0.0f, 2.0f/-io.DisplaySize.y, 0.0f, 0.0f },
{ 0.0f, 0.0f, -1.0f, 0.0f },
{-1.0f, 1.0f, 0.0f, 1.0f },
};
m_funcs->glUseProgram(m_shaderHandle);
m_funcs->glUniform1i(m_attribLocationTex, 0);
m_funcs->glUniformMatrix4fv(m_attribLocationProjMtx, 1, GL_FALSE, &ortho_projection[0][0]);
m_funcs->glBindVertexArray(m_vaoHandle);
for (int n = 0; n < draw_data->CmdListsCount; n++) {
const ImDrawList* cmd_list = draw_data->CmdLists[n];
const ImDrawIdx* idx_buffer_offset = nullptr;
m_funcs->glBindBuffer(GL_ARRAY_BUFFER, m_vboHandle);
m_funcs->glBufferData(GL_ARRAY_BUFFER, static_cast<GLsizeiptr>(cmd_list->VtxBuffer.Size) * sizeof(ImDrawVert), static_cast<const GLvoid*>(cmd_list->VtxBuffer.Data), GL_STREAM_DRAW);
m_funcs->glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_elementsHandle);
m_funcs->glBufferData(GL_ELEMENT_ARRAY_BUFFER, static_cast<GLsizeiptr>(cmd_list->IdxBuffer.Size) * sizeof(ImDrawIdx), static_cast<const GLvoid*>(cmd_list->IdxBuffer.Data), GL_STREAM_DRAW);
for (int cmd_i = 0; cmd_i < cmd_list->CmdBuffer.Size; cmd_i++) {
const ImDrawCmd* pcmd = &cmd_list->CmdBuffer[cmd_i];
if (pcmd->UserCallback) {
pcmd->UserCallback(cmd_list, pcmd);
} else {
m_funcs->glBindTexture(GL_TEXTURE_2D, (GLuint)(intptr_t)pcmd->TextureId);
m_funcs->glScissor(static_cast<int>(pcmd->ClipRect.x), static_cast<int>(fb_height - pcmd->ClipRect.w),
static_cast<int>(pcmd->ClipRect.z - pcmd->ClipRect.x), static_cast<int>(pcmd->ClipRect.w - pcmd->ClipRect.y));
m_funcs->glDrawElements(GL_TRIANGLES, static_cast<GLsizei>(pcmd->ElemCount), sizeof(ImDrawIdx) == 2 ? GL_UNSIGNED_SHORT : GL_UNSIGNED_INT, idx_buffer_offset);
}
idx_buffer_offset += pcmd->ElemCount;
}
}
// Restore modified GL state
m_funcs->glUseProgram(last_program);
m_funcs->glBindTexture(GL_TEXTURE_2D, last_texture);
m_funcs->glActiveTexture(last_active_texture);
m_funcs->glBindVertexArray(last_vertex_array);
m_funcs->glBindBuffer(GL_ARRAY_BUFFER, last_array_buffer);
m_funcs->glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, last_element_array_buffer);
m_funcs->glBlendEquationSeparate(last_blend_equation_rgb, last_blend_equation_alpha);
m_funcs->glBlendFuncSeparate(last_blend_src_rgb, last_blend_dst_rgb, last_blend_src_alpha, last_blend_dst_alpha);
if (last_enable_blend)
m_funcs->glEnable(GL_BLEND); else m_funcs->glDisable(GL_BLEND);
if (last_enable_cull_face)
m_funcs->glEnable(GL_CULL_FACE); else m_funcs->glDisable(GL_CULL_FACE);
if (last_enable_depth_test)
m_funcs->glEnable(GL_DEPTH_TEST); else m_funcs->glDisable(GL_DEPTH_TEST);
if (last_enable_scissor_test)
m_funcs->glEnable(GL_SCISSOR_TEST); else m_funcs->glDisable(GL_SCISSOR_TEST);
m_funcs->glViewport(last_viewport[0], last_viewport[1], static_cast<GLsizei>(last_viewport[2]), static_cast<GLsizei>(last_viewport[3]));
m_funcs->glScissor(last_scissor_box[0], last_scissor_box[1], static_cast<GLsizei>(last_scissor_box[2]), static_cast<GLsizei>(last_scissor_box[3]));
}
bool Qt3DRRD::ImGuiRenderer::createFontsTexture()
{
// Build texture atlas
ImGuiIO& io = ImGui::GetIO();
unsigned char* pixels;
int width, height;
io.Fonts->GetTexDataAsRGBA32(&pixels, &width, &height); // Load as RGBA 32-bits (75% of the memory is wasted, but default font is so small) because it is more likely to be compatible with user's existing shaders. If your ImTextureId represent a higher-level concept than just a GL texture id, consider calling GetTexDataAsAlpha8() instead to save on GPU memory.
// Upload texture to graphics system
GLint last_texture;
m_funcs->glGetIntegerv(GL_TEXTURE_BINDING_2D, &last_texture);
m_funcs->glGenTextures(1, &m_fontTexture);
m_funcs->glBindTexture(GL_TEXTURE_2D, m_fontTexture);
m_funcs->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
m_funcs->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
m_funcs->glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, pixels);
// Store our identifier
io.Fonts->TexID = (void *)(intptr_t)m_fontTexture;
// Restore state
m_funcs->glBindTexture(GL_TEXTURE_2D, last_texture);
return true;
}
bool Qt3DRRD::ImGuiRenderer::createDeviceObjects()
{
auto *glContext = m_renderer->submissionContext()->openGLContext();
if (glContext->format().majorVersion() < 3) {
qWarning() << "Qt3D Profiling overlay requires GL or GL ES >= 3";
return false;
}
// Backup GL state
GLint last_texture, last_array_buffer, last_vertex_array;
m_funcs->glGetIntegerv(GL_TEXTURE_BINDING_2D, &last_texture);
m_funcs->glGetIntegerv(GL_ARRAY_BUFFER_BINDING, &last_array_buffer);
m_funcs->glGetIntegerv(GL_VERTEX_ARRAY_BINDING, &last_vertex_array);
const GLchar *vertex_shader =
"#version 330\n"
"uniform mat4 ProjMtx;\n"
"in vec2 Position;\n"
"in vec2 UV;\n"
"in vec4 Color;\n"
"out vec2 Frag_UV;\n"
"out vec4 Frag_Color;\n"
"void main()\n"
"{\n"
" Frag_UV = UV;\n"
" Frag_Color = Color;\n"
" gl_Position = ProjMtx * vec4(Position.xy, 0, 1);\n"
"}\n";
const GLchar* fragment_shader =
"#version 330\n"
"uniform sampler2D Texture;\n"
"in vec2 Frag_UV;\n"
"in vec4 Frag_Color;\n"
"out vec4 Out_Color;\n"
"void main()\n"
"{\n"
" Out_Color = Frag_Color * texture(Texture, Frag_UV.st);\n"
"}\n";
const GLchar *vertex_shader_es3 =
"#version 300 es\n"
"uniform mat4 ProjMtx;\n"
"in vec2 Position;\n"
"in vec2 UV;\n"
"in vec4 Color;\n"
"out vec2 Frag_UV;\n"
"out vec4 Frag_Color;\n"
"void main()\n"
"{\n"
" Frag_UV = UV;\n"
" Frag_Color = Color;\n"
" gl_Position = ProjMtx * vec4(Position.xy, 0, 1);\n"
"}\n";
const GLchar* fragment_shader_es3 =
"#version 300 es\n"
"precision highp float;\n"
"uniform sampler2D Texture;\n"
"in vec2 Frag_UV;\n"
"in vec4 Frag_Color;\n"
"out vec4 Out_Color;\n"
"void main()\n"
"{\n"
" Out_Color = Frag_Color * texture(Texture, Frag_UV.st);\n"
"}\n";
QString logs;
m_shader = new QOpenGLShaderProgram(this);
if (glContext->isOpenGLES()) {
if (!m_shader->addShaderFromSourceCode(QOpenGLShader::Vertex, vertex_shader_es3))
logs += m_shader->log();
if (!m_shader->addShaderFromSourceCode(QOpenGLShader::Fragment, fragment_shader_es3))
logs += m_shader->log();
} else {
if (!m_shader->addShaderFromSourceCode(QOpenGLShader::Vertex, vertex_shader))
logs += m_shader->log();
if (!m_shader->addShaderFromSourceCode(QOpenGLShader::Fragment, fragment_shader))
logs += m_shader->log();
}
m_shader->link();
logs += m_shader->log();
if (!logs.isEmpty())
qWarning() << logs;
m_shaderHandle = m_shader->programId();
m_attribLocationTex = m_funcs->glGetUniformLocation(m_shaderHandle, "Texture");
m_attribLocationProjMtx = m_funcs->glGetUniformLocation(m_shaderHandle, "ProjMtx");
m_attribLocationPosition = m_funcs->glGetAttribLocation(m_shaderHandle, "Position");
m_attribLocationUV = m_funcs->glGetAttribLocation(m_shaderHandle, "UV");
m_attribLocationColor = m_funcs->glGetAttribLocation(m_shaderHandle, "Color");
m_funcs->glGenBuffers(1, &m_vboHandle);
m_funcs->glGenBuffers(1, &m_elementsHandle);
m_funcs->glGenVertexArrays(1, &m_vaoHandle);
m_funcs->glBindVertexArray(m_vaoHandle);
m_funcs->glBindBuffer(GL_ARRAY_BUFFER, m_vboHandle);
m_funcs->glEnableVertexAttribArray(m_attribLocationPosition);
m_funcs->glEnableVertexAttribArray(m_attribLocationUV);
m_funcs->glEnableVertexAttribArray(m_attribLocationColor);
#define OFFSETOF(TYPE, ELEMENT) (reinterpret_cast<size_t>(&((static_cast<TYPE *>(nullptr))->ELEMENT)))
m_funcs->glVertexAttribPointer(m_attribLocationPosition, 2, GL_FLOAT, GL_FALSE, sizeof(ImDrawVert), reinterpret_cast<GLvoid*>(OFFSETOF(ImDrawVert, pos)));
m_funcs->glVertexAttribPointer(m_attribLocationUV, 2, GL_FLOAT, GL_FALSE, sizeof(ImDrawVert), reinterpret_cast<GLvoid*>(OFFSETOF(ImDrawVert, uv)));
m_funcs->glVertexAttribPointer(m_attribLocationColor, 4, GL_UNSIGNED_BYTE, GL_TRUE, sizeof(ImDrawVert), reinterpret_cast<GLvoid*>(OFFSETOF(ImDrawVert, col)));
#undef OFFSETOF
createFontsTexture();
// Restore modified GL state
m_funcs->glBindTexture(GL_TEXTURE_2D, last_texture);
m_funcs->glBindBuffer(GL_ARRAY_BUFFER, last_array_buffer);
m_funcs->glBindVertexArray(last_vertex_array);
return true;
}
bool Qt3DRRD::ImGuiRenderer::newFrame(const Qt3DRR::OpenGL::RenderView *renderView)
{
if (!m_funcs)
m_funcs = m_renderer->submissionContext()->openGLContext()->extraFunctions();
if (!m_fontTexture)
createDeviceObjects();
if (!m_shader)
return false;
ImGuiIO& io = ImGui::GetIO();
// Setup display size (every frame to accommodate for window resizing)
io.DisplaySize = ImVec2(renderView->surfaceSize().width() / renderView->devicePixelRatio(), renderView->surfaceSize().height() / renderView->devicePixelRatio());
io.DisplayFramebufferScale = ImVec2(renderView->devicePixelRatio(), renderView->devicePixelRatio());
// Setup time step
double current_time = QDateTime::currentMSecsSinceEpoch() / 1000.;
io.DeltaTime = m_time > 0.0 ? static_cast<float>(current_time - m_time) : 1.0f / 60.0f;
if (io.DeltaTime == 0.f)
io.DeltaTime = 1.0f / 60.0f;
m_time = current_time;
// Setup inputs
for (int i = 0; i < 3; i++)
io.MouseDown[i] = m_mousePressed[i];
io.MouseWheelH = m_mouseWheelH;
io.MouseWheel = m_mouseWheel;
m_mouseWheelH = 0;
m_mouseWheel = 0;
// Start the frame
ImGui::NewFrame();
return true;
}
void Qt3DRRD::ImGuiRenderer::onMouseChange(QMouseEvent *event)
{
ImGuiIO& io = ImGui::GetIO();
io.MousePos = ImVec2(event->pos().x(), event->pos().y());
m_mousePressed[0] = event->buttons() & Qt::LeftButton;
m_mousePressed[1] = event->buttons() & Qt::RightButton;
m_mousePressed[2] = event->buttons() & Qt::MiddleButton;
}
#if QT_CONFIG(wheelevent)
void Qt3DRRD::ImGuiRenderer::onWheel(QWheelEvent *event)
{
// 5 lines per unit
m_mouseWheelH += event->pixelDelta().x() / (ImGui::GetTextLineHeight());
m_mouseWheel += event->pixelDelta().y() / (5.f * ImGui::GetTextLineHeight());
}
#endif
void Qt3DRRD::ImGuiRenderer::onKeyPressRelease(QKeyEvent *event)
{
ImGuiIO& io = ImGui::GetIO();
if (keyMap.contains(event->key()))
io.AddKeyEvent(keyMap[event->key()], event->type() == QEvent::KeyPress);
if (event->type() == QEvent::KeyPress) {
QString text = event->text();
if (text.size() == 1)
io.AddInputCharacter(static_cast<ImWchar>(text.at(0).unicode()));
}
#ifdef Q_OS_DARWIN
io.KeyCtrl = event->modifiers() & Qt::MetaModifier;
io.KeyShift = event->modifiers() & Qt::ShiftModifier;
io.KeyAlt = event->modifiers() & Qt::AltModifier;
io.KeySuper = event->modifiers() & Qt::ControlModifier; // Command key
#else
io.KeyCtrl = event->modifiers() & Qt::ControlModifier;
io.KeyShift = event->modifiers() & Qt::ShiftModifier;
io.KeyAlt = event->modifiers() & Qt::AltModifier;
io.KeySuper = event->modifiers() & Qt::MetaModifier;
#endif
}
void Qt3DRRD::ImGuiRenderer::processEvent(QEvent *event)
{
switch (event->type()) {
case QEvent::MouseMove:
case QEvent::MouseButtonPress:
case QEvent::MouseButtonRelease:
this->onMouseChange(static_cast<QMouseEvent *>(event));
break;
#if QT_CONFIG(wheelevent)
case QEvent::Wheel:
this->onWheel(static_cast<QWheelEvent *>(event));
break;
#endif
case QEvent::KeyPress:
case QEvent::KeyRelease:
this->onKeyPressRelease(static_cast<QKeyEvent *>(event));
break;
default:
break;
}
}
QT_END_NAMESPACE