mirror of
https://github.com/Drezil/imgui.git
synced 2024-12-19 14:36:34 +00:00
77a310736d
This patch adds support for the horizontal mouse wheel in ImGui. It affects windows that can be scrolled, as long as the Ctrl key is not being pressed. The scrolling speed has been set empirically so that it matches the scrolling speed on the Firefox browser when the horizontal wheel is used. Internally, it adds a MouseHorizWheel to ImGuiIO, which is then used in NewFrame to scroll the current window. The SDL/GL2, SDL/GL3, GLFW/GL2 and GLFW/GL3 examples has been modified to use it.
303 lines
13 KiB
C++
303 lines
13 KiB
C++
// ImGui SDL2 binding with OpenGL (legacy, fixed pipeline)
|
|
// In this binding, ImTextureID is used to store an OpenGL 'GLuint' texture identifier. Read the FAQ about ImTextureID in imgui.cpp.
|
|
// (SDL is a cross-platform general purpose library for handling windows, inputs, OpenGL/Vulkan graphics context creation, etc.)
|
|
|
|
// **DO NOT USE THIS CODE IF YOUR CODE/ENGINE IS USING MODERN OPENGL (SHADERS, VBO, VAO, etc.)**
|
|
// **Prefer using the code in the sdl_opengl3_example/ folder**
|
|
// This code is mostly provided as a reference to learn how ImGui integration works, because it is shorter to read.
|
|
// If your code is using GL3+ context or any semi modern OpenGL calls, using this is likely to make everything more
|
|
// complicated, will require your code to reset every single OpenGL attributes to their initial state, and might
|
|
// confuse your GPU driver.
|
|
// The GL2 code is unable to reset attributes or even call e.g. "glUseProgram(0)" because they don't exist in that API.
|
|
|
|
// You can copy and use unmodified imgui_impl_* files in your project. See main.cpp for an example of using this.
|
|
// If you use this binding you'll need to call 4 functions: ImGui_ImplXXXX_Init(), ImGui_ImplXXXX_NewFrame(), ImGui::Render() and ImGui_ImplXXXX_Shutdown().
|
|
// If you are new to ImGui, see examples/README.txt and documentation at the top of imgui.cpp.
|
|
// https://github.com/ocornut/imgui
|
|
|
|
#include <SDL.h>
|
|
#include <SDL_syswm.h>
|
|
#include <SDL_opengl.h>
|
|
#include <imgui.h>
|
|
#include "imgui_impl_sdl.h"
|
|
|
|
// Data
|
|
static double g_Time = 0.0f;
|
|
static bool g_MousePressed[3] = { false, false, false };
|
|
static float g_MouseHorizWheel = 0.0f;
|
|
static float g_MouseWheel = 0.0f;
|
|
static GLuint g_FontTexture = 0;
|
|
|
|
// This is the main rendering function that you have to implement and provide to ImGui (via setting up 'RenderDrawListsFn' in the ImGuiIO structure)
|
|
// Note that this implementation is little overcomplicated because we are saving/setting up/restoring every OpenGL state explicitly, in order to be able to run within any OpenGL engine that doesn't do so.
|
|
// If text or lines are blurry when integrating ImGui in your engine: in your Render function, try translating your projection matrix by (0.5f,0.5f) or (0.375f,0.375f)
|
|
void ImGui_ImplSdl_RenderDrawLists(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);
|
|
|
|
// We are using the OpenGL fixed pipeline to make the example code simpler to read!
|
|
// Setup render state: alpha-blending enabled, no face culling, no depth testing, scissor enabled, vertex/texcoord/color pointers, polygon fill.
|
|
GLint last_texture; glGetIntegerv(GL_TEXTURE_BINDING_2D, &last_texture);
|
|
GLint last_polygon_mode[2]; glGetIntegerv(GL_POLYGON_MODE, last_polygon_mode);
|
|
GLint last_viewport[4]; glGetIntegerv(GL_VIEWPORT, last_viewport);
|
|
GLint last_scissor_box[4]; glGetIntegerv(GL_SCISSOR_BOX, last_scissor_box);
|
|
glPushAttrib(GL_ENABLE_BIT | GL_COLOR_BUFFER_BIT | GL_TRANSFORM_BIT);
|
|
glEnable(GL_BLEND);
|
|
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
|
|
glDisable(GL_CULL_FACE);
|
|
glDisable(GL_DEPTH_TEST);
|
|
glEnable(GL_SCISSOR_TEST);
|
|
glEnableClientState(GL_VERTEX_ARRAY);
|
|
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
|
|
glEnableClientState(GL_COLOR_ARRAY);
|
|
glEnable(GL_TEXTURE_2D);
|
|
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
|
|
//glUseProgram(0); // You may want this if using this code in an OpenGL 3+ context where shaders may be bound
|
|
|
|
// Setup viewport, orthographic projection matrix
|
|
glViewport(0, 0, (GLsizei)fb_width, (GLsizei)fb_height);
|
|
glMatrixMode(GL_PROJECTION);
|
|
glPushMatrix();
|
|
glLoadIdentity();
|
|
glOrtho(0.0f, io.DisplaySize.x, io.DisplaySize.y, 0.0f, -1.0f, +1.0f);
|
|
glMatrixMode(GL_MODELVIEW);
|
|
glPushMatrix();
|
|
glLoadIdentity();
|
|
|
|
// Render command lists
|
|
#define OFFSETOF(TYPE, ELEMENT) ((size_t)&(((TYPE *)0)->ELEMENT))
|
|
for (int n = 0; n < draw_data->CmdListsCount; n++)
|
|
{
|
|
const ImDrawList* cmd_list = draw_data->CmdLists[n];
|
|
const ImDrawVert* vtx_buffer = cmd_list->VtxBuffer.Data;
|
|
const ImDrawIdx* idx_buffer = cmd_list->IdxBuffer.Data;
|
|
glVertexPointer(2, GL_FLOAT, sizeof(ImDrawVert), (const GLvoid*)((const char*)vtx_buffer + OFFSETOF(ImDrawVert, pos)));
|
|
glTexCoordPointer(2, GL_FLOAT, sizeof(ImDrawVert), (const GLvoid*)((const char*)vtx_buffer + OFFSETOF(ImDrawVert, uv)));
|
|
glColorPointer(4, GL_UNSIGNED_BYTE, sizeof(ImDrawVert), (const GLvoid*)((const char*)vtx_buffer + OFFSETOF(ImDrawVert, col)));
|
|
|
|
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
|
|
{
|
|
glBindTexture(GL_TEXTURE_2D, (GLuint)(intptr_t)pcmd->TextureId);
|
|
glScissor((int)pcmd->ClipRect.x, (int)(fb_height - pcmd->ClipRect.w), (int)(pcmd->ClipRect.z - pcmd->ClipRect.x), (int)(pcmd->ClipRect.w - pcmd->ClipRect.y));
|
|
glDrawElements(GL_TRIANGLES, (GLsizei)pcmd->ElemCount, sizeof(ImDrawIdx) == 2 ? GL_UNSIGNED_SHORT : GL_UNSIGNED_INT, idx_buffer);
|
|
}
|
|
idx_buffer += pcmd->ElemCount;
|
|
}
|
|
}
|
|
#undef OFFSETOF
|
|
|
|
// Restore modified state
|
|
glDisableClientState(GL_COLOR_ARRAY);
|
|
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
|
|
glDisableClientState(GL_VERTEX_ARRAY);
|
|
glBindTexture(GL_TEXTURE_2D, (GLuint)last_texture);
|
|
glMatrixMode(GL_MODELVIEW);
|
|
glPopMatrix();
|
|
glMatrixMode(GL_PROJECTION);
|
|
glPopMatrix();
|
|
glPopAttrib();
|
|
glPolygonMode(GL_FRONT, last_polygon_mode[0]); glPolygonMode(GL_BACK, last_polygon_mode[1]);
|
|
glViewport(last_viewport[0], last_viewport[1], (GLsizei)last_viewport[2], (GLsizei)last_viewport[3]);
|
|
glScissor(last_scissor_box[0], last_scissor_box[1], (GLsizei)last_scissor_box[2], (GLsizei)last_scissor_box[3]);
|
|
}
|
|
|
|
static const char* ImGui_ImplSdl_GetClipboardText(void*)
|
|
{
|
|
return SDL_GetClipboardText();
|
|
}
|
|
|
|
static void ImGui_ImplSdl_SetClipboardText(void*, const char* text)
|
|
{
|
|
SDL_SetClipboardText(text);
|
|
}
|
|
|
|
// You can read the io.WantCaptureMouse, io.WantCaptureKeyboard flags to tell if dear imgui wants to use your inputs.
|
|
// - When io.WantCaptureMouse is true, do not dispatch mouse input data to your main application.
|
|
// - When io.WantCaptureKeyboard is true, do not dispatch keyboard input data to your main application.
|
|
// Generally you may always pass all inputs to dear imgui, and hide them from your application based on those two flags.
|
|
bool ImGui_ImplSdlGL2_ProcessEvent(SDL_Event* event)
|
|
{
|
|
ImGuiIO& io = ImGui::GetIO();
|
|
switch (event->type)
|
|
{
|
|
case SDL_MOUSEWHEEL:
|
|
{
|
|
if (event->wheel.x > 0)
|
|
g_MouseHorizWheel = 1;
|
|
if (event->wheel.x < 0)
|
|
g_MouseHorizWheel = -1;
|
|
if (event->wheel.y > 0)
|
|
g_MouseWheel = 1;
|
|
if (event->wheel.y < 0)
|
|
g_MouseWheel = -1;
|
|
return true;
|
|
}
|
|
case SDL_MOUSEBUTTONDOWN:
|
|
{
|
|
if (event->button.button == SDL_BUTTON_LEFT) g_MousePressed[0] = true;
|
|
if (event->button.button == SDL_BUTTON_RIGHT) g_MousePressed[1] = true;
|
|
if (event->button.button == SDL_BUTTON_MIDDLE) g_MousePressed[2] = true;
|
|
return true;
|
|
}
|
|
case SDL_TEXTINPUT:
|
|
{
|
|
io.AddInputCharactersUTF8(event->text.text);
|
|
return true;
|
|
}
|
|
case SDL_KEYDOWN:
|
|
case SDL_KEYUP:
|
|
{
|
|
int key = event->key.keysym.sym & ~SDLK_SCANCODE_MASK;
|
|
io.KeysDown[key] = (event->type == SDL_KEYDOWN);
|
|
io.KeyShift = ((SDL_GetModState() & KMOD_SHIFT) != 0);
|
|
io.KeyCtrl = ((SDL_GetModState() & KMOD_CTRL) != 0);
|
|
io.KeyAlt = ((SDL_GetModState() & KMOD_ALT) != 0);
|
|
io.KeySuper = ((SDL_GetModState() & KMOD_GUI) != 0);
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool ImGui_ImplSdlGL2_CreateDeviceObjects()
|
|
{
|
|
// Build texture atlas
|
|
ImGuiIO& io = ImGui::GetIO();
|
|
unsigned char* pixels;
|
|
int width, height;
|
|
io.Fonts->GetTexDataAsAlpha8(&pixels, &width, &height);
|
|
|
|
// Upload texture to graphics system
|
|
GLint last_texture;
|
|
glGetIntegerv(GL_TEXTURE_BINDING_2D, &last_texture);
|
|
glGenTextures(1, &g_FontTexture);
|
|
glBindTexture(GL_TEXTURE_2D, g_FontTexture);
|
|
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
|
|
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
|
|
glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
|
|
glTexImage2D(GL_TEXTURE_2D, 0, GL_ALPHA, width, height, 0, GL_ALPHA, GL_UNSIGNED_BYTE, pixels);
|
|
|
|
// Store our identifier
|
|
io.Fonts->TexID = (void *)(intptr_t)g_FontTexture;
|
|
|
|
// Restore state
|
|
glBindTexture(GL_TEXTURE_2D, last_texture);
|
|
|
|
return true;
|
|
}
|
|
|
|
void ImGui_ImplSdlGL2_InvalidateDeviceObjects()
|
|
{
|
|
if (g_FontTexture)
|
|
{
|
|
glDeleteTextures(1, &g_FontTexture);
|
|
ImGui::GetIO().Fonts->TexID = 0;
|
|
g_FontTexture = 0;
|
|
}
|
|
}
|
|
|
|
bool ImGui_ImplSdlGL2_Init(SDL_Window* window)
|
|
{
|
|
ImGuiIO& io = ImGui::GetIO();
|
|
io.KeyMap[ImGuiKey_Tab] = SDLK_TAB; // Keyboard mapping. ImGui will use those indices to peek into the io.KeyDown[] array.
|
|
io.KeyMap[ImGuiKey_LeftArrow] = SDL_SCANCODE_LEFT;
|
|
io.KeyMap[ImGuiKey_RightArrow] = SDL_SCANCODE_RIGHT;
|
|
io.KeyMap[ImGuiKey_UpArrow] = SDL_SCANCODE_UP;
|
|
io.KeyMap[ImGuiKey_DownArrow] = SDL_SCANCODE_DOWN;
|
|
io.KeyMap[ImGuiKey_PageUp] = SDL_SCANCODE_PAGEUP;
|
|
io.KeyMap[ImGuiKey_PageDown] = SDL_SCANCODE_PAGEDOWN;
|
|
io.KeyMap[ImGuiKey_Home] = SDL_SCANCODE_HOME;
|
|
io.KeyMap[ImGuiKey_End] = SDL_SCANCODE_END;
|
|
io.KeyMap[ImGuiKey_Delete] = SDLK_DELETE;
|
|
io.KeyMap[ImGuiKey_Backspace] = SDLK_BACKSPACE;
|
|
io.KeyMap[ImGuiKey_Enter] = SDLK_RETURN;
|
|
io.KeyMap[ImGuiKey_Escape] = SDLK_ESCAPE;
|
|
io.KeyMap[ImGuiKey_A] = SDLK_a;
|
|
io.KeyMap[ImGuiKey_C] = SDLK_c;
|
|
io.KeyMap[ImGuiKey_V] = SDLK_v;
|
|
io.KeyMap[ImGuiKey_X] = SDLK_x;
|
|
io.KeyMap[ImGuiKey_Y] = SDLK_y;
|
|
io.KeyMap[ImGuiKey_Z] = SDLK_z;
|
|
|
|
io.RenderDrawListsFn = ImGui_ImplSdl_RenderDrawLists; // Alternatively you can set this to NULL and call ImGui::GetDrawData() after ImGui::Render() to get the same ImDrawData pointer.
|
|
io.SetClipboardTextFn = ImGui_ImplSdl_SetClipboardText;
|
|
io.GetClipboardTextFn = ImGui_ImplSdl_GetClipboardText;
|
|
io.ClipboardUserData = NULL;
|
|
|
|
#ifdef _WIN32
|
|
SDL_SysWMinfo wmInfo;
|
|
SDL_VERSION(&wmInfo.version);
|
|
SDL_GetWindowWMInfo(window, &wmInfo);
|
|
io.ImeWindowHandle = wmInfo.info.win.window;
|
|
#else
|
|
(void)window;
|
|
#endif
|
|
|
|
return true;
|
|
}
|
|
|
|
void ImGui_ImplSdlGL2_Shutdown()
|
|
{
|
|
ImGui_ImplSdlGL2_InvalidateDeviceObjects();
|
|
ImGui::Shutdown();
|
|
}
|
|
|
|
void ImGui_ImplSdlGL2_NewFrame(SDL_Window *window)
|
|
{
|
|
if (!g_FontTexture)
|
|
ImGui_ImplSdlGL2_CreateDeviceObjects();
|
|
|
|
ImGuiIO& io = ImGui::GetIO();
|
|
|
|
// Setup display size (every frame to accommodate for window resizing)
|
|
int w, h;
|
|
int display_w, display_h;
|
|
SDL_GetWindowSize(window, &w, &h);
|
|
SDL_GL_GetDrawableSize(window, &display_w, &display_h);
|
|
io.DisplaySize = ImVec2((float)w, (float)h);
|
|
io.DisplayFramebufferScale = ImVec2(w > 0 ? ((float)display_w / w) : 0, h > 0 ? ((float)display_h / h) : 0);
|
|
|
|
// Setup time step
|
|
Uint32 time = SDL_GetTicks();
|
|
double current_time = time / 1000.0;
|
|
io.DeltaTime = g_Time > 0.0 ? (float)(current_time - g_Time) : (float)(1.0f/60.0f);
|
|
g_Time = current_time;
|
|
|
|
// Setup inputs
|
|
// (we already got mouse wheel, keyboard keys & characters from SDL_PollEvent())
|
|
int mx, my;
|
|
Uint32 mouseMask = SDL_GetMouseState(&mx, &my);
|
|
if (SDL_GetWindowFlags(window) & SDL_WINDOW_MOUSE_FOCUS)
|
|
io.MousePos = ImVec2((float)mx, (float)my); // Mouse position, in pixels (set to -1,-1 if no mouse / on another screen, etc.)
|
|
else
|
|
io.MousePos = ImVec2(-FLT_MAX,-FLT_MAX);
|
|
|
|
io.MouseDown[0] = g_MousePressed[0] || (mouseMask & SDL_BUTTON(SDL_BUTTON_LEFT)) != 0; // If a mouse press event came, always pass it as "mouse held this frame", so we don't miss click-release events that are shorter than 1 frame.
|
|
io.MouseDown[1] = g_MousePressed[1] || (mouseMask & SDL_BUTTON(SDL_BUTTON_RIGHT)) != 0;
|
|
io.MouseDown[2] = g_MousePressed[2] || (mouseMask & SDL_BUTTON(SDL_BUTTON_MIDDLE)) != 0;
|
|
g_MousePressed[0] = g_MousePressed[1] = g_MousePressed[2] = false;
|
|
|
|
io.MouseHorizWheel = g_MouseHorizWheel;
|
|
io.MouseWheel = g_MouseWheel;
|
|
g_MouseWheel = g_MouseHorizWheel = 0.0f;
|
|
|
|
// Hide OS mouse cursor if ImGui is drawing it
|
|
SDL_ShowCursor(io.MouseDrawCursor ? 0 : 1);
|
|
|
|
// Start the frame. This call will update the io.WantCaptureMouse, io.WantCaptureKeyboard flag that you can use to dispatch inputs (or not) to your application.
|
|
ImGui::NewFrame();
|
|
}
|