diff options
Diffstat (limited to 'src/plugins/renderers/opengl/debug/imguirenderer.cpp')
| -rw-r--r-- | src/plugins/renderers/opengl/debug/imguirenderer.cpp | 706 |
1 files changed, 706 insertions, 0 deletions
diff --git a/src/plugins/renderers/opengl/debug/imguirenderer.cpp b/src/plugins/renderers/opengl/debug/imguirenderer.cpp new file mode 100644 index 000000000..e23476860 --- /dev/null +++ b/src/plugins/renderers/opengl/debug/imguirenderer.cpp @@ -0,0 +1,706 @@ +/**************************************************************************** +** +** Copyright (C) 2019 Klaralvdalens Datakonsult AB (KDAB). +** Contact: https://www.qt.io/licensing/ +** +** This file is part of the Qt3D module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** Commercial License Usage +** Licensees holding valid commercial Qt licenses may use this file in +** accordance with the commercial license agreement provided with the +** Software or, alternatively, in accordance with the terms contained in +** a written agreement between you and The Qt Company. For licensing terms +** and conditions see https://www.qt.io/terms-conditions. For further +** information use the contact form at https://www.qt.io/contact-us. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 3 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL3 included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 3 requirements +** will be met: https://www.gnu.org/licenses/lgpl-3.0.html. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 2.0 or (at your option) the GNU General +** Public license version 3 or any later version approved by the KDE Free +** Qt Foundation. The licenses are as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3 +** included in the packaging of this file. Please review the following +** information to ensure the GNU General Public License requirements will +** be met: https://www.gnu.org/licenses/gpl-2.0.html and +** https://www.gnu.org/licenses/gpl-3.0.html. +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +/* + * Based on https://github.com/seanchas116/qtimgui/ + * + * MIT License https://github.com/seanchas116/qtimgui/blob/master/LICENSE + * + */ + +#include "imguirenderer_p.h" +#include <renderview_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 + +using namespace Qt3DRender; +using namespace Render; +using namespace Render::Debug; +using namespace Render::OpenGL; + +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 QGeometryRenderer::Points: + case QGeometryRenderer::LineLoop: nPrimitives += numVertices; break; + case QGeometryRenderer::Triangles: nPrimitives += numVertices / 3; break; + case QGeometryRenderer::Lines: nPrimitives += numVertices / 2; break; + case QGeometryRenderer::TriangleFan: + case QGeometryRenderer::TriangleStrip: + case QGeometryRenderer::LineStrip: nPrimitives += numVertices - 1; break; + case QGeometryRenderer::TrianglesAdjacency: nPrimitives += numVertices / 6; break; + case QGeometryRenderer::TriangleStripAdjacency: + case QGeometryRenderer::LineStripAdjacency: nPrimitives += numVertices / 2 - 1; break; + case QGeometryRenderer::LinesAdjacency: nPrimitives += numVertices / 4; break; + case QGeometryRenderer::Patches: nPrimitives += 1; + } + return nPrimitives; + } + + const char *primitiveTypeName(Qt3DRender::QGeometryRenderer::PrimitiveType primitiveType) { + switch (primitiveType) { + case QGeometryRenderer::Points: return "Points"; + case QGeometryRenderer::LineLoop: return "LineLoop"; + case QGeometryRenderer::Triangles: return "Triangles"; + case QGeometryRenderer::TrianglesAdjacency: return "TriangleAdjacency"; + case QGeometryRenderer::TriangleFan: return "TriangleFan"; + case QGeometryRenderer::TriangleStrip: return "TriangleStrip"; + case QGeometryRenderer::TriangleStripAdjacency: return "TriangleStringAdjacency"; + case QGeometryRenderer::LineStrip: return "LineStrip"; + case QGeometryRenderer::LineStripAdjacency: return "LineStripAdjacency"; + case QGeometryRenderer::Lines: return "Lines"; + case QGeometryRenderer::LinesAdjacency: return "LinesAdjacency"; + case QGeometryRenderer::Patches: return "Patches"; + } + return ""; + } +} + +ImGuiRenderer::ImGuiRenderer(Qt3DRender::Render::OpenGL::Renderer *renderer) + : m_renderer(renderer) +{ + ImGui::CreateContext(); + + ImGuiIO &io = ImGui::GetIO(); + for (ImGuiKey key : keyMap.values()) + io.KeyMap[key] = key; + +#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; +} + +void ImGuiRenderer::renderDebugOverlay(const QVector<RenderView *> &renderViews, const RenderView *renderView, int jobsInLastFrame) +{ + if (!newFrame(renderView)) + return; + + const int renderViewsCount = 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); + } + + { + bool pj = m_renderer->services()->systemInformation()->isTraceEnabled(); + bool pg = m_renderer->services()->systemInformation()->isGraphicsTraceEnabled(); + + ImGui::Begin("Qt3D Profiling"); + char caption[50]; + sprintf(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)); + 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::Checkbox("GL", &pg)) + QMetaObject::invokeMethod(m_renderer->services()->systemInformation(), "setGraphicsTraceEnabled", Qt::QueuedConnection, Q_ARG(bool, pg)); + ImGui::SameLine(); + if (ImGui::Button("Reveal")) + QMetaObject::invokeMethod(m_renderer->services()->systemInformation(), "revealLogFolder", Qt::QueuedConnection); + + int nCommands = 0; + int nVertices = 0; + int nPrimitives = 0; + QSet<HGeometryRenderer> inUseGeometries; + QSet<Qt3DCore::QNodeId> inUseTextures; + for (int j=0; j<renderViewsCount; j++) { + const auto &commands = renderViews.at(j)->commands(); + nCommands += commands.size(); + for (int k=0; k<commands.size(); k++) { + const RenderCommand &command = commands.at(k); + if (command.m_type != RenderCommand::Draw) + continue; + 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(); + + 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("FrameGraph Paths##1")) + QMetaObject::invokeMethod(m_renderer->services()->systemInformation(), "dumpCommand", + Qt::QueuedConnection, Q_ARG(QString, QLatin1String("render framepaths"))); + + ImGui::End(); + + if (m_showGLInfoWindow) + showGLInfo(); + if (m_showRenderDetailsWindow) + showRenderDetails(renderViews); + } + + ImGui::Render(); + renderDrawList(ImGui::GetDrawData()); +} + +void ImGuiRenderer::setCapabilities(const QString &capabilities) +{ + m_capabilities = capabilities.toLatin1(); +} + +void ImGuiRenderer::showGLInfo() +{ + ImGui::Begin("Open GL Details", &m_showGLInfoWindow); + ImGui::Text("%s", m_capabilities.data()); + ImGui::End(); +} + +void ImGuiRenderer::showRenderDetails(const QVector<RenderView *> &renderViews) +{ + ImGui::Begin("Render Views", &m_showRenderDetailsWindow); + + int i = 1; + for (const 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; + const auto commands = view->commands(); + for (const RenderCommand &command: commands) { + QString label(QLatin1String("Command ") + QString::number(j++)); + 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 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 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 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 110\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 110\n" + "uniform sampler2D Texture;\n" + "in vec2 Frag_UV;\n" + "in vec4 Frag_Color;\n" + "void main()\n" + "{\n" + " gl_FragColor = Frag_Color * texture2D(Texture, Frag_UV.st);\n" + "}\n"; + +// m_shaderHandle = m_funcs->glCreateProgram(); +// m_vertHandle = m_funcs->glCreateShader(GL_VERTEX_SHADER); +// m_fragHandle = m_funcs->glCreateShader(GL_FRAGMENT_SHADER); +// auto *glContext = m_renderer->submissionContext()->openGLContext(); +// m_funcs->glShaderSource(m_vertHandle, 1, &vertex_shader, nullptr); +// m_funcs->glShaderSource(m_fragHandle, 1, &fragment_shader, nullptr); +// m_funcs->glCompileShader(m_vertHandle); +// m_funcs->glCompileShader(m_fragHandle); +// m_funcs->glAttachShader(m_shaderHandle, m_vertHandle); +// m_funcs->glAttachShader(m_shaderHandle, m_fragHandle); +// m_funcs->glLinkProgram(m_shaderHandle); + + 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 ImGuiRenderer::newFrame(const 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 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; +} + +void ImGuiRenderer::onWheel(QWheelEvent *event) +{ + // 5 lines per unit + m_mouseWheelH += event->pixelDelta().x() / (ImGui::GetTextLineHeight()); + m_mouseWheel += event->pixelDelta().y() / (5.f * ImGui::GetTextLineHeight()); +} + +void ImGuiRenderer::onKeyPressRelease(QKeyEvent *event) +{ + ImGuiIO& io = ImGui::GetIO(); + if (keyMap.contains(event->key())) + io.KeysDown[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 ImGuiRenderer::processEvent(QEvent *event) +{ + switch (event->type()) { + case QEvent::MouseMove: + case QEvent::MouseButtonPress: + case QEvent::MouseButtonRelease: + this->onMouseChange(static_cast<QMouseEvent *>(event)); + break; + case QEvent::Wheel: + this->onWheel(static_cast<QWheelEvent *>(event)); + break; + case QEvent::KeyPress: + case QEvent::KeyRelease: + this->onKeyPressRelease(static_cast<QKeyEvent *>(event)); + break; + default: + break; + } +} + +QT_END_NAMESPACE |