mirror/OpenSpace
1
0
Fork 0
mirror of https://github.com/OpenSpace/OpenSpace.git synced 2026-01-06 11:39:49 -06:00
Code Issues Packages Projects Releases Wiki Activity
Files
ed604e0bb93de60fd93cb1effb439e605bad73c2
OpenSpace/modules/imgui/imguimodule.cpp
Emma Broman 0cc5704b6a Add isGuiWindow check for mouse and keyboard callbacks 
Fix interaction problems when hovering/clicking with the mouse in a non-GUI window, when having a setup with more than one window (e.g. the single_gui.json setup)

Previously, clicking with the mouse in the rendering window without the GUI also triggered mouse clicks in all the other windows, including the GUI windows. This was disturbing for interaction in the single_gui setup

Now, the GUI modules check to see if the clicked window is actually an interaction window
2022-08-05 11:41:10 +02:00

778 lines
27 KiB
C++
Raw Blame History

/*****************************************************************************************
* *
* OpenSpace *
* *
* Copyright (c) 2014-2022 *
* *
* Permission is hereby granted, free of charge, to any person obtaining a copy of this *
* software and associated documentation files (the "Software"), to deal in the Software *
* without restriction, including without limitation the rights to use, copy, modify, *
* merge, publish, distribute, sublicense, and/or sell copies of the Software, and to *
* permit persons to whom the Software is furnished to do so, subject to the following *
* conditions: *
* *
* The above copyright notice and this permission notice shall be included in all copies *
* or substantial portions of the Software. *
* *
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, *
* INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A *
* PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT *
* HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF *
* CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE *
* OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. *
****************************************************************************************/
#include <modules/imgui/imguimodule.h>
#include <modules/imgui/include/imgui_include.h>
#include <openspace/engine/globals.h>
#include <openspace/engine/globalscallbacks.h>
#include <openspace/engine/moduleengine.h>
#include <openspace/engine/windowdelegate.h>
#include <openspace/interaction/sessionrecording.h>
#include <openspace/navigation/navigationhandler.h>
#include <openspace/network/parallelpeer.h>
#include <openspace/rendering/dashboard.h>
#include <openspace/rendering/luaconsole.h>
#include <openspace/rendering/renderengine.h>
#include <openspace/scene/scene.h>
#include <openspace/scripting/scriptengine.h>
#include <ghoul/filesystem/cachemanager.h>
#include <ghoul/filesystem/filesystem.h>
#include <ghoul/opengl/textureunit.h>
// #define SHOW_IMGUI_HELPERS
namespace {
constexpr std::string_view _loggerCat = "GUI";
constexpr std::string_view GuiFont = "${FONTS}/arimo/Arimo-Regular.ttf";
constexpr float FontSize = 14.f;
ImFont* captionFont = nullptr;
constexpr std::array<const char*, 2> UniformNames = { "tex", "ortho" };
constexpr openspace::properties::Property::PropertyInfo EnabledInfo = {
"Enabled",
"Is Enabled",
"This setting determines whether this object will be visible or not"
};
constexpr openspace::properties::Property::PropertyInfo CollapsedInfo = {
"Collapsed",
"Is Collapsed",
"This setting determines whether this window is collapsed or not"
};
constexpr openspace::properties::Property::PropertyInfo ShowHelpInfo = {
"ShowHelpText",
"Show tooltip help",
"If this value is enabled these kinds of tooltips are shown for most properties "
"explaining what impact they have on the visuals"
};
constexpr openspace::properties::Property::PropertyInfo HelpTextDelayInfo = {
"HelpTextDelay",
"Tooltip Delay (in s)",
"This value determines the delay in seconds after which the tooltip is shown"
};
} // namespace
namespace openspace {
void CaptionText(const char* text) {
ImGui::PushFont(captionFont);
ImGui::Text("%s", text);
ImGui::PopFont();
}
ImGUIModule::ImGUIModule()
: OpenSpaceModule(Name)
, _isEnabled(EnabledInfo, false)
, _isCollapsed(CollapsedInfo, false)
, _sceneProperty("Scene", "Scene", gui::GuiPropertyComponent::UseTreeLayout::Yes)
, _property("Settings", "Settings")
, _showHelpText(ShowHelpInfo, true)
, _helpTextDelay(HelpTextDelayInfo, 1.f, 0.f, 10.f)
{
addProperty(_isEnabled);
addProperty(_isCollapsed);
for (gui::GuiComponent* comp : _components) {
addPropertySubOwner(comp);
}
_spaceTime.setEnabled(true);
{
auto showHelpTextFunc = [this]() {
for (gui::GuiComponent* comp : _components) {
comp->setShowHelpTooltip(_showHelpText);
}
};
showHelpTextFunc();
_showHelpText.onChange(std::move(showHelpTextFunc));
addProperty(_showHelpText);
}
{
auto helpTextDelayFunc = [this]() {
for (gui::GuiComponent* comp : _components) {
comp->setShowHelpTooltipDelay(_helpTextDelay);
}
};
helpTextDelayFunc();
_helpTextDelay.onChange(std::move(helpTextDelayFunc));
addProperty(_helpTextDelay);
}
global::callback::draw2D->emplace_back([&]() {
ZoneScopedN("ImGUI")
if (!_isEnabled) {
return;
}
WindowDelegate& delegate = *global::windowDelegate;
const bool showGui = delegate.hasGuiWindow() ? delegate.isGuiWindow() : true;
if (delegate.isMaster() && showGui) {
const glm::ivec2 windowSize = delegate.currentSubwindowSize();
if (windowSize.x <= 0 || windowSize.y <= 0) {
return;
}
const glm::ivec2 resolution = delegate.currentDrawBufferResolution();
const double dt = std::max(delegate.averageDeltaTime(), 0.0);
renderFrame(
static_cast<float>(dt),
glm::vec2(windowSize),
resolution / windowSize,
_mousePosition,
_mouseButtons
);
}
});
global::callback::keyboard->emplace_back(
[&](Key key, KeyModifier mod, KeyAction action,
IsGuiWindow isGuiWindow) -> bool
{
ZoneScopedN("ImGUI")
if (!isGuiWindow || !_isEnabled) {
return false;
}
return keyCallback(key, mod, action);
}
);
global::callback::character->emplace_back(
[&](unsigned int codepoint, KeyModifier modifier,
IsGuiWindow isGuiWindow) -> bool
{
ZoneScopedN("ImGUI")
if (!isGuiWindow || !_isEnabled) {
return false;
}
return charCallback(codepoint, modifier);
}
);
global::callback::mousePosition->emplace_back(
[&](double x, double y, IsGuiWindow isGuiWindow) {
if (!isGuiWindow) {
return; // do nothing
}
_mousePosition = glm::vec2(static_cast<float>(x), static_cast<float>(y));
}
);
global::callback::mouseButton->emplace_back(
[&](MouseButton button, MouseAction action, KeyModifier,
IsGuiWindow isGuiWindow) -> bool
{
ZoneScopedN("ImGUI")
if (!isGuiWindow) {
return false;
}
if (action == MouseAction::Press) {
_mouseButtons |= (1 << static_cast<int>(button));
}
else if (action == MouseAction::Release) {
_mouseButtons &= ~(1 << static_cast<int>(button));
}
return _isEnabled ? mouseButtonCallback(button, action) : false;
}
);
global::callback::mouseScrollWheel->emplace_back(
[&](double, double posY, IsGuiWindow isGuiWindow) -> bool {
ZoneScopedN("ImGUI")
if (!isGuiWindow || !_isEnabled) {
return false;
}
return mouseWheelCallback(posY);
}
);
global::callback::touchDetected->emplace_back(
[&](TouchInput input) -> bool {
return touchDetectedCallback(input);
}
);
global::callback::touchUpdated->emplace_back(
[&](TouchInput input) -> bool {
return touchUpdatedCallback(input);
}
);
global::callback::touchExit->emplace_back(
[&](TouchInput input) {
touchExitCallback(input);
}
);
}
void ImGUIModule::internalInitialize(const ghoul::Dictionary&) {
LDEBUGC("ImGUIModule", "Initializing GUI");
_sceneProperty.setPropertyOwnerFunction(
[]() {
const Scene* scene = global::renderEngine->scene();
const std::vector<SceneGraphNode*>& nodes = scene ?
scene->allSceneGraphNodes() :
std::vector<SceneGraphNode*>();
return std::vector<properties::PropertyOwner*>(nodes.begin(), nodes.end());
}
);
_property.setPropertyOwners({
global::screenSpaceRootPropertyOwner,
global::moduleEngine,
global::navigationHandler,
global::sessionRecording,
global::timeManager,
global::renderEngine,
global::parallelPeer,
global::luaConsole,
global::dashboard
});
}
void ImGUIModule::internalDeinitialize() {
for (ImGuiContext* ctx : _contexts) {
ImGui::DestroyContext(ctx);
}
for (gui::GuiComponent* comp : _components) {
comp->deinitialize();
}
}
void ImGUIModule::internalInitializeGL() {
std::filesystem::path file = FileSys.cacheManager()->cachedFilename("imgui.ini", "");
LDEBUG(fmt::format("Using {} as ImGUI cache location", file));
_iniFileBuffer.resize(file.string().size() + 1);
#ifdef WIN32
strcpy_s(_iniFileBuffer.data(), file.string().size() + 1, file.string().c_str());
#else
strcpy(_iniFileBuffer.data(), file.c_str());
#endif
int nWindows = global::windowDelegate->nWindows();
_contexts.resize(nWindows);
for (int i = 0; i < nWindows; ++i) {
_contexts[i] = ImGui::CreateContext();
ImGui::SetCurrentContext(_contexts[i]);
ImGuiIO& io = ImGui::GetIO();
io.IniFilename = _iniFileBuffer.data();
io.DeltaTime = 1.f / 60.f;
io.KeyMap[ImGuiKey_Tab] = static_cast<int>(Key::Tab);
io.KeyMap[ImGuiKey_LeftArrow] = static_cast<int>(Key::Left);
io.KeyMap[ImGuiKey_RightArrow] = static_cast<int>(Key::Right);
io.KeyMap[ImGuiKey_UpArrow] = static_cast<int>(Key::Up);
io.KeyMap[ImGuiKey_DownArrow] = static_cast<int>(Key::Down);
io.KeyMap[ImGuiKey_Home] = static_cast<int>(Key::Home);
io.KeyMap[ImGuiKey_End] = static_cast<int>(Key::End);
io.KeyMap[ImGuiKey_Delete] = static_cast<int>(Key::Delete);
io.KeyMap[ImGuiKey_Backspace] = static_cast<int>(Key::BackSpace);
io.KeyMap[ImGuiKey_Enter] = static_cast<int>(Key::Enter);
io.KeyMap[ImGuiKey_Escape] = static_cast<int>(Key::Escape);
io.KeyMap[ImGuiKey_A] = static_cast<int>(Key::A);
io.KeyMap[ImGuiKey_C] = static_cast<int>(Key::C);
io.KeyMap[ImGuiKey_V] = static_cast<int>(Key::V);
io.KeyMap[ImGuiKey_X] = static_cast<int>(Key::X);
io.KeyMap[ImGuiKey_Y] = static_cast<int>(Key::Y);
io.KeyMap[ImGuiKey_Z] = static_cast<int>(Key::Z);
io.Fonts->AddFontFromFileTTF(absPath(GuiFont).string().c_str(), FontSize);
captionFont = io.Fonts->AddFontFromFileTTF(
absPath(GuiFont).string().c_str(),
FontSize * 1.5f
);
ImGuiStyle& style = ImGui::GetStyle();
style.WindowPadding = { 4.f, 4.f };
style.WindowRounding = 0.f;
style.FramePadding = { 3.f, 3.f };
style.FrameRounding = 0.f;
style.ItemSpacing = { 3.f, 2.f };
style.ItemInnerSpacing = { 3.f, 2.f };
style.TouchExtraPadding = { 1.f, 1.f };
style.IndentSpacing = 15.f;
style.ScrollbarSize = 10.f;
style.ScrollbarRounding = 0.f;
style.GrabMinSize = 10.f;
style.GrabRounding = 16.f;
style.Colors[ImGuiCol_Text] = ImVec4(0.90f, 0.90f, 0.90f, 1.00f);
style.Colors[ImGuiCol_TextDisabled] = ImVec4(0.60f, 0.60f, 0.60f, 1.00f);
style.Colors[ImGuiCol_WindowBg] = ImVec4(0.13f, 0.13f, 0.13f, 0.96f);
style.Colors[ImGuiCol_ChildBg] = ImVec4(0.00f, 0.00f, 0.00f, 0.00f);
style.Colors[ImGuiCol_PopupBg] = ImVec4(0.05f, 0.05f, 0.10f, 0.90f);
style.Colors[ImGuiCol_Border] = ImVec4(0.65f, 0.65f, 0.65f, 0.59f);
style.Colors[ImGuiCol_BorderShadow] = ImVec4(0.00f, 0.00f, 0.00f, 0.00f);
style.Colors[ImGuiCol_FrameBg] = ImVec4(0.80f, 0.80f, 0.80f, 0.30f);
style.Colors[ImGuiCol_FrameBgHovered] = ImVec4(0.91f, 0.94f, 0.99f, 0.40f);
style.Colors[ImGuiCol_FrameBgActive] = ImVec4(0.90f, 0.90f, 0.90f, 0.45f);
style.Colors[ImGuiCol_TitleBg] = ImVec4(0.71f, 0.81f, 1.00f, 0.45f);
style.Colors[ImGuiCol_TitleBgCollapsed] = ImVec4(0.71f, 0.81f, 1.00f, 0.45f);
style.Colors[ImGuiCol_TitleBgActive] = ImVec4(0.51f, 0.69f, 1.00f, 0.63f);
style.Colors[ImGuiCol_MenuBarBg] = ImVec4(0.26f, 0.27f, 0.33f, 0.80f);
style.Colors[ImGuiCol_ScrollbarBg] = ImVec4(0.00f, 0.00f, 0.00f, 0.00f);
style.Colors[ImGuiCol_ScrollbarGrab] = ImVec4(0.40f, 0.75f, 0.80f, 0.43f);
style.Colors[ImGuiCol_ScrollbarGrabHovered] = ImVec4(0.40f, 0.75f, 0.80f, 0.65f);
style.Colors[ImGuiCol_ScrollbarGrabActive] = ImVec4(0.40f, 0.75f, 0.80f, 0.65f);
style.Colors[ImGuiCol_CheckMark] = ImVec4(1.00f, 1.00f, 1.00f, 0.50f);
style.Colors[ImGuiCol_SliderGrab] = ImVec4(1.00f, 1.00f, 1.00f, 0.30f);
style.Colors[ImGuiCol_SliderGrabActive] = ImVec4(0.50f, 0.80f, 0.76f, 1.00f);
style.Colors[ImGuiCol_Button] = ImVec4(0.36f, 0.54f, 0.68f, 0.62f);
style.Colors[ImGuiCol_ButtonHovered] = ImVec4(0.36f, 0.54f, 0.68f, 1.00f);
style.Colors[ImGuiCol_ButtonActive] = ImVec4(0.36f, 0.61f, 0.81f, 1.00f);
style.Colors[ImGuiCol_Header] = ImVec4(0.69f, 0.69f, 0.69f, 0.45f);
style.Colors[ImGuiCol_HeaderHovered] = ImVec4(0.36f, 0.54f, 0.68f, 0.62f);
style.Colors[ImGuiCol_HeaderActive] = ImVec4(0.53f, 0.63f, 0.87f, 0.80f);
style.Colors[ImGuiCol_Separator] = ImVec4(0.50f, 0.50f, 0.50f, 1.00f);
style.Colors[ImGuiCol_SeparatorHovered] = ImVec4(0.70f, 0.60f, 0.60f, 1.00f);
style.Colors[ImGuiCol_SeparatorActive] = ImVec4(0.90f, 0.70f, 0.70f, 1.00f);
style.Colors[ImGuiCol_ResizeGrip] = ImVec4(1.00f, 1.00f, 1.00f, 1.00f);
style.Colors[ImGuiCol_ResizeGripHovered] = ImVec4(1.00f, 1.00f, 1.00f, 0.60f);
style.Colors[ImGuiCol_ResizeGripActive] = ImVec4(1.00f, 1.00f, 1.00f, 0.90f);
style.Colors[ImGuiCol_PlotLines] = ImVec4(1.00f, 1.00f, 1.00f, 1.00f);
style.Colors[ImGuiCol_PlotLinesHovered] = ImVec4(0.90f, 0.70f, 0.00f, 1.00f);
style.Colors[ImGuiCol_PlotHistogram] = ImVec4(0.90f, 0.70f, 0.00f, 1.00f);
style.Colors[ImGuiCol_PlotHistogramHovered] = ImVec4(1.00f, 0.60f, 0.00f, 1.00f);
style.Colors[ImGuiCol_TextSelectedBg] = ImVec4(0.44f, 0.63f, 1.00f, 0.35f);
style.Colors[ImGuiCol_ModalWindowDimBg] = ImVec4(0.20f, 0.20f, 0.20f, 0.35f);
}
for (gui::GuiComponent* comp : _components) {
comp->initialize();
}
_program = ghoul::opengl::ProgramObject::Build(
"GUI",
absPath("${MODULE_IMGUI}/shaders/gui_vs.glsl"),
absPath("${MODULE_IMGUI}/shaders/gui_fs.glsl")
);
ghoul::opengl::updateUniformLocations(*_program, _uniformCache, UniformNames);
{
unsigned char* texData;
glm::ivec2 texSize = glm::ivec2(0, 0);
for (int i = 0; i < nWindows; ++i) {
ImGui::SetCurrentContext(_contexts[i]);
ImGui::GetIO().Fonts->GetTexDataAsRGBA32(&texData, &texSize.x, &texSize.y);
}
_fontTexture = std::make_unique<ghoul::opengl::Texture>(
texData,
glm::uvec3(texSize.x, texSize.y, 1),
GL_TEXTURE_2D
);
_fontTexture->setName("Gui Text");
_fontTexture->setDataOwnership(ghoul::opengl::Texture::TakeOwnership::No);
_fontTexture->uploadTexture();
}
for (int i = 0; i < nWindows; ++i) {
uintptr_t texture = static_cast<GLuint>(*_fontTexture);
ImGui::SetCurrentContext(_contexts[i]);
ImGui::GetIO().Fonts->TexID = reinterpret_cast<void*>(texture);
}
glGenBuffers(1, &vbo);
glBindBuffer(GL_ARRAY_BUFFER, vbo);
glBufferData(GL_ARRAY_BUFFER, 0, nullptr, GL_DYNAMIC_DRAW);
glGenBuffers(1, &vboElements);
glGenVertexArrays(1, &vao);
glBindVertexArray(vao);
glBindBuffer(GL_ARRAY_BUFFER, vbo);
GLuint positionAttrib = _program->attributeLocation("in_position");
GLuint uvAttrib = _program->attributeLocation("in_uv");
GLuint colorAttrib = _program->attributeLocation("in_color");
glEnableVertexAttribArray(positionAttrib);
glVertexAttribPointer(
positionAttrib,
2,
GL_FLOAT,
GL_FALSE,
sizeof(ImDrawVert),
nullptr
);
glEnableVertexAttribArray(uvAttrib);
glVertexAttribPointer(
uvAttrib,
2,
GL_FLOAT,
GL_FALSE,
sizeof(ImDrawVert),
reinterpret_cast<GLvoid*>(offsetof(ImDrawVert, uv))
);
glEnableVertexAttribArray(colorAttrib);
glVertexAttribPointer(
colorAttrib,
4,
GL_UNSIGNED_BYTE,
GL_TRUE,
sizeof(ImDrawVert),
reinterpret_cast<GLvoid*>(offsetof(ImDrawVert, col))
);
glBindVertexArray(0);
for (gui::GuiComponent* comp : _components) {
comp->initializeGL();
}
}
void ImGUIModule::internalDeinitializeGL() {
_program = nullptr;
_fontTexture = nullptr;
glDeleteVertexArrays(1, &vao);
glDeleteBuffers(1, &vbo);
glDeleteBuffers(1, &vboElements);
for (gui::GuiComponent* comp : _components) {
comp->deinitializeGL();
}
}
void ImGUIModule::renderFrame(float deltaTime, const glm::vec2& windowSize,
const glm::vec2& dpiScaling, const glm::vec2& mousePos,
uint32_t mouseButtonsPressed)
{
const int iWindow = global::windowDelegate->currentWindowId();
ImGui::SetCurrentContext(_contexts[iWindow]);
ImGuiIO& io = ImGui::GetIO();
io.DisplaySize = ImVec2(windowSize.x, windowSize.y);
io.DisplayFramebufferScale = ImVec2(dpiScaling.x, dpiScaling.y);
io.DeltaTime = deltaTime;
io.MousePos = ImVec2(mousePos.x, mousePos.y);
io.MouseDown[0] = mouseButtonsPressed & (1 << 0);
io.MouseDown[1] = mouseButtonsPressed & (1 << 1);
ImGui::NewFrame();
if (_program->isDirty()) {
_program->rebuildFromFile();
ghoul::opengl::updateUniformLocations(*_program, _uniformCache, UniformNames);
}
//
// Render
ImGui::SetNextWindowCollapsed(_isCollapsed);
ImGui::Begin("OpenSpace GUI", nullptr);
_isCollapsed = ImGui::IsWindowCollapsed();
for (gui::GuiComponent* comp : _components) {
bool enabled = comp->isEnabled();
ImGui::Checkbox(comp->guiName().c_str(), &enabled);
comp->setEnabled(enabled);
}
#ifdef SHOW_IMGUI_HELPERS
ImGui::Checkbox("ImGUI Internals", &_showInternals);
if (_showInternals) {
ImGui::Begin("Style Editor");
ImGui::ShowStyleEditor();
ImGui::End();
ImGui::Begin("Test Window");
ImGui::ShowDemoWindow();
ImGui::End();
ImGui::Begin("Metrics Window");
ImGui::ShowMetricsWindow();
ImGui::End();
}
#endif
ImGui::End();
for (gui::GuiComponent* comp : _components) {
if (comp->isEnabled()) {
comp->render();
}
}
ImGui::Render();
// Drawing
ImDrawData* drawData = ImGui::GetDrawData();
// Avoid rendering when minimized, scale coordinates for retina displays
// (screen coordinates != framebuffer coordinates)
GLsizei fbWidth = static_cast<GLsizei>(
io.DisplaySize.x * io.DisplayFramebufferScale.x
);
GLsizei fbHeight = static_cast<GLsizei>(
io.DisplaySize.y * io.DisplayFramebufferScale.y
);
if (fbWidth == 0 || fbHeight == 0) {
return;
}
drawData->ScaleClipRects(io.DisplayFramebufferScale);
// Setup render state:
// alpha-blending enabled, no face culling, no depth testing, scissor enabled
glEnable(GL_BLEND);
glBlendEquation(GL_FUNC_ADD);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glDisable(GL_CULL_FACE);
glDisable(GL_DEPTH_TEST);
glEnable(GL_SCISSOR_TEST);
ghoul::opengl::TextureUnit unit;
unit.activate();
_fontTexture->bind();
// Setup orthographic projection matrix
const float width = ImGui::GetIO().DisplaySize.x;
const float height = ImGui::GetIO().DisplaySize.y;
glViewport(0, 0, fbWidth, fbHeight);
const glm::mat4 ortho(
2.f / width, 0.f, 0.f, 0.f,
0.f, 2.f / -height, 0.f, 0.f,
0.f, 0.f, -1.f, 0.f,
-1.f, 1.f, 0.f, 1.f
);
_program->activate();
_program->setUniform(_uniformCache.tex, unit);
_program->setUniform(_uniformCache.ortho, ortho);
glBindVertexArray(vao);
for (int i = 0; i < drawData->CmdListsCount; ++i) {
const ImDrawList* cmdList = drawData->CmdLists[i];
const ImDrawIdx* indexBufferOffset = nullptr;
glBindBuffer(GL_ARRAY_BUFFER, vbo);
glBufferData(
GL_ARRAY_BUFFER,
cmdList->VtxBuffer.size() * sizeof(ImDrawVert),
reinterpret_cast<const GLvoid*>(&cmdList->VtxBuffer.front()),
GL_STREAM_DRAW
);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, vboElements);
glBufferData(
GL_ELEMENT_ARRAY_BUFFER,
cmdList->IdxBuffer.size() * sizeof(ImDrawIdx),
reinterpret_cast<const GLvoid*>(&cmdList->IdxBuffer.front()),
GL_STREAM_DRAW
);
for (const ImDrawCmd* pcmd = cmdList->CmdBuffer.begin();
pcmd != cmdList->CmdBuffer.end();
pcmd++)
{
if (pcmd->UserCallback) {
pcmd->UserCallback(cmdList, pcmd);
}
else {
glBindTexture(
GL_TEXTURE_2D,
static_cast<GLuint>(reinterpret_cast<intptr_t>(pcmd->TextureId))
);
glScissor(
static_cast<int>(pcmd->ClipRect.x),
static_cast<int>(fbHeight - pcmd->ClipRect.w),
static_cast<int>(pcmd->ClipRect.z - pcmd->ClipRect.x),
static_cast<int>(pcmd->ClipRect.w - pcmd->ClipRect.y)
);
glDrawElements(
GL_TRIANGLES,
static_cast<GLsizei>(pcmd->ElemCount),
sizeof(ImDrawIdx) == 2 ? GL_UNSIGNED_SHORT : GL_UNSIGNED_INT,
indexBufferOffset
);
}
indexBufferOffset += pcmd->ElemCount;
}
}
glBindVertexArray(0);
_program->deactivate();
glDisable(GL_SCISSOR_TEST);
}
bool ImGUIModule::mouseButtonCallback(MouseButton, MouseAction) {
ImGuiIO& io = ImGui::GetIO();
bool consumeEvent = io.WantCaptureMouse;
return consumeEvent;
}
bool ImGUIModule::mouseWheelCallback(double position) {
ImGuiIO& io = ImGui::GetIO();
bool consumeEvent = io.WantCaptureMouse;
if (consumeEvent) {
io.MouseWheel = static_cast<float>(position);
}
return consumeEvent;
}
bool ImGUIModule::keyCallback(Key key, KeyModifier modifier, KeyAction action) {
const int keyIndex = static_cast<int>(key);
if (keyIndex < 0) {
return false;
}
const bool hasShift = hasKeyModifier(modifier, KeyModifier::Shift);
const bool hasCtrl = hasKeyModifier(modifier, KeyModifier::Control);
const bool hasAlt = hasKeyModifier(modifier, KeyModifier::Alt);
ImGuiIO& io = ImGui::GetIO();
const bool consumeEvent = io.WantCaptureKeyboard;
if (consumeEvent) {
if (action == KeyAction::Press) {
io.KeysDown[keyIndex] = true;
}
io.KeyShift = hasShift;
io.KeyCtrl = hasCtrl;
io.KeyAlt = hasAlt;
}
// Even if the event is not consumed,
// set keys and modifiers to false when they are released.
if (action == KeyAction::Release) {
io.KeysDown[keyIndex] = false;
}
if (!hasShift) {
io.KeyShift = false;
}
if (!hasCtrl) {
io.KeyCtrl = false;
}
if (!hasAlt) {
io.KeyAlt = false;
}
return consumeEvent;
}
bool ImGUIModule::charCallback(unsigned int character, KeyModifier) {
ImGuiIO& io = ImGui::GetIO();
bool consumeEvent = io.WantCaptureKeyboard;
if (consumeEvent) {
io.AddInputCharacter(static_cast<unsigned short>(character));
}
return consumeEvent;
}
bool ImGUIModule::touchDetectedCallback(TouchInput input) {
ImGuiIO& io = ImGui::GetIO();
const glm::vec2 windowPos = input.currentWindowCoordinates();
const bool consumeEvent = io.WantCaptureMouse;
if (!consumeEvent) {
return false;
}
if (_validTouchStates.empty()) {
io.MousePos = { windowPos.x, windowPos.y };
io.MouseClicked[0] = true;
}
_validTouchStates.push_back(input);
return true;
}
bool ImGUIModule::touchUpdatedCallback(TouchInput input) {
if (_validTouchStates.empty()) {
return false;
}
ImGuiIO& io = ImGui::GetIO();
auto it = std::find_if(
_validTouchStates.cbegin(),
_validTouchStates.cend(),
[&](const TouchInput& state) {
return state.fingerId == input.fingerId &&
state.touchDeviceId == input.touchDeviceId;
}
);
if (it == _validTouchStates.cbegin()) {
glm::vec2 windowPos = input.currentWindowCoordinates();
io.MousePos = ImVec2(windowPos.x, windowPos.y);
io.MouseClicked[0] = true;
return true;
}
else if (it != _validTouchStates.cend()) {
return true;
}
return false;
}
void ImGUIModule::touchExitCallback(TouchInput input) {
if (_validTouchStates.empty()) {
return;
}
const auto found = std::find_if(
_validTouchStates.cbegin(),
_validTouchStates.cend(),
[&](const TouchInput& state) {
return state.fingerId == input.fingerId &&
state.touchDeviceId == input.touchDeviceId;
}
);
if (found == _validTouchStates.cend()) {
return;
}
ImGuiIO& io = ImGui::GetIO();
_validTouchStates.erase(found);
if (_validTouchStates.empty()) {
glm::vec2 windowPos = input.currentWindowCoordinates();
io.MousePos = ImVec2(windowPos.x, windowPos.y);
io.MouseClicked[0] = false;
}
}
} // namespace openspace
Reference in New Issue View Git Blame Copy Permalink