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