1// dear imgui: Renderer Backend for modern OpenGL with shaders / programmatic pipeline
2// - Desktop GL: 2.x 3.x 4.x
3// - Embedded GL: ES 2.0 (WebGL 1.0), ES 3.0 (WebGL 2.0)
4// This needs to be used along with a Platform Backend (e.g. GLFW, SDL, Win32, custom..)
5
6// Implemented features:
7// [X] Renderer: User texture binding. Use 'GLuint' OpenGL texture identifier as void*/ImTextureID. Read the FAQ about ImTextureID!
8// [x] Renderer: Large meshes support (64k+ vertices) even with 16-bit indices (ImGuiBackendFlags_RendererHasVtxOffset) [Desktop OpenGL only!]
9// [X] Renderer: Multi-viewport support (multiple windows). Enable with 'io.ConfigFlags |= ImGuiConfigFlags_ViewportsEnable'.
10
11// About WebGL/ES:
12// - You need to '#define IMGUI_IMPL_OPENGL_ES2' or '#define IMGUI_IMPL_OPENGL_ES3' to use WebGL or OpenGL ES.
13// - This is done automatically on iOS, Android and Emscripten targets.
14// - For other targets, the define needs to be visible from the imgui_impl_opengl3.cpp compilation unit. If unsure, define globally or in imconfig.h.
15
16// You can use unmodified imgui_impl_* files in your project. See examples/ folder for examples of using this.
17// Prefer including the entire imgui/ repository into your project (either as a copy or as a submodule), and only build the backends you need.
18// Learn about Dear ImGui:
19// - FAQ https://dearimgui.com/faq
20// - Getting Started https://dearimgui.com/getting-started
21// - Documentation https://dearimgui.com/docs (same as your local docs/ folder).
22// - Introduction, links and more at the top of imgui.cpp
23
24// CHANGELOG
25// (minor and older changes stripped away, please see git history for details)
26// 2025-XX-XX: Platform: Added support for multiple windows via the ImGuiPlatformIO interface.
27// 2025-02-18: OpenGL: Lazily reinitialize embedded GL loader for when calling backend from e.g. other DLL boundaries. (#8406)
28// 2024-10-07: OpenGL: Changed default texture sampler to Clamp instead of Repeat/Wrap.
29// 2024-06-28: OpenGL: ImGui_ImplOpenGL3_NewFrame() recreates font texture if it has been destroyed by ImGui_ImplOpenGL3_DestroyFontsTexture(). (#7748)
30// 2024-05-07: OpenGL: Update loader for Linux to support EGL/GLVND. (#7562)
31// 2024-04-16: OpenGL: Detect ES3 contexts on desktop based on version string, to e.g. avoid calling glPolygonMode() on them. (#7447)
32// 2024-01-09: OpenGL: Update GL3W based imgui_impl_opengl3_loader.h to load "libGL.so" and variants, fixing regression on distros missing a symlink.
33// 2023-11-08: OpenGL: Update GL3W based imgui_impl_opengl3_loader.h to load "libGL.so" instead of "libGL.so.1", accommodating for NetBSD systems having only "libGL.so.3" available. (#6983)
34// 2023-10-05: OpenGL: Rename symbols in our internal loader so that LTO compilation with another copy of gl3w is possible. (#6875, #6668, #4445)
35// 2023-06-20: OpenGL: Fixed erroneous use glGetIntegerv(GL_CONTEXT_PROFILE_MASK) on contexts lower than 3.2. (#6539, #6333)
36// 2023-05-09: OpenGL: Support for glBindSampler() backup/restore on ES3. (#6375)
37// 2023-04-18: OpenGL: Restore front and back polygon mode separately when supported by context. (#6333)
38// 2023-03-23: OpenGL: Properly restoring "no shader program bound" if it was the case prior to running the rendering function. (#6267, #6220, #6224)
39// 2023-03-15: OpenGL: Fixed GL loader crash when GL_VERSION returns NULL. (#6154, #4445, #3530)
40// 2023-03-06: OpenGL: Fixed restoration of a potentially deleted OpenGL program, by calling glIsProgram(). (#6220, #6224)
41// 2022-11-09: OpenGL: Reverted use of glBufferSubData(), too many corruptions issues + old issues seemingly can't be reproed with Intel drivers nowadays (revert 2021-12-15 and 2022-05-23 changes).
42// 2022-10-11: Using 'nullptr' instead of 'NULL' as per our switch to C++11.
43// 2022-09-27: OpenGL: Added ability to '#define IMGUI_IMPL_OPENGL_DEBUG'.
44// 2022-05-23: OpenGL: Reworking 2021-12-15 "Using buffer orphaning" so it only happens on Intel GPU, seems to cause problems otherwise. (#4468, #4825, #4832, #5127).
45// 2022-05-13: OpenGL: Fixed state corruption on OpenGL ES 2.0 due to not preserving GL_ELEMENT_ARRAY_BUFFER_BINDING and vertex attribute states.
46// 2021-12-15: OpenGL: Using buffer orphaning + glBufferSubData(), seems to fix leaks with multi-viewports with some Intel HD drivers.
47// 2021-08-23: OpenGL: Fixed ES 3.0 shader ("#version 300 es") use normal precision floats to avoid wobbly rendering at HD resolutions.
48// 2021-08-19: OpenGL: Embed and use our own minimal GL loader (imgui_impl_opengl3_loader.h), removing requirement and support for third-party loader.
49// 2021-06-29: Reorganized backend to pull data from a single structure to facilitate usage with multiple-contexts (all g_XXXX access changed to bd->XXXX).
50// 2021-06-25: OpenGL: Use OES_vertex_array extension on Emscripten + backup/restore current state.
51// 2021-06-21: OpenGL: Destroy individual vertex/fragment shader objects right after they are linked into the main shader.
52// 2021-05-24: OpenGL: Access GL_CLIP_ORIGIN when "GL_ARB_clip_control" extension is detected, inside of just OpenGL 4.5 version.
53// 2021-05-19: OpenGL: Replaced direct access to ImDrawCmd::TextureId with a call to ImDrawCmd::GetTexID(). (will become a requirement)
54// 2021-04-06: OpenGL: Don't try to read GL_CLIP_ORIGIN unless we're OpenGL 4.5 or greater.
55// 2021-02-18: OpenGL: Change blending equation to preserve alpha in output buffer.
56// 2021-01-03: OpenGL: Backup, setup and restore GL_STENCIL_TEST state.
57// 2020-10-23: OpenGL: Backup, setup and restore GL_PRIMITIVE_RESTART state.
58// 2020-10-15: OpenGL: Use glGetString(GL_VERSION) instead of glGetIntegerv(GL_MAJOR_VERSION, ...) when the later returns zero (e.g. Desktop GL 2.x)
59// 2020-09-17: OpenGL: Fix to avoid compiling/calling glBindSampler() on ES or pre-3.3 context which have the defines set by a loader.
60// 2020-07-10: OpenGL: Added support for glad2 OpenGL loader.
61// 2020-05-08: OpenGL: Made default GLSL version 150 (instead of 130) on OSX.
62// 2020-04-21: OpenGL: Fixed handling of glClipControl(GL_UPPER_LEFT) by inverting projection matrix.
63// 2020-04-12: OpenGL: Fixed context version check mistakenly testing for 4.0+ instead of 3.2+ to enable ImGuiBackendFlags_RendererHasVtxOffset.
64// 2020-03-24: OpenGL: Added support for glbinding 2.x OpenGL loader.
65// 2020-01-07: OpenGL: Added support for glbinding 3.x OpenGL loader.
66// 2019-10-25: OpenGL: Using a combination of GL define and runtime GL version to decide whether to use glDrawElementsBaseVertex(). Fix building with pre-3.2 GL loaders.
67// 2019-09-22: OpenGL: Detect default GL loader using __has_include compiler facility.
68// 2019-09-16: OpenGL: Tweak initialization code to allow application calling ImGui_ImplOpenGL3_CreateFontsTexture() before the first NewFrame() call.
69// 2019-05-29: OpenGL: Desktop GL only: Added support for large mesh (64K+ vertices), enable ImGuiBackendFlags_RendererHasVtxOffset flag.
70// 2019-04-30: OpenGL: Added support for special ImDrawCallback_ResetRenderState callback to reset render state.
71// 2019-03-29: OpenGL: Not calling glBindBuffer more than necessary in the render loop.
72// 2019-03-15: OpenGL: Added a GL call + comments in ImGui_ImplOpenGL3_Init() to detect uninitialized GL function loaders early.
73// 2019-03-03: OpenGL: Fix support for ES 2.0 (WebGL 1.0).
74// 2019-02-20: OpenGL: Fix for OSX not supporting OpenGL 4.5, we don't try to read GL_CLIP_ORIGIN even if defined by the headers/loader.
75// 2019-02-11: OpenGL: Projecting clipping rectangles correctly using draw_data->FramebufferScale to allow multi-viewports for retina display.
76// 2019-02-01: OpenGL: Using GLSL 410 shaders for any version over 410 (e.g. 430, 450).
77// 2018-11-30: Misc: Setting up io.BackendRendererName so it can be displayed in the About Window.
78// 2018-11-13: OpenGL: Support for GL 4.5's glClipControl(GL_UPPER_LEFT) / GL_CLIP_ORIGIN.
79// 2018-08-29: OpenGL: Added support for more OpenGL loaders: glew and glad, with comments indicative that any loader can be used.
80// 2018-08-09: OpenGL: Default to OpenGL ES 3 on iOS and Android. GLSL version default to "#version 300 ES".
81// 2018-07-30: OpenGL: Support for GLSL 300 ES and 410 core. Fixes for Emscripten compilation.
82// 2018-07-10: OpenGL: Support for more GLSL versions (based on the GLSL version string). Added error output when shaders fail to compile/link.
83// 2018-06-08: Misc: Extracted imgui_impl_opengl3.cpp/.h away from the old combined GLFW/SDL+OpenGL3 examples.
84// 2018-06-08: OpenGL: Use draw_data->DisplayPos and draw_data->DisplaySize to setup projection matrix and clipping rectangle.
85// 2018-05-25: OpenGL: Removed unnecessary backup/restore of GL_ELEMENT_ARRAY_BUFFER_BINDING since this is part of the VAO state.
86// 2018-05-14: OpenGL: Making the call to glBindSampler() optional so 3.2 context won't fail if the function is a nullptr pointer.
87// 2018-03-06: OpenGL: Added const char* glsl_version parameter to ImGui_ImplOpenGL3_Init() so user can override the GLSL version e.g. "#version 150".
88// 2018-02-23: OpenGL: Create the VAO in the render function so the setup can more easily be used with multiple shared GL context.
89// 2018-02-16: Misc: Obsoleted the io.RenderDrawListsFn callback and exposed ImGui_ImplSdlGL3_RenderDrawData() in the .h file so you can call it yourself.
90// 2018-01-07: OpenGL: Changed GLSL shader version from 330 to 150.
91// 2017-09-01: OpenGL: Save and restore current bound sampler. Save and restore current polygon mode.
92// 2017-05-01: OpenGL: Fixed save and restore of current blend func state.
93// 2017-05-01: OpenGL: Fixed save and restore of current GL_ACTIVE_TEXTURE.
94// 2016-09-05: OpenGL: Fixed save and restore of current scissor rectangle.
95// 2016-07-29: OpenGL: Explicitly setting GL_UNPACK_ROW_LENGTH to reduce issues because SDL changes it. (#752)
96
97//----------------------------------------
98// OpenGL GLSL GLSL
99// version version string
100//----------------------------------------
101// 2.0 110 "#version 110"
102// 2.1 120 "#version 120"
103// 3.0 130 "#version 130"
104// 3.1 140 "#version 140"
105// 3.2 150 "#version 150"
106// 3.3 330 "#version 330 core"
107// 4.0 400 "#version 400 core"
108// 4.1 410 "#version 410 core"
109// 4.2 420 "#version 410 core"
110// 4.3 430 "#version 430 core"
111// ES 2.0 100 "#version 100" = WebGL 1.0
112// ES 3.0 300 "#version 300 es" = WebGL 2.0
113//----------------------------------------
114
115#if defined(_MSC_VER) && !defined(_CRT_SECURE_NO_WARNINGS)
116#define _CRT_SECURE_NO_WARNINGS
117#endif
118
119#include "imgui.h"
120#ifndef IMGUI_DISABLE
121#include "imgui_impl_opengl3.h"
122#include <stdio.h>
123#include <stdint.h> // intptr_t
124#if defined(__APPLE__)
125#include <TargetConditionals.h>
126#endif
127
128// Clang/GCC warnings with -Weverything
129#if defined(__clang__)
130#pragma clang diagnostic push
131#pragma clang diagnostic ignored "-Wunknown-warning-option" // warning: ignore unknown flags
132#pragma clang diagnostic ignored "-Wold-style-cast" // warning: use of old-style cast
133#pragma clang diagnostic ignored "-Wsign-conversion" // warning: implicit conversion changes signedness
134#pragma clang diagnostic ignored "-Wunused-macros" // warning: macro is not used
135#pragma clang diagnostic ignored "-Wnonportable-system-include-path"
136#pragma clang diagnostic ignored "-Wcast-function-type" // warning: cast between incompatible function types (for loader)
137#endif
138#if defined(__GNUC__)
139#pragma GCC diagnostic push
140#pragma GCC diagnostic ignored "-Wpragmas" // warning: unknown option after '#pragma GCC diagnostic' kind
141#pragma GCC diagnostic ignored "-Wunknown-warning-option" // warning: unknown warning group 'xxx'
142#pragma GCC diagnostic ignored "-Wcast-function-type" // warning: cast between incompatible function types (for loader)
143#pragma GCC diagnostic ignored "-Wstrict-overflow" // warning: assuming signed overflow does not occur when simplifying division / ..when changing X +- C1 cmp C2 to X cmp C2 -+ C1
144#endif
145
146// GL includes
147#if defined(IMGUI_IMPL_OPENGL_ES2)
148#if (defined(__APPLE__) && (TARGET_OS_IOS || TARGET_OS_TV))
149#include <OpenGLES/ES2/gl.h> // Use GL ES 2
150#else
151#include <GLES2/gl2.h> // Use GL ES 2
152#endif
153#if defined(__EMSCRIPTEN__)
154#ifndef GL_GLEXT_PROTOTYPES
155#define GL_GLEXT_PROTOTYPES
156#endif
157#include <GLES2/gl2ext.h>
158#endif
159#elif defined(IMGUI_IMPL_OPENGL_ES3)
160#if (defined(__APPLE__) && (TARGET_OS_IOS || TARGET_OS_TV))
161#include <OpenGLES/ES3/gl.h> // Use GL ES 3
162#else
163#include <GLES3/gl3.h> // Use GL ES 3
164#endif
165#elif !defined(IMGUI_IMPL_OPENGL_LOADER_CUSTOM)
166// Modern desktop OpenGL doesn't have a standard portable header file to load OpenGL function pointers.
167// Helper libraries are often used for this purpose! Here we are using our own minimal custom loader based on gl3w.
168// In the rest of your app/engine, you can use another loader of your choice (gl3w, glew, glad, glbinding, glext, glLoadGen, etc.).
169// If you happen to be developing a new feature for this backend (imgui_impl_opengl3.cpp):
170// - You may need to regenerate imgui_impl_opengl3_loader.h to add new symbols. See https://github.com/dearimgui/gl3w_stripped
171// Typically you would run: python3 ./gl3w_gen.py --output ../imgui/backends/imgui_impl_opengl3_loader.h --ref ../imgui/backends/imgui_impl_opengl3.cpp ./extra_symbols.txt
172// - You can temporarily use an unstripped version. See https://github.com/dearimgui/gl3w_stripped/releases
173// Changes to this backend using new APIs should be accompanied by a regenerated stripped loader version.
174#define IMGL3W_IMPL
175#define IMGUI_IMPL_OPENGL_LOADER_IMGL3W
176#include "imgui_impl_opengl3_loader.h"
177#endif
178
179// Vertex arrays are not supported on ES2/WebGL1 unless Emscripten which uses an extension
180#ifndef IMGUI_IMPL_OPENGL_ES2
181#define IMGUI_IMPL_OPENGL_USE_VERTEX_ARRAY
182#elif defined(__EMSCRIPTEN__)
183#define IMGUI_IMPL_OPENGL_USE_VERTEX_ARRAY
184#define glBindVertexArray glBindVertexArrayOES
185#define glGenVertexArrays glGenVertexArraysOES
186#define glDeleteVertexArrays glDeleteVertexArraysOES
187#define GL_VERTEX_ARRAY_BINDING GL_VERTEX_ARRAY_BINDING_OES
188#endif
189
190// Desktop GL 2.0+ has extension and glPolygonMode() which GL ES and WebGL don't have..
191// A desktop ES context can technically compile fine with our loader, so we also perform a runtime checks
192#if !defined(IMGUI_IMPL_OPENGL_ES2) && !defined(IMGUI_IMPL_OPENGL_ES3)
193#define IMGUI_IMPL_OPENGL_HAS_EXTENSIONS // has glGetIntegerv(GL_NUM_EXTENSIONS)
194#define IMGUI_IMPL_OPENGL_MAY_HAVE_POLYGON_MODE // may have glPolygonMode()
195#endif
196
197// Desktop GL 2.1+ and GL ES 3.0+ have glBindBuffer() with GL_PIXEL_UNPACK_BUFFER target.
198#if !defined(IMGUI_IMPL_OPENGL_ES2)
199#define IMGUI_IMPL_OPENGL_MAY_HAVE_BIND_BUFFER_PIXEL_UNPACK
200#endif
201
202// Desktop GL 3.1+ has GL_PRIMITIVE_RESTART state
203#if !defined(IMGUI_IMPL_OPENGL_ES2) && !defined(IMGUI_IMPL_OPENGL_ES3) && defined(GL_VERSION_3_1)
204#define IMGUI_IMPL_OPENGL_MAY_HAVE_PRIMITIVE_RESTART
205#endif
206
207// Desktop GL 3.2+ has glDrawElementsBaseVertex() which GL ES and WebGL don't have.
208#if !defined(IMGUI_IMPL_OPENGL_ES2) && !defined(IMGUI_IMPL_OPENGL_ES3) && defined(GL_VERSION_3_2)
209#define IMGUI_IMPL_OPENGL_MAY_HAVE_VTX_OFFSET
210#endif
211
212// Desktop GL 3.3+ and GL ES 3.0+ have glBindSampler()
213#if !defined(IMGUI_IMPL_OPENGL_ES2) && (defined(IMGUI_IMPL_OPENGL_ES3) || defined(GL_VERSION_3_3))
214#define IMGUI_IMPL_OPENGL_MAY_HAVE_BIND_SAMPLER
215#endif
216
217// [Debugging]
218//#define IMGUI_IMPL_OPENGL_DEBUG
219#ifdef IMGUI_IMPL_OPENGL_DEBUG
220#include <stdio.h>
221#define GL_CALL(_CALL) do { _CALL; GLenum gl_err = glGetError(); if (gl_err != 0) fprintf(stderr, "GL error 0x%x returned from '%s'.\n", gl_err, #_CALL); } while (0) // Call with error check
222#else
223#define GL_CALL(_CALL) _CALL // Call without error check
224#endif
225
226// OpenGL Data
227struct ImGui_ImplOpenGL3_Data
228{
229 GLuint GlVersion; // Extracted at runtime using GL_MAJOR_VERSION, GL_MINOR_VERSION queries (e.g. 320 for GL 3.2)
230 char GlslVersionString[32]; // Specified by user or detected based on compile time GL settings.
231 bool GlProfileIsES2;
232 bool GlProfileIsES3;
233 bool GlProfileIsCompat;
234 GLint GlProfileMask;
235 GLuint FontTexture;
236 GLuint ShaderHandle;
237 GLint AttribLocationTex; // Uniforms location
238 GLint AttribLocationProjMtx;
239 GLuint AttribLocationVtxPos; // Vertex attributes location
240 GLuint AttribLocationVtxUV;
241 GLuint AttribLocationVtxColor;
242 unsigned int VboHandle, ElementsHandle;
243 GLsizeiptr VertexBufferSize;
244 GLsizeiptr IndexBufferSize;
245 bool HasPolygonMode;
246 bool HasClipOrigin;
247 bool UseBufferSubData;
248
249 ImGui_ImplOpenGL3_Data() { memset(s: (void*)this, c: 0, n: sizeof(*this)); }
250};
251
252// Backend data stored in io.BackendRendererUserData to allow support for multiple Dear ImGui contexts
253// It is STRONGLY preferred that you use docking branch with multi-viewports (== single Dear ImGui context + multiple windows) instead of multiple Dear ImGui contexts.
254static ImGui_ImplOpenGL3_Data* ImGui_ImplOpenGL3_GetBackendData()
255{
256 return ImGui::GetCurrentContext() ? (ImGui_ImplOpenGL3_Data*)ImGui::GetIO().BackendRendererUserData : nullptr;
257}
258
259// Forward Declarations
260static void ImGui_ImplOpenGL3_InitMultiViewportSupport();
261static void ImGui_ImplOpenGL3_ShutdownMultiViewportSupport();
262
263// OpenGL vertex attribute state (for ES 1.0 and ES 2.0 only)
264#ifndef IMGUI_IMPL_OPENGL_USE_VERTEX_ARRAY
265struct ImGui_ImplOpenGL3_VtxAttribState
266{
267 GLint Enabled, Size, Type, Normalized, Stride;
268 GLvoid* Ptr;
269
270 void GetState(GLint index)
271 {
272 glGetVertexAttribiv(index, GL_VERTEX_ATTRIB_ARRAY_ENABLED, &Enabled);
273 glGetVertexAttribiv(index, GL_VERTEX_ATTRIB_ARRAY_SIZE, &Size);
274 glGetVertexAttribiv(index, GL_VERTEX_ATTRIB_ARRAY_TYPE, &Type);
275 glGetVertexAttribiv(index, GL_VERTEX_ATTRIB_ARRAY_NORMALIZED, &Normalized);
276 glGetVertexAttribiv(index, GL_VERTEX_ATTRIB_ARRAY_STRIDE, &Stride);
277 glGetVertexAttribPointerv(index, GL_VERTEX_ATTRIB_ARRAY_POINTER, &Ptr);
278 }
279 void SetState(GLint index)
280 {
281 glVertexAttribPointer(index, Size, Type, (GLboolean)Normalized, Stride, Ptr);
282 if (Enabled) glEnableVertexAttribArray(index); else glDisableVertexAttribArray(index);
283 }
284};
285#endif
286
287// Not static to allow third-party code to use that if they want to (but undocumented)
288bool ImGui_ImplOpenGL3_InitLoader();
289bool ImGui_ImplOpenGL3_InitLoader()
290{
291 // Initialize our loader
292#ifdef IMGUI_IMPL_OPENGL_LOADER_IMGL3W
293 if (glGetIntegerv == nullptr && imgl3wInit() != 0)
294 {
295 fprintf(stderr, format: "Failed to initialize OpenGL loader!\n");
296 return false;
297 }
298#endif
299 return true;
300}
301
302// Functions
303bool ImGui_ImplOpenGL3_Init(const char* glsl_version)
304{
305 ImGuiIO& io = ImGui::GetIO();
306 IMGUI_CHECKVERSION();
307 IM_ASSERT(io.BackendRendererUserData == nullptr && "Already initialized a renderer backend!");
308
309 // Initialize loader
310 if (!ImGui_ImplOpenGL3_InitLoader())
311 return false;
312
313 // Setup backend capabilities flags
314 ImGui_ImplOpenGL3_Data* bd = IM_NEW(ImGui_ImplOpenGL3_Data)();
315 io.BackendRendererUserData = (void*)bd;
316 io.BackendRendererName = "imgui_impl_opengl3";
317
318 // Query for GL version (e.g. 320 for GL 3.2)
319 const char* gl_version_str = (const char*)glGetString(GL_VERSION);
320#if defined(IMGUI_IMPL_OPENGL_ES2)
321 // GLES 2
322 bd->GlVersion = 200;
323 bd->GlProfileIsES2 = true;
324 IM_UNUSED(gl_version_str);
325#else
326 // Desktop or GLES 3
327 GLint major = 0;
328 GLint minor = 0;
329 glGetIntegerv(GL_MAJOR_VERSION, &major);
330 glGetIntegerv(GL_MINOR_VERSION, &minor);
331 if (major == 0 && minor == 0)
332 sscanf(s: gl_version_str, format: "%d.%d", &major, &minor); // Query GL_VERSION in desktop GL 2.x, the string will start with "<major>.<minor>"
333 bd->GlVersion = (GLuint)(major * 100 + minor * 10);
334#if defined(GL_CONTEXT_PROFILE_MASK)
335 if (bd->GlVersion >= 320)
336 glGetIntegerv(GL_CONTEXT_PROFILE_MASK, &bd->GlProfileMask);
337 bd->GlProfileIsCompat = (bd->GlProfileMask & GL_CONTEXT_COMPATIBILITY_PROFILE_BIT) != 0;
338#endif
339
340#if defined(IMGUI_IMPL_OPENGL_ES3)
341 bd->GlProfileIsES3 = true;
342#else
343 if (strncmp(s1: gl_version_str, s2: "OpenGL ES 3", n: 11) == 0)
344 bd->GlProfileIsES3 = true;
345#endif
346
347 bd->UseBufferSubData = false;
348 /*
349 // Query vendor to enable glBufferSubData kludge
350#ifdef _WIN32
351 if (const char* vendor = (const char*)glGetString(GL_VENDOR))
352 if (strncmp(vendor, "Intel", 5) == 0)
353 bd->UseBufferSubData = true;
354#endif
355 */
356#endif
357
358#ifdef IMGUI_IMPL_OPENGL_DEBUG
359 printf("GlVersion = %d, \"%s\"\nGlProfileIsCompat = %d\nGlProfileMask = 0x%X\nGlProfileIsES2/IsEs3 = %d/%d\nGL_VENDOR = '%s'\nGL_RENDERER = '%s'\n", bd->GlVersion, gl_version_str, bd->GlProfileIsCompat, bd->GlProfileMask, bd->GlProfileIsES2, bd->GlProfileIsES3, (const char*)glGetString(GL_VENDOR), (const char*)glGetString(GL_RENDERER)); // [DEBUG]
360#endif
361
362#ifdef IMGUI_IMPL_OPENGL_MAY_HAVE_VTX_OFFSET
363 if (bd->GlVersion >= 320)
364 io.BackendFlags |= ImGuiBackendFlags_RendererHasVtxOffset; // We can honor the ImDrawCmd::VtxOffset field, allowing for large meshes.
365#endif
366 io.BackendFlags |= ImGuiBackendFlags_RendererHasViewports; // We can create multi-viewports on the Renderer side (optional)
367
368 // Store GLSL version string so we can refer to it later in case we recreate shaders.
369 // Note: GLSL version is NOT the same as GL version. Leave this to nullptr if unsure.
370 if (glsl_version == nullptr)
371 {
372#if defined(IMGUI_IMPL_OPENGL_ES2)
373 glsl_version = "#version 100";
374#elif defined(IMGUI_IMPL_OPENGL_ES3)
375 glsl_version = "#version 300 es";
376#elif defined(__APPLE__)
377 glsl_version = "#version 150";
378#else
379 glsl_version = "#version 130";
380#endif
381 }
382 IM_ASSERT((int)strlen(glsl_version) + 2 < IM_ARRAYSIZE(bd->GlslVersionString));
383 strcpy(dest: bd->GlslVersionString, src: glsl_version);
384 strcat(dest: bd->GlslVersionString, src: "\n");
385
386 // Make an arbitrary GL call (we don't actually need the result)
387 // IF YOU GET A CRASH HERE: it probably means the OpenGL function loader didn't do its job. Let us know!
388 GLint current_texture;
389 glGetIntegerv(GL_TEXTURE_BINDING_2D, &current_texture);
390
391 // Detect extensions we support
392#ifdef IMGUI_IMPL_OPENGL_MAY_HAVE_POLYGON_MODE
393 bd->HasPolygonMode = (!bd->GlProfileIsES2 && !bd->GlProfileIsES3);
394#endif
395 bd->HasClipOrigin = (bd->GlVersion >= 450);
396#ifdef IMGUI_IMPL_OPENGL_HAS_EXTENSIONS
397 GLint num_extensions = 0;
398 glGetIntegerv(GL_NUM_EXTENSIONS, &num_extensions);
399 for (GLint i = 0; i < num_extensions; i++)
400 {
401 const char* extension = (const char*)glGetStringi(GL_EXTENSIONS, i);
402 if (extension != nullptr && strcmp(s1: extension, s2: "GL_ARB_clip_control") == 0)
403 bd->HasClipOrigin = true;
404 }
405#endif
406
407 ImGui_ImplOpenGL3_InitMultiViewportSupport();
408
409 return true;
410}
411
412void ImGui_ImplOpenGL3_Shutdown()
413{
414 ImGui_ImplOpenGL3_Data* bd = ImGui_ImplOpenGL3_GetBackendData();
415 IM_ASSERT(bd != nullptr && "No renderer backend to shutdown, or already shutdown?");
416 ImGuiIO& io = ImGui::GetIO();
417
418 ImGui_ImplOpenGL3_ShutdownMultiViewportSupport();
419 ImGui_ImplOpenGL3_DestroyDeviceObjects();
420 io.BackendRendererName = nullptr;
421 io.BackendRendererUserData = nullptr;
422 io.BackendFlags &= ~(ImGuiBackendFlags_RendererHasVtxOffset | ImGuiBackendFlags_RendererHasViewports);
423 IM_DELETE(p: bd);
424}
425
426void ImGui_ImplOpenGL3_NewFrame()
427{
428 ImGui_ImplOpenGL3_Data* bd = ImGui_ImplOpenGL3_GetBackendData();
429 IM_ASSERT(bd != nullptr && "Context or backend not initialized! Did you call ImGui_ImplOpenGL3_Init()?");
430
431 ImGui_ImplOpenGL3_InitLoader(); // Lazily init loader if not already done for e.g. DLL boundaries.
432
433 if (!bd->ShaderHandle)
434 ImGui_ImplOpenGL3_CreateDeviceObjects();
435 if (!bd->FontTexture)
436 ImGui_ImplOpenGL3_CreateFontsTexture();
437}
438
439static void ImGui_ImplOpenGL3_SetupRenderState(ImDrawData* draw_data, int fb_width, int fb_height, GLuint vertex_array_object)
440{
441 ImGui_ImplOpenGL3_Data* bd = ImGui_ImplOpenGL3_GetBackendData();
442
443 // Setup render state: alpha-blending enabled, no face culling, no depth testing, scissor enabled, polygon fill
444 glEnable(GL_BLEND);
445 glBlendEquation(GL_FUNC_ADD);
446 glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
447 glDisable(GL_CULL_FACE);
448 glDisable(GL_DEPTH_TEST);
449 glDisable(GL_STENCIL_TEST);
450 glEnable(GL_SCISSOR_TEST);
451#ifdef IMGUI_IMPL_OPENGL_MAY_HAVE_PRIMITIVE_RESTART
452 if (bd->GlVersion >= 310)
453 glDisable(GL_PRIMITIVE_RESTART);
454#endif
455#ifdef IMGUI_IMPL_OPENGL_MAY_HAVE_POLYGON_MODE
456 if (bd->HasPolygonMode)
457 glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
458#endif
459
460 // Support for GL 4.5 rarely used glClipControl(GL_UPPER_LEFT)
461#if defined(GL_CLIP_ORIGIN)
462 bool clip_origin_lower_left = true;
463 if (bd->HasClipOrigin)
464 {
465 GLenum current_clip_origin = 0; glGetIntegerv(GL_CLIP_ORIGIN, (GLint*)&current_clip_origin);
466 if (current_clip_origin == GL_UPPER_LEFT)
467 clip_origin_lower_left = false;
468 }
469#endif
470
471 // Setup viewport, orthographic projection matrix
472 // Our visible imgui space lies from draw_data->DisplayPos (top left) to draw_data->DisplayPos+data_data->DisplaySize (bottom right). DisplayPos is (0,0) for single viewport apps.
473 GL_CALL(glViewport(0, 0, (GLsizei)fb_width, (GLsizei)fb_height));
474 float L = draw_data->DisplayPos.x;
475 float R = draw_data->DisplayPos.x + draw_data->DisplaySize.x;
476 float T = draw_data->DisplayPos.y;
477 float B = draw_data->DisplayPos.y + draw_data->DisplaySize.y;
478#if defined(GL_CLIP_ORIGIN)
479 if (!clip_origin_lower_left) { float tmp = T; T = B; B = tmp; } // Swap top and bottom if origin is upper left
480#endif
481 const float ortho_projection[4][4] =
482 {
483 { 2.0f/(R-L), 0.0f, 0.0f, 0.0f },
484 { 0.0f, 2.0f/(T-B), 0.0f, 0.0f },
485 { 0.0f, 0.0f, -1.0f, 0.0f },
486 { (R+L)/(L-R), (T+B)/(B-T), 0.0f, 1.0f },
487 };
488 glUseProgram(bd->ShaderHandle);
489 glUniform1i(bd->AttribLocationTex, 0);
490 glUniformMatrix4fv(bd->AttribLocationProjMtx, 1, GL_FALSE, &ortho_projection[0][0]);
491
492#ifdef IMGUI_IMPL_OPENGL_MAY_HAVE_BIND_SAMPLER
493 if (bd->GlVersion >= 330 || bd->GlProfileIsES3)
494 glBindSampler(0, 0); // We use combined texture/sampler state. Applications using GL 3.3 and GL ES 3.0 may set that otherwise.
495#endif
496
497 (void)vertex_array_object;
498#ifdef IMGUI_IMPL_OPENGL_USE_VERTEX_ARRAY
499 glBindVertexArray(vertex_array_object);
500#endif
501
502 // Bind vertex/index buffers and setup attributes for ImDrawVert
503 GL_CALL(glBindBuffer(GL_ARRAY_BUFFER, bd->VboHandle));
504 GL_CALL(glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, bd->ElementsHandle));
505 GL_CALL(glEnableVertexAttribArray(bd->AttribLocationVtxPos));
506 GL_CALL(glEnableVertexAttribArray(bd->AttribLocationVtxUV));
507 GL_CALL(glEnableVertexAttribArray(bd->AttribLocationVtxColor));
508 GL_CALL(glVertexAttribPointer(bd->AttribLocationVtxPos, 2, GL_FLOAT, GL_FALSE, sizeof(ImDrawVert), (GLvoid*)offsetof(ImDrawVert, pos)));
509 GL_CALL(glVertexAttribPointer(bd->AttribLocationVtxUV, 2, GL_FLOAT, GL_FALSE, sizeof(ImDrawVert), (GLvoid*)offsetof(ImDrawVert, uv)));
510 GL_CALL(glVertexAttribPointer(bd->AttribLocationVtxColor, 4, GL_UNSIGNED_BYTE, GL_TRUE, sizeof(ImDrawVert), (GLvoid*)offsetof(ImDrawVert, col)));
511}
512
513// OpenGL3 Render function.
514// Note that this implementation is little overcomplicated because we are saving/setting up/restoring every OpenGL state explicitly.
515// This is in order to be able to run within an OpenGL engine that doesn't do so.
516void ImGui_ImplOpenGL3_RenderDrawData(ImDrawData* draw_data)
517{
518 // Avoid rendering when minimized, scale coordinates for retina displays (screen coordinates != framebuffer coordinates)
519 int fb_width = (int)(draw_data->DisplaySize.x * draw_data->FramebufferScale.x);
520 int fb_height = (int)(draw_data->DisplaySize.y * draw_data->FramebufferScale.y);
521 if (fb_width <= 0 || fb_height <= 0)
522 return;
523
524 ImGui_ImplOpenGL3_InitLoader(); // Lazily init loader if not already done for e.g. DLL boundaries.
525
526 ImGui_ImplOpenGL3_Data* bd = ImGui_ImplOpenGL3_GetBackendData();
527
528 // Backup GL state
529 GLenum last_active_texture; glGetIntegerv(GL_ACTIVE_TEXTURE, (GLint*)&last_active_texture);
530 glActiveTexture(GL_TEXTURE0);
531 GLuint last_program; glGetIntegerv(GL_CURRENT_PROGRAM, (GLint*)&last_program);
532 GLuint last_texture; glGetIntegerv(GL_TEXTURE_BINDING_2D, (GLint*)&last_texture);
533#ifdef IMGUI_IMPL_OPENGL_MAY_HAVE_BIND_SAMPLER
534 GLuint last_sampler; if (bd->GlVersion >= 330 || bd->GlProfileIsES3) { glGetIntegerv(GL_SAMPLER_BINDING, (GLint*)&last_sampler); } else { last_sampler = 0; }
535#endif
536 GLuint last_array_buffer; glGetIntegerv(GL_ARRAY_BUFFER_BINDING, (GLint*)&last_array_buffer);
537#ifndef IMGUI_IMPL_OPENGL_USE_VERTEX_ARRAY
538 // This is part of VAO on OpenGL 3.0+ and OpenGL ES 3.0+.
539 GLint last_element_array_buffer; glGetIntegerv(GL_ELEMENT_ARRAY_BUFFER_BINDING, &last_element_array_buffer);
540 ImGui_ImplOpenGL3_VtxAttribState last_vtx_attrib_state_pos; last_vtx_attrib_state_pos.GetState(bd->AttribLocationVtxPos);
541 ImGui_ImplOpenGL3_VtxAttribState last_vtx_attrib_state_uv; last_vtx_attrib_state_uv.GetState(bd->AttribLocationVtxUV);
542 ImGui_ImplOpenGL3_VtxAttribState last_vtx_attrib_state_color; last_vtx_attrib_state_color.GetState(bd->AttribLocationVtxColor);
543#endif
544#ifdef IMGUI_IMPL_OPENGL_USE_VERTEX_ARRAY
545 GLuint last_vertex_array_object; glGetIntegerv(GL_VERTEX_ARRAY_BINDING, (GLint*)&last_vertex_array_object);
546#endif
547#ifdef IMGUI_IMPL_OPENGL_MAY_HAVE_POLYGON_MODE
548 GLint last_polygon_mode[2]; if (bd->HasPolygonMode) { glGetIntegerv(GL_POLYGON_MODE, last_polygon_mode); }
549#endif
550 GLint last_viewport[4]; glGetIntegerv(GL_VIEWPORT, last_viewport);
551 GLint last_scissor_box[4]; glGetIntegerv(GL_SCISSOR_BOX, last_scissor_box);
552 GLenum last_blend_src_rgb; glGetIntegerv(GL_BLEND_SRC_RGB, (GLint*)&last_blend_src_rgb);
553 GLenum last_blend_dst_rgb; glGetIntegerv(GL_BLEND_DST_RGB, (GLint*)&last_blend_dst_rgb);
554 GLenum last_blend_src_alpha; glGetIntegerv(GL_BLEND_SRC_ALPHA, (GLint*)&last_blend_src_alpha);
555 GLenum last_blend_dst_alpha; glGetIntegerv(GL_BLEND_DST_ALPHA, (GLint*)&last_blend_dst_alpha);
556 GLenum last_blend_equation_rgb; glGetIntegerv(GL_BLEND_EQUATION_RGB, (GLint*)&last_blend_equation_rgb);
557 GLenum last_blend_equation_alpha; glGetIntegerv(GL_BLEND_EQUATION_ALPHA, (GLint*)&last_blend_equation_alpha);
558 GLboolean last_enable_blend = glIsEnabled(GL_BLEND);
559 GLboolean last_enable_cull_face = glIsEnabled(GL_CULL_FACE);
560 GLboolean last_enable_depth_test = glIsEnabled(GL_DEPTH_TEST);
561 GLboolean last_enable_stencil_test = glIsEnabled(GL_STENCIL_TEST);
562 GLboolean last_enable_scissor_test = glIsEnabled(GL_SCISSOR_TEST);
563#ifdef IMGUI_IMPL_OPENGL_MAY_HAVE_PRIMITIVE_RESTART
564 GLboolean last_enable_primitive_restart = (bd->GlVersion >= 310) ? glIsEnabled(GL_PRIMITIVE_RESTART) : GL_FALSE;
565#endif
566
567 // Setup desired GL state
568 // Recreate the VAO every time (this is to easily allow multiple GL contexts to be rendered to. VAO are not shared among GL contexts)
569 // The renderer would actually work without any VAO bound, but then our VertexAttrib calls would overwrite the default one currently bound.
570 GLuint vertex_array_object = 0;
571#ifdef IMGUI_IMPL_OPENGL_USE_VERTEX_ARRAY
572 GL_CALL(glGenVertexArrays(1, &vertex_array_object));
573#endif
574 ImGui_ImplOpenGL3_SetupRenderState(draw_data, fb_width, fb_height, vertex_array_object);
575
576 // Will project scissor/clipping rectangles into framebuffer space
577 ImVec2 clip_off = draw_data->DisplayPos; // (0,0) unless using multi-viewports
578 ImVec2 clip_scale = draw_data->FramebufferScale; // (1,1) unless using retina display which are often (2,2)
579
580 // Render command lists
581 for (int n = 0; n < draw_data->CmdListsCount; n++)
582 {
583 const ImDrawList* draw_list = draw_data->CmdLists[n];
584
585 // Upload vertex/index buffers
586 // - OpenGL drivers are in a very sorry state nowadays....
587 // During 2021 we attempted to switch from glBufferData() to orphaning+glBufferSubData() following reports
588 // of leaks on Intel GPU when using multi-viewports on Windows.
589 // - After this we kept hearing of various display corruptions issues. We started disabling on non-Intel GPU, but issues still got reported on Intel.
590 // - We are now back to using exclusively glBufferData(). So bd->UseBufferSubData IS ALWAYS FALSE in this code.
591 // We are keeping the old code path for a while in case people finding new issues may want to test the bd->UseBufferSubData path.
592 // - See https://github.com/ocornut/imgui/issues/4468 and please report any corruption issues.
593 const GLsizeiptr vtx_buffer_size = (GLsizeiptr)draw_list->VtxBuffer.Size * (int)sizeof(ImDrawVert);
594 const GLsizeiptr idx_buffer_size = (GLsizeiptr)draw_list->IdxBuffer.Size * (int)sizeof(ImDrawIdx);
595 if (bd->UseBufferSubData)
596 {
597 if (bd->VertexBufferSize < vtx_buffer_size)
598 {
599 bd->VertexBufferSize = vtx_buffer_size;
600 GL_CALL(glBufferData(GL_ARRAY_BUFFER, bd->VertexBufferSize, nullptr, GL_STREAM_DRAW));
601 }
602 if (bd->IndexBufferSize < idx_buffer_size)
603 {
604 bd->IndexBufferSize = idx_buffer_size;
605 GL_CALL(glBufferData(GL_ELEMENT_ARRAY_BUFFER, bd->IndexBufferSize, nullptr, GL_STREAM_DRAW));
606 }
607 GL_CALL(glBufferSubData(GL_ARRAY_BUFFER, 0, vtx_buffer_size, (const GLvoid*)draw_list->VtxBuffer.Data));
608 GL_CALL(glBufferSubData(GL_ELEMENT_ARRAY_BUFFER, 0, idx_buffer_size, (const GLvoid*)draw_list->IdxBuffer.Data));
609 }
610 else
611 {
612 GL_CALL(glBufferData(GL_ARRAY_BUFFER, vtx_buffer_size, (const GLvoid*)draw_list->VtxBuffer.Data, GL_STREAM_DRAW));
613 GL_CALL(glBufferData(GL_ELEMENT_ARRAY_BUFFER, idx_buffer_size, (const GLvoid*)draw_list->IdxBuffer.Data, GL_STREAM_DRAW));
614 }
615
616 for (int cmd_i = 0; cmd_i < draw_list->CmdBuffer.Size; cmd_i++)
617 {
618 const ImDrawCmd* pcmd = &draw_list->CmdBuffer[cmd_i];
619 if (pcmd->UserCallback != nullptr)
620 {
621 // User callback, registered via ImDrawList::AddCallback()
622 // (ImDrawCallback_ResetRenderState is a special callback value used by the user to request the renderer to reset render state.)
623 if (pcmd->UserCallback == ImDrawCallback_ResetRenderState)
624 ImGui_ImplOpenGL3_SetupRenderState(draw_data, fb_width, fb_height, vertex_array_object);
625 else
626 pcmd->UserCallback(draw_list, pcmd);
627 }
628 else
629 {
630 // Project scissor/clipping rectangles into framebuffer space
631 ImVec2 clip_min((pcmd->ClipRect.x - clip_off.x) * clip_scale.x, (pcmd->ClipRect.y - clip_off.y) * clip_scale.y);
632 ImVec2 clip_max((pcmd->ClipRect.z - clip_off.x) * clip_scale.x, (pcmd->ClipRect.w - clip_off.y) * clip_scale.y);
633 if (clip_max.x <= clip_min.x || clip_max.y <= clip_min.y)
634 continue;
635
636 // Apply scissor/clipping rectangle (Y is inverted in OpenGL)
637 GL_CALL(glScissor((int)clip_min.x, (int)((float)fb_height - clip_max.y), (int)(clip_max.x - clip_min.x), (int)(clip_max.y - clip_min.y)));
638
639 // Bind texture, Draw
640 GL_CALL(glBindTexture(GL_TEXTURE_2D, (GLuint)(intptr_t)pcmd->GetTexID()));
641#ifdef IMGUI_IMPL_OPENGL_MAY_HAVE_VTX_OFFSET
642 if (bd->GlVersion >= 320)
643 GL_CALL(glDrawElementsBaseVertex(GL_TRIANGLES, (GLsizei)pcmd->ElemCount, sizeof(ImDrawIdx) == 2 ? GL_UNSIGNED_SHORT : GL_UNSIGNED_INT, (void*)(intptr_t)(pcmd->IdxOffset * sizeof(ImDrawIdx)), (GLint)pcmd->VtxOffset));
644 else
645#endif
646 GL_CALL(glDrawElements(GL_TRIANGLES, (GLsizei)pcmd->ElemCount, sizeof(ImDrawIdx) == 2 ? GL_UNSIGNED_SHORT : GL_UNSIGNED_INT, (void*)(intptr_t)(pcmd->IdxOffset * sizeof(ImDrawIdx))));
647 }
648 }
649 }
650
651 // Destroy the temporary VAO
652#ifdef IMGUI_IMPL_OPENGL_USE_VERTEX_ARRAY
653 GL_CALL(glDeleteVertexArrays(1, &vertex_array_object));
654#endif
655
656 // Restore modified GL state
657 // This "glIsProgram()" check is required because if the program is "pending deletion" at the time of binding backup, it will have been deleted by now and will cause an OpenGL error. See #6220.
658 if (last_program == 0 || glIsProgram(last_program)) glUseProgram(last_program);
659 glBindTexture(GL_TEXTURE_2D, last_texture);
660#ifdef IMGUI_IMPL_OPENGL_MAY_HAVE_BIND_SAMPLER
661 if (bd->GlVersion >= 330 || bd->GlProfileIsES3)
662 glBindSampler(0, last_sampler);
663#endif
664 glActiveTexture(last_active_texture);
665#ifdef IMGUI_IMPL_OPENGL_USE_VERTEX_ARRAY
666 glBindVertexArray(last_vertex_array_object);
667#endif
668 glBindBuffer(GL_ARRAY_BUFFER, last_array_buffer);
669#ifndef IMGUI_IMPL_OPENGL_USE_VERTEX_ARRAY
670 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, last_element_array_buffer);
671 last_vtx_attrib_state_pos.SetState(bd->AttribLocationVtxPos);
672 last_vtx_attrib_state_uv.SetState(bd->AttribLocationVtxUV);
673 last_vtx_attrib_state_color.SetState(bd->AttribLocationVtxColor);
674#endif
675 glBlendEquationSeparate(last_blend_equation_rgb, last_blend_equation_alpha);
676 glBlendFuncSeparate(last_blend_src_rgb, last_blend_dst_rgb, last_blend_src_alpha, last_blend_dst_alpha);
677 if (last_enable_blend) glEnable(GL_BLEND); else glDisable(GL_BLEND);
678 if (last_enable_cull_face) glEnable(GL_CULL_FACE); else glDisable(GL_CULL_FACE);
679 if (last_enable_depth_test) glEnable(GL_DEPTH_TEST); else glDisable(GL_DEPTH_TEST);
680 if (last_enable_stencil_test) glEnable(GL_STENCIL_TEST); else glDisable(GL_STENCIL_TEST);
681 if (last_enable_scissor_test) glEnable(GL_SCISSOR_TEST); else glDisable(GL_SCISSOR_TEST);
682#ifdef IMGUI_IMPL_OPENGL_MAY_HAVE_PRIMITIVE_RESTART
683 if (bd->GlVersion >= 310) { if (last_enable_primitive_restart) glEnable(GL_PRIMITIVE_RESTART); else glDisable(GL_PRIMITIVE_RESTART); }
684#endif
685
686#ifdef IMGUI_IMPL_OPENGL_MAY_HAVE_POLYGON_MODE
687 // Desktop OpenGL 3.0 and OpenGL 3.1 had separate polygon draw modes for front-facing and back-facing faces of polygons
688 if (bd->HasPolygonMode) { if (bd->GlVersion <= 310 || bd->GlProfileIsCompat) { glPolygonMode(GL_FRONT, (GLenum)last_polygon_mode[0]); glPolygonMode(GL_BACK, (GLenum)last_polygon_mode[1]); } else { glPolygonMode(GL_FRONT_AND_BACK, (GLenum)last_polygon_mode[0]); } }
689#endif // IMGUI_IMPL_OPENGL_MAY_HAVE_POLYGON_MODE
690
691 glViewport(last_viewport[0], last_viewport[1], (GLsizei)last_viewport[2], (GLsizei)last_viewport[3]);
692 glScissor(last_scissor_box[0], last_scissor_box[1], (GLsizei)last_scissor_box[2], (GLsizei)last_scissor_box[3]);
693 (void)bd; // Not all compilation paths use this
694}
695
696bool ImGui_ImplOpenGL3_CreateFontsTexture()
697{
698 ImGuiIO& io = ImGui::GetIO();
699 ImGui_ImplOpenGL3_Data* bd = ImGui_ImplOpenGL3_GetBackendData();
700
701 // Build texture atlas
702 unsigned char* pixels;
703 int width, height;
704 io.Fonts->GetTexDataAsRGBA32(out_pixels: &pixels, out_width: &width, out_height: &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.
705
706 // Upload texture to graphics system
707 // (Bilinear sampling is required by default. Set 'io.Fonts->Flags |= ImFontAtlasFlags_NoBakedLines' or 'style.AntiAliasedLinesUseTex = false' to allow point/nearest sampling)
708 GLint last_texture;
709 GL_CALL(glGetIntegerv(GL_TEXTURE_BINDING_2D, &last_texture));
710 GL_CALL(glGenTextures(1, &bd->FontTexture));
711 GL_CALL(glBindTexture(GL_TEXTURE_2D, bd->FontTexture));
712 GL_CALL(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR));
713 GL_CALL(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR));
714 GL_CALL(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE));
715 GL_CALL(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE));
716#ifdef GL_UNPACK_ROW_LENGTH // Not on WebGL/ES
717 GL_CALL(glPixelStorei(GL_UNPACK_ROW_LENGTH, 0));
718#endif
719 GL_CALL(glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, pixels));
720
721 // Store identifier
722 io.Fonts->SetTexID((ImTextureID)(intptr_t)bd->FontTexture);
723
724 // Restore state
725 GL_CALL(glBindTexture(GL_TEXTURE_2D, last_texture));
726
727 return true;
728}
729
730void ImGui_ImplOpenGL3_DestroyFontsTexture()
731{
732 ImGuiIO& io = ImGui::GetIO();
733 ImGui_ImplOpenGL3_Data* bd = ImGui_ImplOpenGL3_GetBackendData();
734 if (bd->FontTexture)
735 {
736 glDeleteTextures(1, &bd->FontTexture);
737 io.Fonts->SetTexID(0);
738 bd->FontTexture = 0;
739 }
740}
741
742// If you get an error please report on github. You may try different GL context version or GLSL version. See GL<>GLSL version table at the top of this file.
743static bool CheckShader(GLuint handle, const char* desc)
744{
745 ImGui_ImplOpenGL3_Data* bd = ImGui_ImplOpenGL3_GetBackendData();
746 GLint status = 0, log_length = 0;
747 glGetShaderiv(handle, GL_COMPILE_STATUS, &status);
748 glGetShaderiv(handle, GL_INFO_LOG_LENGTH, &log_length);
749 if ((GLboolean)status == GL_FALSE)
750 fprintf(stderr, format: "ERROR: ImGui_ImplOpenGL3_CreateDeviceObjects: failed to compile %s! With GLSL: %s\n", desc, bd->GlslVersionString);
751 if (log_length > 1)
752 {
753 ImVector<char> buf;
754 buf.resize(new_size: (int)(log_length + 1));
755 glGetShaderInfoLog(handle, log_length, nullptr, (GLchar*)buf.begin());
756 fprintf(stderr, format: "%s\n", buf.begin());
757 }
758 return (GLboolean)status == GL_TRUE;
759}
760
761// If you get an error please report on GitHub. You may try different GL context version or GLSL version.
762static bool CheckProgram(GLuint handle, const char* desc)
763{
764 ImGui_ImplOpenGL3_Data* bd = ImGui_ImplOpenGL3_GetBackendData();
765 GLint status = 0, log_length = 0;
766 glGetProgramiv(handle, GL_LINK_STATUS, &status);
767 glGetProgramiv(handle, GL_INFO_LOG_LENGTH, &log_length);
768 if ((GLboolean)status == GL_FALSE)
769 fprintf(stderr, format: "ERROR: ImGui_ImplOpenGL3_CreateDeviceObjects: failed to link %s! With GLSL %s\n", desc, bd->GlslVersionString);
770 if (log_length > 1)
771 {
772 ImVector<char> buf;
773 buf.resize(new_size: (int)(log_length + 1));
774 glGetProgramInfoLog(handle, log_length, nullptr, (GLchar*)buf.begin());
775 fprintf(stderr, format: "%s\n", buf.begin());
776 }
777 return (GLboolean)status == GL_TRUE;
778}
779
780bool ImGui_ImplOpenGL3_CreateDeviceObjects()
781{
782 ImGui_ImplOpenGL3_Data* bd = ImGui_ImplOpenGL3_GetBackendData();
783
784 // Backup GL state
785 GLint last_texture, last_array_buffer;
786 glGetIntegerv(GL_TEXTURE_BINDING_2D, &last_texture);
787 glGetIntegerv(GL_ARRAY_BUFFER_BINDING, &last_array_buffer);
788#ifdef IMGUI_IMPL_OPENGL_MAY_HAVE_BIND_BUFFER_PIXEL_UNPACK
789 GLint last_pixel_unpack_buffer = 0;
790 if (bd->GlVersion >= 210) { glGetIntegerv(GL_PIXEL_UNPACK_BUFFER_BINDING, &last_pixel_unpack_buffer); glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0); }
791#endif
792#ifdef IMGUI_IMPL_OPENGL_USE_VERTEX_ARRAY
793 GLint last_vertex_array;
794 glGetIntegerv(GL_VERTEX_ARRAY_BINDING, &last_vertex_array);
795#endif
796
797 // Parse GLSL version string
798 int glsl_version = 130;
799 sscanf(s: bd->GlslVersionString, format: "#version %d", &glsl_version);
800
801 const GLchar* vertex_shader_glsl_120 =
802 "uniform mat4 ProjMtx;\n"
803 "attribute vec2 Position;\n"
804 "attribute vec2 UV;\n"
805 "attribute vec4 Color;\n"
806 "varying vec2 Frag_UV;\n"
807 "varying vec4 Frag_Color;\n"
808 "void main()\n"
809 "{\n"
810 " Frag_UV = UV;\n"
811 " Frag_Color = Color;\n"
812 " gl_Position = ProjMtx * vec4(Position.xy,0,1);\n"
813 "}\n";
814
815 const GLchar* vertex_shader_glsl_130 =
816 "uniform mat4 ProjMtx;\n"
817 "in vec2 Position;\n"
818 "in vec2 UV;\n"
819 "in vec4 Color;\n"
820 "out vec2 Frag_UV;\n"
821 "out vec4 Frag_Color;\n"
822 "void main()\n"
823 "{\n"
824 " Frag_UV = UV;\n"
825 " Frag_Color = Color;\n"
826 " gl_Position = ProjMtx * vec4(Position.xy,0,1);\n"
827 "}\n";
828
829 const GLchar* vertex_shader_glsl_300_es =
830 "precision highp float;\n"
831 "layout (location = 0) in vec2 Position;\n"
832 "layout (location = 1) in vec2 UV;\n"
833 "layout (location = 2) in vec4 Color;\n"
834 "uniform mat4 ProjMtx;\n"
835 "out vec2 Frag_UV;\n"
836 "out vec4 Frag_Color;\n"
837 "void main()\n"
838 "{\n"
839 " Frag_UV = UV;\n"
840 " Frag_Color = Color;\n"
841 " gl_Position = ProjMtx * vec4(Position.xy,0,1);\n"
842 "}\n";
843
844 const GLchar* vertex_shader_glsl_410_core =
845 "layout (location = 0) in vec2 Position;\n"
846 "layout (location = 1) in vec2 UV;\n"
847 "layout (location = 2) in vec4 Color;\n"
848 "uniform mat4 ProjMtx;\n"
849 "out vec2 Frag_UV;\n"
850 "out vec4 Frag_Color;\n"
851 "void main()\n"
852 "{\n"
853 " Frag_UV = UV;\n"
854 " Frag_Color = Color;\n"
855 " gl_Position = ProjMtx * vec4(Position.xy,0,1);\n"
856 "}\n";
857
858 const GLchar* fragment_shader_glsl_120 =
859 "#ifdef GL_ES\n"
860 " precision mediump float;\n"
861 "#endif\n"
862 "uniform sampler2D Texture;\n"
863 "varying vec2 Frag_UV;\n"
864 "varying vec4 Frag_Color;\n"
865 "void main()\n"
866 "{\n"
867 " gl_FragColor = Frag_Color * texture2D(Texture, Frag_UV.st);\n"
868 "}\n";
869
870 const GLchar* fragment_shader_glsl_130 =
871 "uniform sampler2D Texture;\n"
872 "in vec2 Frag_UV;\n"
873 "in vec4 Frag_Color;\n"
874 "out vec4 Out_Color;\n"
875 "void main()\n"
876 "{\n"
877 " Out_Color = Frag_Color * texture(Texture, Frag_UV.st);\n"
878 "}\n";
879
880 const GLchar* fragment_shader_glsl_300_es =
881 "precision mediump float;\n"
882 "uniform sampler2D Texture;\n"
883 "in vec2 Frag_UV;\n"
884 "in vec4 Frag_Color;\n"
885 "layout (location = 0) out vec4 Out_Color;\n"
886 "void main()\n"
887 "{\n"
888 " Out_Color = Frag_Color * texture(Texture, Frag_UV.st);\n"
889 "}\n";
890
891 const GLchar* fragment_shader_glsl_410_core =
892 "in vec2 Frag_UV;\n"
893 "in vec4 Frag_Color;\n"
894 "uniform sampler2D Texture;\n"
895 "layout (location = 0) out vec4 Out_Color;\n"
896 "void main()\n"
897 "{\n"
898 " Out_Color = Frag_Color * texture(Texture, Frag_UV.st);\n"
899 "}\n";
900
901 // Select shaders matching our GLSL versions
902 const GLchar* vertex_shader = nullptr;
903 const GLchar* fragment_shader = nullptr;
904 if (glsl_version < 130)
905 {
906 vertex_shader = vertex_shader_glsl_120;
907 fragment_shader = fragment_shader_glsl_120;
908 }
909 else if (glsl_version >= 410)
910 {
911 vertex_shader = vertex_shader_glsl_410_core;
912 fragment_shader = fragment_shader_glsl_410_core;
913 }
914 else if (glsl_version == 300)
915 {
916 vertex_shader = vertex_shader_glsl_300_es;
917 fragment_shader = fragment_shader_glsl_300_es;
918 }
919 else
920 {
921 vertex_shader = vertex_shader_glsl_130;
922 fragment_shader = fragment_shader_glsl_130;
923 }
924
925 // Create shaders
926 const GLchar* vertex_shader_with_version[2] = { bd->GlslVersionString, vertex_shader };
927 GLuint vert_handle;
928 GL_CALL(vert_handle = glCreateShader(GL_VERTEX_SHADER));
929 glShaderSource(vert_handle, 2, vertex_shader_with_version, nullptr);
930 glCompileShader(vert_handle);
931 CheckShader(handle: vert_handle, desc: "vertex shader");
932
933 const GLchar* fragment_shader_with_version[2] = { bd->GlslVersionString, fragment_shader };
934 GLuint frag_handle;
935 GL_CALL(frag_handle = glCreateShader(GL_FRAGMENT_SHADER));
936 glShaderSource(frag_handle, 2, fragment_shader_with_version, nullptr);
937 glCompileShader(frag_handle);
938 CheckShader(handle: frag_handle, desc: "fragment shader");
939
940 // Link
941 bd->ShaderHandle = glCreateProgram();
942 glAttachShader(bd->ShaderHandle, vert_handle);
943 glAttachShader(bd->ShaderHandle, frag_handle);
944 glLinkProgram(bd->ShaderHandle);
945 CheckProgram(handle: bd->ShaderHandle, desc: "shader program");
946
947 glDetachShader(bd->ShaderHandle, vert_handle);
948 glDetachShader(bd->ShaderHandle, frag_handle);
949 glDeleteShader(vert_handle);
950 glDeleteShader(frag_handle);
951
952 bd->AttribLocationTex = glGetUniformLocation(bd->ShaderHandle, "Texture");
953 bd->AttribLocationProjMtx = glGetUniformLocation(bd->ShaderHandle, "ProjMtx");
954 bd->AttribLocationVtxPos = (GLuint)glGetAttribLocation(bd->ShaderHandle, "Position");
955 bd->AttribLocationVtxUV = (GLuint)glGetAttribLocation(bd->ShaderHandle, "UV");
956 bd->AttribLocationVtxColor = (GLuint)glGetAttribLocation(bd->ShaderHandle, "Color");
957
958 // Create buffers
959 glGenBuffers(1, &bd->VboHandle);
960 glGenBuffers(1, &bd->ElementsHandle);
961
962 ImGui_ImplOpenGL3_CreateFontsTexture();
963
964 // Restore modified GL state
965 glBindTexture(GL_TEXTURE_2D, last_texture);
966 glBindBuffer(GL_ARRAY_BUFFER, last_array_buffer);
967#ifdef IMGUI_IMPL_OPENGL_MAY_HAVE_BIND_BUFFER_PIXEL_UNPACK
968 if (bd->GlVersion >= 210) { glBindBuffer(GL_PIXEL_UNPACK_BUFFER, last_pixel_unpack_buffer); }
969#endif
970#ifdef IMGUI_IMPL_OPENGL_USE_VERTEX_ARRAY
971 glBindVertexArray(last_vertex_array);
972#endif
973
974 return true;
975}
976
977void ImGui_ImplOpenGL3_DestroyDeviceObjects()
978{
979 ImGui_ImplOpenGL3_Data* bd = ImGui_ImplOpenGL3_GetBackendData();
980 if (bd->VboHandle) { glDeleteBuffers(1, &bd->VboHandle); bd->VboHandle = 0; }
981 if (bd->ElementsHandle) { glDeleteBuffers(1, &bd->ElementsHandle); bd->ElementsHandle = 0; }
982 if (bd->ShaderHandle) { glDeleteProgram(bd->ShaderHandle); bd->ShaderHandle = 0; }
983 ImGui_ImplOpenGL3_DestroyFontsTexture();
984}
985
986//--------------------------------------------------------------------------------------------------------
987// MULTI-VIEWPORT / PLATFORM INTERFACE SUPPORT
988// This is an _advanced_ and _optional_ feature, allowing the backend to create and handle multiple viewports simultaneously.
989// If you are new to dear imgui or creating a new binding for dear imgui, it is recommended that you completely ignore this section first..
990//--------------------------------------------------------------------------------------------------------
991
992static void ImGui_ImplOpenGL3_RenderWindow(ImGuiViewport* viewport, void*)
993{
994 if (!(viewport->Flags & ImGuiViewportFlags_NoRendererClear))
995 {
996 ImVec4 clear_color = ImVec4(0.0f, 0.0f, 0.0f, 1.0f);
997 glClearColor(clear_color.x, clear_color.y, clear_color.z, clear_color.w);
998 glClear(GL_COLOR_BUFFER_BIT);
999 }
1000 ImGui_ImplOpenGL3_RenderDrawData(draw_data: viewport->DrawData);
1001}
1002
1003static void ImGui_ImplOpenGL3_InitMultiViewportSupport()
1004{
1005 ImGuiPlatformIO& platform_io = ImGui::GetPlatformIO();
1006 platform_io.Renderer_RenderWindow = ImGui_ImplOpenGL3_RenderWindow;
1007}
1008
1009static void ImGui_ImplOpenGL3_ShutdownMultiViewportSupport()
1010{
1011 ImGui::DestroyPlatformWindows();
1012}
1013
1014//-----------------------------------------------------------------------------
1015
1016#if defined(__GNUC__)
1017#pragma GCC diagnostic pop
1018#endif
1019#if defined(__clang__)
1020#pragma clang diagnostic pop
1021#endif
1022
1023#endif // #ifndef IMGUI_DISABLE
1024

Provided by KDAB

Privacy Policy
Learn to use CMake with our Intro Training
Find out more

source code of imgui/backends/imgui_impl_opengl3.cpp