imgui_impl_opengl3.cpp 45 KB

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