Debian Codegraph @

subprojects/imgui-1.91.6/backends/imgui_impl_sdlrenderer2.cpp

raw
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