| 1 |
// dear imgui: Renderer Backend for SDL_Renderer for SDL2 |
| 2 |
// (Requires: SDL 2.0.17+) |
| 3 |
|
| 4 |
// Note how SDL_Renderer is an _optional_ component of SDL2. |
| 5 |
// For a multi-platform app consider using e.g. SDL+DirectX on Windows and SDL+OpenGL on Linux/OSX. |
| 6 |
// If your application will want to render any non trivial amount of graphics other than UI, |
| 7 |
// please be aware that SDL_Renderer currently offers a limited graphic API to the end-user and |
| 8 |
// it might be difficult to step out of those boundaries. |
| 9 |
|
| 10 |
// Implemented features: |
| 11 |
// [X] Renderer: User texture binding. Use 'SDL_Texture*' as ImTextureID. Read the FAQ about ImTextureID! |
| 12 |
// [X] Renderer: Large meshes support (64k+ vertices) even with 16-bit indices (ImGuiBackendFlags_RendererHasVtxOffset). |
| 13 |
// [X] Renderer: Expose selected render state for draw callbacks to use. Access in '(ImGui_ImplXXXX_RenderState*)GetPlatformIO().Renderer_RenderState'. |
| 14 |
|
| 15 |
// You can copy and use unmodified imgui_impl_* files in your project. See examples/ folder for examples of using this. |
| 16 |
// Prefer including the entire imgui/ repository into your project (either as a copy or as a submodule), and only build the backends you need. |
| 17 |
// Learn about Dear ImGui: |
| 18 |
// - FAQ https://dearimgui.com/faq |
| 19 |
// - Getting Started https://dearimgui.com/getting-started |
| 20 |
// - Documentation https://dearimgui.com/docs (same as your local docs/ folder). |
| 21 |
// - Introduction, links and more at the top of imgui.cpp |
| 22 |
|
| 23 |
// CHANGELOG |
| 24 |
// 2024-10-09: Expose selected render state in ImGui_ImplSDLRenderer2_RenderState, which you can access in 'void* platform_io.Renderer_RenderState' during draw callbacks. |
| 25 |
// 2024-05-14: *BREAKING CHANGE* ImGui_ImplSDLRenderer3_RenderDrawData() requires SDL_Renderer* passed as parameter. |
| 26 |
// 2023-05-30: Renamed imgui_impl_sdlrenderer.h/.cpp to imgui_impl_sdlrenderer2.h/.cpp to accommodate for upcoming SDL3. |
| 27 |
// 2022-10-11: Using 'nullptr' instead of 'NULL' as per our switch to C++11. |
| 28 |
// 2021-12-21: Update SDL_RenderGeometryRaw() format to work with SDL 2.0.19. |
| 29 |
// 2021-12-03: Added support for large mesh (64K+ vertices), enable ImGuiBackendFlags_RendererHasVtxOffset flag. |
| 30 |
// 2021-10-06: Backup and restore modified ClipRect/Viewport. |
| 31 |
// 2021-09-21: Initial version. |
| 32 |
|
| 33 |
#include "imgui.h" |
| 34 |
#ifndef IMGUI_DISABLE |
| 35 |
#include "imgui_impl_sdlrenderer2.h" |
| 36 |
#include <stdint.h> // intptr_t |
| 37 |
|
| 38 |
// Clang warnings with -Weverything |
| 39 |
#if defined(__clang__) |
| 40 |
#pragma clang diagnostic push |
| 41 |
#pragma clang diagnostic ignored "-Wsign-conversion" // warning: implicit conversion changes signedness |
| 42 |
#endif |
| 43 |
|
| 44 |
// SDL |
| 45 |
#include <SDL.h> |
| 46 |
#if !SDL_VERSION_ATLEAST(2,0,17) |
| 47 |
#error This backend requires SDL 2.0.17+ because of SDL_RenderGeometry() function |
| 48 |
#endif |
| 49 |
|
| 50 |
// SDL_Renderer data |
| 51 |
struct ImGui_ImplSDLRenderer2_Data |
| 52 |
{ |
| 53 |
SDL_Renderer* Renderer; // Main viewport's renderer |
| 54 |
SDL_Texture* FontTexture; |
| 55 |
ImGui_ImplSDLRenderer2_Data() { memset((void*)this, 0, sizeof(*this)); } |
| 56 |
}; |
| 57 |
|
| 58 |
// Backend data stored in io.BackendRendererUserData to allow support for multiple Dear ImGui contexts |
| 59 |
// It is STRONGLY preferred that you use docking branch with multi-viewports (== single Dear ImGui context + multiple windows) instead of multiple Dear ImGui contexts. |
| 60 |
static ImGui_ImplSDLRenderer2_Data* ImGui_ImplSDLRenderer2_GetBackendData() |
| 61 |
{ |
| 62 |
return ImGui::GetCurrentContext() ? (ImGui_ImplSDLRenderer2_Data*)ImGui::GetIO().BackendRendererUserData : nullptr; |
| 63 |
} |
| 64 |
|
| 65 |
// Functions |
| 66 |
bool ImGui_ImplSDLRenderer2_Init(SDL_Renderer* renderer) |
| 67 |
{ |
| 68 |
ImGuiIO& io = ImGui::GetIO(); |
| 69 |
IMGUI_CHECKVERSION(); |
| 70 |
IM_ASSERT(io.BackendRendererUserData == nullptr && "Already initialized a renderer backend!"); |
| 71 |
IM_ASSERT(renderer != nullptr && "SDL_Renderer not initialized!"); |
| 72 |
|
| 73 |
// Setup backend capabilities flags |
| 74 |
ImGui_ImplSDLRenderer2_Data* bd = IM_NEW(ImGui_ImplSDLRenderer2_Data)(); |
| 75 |
io.BackendRendererUserData = (void*)bd; |
| 76 |
io.BackendRendererName = "imgui_impl_sdlrenderer2"; |
| 77 |
io.BackendFlags |= ImGuiBackendFlags_RendererHasVtxOffset; // We can honor the ImDrawCmd::VtxOffset field, allowing for large meshes. |
| 78 |
|
| 79 |
bd->Renderer = renderer; |
| 80 |
|
| 81 |
return true; |
| 82 |
} |
| 83 |
|
| 84 |
void ImGui_ImplSDLRenderer2_Shutdown() |
| 85 |
{ |
| 86 |
ImGui_ImplSDLRenderer2_Data* bd = ImGui_ImplSDLRenderer2_GetBackendData(); |
| 87 |
IM_ASSERT(bd != nullptr && "No renderer backend to shutdown, or already shutdown?"); |
| 88 |
ImGuiIO& io = ImGui::GetIO(); |
| 89 |
|
| 90 |
ImGui_ImplSDLRenderer2_DestroyDeviceObjects(); |
| 91 |
|
| 92 |
io.BackendRendererName = nullptr; |
| 93 |
io.BackendRendererUserData = nullptr; |
| 94 |
io.BackendFlags &= ~ImGuiBackendFlags_RendererHasVtxOffset; |
| 95 |
IM_DELETE(bd); |
| 96 |
} |
| 97 |
|
| 98 |
static void ImGui_ImplSDLRenderer2_SetupRenderState(SDL_Renderer* renderer) |
| 99 |
{ |
| 100 |
// Clear out any viewports and cliprect set by the user |
| 101 |
// FIXME: Technically speaking there are lots of other things we could backup/setup/restore during our render process. |
| 102 |
SDL_RenderSetViewport(renderer, nullptr); |
| 103 |
SDL_RenderSetClipRect(renderer, nullptr); |
| 104 |
} |
| 105 |
|
| 106 |
void ImGui_ImplSDLRenderer2_NewFrame() |
| 107 |
{ |
| 108 |
ImGui_ImplSDLRenderer2_Data* bd = ImGui_ImplSDLRenderer2_GetBackendData(); |
| 109 |
IM_ASSERT(bd != nullptr && "Context or backend not initialized! Did you call ImGui_ImplSDLRenderer2_Init()?"); |
| 110 |
|
| 111 |
if (!bd->FontTexture) |
| 112 |
ImGui_ImplSDLRenderer2_CreateDeviceObjects(); |
| 113 |
} |
| 114 |
|
| 115 |
void ImGui_ImplSDLRenderer2_RenderDrawData(ImDrawData* draw_data, SDL_Renderer* renderer) |
| 116 |
{ |
| 117 |
// If there's a scale factor set by the user, use that instead |
| 118 |
// If the user has specified a scale factor to SDL_Renderer already via SDL_RenderSetScale(), SDL will scale whatever we pass |
| 119 |
// to SDL_RenderGeometryRaw() by that scale factor. In that case we don't want to be also scaling it ourselves here. |
| 120 |
float rsx = 1.0f; |
| 121 |
float rsy = 1.0f; |
| 122 |
SDL_RenderGetScale(renderer, &rsx, &rsy); |
| 123 |
ImVec2 render_scale; |
| 124 |
render_scale.x = (rsx == 1.0f) ? draw_data->FramebufferScale.x : 1.0f; |
| 125 |
render_scale.y = (rsy == 1.0f) ? draw_data->FramebufferScale.y : 1.0f; |
| 126 |
|
| 127 |
// Avoid rendering when minimized, scale coordinates for retina displays (screen coordinates != framebuffer coordinates) |
| 128 |
int fb_width = (int)(draw_data->DisplaySize.x * render_scale.x); |
| 129 |
int fb_height = (int)(draw_data->DisplaySize.y * render_scale.y); |
| 130 |
if (fb_width == 0 || fb_height == 0) |
| 131 |
return; |
| 132 |
|
| 133 |
// Backup SDL_Renderer state that will be modified to restore it afterwards |
| 134 |
struct BackupSDLRendererState |
| 135 |
{ |
| 136 |
SDL_Rect Viewport; |
| 137 |
bool ClipEnabled; |
| 138 |
SDL_Rect ClipRect; |
| 139 |
}; |
| 140 |
BackupSDLRendererState old = {}; |
| 141 |
old.ClipEnabled = SDL_RenderIsClipEnabled(renderer) == SDL_TRUE; |
| 142 |
SDL_RenderGetViewport(renderer, &old.Viewport); |
| 143 |
SDL_RenderGetClipRect(renderer, &old.ClipRect); |
| 144 |
|
| 145 |
// Setup desired state |
| 146 |
ImGui_ImplSDLRenderer2_SetupRenderState(renderer); |
| 147 |
|
| 148 |
// Setup render state structure (for callbacks and custom texture bindings) |
| 149 |
ImGuiPlatformIO& platform_io = ImGui::GetPlatformIO(); |
| 150 |
ImGui_ImplSDLRenderer2_RenderState render_state; |
| 151 |
render_state.Renderer = renderer; |
| 152 |
platform_io.Renderer_RenderState = &render_state; |
| 153 |
|
| 154 |
// Will project scissor/clipping rectangles into framebuffer space |
| 155 |
ImVec2 clip_off = draw_data->DisplayPos; // (0,0) unless using multi-viewports |
| 156 |
ImVec2 clip_scale = render_scale; |
| 157 |
|
| 158 |
// Render command lists |
| 159 |
for (int n = 0; n < draw_data->CmdListsCount; n++) |
| 160 |
{ |
| 161 |
const ImDrawList* draw_list = draw_data->CmdLists[n]; |
| 162 |
const ImDrawVert* vtx_buffer = draw_list->VtxBuffer.Data; |
| 163 |
const ImDrawIdx* idx_buffer = draw_list->IdxBuffer.Data; |
| 164 |
|
| 165 |
for (int cmd_i = 0; cmd_i < draw_list->CmdBuffer.Size; cmd_i++) |
| 166 |
{ |
| 167 |
const ImDrawCmd* pcmd = &draw_list->CmdBuffer[cmd_i]; |
| 168 |
if (pcmd->UserCallback) |
| 169 |
{ |
| 170 |
// User callback, registered via ImDrawList::AddCallback() |
| 171 |
// (ImDrawCallback_ResetRenderState is a special callback value used by the user to request the renderer to reset render state.) |
| 172 |
if (pcmd->UserCallback == ImDrawCallback_ResetRenderState) |
| 173 |
ImGui_ImplSDLRenderer2_SetupRenderState(renderer); |
| 174 |
else |
| 175 |
pcmd->UserCallback(draw_list, pcmd); |
| 176 |
} |
| 177 |
else |
| 178 |
{ |
| 179 |
// Project scissor/clipping rectangles into framebuffer space |
| 180 |
ImVec2 clip_min((pcmd->ClipRect.x - clip_off.x) * clip_scale.x, (pcmd->ClipRect.y - clip_off.y) * clip_scale.y); |
| 181 |
ImVec2 clip_max((pcmd->ClipRect.z - clip_off.x) * clip_scale.x, (pcmd->ClipRect.w - clip_off.y) * clip_scale.y); |
| 182 |
if (clip_min.x < 0.0f) { clip_min.x = 0.0f; } |
| 183 |
if (clip_min.y < 0.0f) { clip_min.y = 0.0f; } |
| 184 |
if (clip_max.x > (float)fb_width) { clip_max.x = (float)fb_width; } |
| 185 |
if (clip_max.y > (float)fb_height) { clip_max.y = (float)fb_height; } |
| 186 |
if (clip_max.x <= clip_min.x || clip_max.y <= clip_min.y) |
| 187 |
continue; |
| 188 |
|
| 189 |
SDL_Rect r = { (int)(clip_min.x), (int)(clip_min.y), (int)(clip_max.x - clip_min.x), (int)(clip_max.y - clip_min.y) }; |
| 190 |
SDL_RenderSetClipRect(renderer, &r); |
| 191 |
|
| 192 |
const float* xy = (const float*)(const void*)((const char*)(vtx_buffer + pcmd->VtxOffset) + offsetof(ImDrawVert, pos)); |
| 193 |
const float* uv = (const float*)(const void*)((const char*)(vtx_buffer + pcmd->VtxOffset) + offsetof(ImDrawVert, uv)); |
| 194 |
#if SDL_VERSION_ATLEAST(2,0,19) |
| 195 |
const SDL_Color* color = (const SDL_Color*)(const void*)((const char*)(vtx_buffer + pcmd->VtxOffset) + offsetof(ImDrawVert, col)); // SDL 2.0.19+ |
| 196 |
#else |
| 197 |
const int* color = (const int*)(const void*)((const char*)(vtx_buffer + pcmd->VtxOffset) + offsetof(ImDrawVert, col)); // SDL 2.0.17 and 2.0.18 |
| 198 |
#endif |
| 199 |
|
| 200 |
// Bind texture, Draw |
| 201 |
SDL_Texture* tex = (SDL_Texture*)pcmd->GetTexID(); |
| 202 |
SDL_RenderGeometryRaw(renderer, tex, |
| 203 |
xy, (int)sizeof(ImDrawVert), |
| 204 |
color, (int)sizeof(ImDrawVert), |
| 205 |
uv, (int)sizeof(ImDrawVert), |
| 206 |
draw_list->VtxBuffer.Size - pcmd->VtxOffset, |
| 207 |
idx_buffer + pcmd->IdxOffset, pcmd->ElemCount, sizeof(ImDrawIdx)); |
| 208 |
} |
| 209 |
} |
| 210 |
} |
| 211 |
platform_io.Renderer_RenderState = nullptr; |
| 212 |
|
| 213 |
// Restore modified SDL_Renderer state |
| 214 |
SDL_RenderSetViewport(renderer, &old.Viewport); |
| 215 |
SDL_RenderSetClipRect(renderer, old.ClipEnabled ? &old.ClipRect : nullptr); |
| 216 |
} |
| 217 |
|
| 218 |
// Called by Init/NewFrame/Shutdown |
| 219 |
bool ImGui_ImplSDLRenderer2_CreateFontsTexture() |
| 220 |
{ |
| 221 |
ImGuiIO& io = ImGui::GetIO(); |
| 222 |
ImGui_ImplSDLRenderer2_Data* bd = ImGui_ImplSDLRenderer2_GetBackendData(); |
| 223 |
|
| 224 |
// Build texture atlas |
| 225 |
unsigned char* pixels; |
| 226 |
int width, height; |
| 227 |
io.Fonts->GetTexDataAsRGBA32(&pixels, &width, &height); // Load as RGBA 32-bit (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. |
| 228 |
|
| 229 |
// Upload texture to graphics system |
| 230 |
// (Bilinear sampling is required by default. Set 'io.Fonts->Flags |= ImFontAtlasFlags_NoBakedLines' or 'style.AntiAliasedLinesUseTex = false' to allow point/nearest sampling) |
| 231 |
bd->FontTexture = SDL_CreateTexture(bd->Renderer, SDL_PIXELFORMAT_ABGR8888, SDL_TEXTUREACCESS_STATIC, width, height); |
| 232 |
if (bd->FontTexture == nullptr) |
| 233 |
{ |
| 234 |
SDL_Log("error creating texture"); |
| 235 |
return false; |
| 236 |
} |
| 237 |
SDL_UpdateTexture(bd->FontTexture, nullptr, pixels, 4 * width); |
| 238 |
SDL_SetTextureBlendMode(bd->FontTexture, SDL_BLENDMODE_BLEND); |
| 239 |
SDL_SetTextureScaleMode(bd->FontTexture, SDL_ScaleModeLinear); |
| 240 |
|
| 241 |
// Store our identifier |
| 242 |
io.Fonts->SetTexID((ImTextureID)(intptr_t)bd->FontTexture); |
| 243 |
|
| 244 |
return true; |
| 245 |
} |
| 246 |
|
| 247 |
void ImGui_ImplSDLRenderer2_DestroyFontsTexture() |
| 248 |
{ |
| 249 |
ImGuiIO& io = ImGui::GetIO(); |
| 250 |
ImGui_ImplSDLRenderer2_Data* bd = ImGui_ImplSDLRenderer2_GetBackendData(); |
| 251 |
if (bd->FontTexture) |
| 252 |
{ |
| 253 |
io.Fonts->SetTexID(0); |
| 254 |
SDL_DestroyTexture(bd->FontTexture); |
| 255 |
bd->FontTexture = nullptr; |
| 256 |
} |
| 257 |
} |
| 258 |
|
| 259 |
bool ImGui_ImplSDLRenderer2_CreateDeviceObjects() |
| 260 |
{ |
| 261 |
return ImGui_ImplSDLRenderer2_CreateFontsTexture(); |
| 262 |
} |
| 263 |
|
| 264 |
void ImGui_ImplSDLRenderer2_DestroyDeviceObjects() |
| 265 |
{ |
| 266 |
ImGui_ImplSDLRenderer2_DestroyFontsTexture(); |
| 267 |
} |
| 268 |
|
| 269 |
//----------------------------------------------------------------------------- |
| 270 |
|
| 271 |
#if defined(__clang__) |
| 272 |
#pragma clang diagnostic pop |
| 273 |
#endif |
| 274 |
|
| 275 |
#endif // #ifndef IMGUI_DISABLE |