Debian Codegraph @

subprojects/imgui-1.91.6/backends/imgui_impl_opengl3.cpp

raw
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
10 // About WebGL/ES:
11 // - You need to '#define IMGUI_IMPL_OPENGL_ES2' or '#define IMGUI_IMPL_OPENGL_ES3' to use WebGL or OpenGL ES.
12 // - This is done automatically on iOS, Android and Emscripten targets.
13 // - 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.
14
15 // You can use unmodified imgui_impl_* files in your project. See examples/ folder for examples of using this.
16 // Prefer including the entire imgui/ repository into your project (either as a copy or as a submodule), and only build the backends you need.
17 // Learn about Dear ImGui:
18 // - FAQ https://dearimgui.com/faq
19 // - Getting Started https://dearimgui.com/getting-started
20 // - Documentation https://dearimgui.com/docs (same as your local docs/ folder).
21 // - Introduction, links and more at the top of imgui.cpp
22
23 // CHANGELOG
24 // (minor and older changes stripped away, please see git history for details)
25 // 2024-10-07: OpenGL: Changed default texture sampler to Clamp instead of Repeat/Wrap.
26 // 2024-06-28: OpenGL: ImGui_ImplOpenGL3_NewFrame() recreates font texture if it has been destroyed by ImGui_ImplOpenGL3_DestroyFontsTexture(). (#7748)
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 "-Wunknown-warning-option" // warning: ignore unknown flags
129 #pragma clang diagnostic ignored "-Wold-style-cast" // warning: use of old-style cast
130 #pragma clang diagnostic ignored "-Wsign-conversion" // warning: implicit conversion changes signedness
131 #pragma clang diagnostic ignored "-Wunused-macros" // warning: macro is not used
132 #pragma clang diagnostic ignored "-Wnonportable-system-include-path"
133 #pragma clang diagnostic ignored "-Wcast-function-type" // warning: cast between incompatible function types (for loader)
134 #endif
135 #if defined(__GNUC__)
136 #pragma GCC diagnostic push
137 #pragma GCC diagnostic ignored "-Wpragmas" // warning: unknown option after '#pragma GCC diagnostic' kind
138 #pragma GCC diagnostic ignored "-Wunknown-warning-option" // warning: unknown warning group 'xxx'
139 #pragma GCC diagnostic ignored "-Wcast-function-type" // warning: cast between incompatible function types (for loader)
140 #endif
141
142 // GL includes
143 #if defined(IMGUI_IMPL_OPENGL_ES2)
144 #if (defined(__APPLE__) && (TARGET_OS_IOS || TARGET_OS_TV))
145 #include <OpenGLES/ES2/gl.h> // Use GL ES 2
146 #else
147 #include <GLES2/gl2.h> // Use GL ES 2
148 #endif
149 #if defined(__EMSCRIPTEN__)
150 #ifndef GL_GLEXT_PROTOTYPES
151 #define GL_GLEXT_PROTOTYPES
152 #endif
153 #include <GLES2/gl2ext.h>
154 #endif
155 #elif defined(IMGUI_IMPL_OPENGL_ES3)
156 #if (defined(__APPLE__) && (TARGET_OS_IOS || TARGET_OS_TV))
157 #include <OpenGLES/ES3/gl.h> // Use GL ES 3
158 #else
159 #include <GLES3/gl3.h> // Use GL ES 3
160 #endif
161 #elif !defined(IMGUI_IMPL_OPENGL_LOADER_CUSTOM)
162 // Modern desktop OpenGL doesn't have a standard portable header file to load OpenGL function pointers.
163 // Helper libraries are often used for this purpose! Here we are using our own minimal custom loader based on gl3w.
164 // In the rest of your app/engine, you can use another loader of your choice (gl3w, glew, glad, glbinding, glext, glLoadGen, etc.).
165 // If you happen to be developing a new feature for this backend (imgui_impl_opengl3.cpp):
166 // - You may need to regenerate imgui_impl_opengl3_loader.h to add new symbols. See https://github.com/dearimgui/gl3w_stripped
167 // 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
168 // - You can temporarily use an unstripped version. See https://github.com/dearimgui/gl3w_stripped/releases
169 // Changes to this backend using new APIs should be accompanied by a regenerated stripped loader version.
170 #define IMGL3W_IMPL
171 #include "imgui_impl_opengl3_loader.h"
172 #endif
173
174 // Vertex arrays are not supported on ES2/WebGL1 unless Emscripten which uses an extension
175 #ifndef IMGUI_IMPL_OPENGL_ES2
176 #define IMGUI_IMPL_OPENGL_USE_VERTEX_ARRAY
177 #elif defined(__EMSCRIPTEN__)
178 #define IMGUI_IMPL_OPENGL_USE_VERTEX_ARRAY
179 #define glBindVertexArray glBindVertexArrayOES
180 #define glGenVertexArrays glGenVertexArraysOES
181 #define glDeleteVertexArrays glDeleteVertexArraysOES
182 #define GL_VERTEX_ARRAY_BINDING GL_VERTEX_ARRAY_BINDING_OES
183 #endif
184
185 // Desktop GL 2.0+ has extension and glPolygonMode() which GL ES and WebGL don't have..
186 // A desktop ES context can technically compile fine with our loader, so we also perform a runtime checks
187 #if !defined(IMGUI_IMPL_OPENGL_ES2) && !defined(IMGUI_IMPL_OPENGL_ES3)
188 #define IMGUI_IMPL_OPENGL_HAS_EXTENSIONS // has glGetIntegerv(GL_NUM_EXTENSIONS)
189 #define IMGUI_IMPL_OPENGL_MAY_HAVE_POLYGON_MODE // may have glPolygonMode()
190 #endif
191
192 // Desktop GL 2.1+ and GL ES 3.0+ have glBindBuffer() with GL_PIXEL_UNPACK_BUFFER target.
193 #if !defined(IMGUI_IMPL_OPENGL_ES2)
194 #define IMGUI_IMPL_OPENGL_MAY_HAVE_BIND_BUFFER_PIXEL_UNPACK
195 #endif
196
197 // Desktop GL 3.1+ has GL_PRIMITIVE_RESTART state
198 #if !defined(IMGUI_IMPL_OPENGL_ES2) && !defined(IMGUI_IMPL_OPENGL_ES3) && defined(GL_VERSION_3_1)
199 #define IMGUI_IMPL_OPENGL_MAY_HAVE_PRIMITIVE_RESTART
200 #endif
201
202 // Desktop GL 3.2+ has glDrawElementsBaseVertex() which GL ES and WebGL don't have.
203 #if !defined(IMGUI_IMPL_OPENGL_ES2) && !defined(IMGUI_IMPL_OPENGL_ES3) && defined(GL_VERSION_3_2)
204 #define IMGUI_IMPL_OPENGL_MAY_HAVE_VTX_OFFSET
205 #endif
206
207 // Desktop GL 3.3+ and GL ES 3.0+ have glBindSampler()
208 #if !defined(IMGUI_IMPL_OPENGL_ES2) && (defined(IMGUI_IMPL_OPENGL_ES3) || defined(GL_VERSION_3_3))
209 #define IMGUI_IMPL_OPENGL_MAY_HAVE_BIND_SAMPLER
210 #endif
211
212 // [Debugging]
213 //#define IMGUI_IMPL_OPENGL_DEBUG
214 #ifdef IMGUI_IMPL_OPENGL_DEBUG
215 #include <stdio.h>
216 #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
217 #else
218 #define GL_CALL(_CALL) _CALL // Call without error check
219 #endif
220
221 // OpenGL Data
222 struct ImGui_ImplOpenGL3_Data
223 {
224 GLuint GlVersion; // Extracted at runtime using GL_MAJOR_VERSION, GL_MINOR_VERSION queries (e.g. 320 for GL 3.2)
225 char GlslVersionString[32]; // Specified by user or detected based on compile time GL settings.
226 bool GlProfileIsES2;
227 bool GlProfileIsES3;
228 bool GlProfileIsCompat;
229 GLint GlProfileMask;
230 GLuint FontTexture;
231 GLuint ShaderHandle;
232 GLint AttribLocationTex; // Uniforms location
233 GLint AttribLocationProjMtx;
234 GLuint AttribLocationVtxPos; // Vertex attributes location
235 GLuint AttribLocationVtxUV;
236 GLuint AttribLocationVtxColor;
237 unsigned int VboHandle, ElementsHandle;
238 GLsizeiptr VertexBufferSize;
239 GLsizeiptr IndexBufferSize;
240 bool HasPolygonMode;
241 bool HasClipOrigin;
242 bool UseBufferSubData;
243
244 ImGui_ImplOpenGL3_Data() { memset((void*)this, 0, sizeof(*this)); }
245 };
246
247 // Backend data stored in io.BackendRendererUserData to allow support for multiple Dear ImGui contexts
248 // It is STRONGLY preferred that you use docking branch with multi-viewports (== single Dear ImGui context + multiple windows) instead of multiple Dear ImGui contexts.
249 static ImGui_ImplOpenGL3_Data* ImGui_ImplOpenGL3_GetBackendData()
250 {
251 return ImGui::GetCurrentContext() ? (ImGui_ImplOpenGL3_Data*)ImGui::GetIO().BackendRendererUserData : nullptr;
252 }
253
254 // OpenGL vertex attribute state (for ES 1.0 and ES 2.0 only)
255 #ifndef IMGUI_IMPL_OPENGL_USE_VERTEX_ARRAY
256 struct ImGui_ImplOpenGL3_VtxAttribState
257 {
258 GLint Enabled, Size, Type, Normalized, Stride;
259 GLvoid* Ptr;
260
261 void GetState(GLint index)
262 {
263 glGetVertexAttribiv(index, GL_VERTEX_ATTRIB_ARRAY_ENABLED, &Enabled);
264 glGetVertexAttribiv(index, GL_VERTEX_ATTRIB_ARRAY_SIZE, &Size);
265 glGetVertexAttribiv(index, GL_VERTEX_ATTRIB_ARRAY_TYPE, &Type);
266 glGetVertexAttribiv(index, GL_VERTEX_ATTRIB_ARRAY_NORMALIZED, &Normalized);
267 glGetVertexAttribiv(index, GL_VERTEX_ATTRIB_ARRAY_STRIDE, &Stride);
268 glGetVertexAttribPointerv(index, GL_VERTEX_ATTRIB_ARRAY_POINTER, &Ptr);
269 }
270 void SetState(GLint index)
271 {
272 glVertexAttribPointer(index, Size, Type, (GLboolean)Normalized, Stride, Ptr);
273 if (Enabled) glEnableVertexAttribArray(index); else glDisableVertexAttribArray(index);
274 }
275 };
276 #endif
277
278 // Functions
279 bool ImGui_ImplOpenGL3_Init(const char* glsl_version)
280 {
281 ImGuiIO& io = ImGui::GetIO();
282 IMGUI_CHECKVERSION();
283 IM_ASSERT(io.BackendRendererUserData == nullptr && "Already initialized a renderer backend!");
284
285 // Initialize our loader
286 #if !defined(IMGUI_IMPL_OPENGL_ES2) && !defined(IMGUI_IMPL_OPENGL_ES3) && !defined(IMGUI_IMPL_OPENGL_LOADER_CUSTOM)
287 if (imgl3wInit() != 0)
288 {
289 fprintf(stderr, "Failed to initialize OpenGL loader!\n");
290 return false;
291 }
292 #endif
293
294 // Setup backend capabilities flags
295 ImGui_ImplOpenGL3_Data* bd = IM_NEW(ImGui_ImplOpenGL3_Data)();
296 io.BackendRendererUserData = (void*)bd;
297 io.BackendRendererName = "imgui_impl_opengl3";
298
299 // Query for GL version (e.g. 320 for GL 3.2)
300 const char* gl_version_str = (const char*)glGetString(GL_VERSION);
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 GLint major = 0;
308 GLint minor = 0;
309 glGetIntegerv(GL_MAJOR_VERSION, &major);
310 glGetIntegerv(GL_MINOR_VERSION, &minor);
311 if (major == 0 && minor == 0)
312 sscanf(gl_version_str, "%d.%d", &major, &minor); // Query GL_VERSION in desktop GL 2.x, the string will start with "<major>.<minor>"
313 bd->GlVersion = (GLuint)(major * 100 + minor * 10);
314 #if defined(GL_CONTEXT_PROFILE_MASK)
315 if (bd->GlVersion >= 320)
316 glGetIntegerv(GL_CONTEXT_PROFILE_MASK, &bd->GlProfileMask);
317 bd->GlProfileIsCompat = (bd->GlProfileMask & GL_CONTEXT_COMPATIBILITY_PROFILE_BIT) != 0;
318 #endif
319
320 #if defined(IMGUI_IMPL_OPENGL_ES3)
321 bd->GlProfileIsES3 = true;
322 #else
323 if (strncmp(gl_version_str, "OpenGL ES 3", 11) == 0)
324 bd->GlProfileIsES3 = true;
325 #endif
326
327 bd->UseBufferSubData = false;
328 /*
329 // Query vendor to enable glBufferSubData kludge
330 #ifdef _WIN32
331 if (const char* vendor = (const char*)glGetString(GL_VENDOR))
332 if (strncmp(vendor, "Intel", 5) == 0)
333 bd->UseBufferSubData = true;
334 #endif
335 */
336 #endif
337
338 #ifdef IMGUI_IMPL_OPENGL_DEBUG
339 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]
340 #endif
341
342 #ifdef IMGUI_IMPL_OPENGL_MAY_HAVE_VTX_OFFSET
343 if (bd->GlVersion >= 320)
344 io.BackendFlags |= ImGuiBackendFlags_RendererHasVtxOffset; // We can honor the ImDrawCmd::VtxOffset field, allowing for large meshes.
345 #endif
346
347 // Store GLSL version string so we can refer to it later in case we recreate shaders.
348 // Note: GLSL version is NOT the same as GL version. Leave this to nullptr if unsure.
349 if (glsl_version == nullptr)
350 {
351 #if defined(IMGUI_IMPL_OPENGL_ES2)
352 glsl_version = "#version 100";
353 #elif defined(IMGUI_IMPL_OPENGL_ES3)
354 glsl_version = "#version 300 es";
355 #elif defined(__APPLE__)
356 glsl_version = "#version 150";
357 #else
358 glsl_version = "#version 130";
359 #endif
360 }
361 IM_ASSERT((int)strlen(glsl_version) + 2 < IM_ARRAYSIZE(bd->GlslVersionString));
362 strcpy(bd->GlslVersionString, glsl_version);
363 strcat(bd->GlslVersionString, "\n");
364
365 // Make an arbitrary GL call (we don't actually need the result)
366 // IF YOU GET A CRASH HERE: it probably means the OpenGL function loader didn't do its job. Let us know!
367 GLint current_texture;
368 glGetIntegerv(GL_TEXTURE_BINDING_2D, &current_texture);
369
370 // Detect extensions we support
371 #ifdef IMGUI_IMPL_OPENGL_MAY_HAVE_POLYGON_MODE
372 bd->HasPolygonMode = (!bd->GlProfileIsES2 && !bd->GlProfileIsES3);
373 #endif
374 bd->HasClipOrigin = (bd->GlVersion >= 450);
375 #ifdef IMGUI_IMPL_OPENGL_HAS_EXTENSIONS
376 GLint num_extensions = 0;
377 glGetIntegerv(GL_NUM_EXTENSIONS, &num_extensions);
378 for (GLint i = 0; i < num_extensions; i++)
379 {
380 const char* extension = (const char*)glGetStringi(GL_EXTENSIONS, i);
381 if (extension != nullptr && strcmp(extension, "GL_ARB_clip_control") == 0)
382 bd->HasClipOrigin = true;
383 }
384 #endif
385
386 return true;
387 }
388
389 void ImGui_ImplOpenGL3_Shutdown()
390 {
391 ImGui_ImplOpenGL3_Data* bd = ImGui_ImplOpenGL3_GetBackendData();
392 IM_ASSERT(bd != nullptr && "No renderer backend to shutdown, or already shutdown?");
393 ImGuiIO& io = ImGui::GetIO();
394
395 ImGui_ImplOpenGL3_DestroyDeviceObjects();
396 io.BackendRendererName = nullptr;
397 io.BackendRendererUserData = nullptr;
398 io.BackendFlags &= ~ImGuiBackendFlags_RendererHasVtxOffset;
399 IM_DELETE(bd);
400 }
401
402 void ImGui_ImplOpenGL3_NewFrame()
403 {
404 ImGui_ImplOpenGL3_Data* bd = ImGui_ImplOpenGL3_GetBackendData();
405 IM_ASSERT(bd != nullptr && "Context or backend not initialized! Did you call ImGui_ImplOpenGL3_Init()?");
406
407 if (!bd->ShaderHandle)
408 ImGui_ImplOpenGL3_CreateDeviceObjects();
409 if (!bd->FontTexture)
410 ImGui_ImplOpenGL3_CreateFontsTexture();
411 }
412
413 static void ImGui_ImplOpenGL3_SetupRenderState(ImDrawData* draw_data, int fb_width, int fb_height, GLuint vertex_array_object)
414 {
415 ImGui_ImplOpenGL3_Data* bd = ImGui_ImplOpenGL3_GetBackendData();
416
417 // Setup render state: alpha-blending enabled, no face culling, no depth testing, scissor enabled, polygon fill
418 glEnable(GL_BLEND);
419 glBlendEquation(GL_FUNC_ADD);
420 glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
421 glDisable(GL_CULL_FACE);
422 glDisable(GL_DEPTH_TEST);
423 glDisable(GL_STENCIL_TEST);
424 glEnable(GL_SCISSOR_TEST);
425 #ifdef IMGUI_IMPL_OPENGL_MAY_HAVE_PRIMITIVE_RESTART
426 if (bd->GlVersion >= 310)
427 glDisable(GL_PRIMITIVE_RESTART);
428 #endif
429 #ifdef IMGUI_IMPL_OPENGL_MAY_HAVE_POLYGON_MODE
430 if (bd->HasPolygonMode)
431 glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
432 #endif
433
434 // Support for GL 4.5 rarely used glClipControl(GL_UPPER_LEFT)
435 #if defined(GL_CLIP_ORIGIN)
436 bool clip_origin_lower_left = true;
437 if (bd->HasClipOrigin)
438 {
439 GLenum current_clip_origin = 0; glGetIntegerv(GL_CLIP_ORIGIN, (GLint*)&current_clip_origin);
440 if (current_clip_origin == GL_UPPER_LEFT)
441 clip_origin_lower_left = false;
442 }
443 #endif
444
445 // Setup viewport, orthographic projection matrix
446 // 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.
447 GL_CALL(glViewport(0, 0, (GLsizei)fb_width, (GLsizei)fb_height));
448 float L = draw_data->DisplayPos.x;
449 float R = draw_data->DisplayPos.x + draw_data->DisplaySize.x;
450 float T = draw_data->DisplayPos.y;
451 float B = draw_data->DisplayPos.y + draw_data->DisplaySize.y;
452 #if defined(GL_CLIP_ORIGIN)
453 if (!clip_origin_lower_left) { float tmp = T; T = B; B = tmp; } // Swap top and bottom if origin is upper left
454 #endif
455 const float ortho_projection[4][4] =
456 {
457 { 2.0f/(R-L), 0.0f, 0.0f, 0.0f },
458 { 0.0f, 2.0f/(T-B), 0.0f, 0.0f },
459 { 0.0f, 0.0f, -1.0f, 0.0f },
460 { (R+L)/(L-R), (T+B)/(B-T), 0.0f, 1.0f },
461 };
462 glUseProgram(bd->ShaderHandle);
463 glUniform1i(bd->AttribLocationTex, 0);
464 glUniformMatrix4fv(bd->AttribLocationProjMtx, 1, GL_FALSE, &ortho_projection[0][0]);
465
466 #ifdef IMGUI_IMPL_OPENGL_MAY_HAVE_BIND_SAMPLER
467 if (bd->GlVersion >= 330 || bd->GlProfileIsES3)
468 glBindSampler(0, 0); // We use combined texture/sampler state. Applications using GL 3.3 and GL ES 3.0 may set that otherwise.
469 #endif
470
471 (void)vertex_array_object;
472 #ifdef IMGUI_IMPL_OPENGL_USE_VERTEX_ARRAY
473 glBindVertexArray(vertex_array_object);
474 #endif
475
476 // Bind vertex/index buffers and setup attributes for ImDrawVert
477 GL_CALL(glBindBuffer(GL_ARRAY_BUFFER, bd->VboHandle));
478 GL_CALL(glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, bd->ElementsHandle));
479 GL_CALL(glEnableVertexAttribArray(bd->AttribLocationVtxPos));
480 GL_CALL(glEnableVertexAttribArray(bd->AttribLocationVtxUV));
481 GL_CALL(glEnableVertexAttribArray(bd->AttribLocationVtxColor));
482 GL_CALL(glVertexAttribPointer(bd->AttribLocationVtxPos, 2, GL_FLOAT, GL_FALSE, sizeof(ImDrawVert), (GLvoid*)offsetof(ImDrawVert, pos)));
483 GL_CALL(glVertexAttribPointer(bd->AttribLocationVtxUV, 2, GL_FLOAT, GL_FALSE, sizeof(ImDrawVert), (GLvoid*)offsetof(ImDrawVert, uv)));
484 GL_CALL(glVertexAttribPointer(bd->AttribLocationVtxColor, 4, GL_UNSIGNED_BYTE, GL_TRUE, sizeof(ImDrawVert), (GLvoid*)offsetof(ImDrawVert, col)));
485 }
486
487 // OpenGL3 Render function.
488 // Note that this implementation is little overcomplicated because we are saving/setting up/restoring every OpenGL state explicitly.
489 // This is in order to be able to run within an OpenGL engine that doesn't do so.
490 void ImGui_ImplOpenGL3_RenderDrawData(ImDrawData* draw_data)
491 {
492 // Avoid rendering when minimized, scale coordinates for retina displays (screen coordinates != framebuffer coordinates)
493 int fb_width = (int)(draw_data->DisplaySize.x * draw_data->FramebufferScale.x);
494 int fb_height = (int)(draw_data->DisplaySize.y * draw_data->FramebufferScale.y);
495 if (fb_width <= 0 || fb_height <= 0)
496 return;
497
498 ImGui_ImplOpenGL3_Data* bd = ImGui_ImplOpenGL3_GetBackendData();
499
500 // Backup GL state
501 GLenum last_active_texture; glGetIntegerv(GL_ACTIVE_TEXTURE, (GLint*)&last_active_texture);
502 glActiveTexture(GL_TEXTURE0);
503 GLuint last_program; glGetIntegerv(GL_CURRENT_PROGRAM, (GLint*)&last_program);
504 GLuint last_texture; glGetIntegerv(GL_TEXTURE_BINDING_2D, (GLint*)&last_texture);
505 #ifdef IMGUI_IMPL_OPENGL_MAY_HAVE_BIND_SAMPLER
506 GLuint last_sampler; if (bd->GlVersion >= 330 || bd->GlProfileIsES3) { glGetIntegerv(GL_SAMPLER_BINDING, (GLint*)&last_sampler); } else { last_sampler = 0; }
507 #endif
508 GLuint last_array_buffer; glGetIntegerv(GL_ARRAY_BUFFER_BINDING, (GLint*)&last_array_buffer);
509 #ifndef IMGUI_IMPL_OPENGL_USE_VERTEX_ARRAY
510 // This is part of VAO on OpenGL 3.0+ and OpenGL ES 3.0+.
511 GLint last_element_array_buffer; glGetIntegerv(GL_ELEMENT_ARRAY_BUFFER_BINDING, &last_element_array_buffer);
512 ImGui_ImplOpenGL3_VtxAttribState last_vtx_attrib_state_pos; last_vtx_attrib_state_pos.GetState(bd->AttribLocationVtxPos);
513 ImGui_ImplOpenGL3_VtxAttribState last_vtx_attrib_state_uv; last_vtx_attrib_state_uv.GetState(bd->AttribLocationVtxUV);
514 ImGui_ImplOpenGL3_VtxAttribState last_vtx_attrib_state_color; last_vtx_attrib_state_color.GetState(bd->AttribLocationVtxColor);
515 #endif
516 #ifdef IMGUI_IMPL_OPENGL_USE_VERTEX_ARRAY
517 GLuint last_vertex_array_object; glGetIntegerv(GL_VERTEX_ARRAY_BINDING, (GLint*)&last_vertex_array_object);
518 #endif
519 #ifdef IMGUI_IMPL_OPENGL_MAY_HAVE_POLYGON_MODE
520 GLint last_polygon_mode[2]; if (bd->HasPolygonMode) { glGetIntegerv(GL_POLYGON_MODE, last_polygon_mode); }
521 #endif
522 GLint last_viewport[4]; glGetIntegerv(GL_VIEWPORT, last_viewport);
523 GLint last_scissor_box[4]; glGetIntegerv(GL_SCISSOR_BOX, last_scissor_box);
524 GLenum last_blend_src_rgb; glGetIntegerv(GL_BLEND_SRC_RGB, (GLint*)&last_blend_src_rgb);
525 GLenum last_blend_dst_rgb; glGetIntegerv(GL_BLEND_DST_RGB, (GLint*)&last_blend_dst_rgb);
526 GLenum last_blend_src_alpha; glGetIntegerv(GL_BLEND_SRC_ALPHA, (GLint*)&last_blend_src_alpha);
527 GLenum last_blend_dst_alpha; glGetIntegerv(GL_BLEND_DST_ALPHA, (GLint*)&last_blend_dst_alpha);
528 GLenum last_blend_equation_rgb; glGetIntegerv(GL_BLEND_EQUATION_RGB, (GLint*)&last_blend_equation_rgb);
529 GLenum last_blend_equation_alpha; glGetIntegerv(GL_BLEND_EQUATION_ALPHA, (GLint*)&last_blend_equation_alpha);
530 GLboolean last_enable_blend = glIsEnabled(GL_BLEND);
531 GLboolean last_enable_cull_face = glIsEnabled(GL_CULL_FACE);
532 GLboolean last_enable_depth_test = glIsEnabled(GL_DEPTH_TEST);
533 GLboolean last_enable_stencil_test = glIsEnabled(GL_STENCIL_TEST);
534 GLboolean last_enable_scissor_test = glIsEnabled(GL_SCISSOR_TEST);
535 #ifdef IMGUI_IMPL_OPENGL_MAY_HAVE_PRIMITIVE_RESTART
536 GLboolean last_enable_primitive_restart = (bd->GlVersion >= 310) ? glIsEnabled(GL_PRIMITIVE_RESTART) : GL_FALSE;
537 #endif
538
539 // Setup desired GL state
540 // Recreate the VAO every time (this is to easily allow multiple GL contexts to be rendered to. VAO are not shared among GL contexts)
541 // The renderer would actually work without any VAO bound, but then our VertexAttrib calls would overwrite the default one currently bound.
542 GLuint vertex_array_object = 0;
543 #ifdef IMGUI_IMPL_OPENGL_USE_VERTEX_ARRAY
544 GL_CALL(glGenVertexArrays(1, &vertex_array_object));
545 #endif
546 ImGui_ImplOpenGL3_SetupRenderState(draw_data, fb_width, fb_height, vertex_array_object);
547
548 // Will project scissor/clipping rectangles into framebuffer space
549 ImVec2 clip_off = draw_data->DisplayPos; // (0,0) unless using multi-viewports
550 ImVec2 clip_scale = draw_data->FramebufferScale; // (1,1) unless using retina display which are often (2,2)
551
552 // Render command lists
553 for (int n = 0; n < draw_data->CmdListsCount; n++)
554 {
555 const ImDrawList* draw_list = draw_data->CmdLists[n];
556
557 // Upload vertex/index buffers
558 // - OpenGL drivers are in a very sorry state nowadays....
559 // During 2021 we attempted to switch from glBufferData() to orphaning+glBufferSubData() following reports
560 // of leaks on Intel GPU when using multi-viewports on Windows.
561 // - After this we kept hearing of various display corruptions issues. We started disabling on non-Intel GPU, but issues still got reported on Intel.
562 // - We are now back to using exclusively glBufferData(). So bd->UseBufferSubData IS ALWAYS FALSE in this code.
563 // We are keeping the old code path for a while in case people finding new issues may want to test the bd->UseBufferSubData path.
564 // - See https://github.com/ocornut/imgui/issues/4468 and please report any corruption issues.
565 const GLsizeiptr vtx_buffer_size = (GLsizeiptr)draw_list->VtxBuffer.Size * (int)sizeof(ImDrawVert);
566 const GLsizeiptr idx_buffer_size = (GLsizeiptr)draw_list->IdxBuffer.Size * (int)sizeof(ImDrawIdx);
567 if (bd->UseBufferSubData)
568 {
569 if (bd->VertexBufferSize < vtx_buffer_size)
570 {
571 bd->VertexBufferSize = vtx_buffer_size;
572 GL_CALL(glBufferData(GL_ARRAY_BUFFER, bd->VertexBufferSize, nullptr, GL_STREAM_DRAW));
573 }
574 if (bd->IndexBufferSize < idx_buffer_size)
575 {
576 bd->IndexBufferSize = idx_buffer_size;
577 GL_CALL(glBufferData(GL_ELEMENT_ARRAY_BUFFER, bd->IndexBufferSize, nullptr, GL_STREAM_DRAW));
578 }
579 GL_CALL(glBufferSubData(GL_ARRAY_BUFFER, 0, vtx_buffer_size, (const GLvoid*)draw_list->VtxBuffer.Data));
580 GL_CALL(glBufferSubData(GL_ELEMENT_ARRAY_BUFFER, 0, idx_buffer_size, (const GLvoid*)draw_list->IdxBuffer.Data));
581 }
582 else
583 {
584 GL_CALL(glBufferData(GL_ARRAY_BUFFER, vtx_buffer_size, (const GLvoid*)draw_list->VtxBuffer.Data, GL_STREAM_DRAW));
585 GL_CALL(glBufferData(GL_ELEMENT_ARRAY_BUFFER, idx_buffer_size, (const GLvoid*)draw_list->IdxBuffer.Data, GL_STREAM_DRAW));
586 }
587
588 for (int cmd_i = 0; cmd_i < draw_list->CmdBuffer.Size; cmd_i++)
589 {
590 const ImDrawCmd* pcmd = &draw_list->CmdBuffer[cmd_i];
591 if (pcmd->UserCallback != nullptr)
592 {
593 // User callback, registered via ImDrawList::AddCallback()
594 // (ImDrawCallback_ResetRenderState is a special callback value used by the user to request the renderer to reset render state.)
595 if (pcmd->UserCallback == ImDrawCallback_ResetRenderState)
596 ImGui_ImplOpenGL3_SetupRenderState(draw_data, fb_width, fb_height, vertex_array_object);
597 else
598 pcmd->UserCallback(draw_list, pcmd);
599 }
600 else
601 {
602 // Project scissor/clipping rectangles into framebuffer space
603 ImVec2 clip_min((pcmd->ClipRect.x - clip_off.x) * clip_scale.x, (pcmd->ClipRect.y - clip_off.y) * clip_scale.y);
604 ImVec2 clip_max((pcmd->ClipRect.z - clip_off.x) * clip_scale.x, (pcmd->ClipRect.w - clip_off.y) * clip_scale.y);
605 if (clip_max.x <= clip_min.x || clip_max.y <= clip_min.y)
606 continue;
607
608 // Apply scissor/clipping rectangle (Y is inverted in OpenGL)
609 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)));
610
611 // Bind texture, Draw
612 GL_CALL(glBindTexture(GL_TEXTURE_2D, (GLuint)(intptr_t)pcmd->GetTexID()));
613 #ifdef IMGUI_IMPL_OPENGL_MAY_HAVE_VTX_OFFSET
614 if (bd->GlVersion >= 320)
615 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));
616 else
617 #endif
618 GL_CALL(glDrawElements(GL_TRIANGLES, (GLsizei)pcmd->ElemCount, sizeof(ImDrawIdx) == 2 ? GL_UNSIGNED_SHORT : GL_UNSIGNED_INT, (void*)(intptr_t)(pcmd->IdxOffset * sizeof(ImDrawIdx))));
619 }
620 }
621 }
622
623 // Destroy the temporary VAO
624 #ifdef IMGUI_IMPL_OPENGL_USE_VERTEX_ARRAY
625 GL_CALL(glDeleteVertexArrays(1, &vertex_array_object));
626 #endif
627
628 // Restore modified GL state
629 // 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.
630 if (last_program == 0 || glIsProgram(last_program)) glUseProgram(last_program);
631 glBindTexture(GL_TEXTURE_2D, last_texture);
632 #ifdef IMGUI_IMPL_OPENGL_MAY_HAVE_BIND_SAMPLER
633 if (bd->GlVersion >= 330 || bd->GlProfileIsES3)
634 glBindSampler(0, last_sampler);
635 #endif
636 glActiveTexture(last_active_texture);
637 #ifdef IMGUI_IMPL_OPENGL_USE_VERTEX_ARRAY
638 glBindVertexArray(last_vertex_array_object);
639 #endif
640 glBindBuffer(GL_ARRAY_BUFFER, last_array_buffer);
641 #ifndef IMGUI_IMPL_OPENGL_USE_VERTEX_ARRAY
642 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, last_element_array_buffer);
643 last_vtx_attrib_state_pos.SetState(bd->AttribLocationVtxPos);
644 last_vtx_attrib_state_uv.SetState(bd->AttribLocationVtxUV);
645 last_vtx_attrib_state_color.SetState(bd->AttribLocationVtxColor);
646 #endif
647 glBlendEquationSeparate(last_blend_equation_rgb, last_blend_equation_alpha);
648 glBlendFuncSeparate(last_blend_src_rgb, last_blend_dst_rgb, last_blend_src_alpha, last_blend_dst_alpha);
649 if (last_enable_blend) glEnable(GL_BLEND); else glDisable(GL_BLEND);
650 if (last_enable_cull_face) glEnable(GL_CULL_FACE); else glDisable(GL_CULL_FACE);
651 if (last_enable_depth_test) glEnable(GL_DEPTH_TEST); else glDisable(GL_DEPTH_TEST);
652 if (last_enable_stencil_test) glEnable(GL_STENCIL_TEST); else glDisable(GL_STENCIL_TEST);
653 if (last_enable_scissor_test) glEnable(GL_SCISSOR_TEST); else glDisable(GL_SCISSOR_TEST);
654 #ifdef IMGUI_IMPL_OPENGL_MAY_HAVE_PRIMITIVE_RESTART
655 if (bd->GlVersion >= 310) { if (last_enable_primitive_restart) glEnable(GL_PRIMITIVE_RESTART); else glDisable(GL_PRIMITIVE_RESTART); }
656 #endif
657
658 #ifdef IMGUI_IMPL_OPENGL_MAY_HAVE_POLYGON_MODE
659 // Desktop OpenGL 3.0 and OpenGL 3.1 had separate polygon draw modes for front-facing and back-facing faces of polygons
660 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]); } }
661 #endif // IMGUI_IMPL_OPENGL_MAY_HAVE_POLYGON_MODE
662
663 glViewport(last_viewport[0], last_viewport[1], (GLsizei)last_viewport[2], (GLsizei)last_viewport[3]);
664 glScissor(last_scissor_box[0], last_scissor_box[1], (GLsizei)last_scissor_box[2], (GLsizei)last_scissor_box[3]);
665 (void)bd; // Not all compilation paths use this
666 }
667
668 bool ImGui_ImplOpenGL3_CreateFontsTexture()
669 {
670 ImGuiIO& io = ImGui::GetIO();
671 ImGui_ImplOpenGL3_Data* bd = ImGui_ImplOpenGL3_GetBackendData();
672
673 // Build texture atlas
674 unsigned char* pixels;
675 int width, height;
676 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.
677
678 // Upload texture to graphics system
679 // (Bilinear sampling is required by default. Set 'io.Fonts->Flags |= ImFontAtlasFlags_NoBakedLines' or 'style.AntiAliasedLinesUseTex = false' to allow point/nearest sampling)
680 GLint last_texture;
681 GL_CALL(glGetIntegerv(GL_TEXTURE_BINDING_2D, &last_texture));
682 GL_CALL(glGenTextures(1, &bd->FontTexture));
683 GL_CALL(glBindTexture(GL_TEXTURE_2D, bd->FontTexture));
684 GL_CALL(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR));
685 GL_CALL(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR));
686 GL_CALL(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE));
687 GL_CALL(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE));
688 #ifdef GL_UNPACK_ROW_LENGTH // Not on WebGL/ES
689 GL_CALL(glPixelStorei(GL_UNPACK_ROW_LENGTH, 0));
690 #endif
691 GL_CALL(glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, pixels));
692
693 // Store identifier
694 io.Fonts->SetTexID((ImTextureID)(intptr_t)bd->FontTexture);
695
696 // Restore state
697 GL_CALL(glBindTexture(GL_TEXTURE_2D, last_texture));
698
699 return true;
700 }
701
702 void ImGui_ImplOpenGL3_DestroyFontsTexture()
703 {
704 ImGuiIO& io = ImGui::GetIO();
705 ImGui_ImplOpenGL3_Data* bd = ImGui_ImplOpenGL3_GetBackendData();
706 if (bd->FontTexture)
707 {
708 glDeleteTextures(1, &bd->FontTexture);
709 io.Fonts->SetTexID(0);
710 bd->FontTexture = 0;
711 }
712 }
713
714 // 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.
715 static bool CheckShader(GLuint handle, const char* desc)
716 {
717 ImGui_ImplOpenGL3_Data* bd = ImGui_ImplOpenGL3_GetBackendData();
718 GLint status = 0, log_length = 0;
719 glGetShaderiv(handle, GL_COMPILE_STATUS, &status);
720 glGetShaderiv(handle, GL_INFO_LOG_LENGTH, &log_length);
721 if ((GLboolean)status == GL_FALSE)
722 fprintf(stderr, "ERROR: ImGui_ImplOpenGL3_CreateDeviceObjects: failed to compile %s! With GLSL: %s\n", desc, bd->GlslVersionString);
723 if (log_length > 1)
724 {
725 ImVector<char> buf;
726 buf.resize((int)(log_length + 1));
727 glGetShaderInfoLog(handle, log_length, nullptr, (GLchar*)buf.begin());
728 fprintf(stderr, "%s\n", buf.begin());
729 }
730 return (GLboolean)status == GL_TRUE;
731 }
732
733 // If you get an error please report on GitHub. You may try different GL context version or GLSL version.
734 static bool CheckProgram(GLuint handle, const char* desc)
735 {
736 ImGui_ImplOpenGL3_Data* bd = ImGui_ImplOpenGL3_GetBackendData();
737 GLint status = 0, log_length = 0;
738 glGetProgramiv(handle, GL_LINK_STATUS, &status);
739 glGetProgramiv(handle, GL_INFO_LOG_LENGTH, &log_length);
740 if ((GLboolean)status == GL_FALSE)
741 fprintf(stderr, "ERROR: ImGui_ImplOpenGL3_CreateDeviceObjects: failed to link %s! With GLSL %s\n", desc, bd->GlslVersionString);
742 if (log_length > 1)
743 {
744 ImVector<char> buf;
745 buf.resize((int)(log_length + 1));
746 glGetProgramInfoLog(handle, log_length, nullptr, (GLchar*)buf.begin());
747 fprintf(stderr, "%s\n", buf.begin());
748 }
749 return (GLboolean)status == GL_TRUE;
750 }
751
752 bool ImGui_ImplOpenGL3_CreateDeviceObjects()
753 {
754 ImGui_ImplOpenGL3_Data* bd = ImGui_ImplOpenGL3_GetBackendData();
755
756 // Backup GL state
757 GLint last_texture, last_array_buffer;
758 glGetIntegerv(GL_TEXTURE_BINDING_2D, &last_texture);
759 glGetIntegerv(GL_ARRAY_BUFFER_BINDING, &last_array_buffer);
760 #ifdef IMGUI_IMPL_OPENGL_MAY_HAVE_BIND_BUFFER_PIXEL_UNPACK
761 GLint last_pixel_unpack_buffer = 0;
762 if (bd->GlVersion >= 210) { glGetIntegerv(GL_PIXEL_UNPACK_BUFFER_BINDING, &last_pixel_unpack_buffer); glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0); }
763 #endif
764 #ifdef IMGUI_IMPL_OPENGL_USE_VERTEX_ARRAY
765 GLint last_vertex_array;
766 glGetIntegerv(GL_VERTEX_ARRAY_BINDING, &last_vertex_array);
767 #endif
768
769 // Parse GLSL version string
770 int glsl_version = 130;
771 sscanf(bd->GlslVersionString, "#version %d", &glsl_version);
772
773 const GLchar* vertex_shader_glsl_120 =
774 "uniform mat4 ProjMtx;\n"
775 "attribute vec2 Position;\n"
776 "attribute vec2 UV;\n"
777 "attribute vec4 Color;\n"
778 "varying vec2 Frag_UV;\n"
779 "varying vec4 Frag_Color;\n"
780 "void main()\n"
781 "{\n"
782 " Frag_UV = UV;\n"
783 " Frag_Color = Color;\n"
784 " gl_Position = ProjMtx * vec4(Position.xy,0,1);\n"
785 "}\n";
786
787 const GLchar* vertex_shader_glsl_130 =
788 "uniform mat4 ProjMtx;\n"
789 "in vec2 Position;\n"
790 "in vec2 UV;\n"
791 "in vec4 Color;\n"
792 "out vec2 Frag_UV;\n"
793 "out vec4 Frag_Color;\n"
794 "void main()\n"
795 "{\n"
796 " Frag_UV = UV;\n"
797 " Frag_Color = Color;\n"
798 " gl_Position = ProjMtx * vec4(Position.xy,0,1);\n"
799 "}\n";
800
801 const GLchar* vertex_shader_glsl_300_es =
802 "precision highp float;\n"
803 "layout (location = 0) in vec2 Position;\n"
804 "layout (location = 1) in vec2 UV;\n"
805 "layout (location = 2) in vec4 Color;\n"
806 "uniform mat4 ProjMtx;\n"
807 "out vec2 Frag_UV;\n"
808 "out vec4 Frag_Color;\n"
809 "void main()\n"
810 "{\n"
811 " Frag_UV = UV;\n"
812 " Frag_Color = Color;\n"
813 " gl_Position = ProjMtx * vec4(Position.xy,0,1);\n"
814 "}\n";
815
816 const GLchar* vertex_shader_glsl_410_core =
817 "layout (location = 0) in vec2 Position;\n"
818 "layout (location = 1) in vec2 UV;\n"
819 "layout (location = 2) in vec4 Color;\n"
820 "uniform mat4 ProjMtx;\n"
821 "out vec2 Frag_UV;\n"
822 "out vec4 Frag_Color;\n"
823 "void main()\n"
824 "{\n"
825 " Frag_UV = UV;\n"
826 " Frag_Color = Color;\n"
827 " gl_Position = ProjMtx * vec4(Position.xy,0,1);\n"
828 "}\n";
829
830 const GLchar* fragment_shader_glsl_120 =
831 "#ifdef GL_ES\n"
832 " precision mediump float;\n"
833 "#endif\n"
834 "uniform sampler2D Texture;\n"
835 "varying vec2 Frag_UV;\n"
836 "varying vec4 Frag_Color;\n"
837 "void main()\n"
838 "{\n"
839 " gl_FragColor = Frag_Color * texture2D(Texture, Frag_UV.st);\n"
840 "}\n";
841
842 const GLchar* fragment_shader_glsl_130 =
843 "uniform sampler2D Texture;\n"
844 "in vec2 Frag_UV;\n"
845 "in vec4 Frag_Color;\n"
846 "out vec4 Out_Color;\n"
847 "void main()\n"
848 "{\n"
849 " Out_Color = Frag_Color * texture(Texture, Frag_UV.st);\n"
850 "}\n";
851
852 const GLchar* fragment_shader_glsl_300_es =
853 "precision mediump float;\n"
854 "uniform sampler2D Texture;\n"
855 "in vec2 Frag_UV;\n"
856 "in vec4 Frag_Color;\n"
857 "layout (location = 0) out vec4 Out_Color;\n"
858 "void main()\n"
859 "{\n"
860 " Out_Color = Frag_Color * texture(Texture, Frag_UV.st);\n"
861 "}\n";
862
863 const GLchar* fragment_shader_glsl_410_core =
864 "in vec2 Frag_UV;\n"
865 "in vec4 Frag_Color;\n"
866 "uniform sampler2D Texture;\n"
867 "layout (location = 0) out vec4 Out_Color;\n"
868 "void main()\n"
869 "{\n"
870 " Out_Color = Frag_Color * texture(Texture, Frag_UV.st);\n"
871 "}\n";
872
873 // Select shaders matching our GLSL versions
874 const GLchar* vertex_shader = nullptr;
875 const GLchar* fragment_shader = nullptr;
876 if (glsl_version < 130)
877 {
878 vertex_shader = vertex_shader_glsl_120;
879 fragment_shader = fragment_shader_glsl_120;
880 }
881 else if (glsl_version >= 410)
882 {
883 vertex_shader = vertex_shader_glsl_410_core;
884 fragment_shader = fragment_shader_glsl_410_core;
885 }
886 else if (glsl_version == 300)
887 {
888 vertex_shader = vertex_shader_glsl_300_es;
889 fragment_shader = fragment_shader_glsl_300_es;
890 }
891 else
892 {
893 vertex_shader = vertex_shader_glsl_130;
894 fragment_shader = fragment_shader_glsl_130;
895 }
896
897 // Create shaders
898 const GLchar* vertex_shader_with_version[2] = { bd->GlslVersionString, vertex_shader };
899 GLuint vert_handle;
900 GL_CALL(vert_handle = glCreateShader(GL_VERTEX_SHADER));
901 glShaderSource(vert_handle, 2, vertex_shader_with_version, nullptr);
902 glCompileShader(vert_handle);
903 CheckShader(vert_handle, "vertex shader");
904
905 const GLchar* fragment_shader_with_version[2] = { bd->GlslVersionString, fragment_shader };
906 GLuint frag_handle;
907 GL_CALL(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
934 ImGui_ImplOpenGL3_CreateFontsTexture();
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
949 void ImGui_ImplOpenGL3_DestroyDeviceObjects()
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; }
955 ImGui_ImplOpenGL3_DestroyFontsTexture();
956 }
957
958 //-----------------------------------------------------------------------------
959
960 #if defined(__GNUC__)
961 #pragma GCC diagnostic pop
962 #endif
963 #if defined(__clang__)
964 #pragma clang diagnostic pop
965 #endif
966
967 #endif // #ifndef IMGUI_DISABLE