2020-10-12 15:34:22 +00:00
// dear imgui: Renderer Backend for modern OpenGL with shaders / programmatic pipeline
2019-09-22 21:19:04 +00:00
// - Desktop GL: 2.x 3.x 4.x
2019-03-03 22:14:30 +00:00
// - Embedded GL: ES 2.0 (WebGL 1.0), ES 3.0 (WebGL 2.0)
2020-10-12 15:34:22 +00:00
// This needs to be used along with a Platform Backend (e.g. GLFW, SDL, Win32, custom..)
2018-06-08 17:37:33 +00:00
// Implemented features:
2019-10-16 09:23:15 +00:00
// [X] Renderer: User texture binding. Use 'GLuint' OpenGL texture identifier as void*/ImTextureID. Read the FAQ about ImTextureID!
2019-11-20 10:58:25 +00:00
// [x] Renderer: Desktop GL only: Support for large meshes (64k+ vertices) with 16-bit indices.
2018-06-08 17:37:33 +00:00
2021-06-19 18:04:16 +00:00
// You can use unmodified imgui_impl_* files in your project. See examples/ folder for examples of using this.
2021-05-27 11:59:35 +00:00
// Prefer including the entire imgui/ repository into your project (either as a copy or as a submodule), and only build the backends you need.
2020-10-14 10:22:53 +00:00
// If you are new to Dear ImGui, read documentation from the docs/ folder + read the top of imgui.cpp.
// Read online: https://github.com/ocornut/imgui/tree/master/docs
2018-07-04 17:06:28 +00:00
2018-08-04 14:09:56 +00:00
// CHANGELOG
2018-06-08 17:37:33 +00:00
// (minor and older changes stripped away, please see git history for details)
2021-06-25 02:55:32 +00:00
// 2021-06-25: OpenGL: Use OES_vertex_array extension on Emscripten + backup/restore current state.
2021-06-19 18:04:16 +00:00
// 2021-06-21: OpenGL: Destroy individual vertex/fragment shader objects right after they are linked into the main shader.
2021-05-24 21:38:50 +00:00
// 2021-05-24: OpenGL: Access GL_CLIP_ORIGIN when "GL_ARB_clip_control" extension is detected, inside of just OpenGL 4.5 version.
2021-02-07 11:36:54 +00:00
// 2021-05-19: OpenGL: Replaced direct access to ImDrawCmd::TextureId with a call to ImDrawCmd::GetTexID(). (will become a requirement)
2021-04-06 10:36:52 +00:00
// 2021-04-06: OpenGL: Don't try to read GL_CLIP_ORIGIN unless we're OpenGL 4.5 or greater.
2021-02-17 18:29:07 +00:00
// 2021-02-18: OpenGL: Change blending equation to preserve alpha in output buffer.
2021-01-03 14:55:12 +00:00
// 2021-01-03: OpenGL: Backup, setup and restore GL_STENCIL_TEST state.
// 2020-10-23: OpenGL: Backup, setup and restore GL_PRIMITIVE_RESTART state.
2020-10-15 03:39:08 +00:00
// 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)
2020-09-17 07:33:48 +00:00
// 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.
2020-07-10 12:36:00 +00:00
// 2020-07-10: OpenGL: Added support for glad2 OpenGL loader.
2020-05-08 15:29:14 +00:00
// 2020-05-08: OpenGL: Made default GLSL version 150 (instead of 130) on OSX.
2020-04-21 00:13:06 +00:00
// 2020-04-21: OpenGL: Fixed handling of glClipControl(GL_UPPER_LEFT) by inverting projection matrix.
2020-04-12 16:01:10 +00:00
// 2020-04-12: OpenGL: Fixed context version check mistakenly testing for 4.0+ instead of 3.2+ to enable ImGuiBackendFlags_RendererHasVtxOffset.
2020-03-24 17:42:18 +00:00
// 2020-03-24: OpenGL: Added support for glbinding 2.x OpenGL loader.
// 2020-01-07: OpenGL: Added support for glbinding 3.x OpenGL loader.
2019-10-25 09:56:36 +00:00
// 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.
2019-09-22 21:19:04 +00:00
// 2019-09-22: OpenGL: Detect default GL loader using __has_include compiler facility.
2019-09-16 10:08:23 +00:00
// 2019-09-16: OpenGL: Tweak initialization code to allow application calling ImGui_ImplOpenGL3_CreateFontsTexture() before the first NewFrame() call.
2019-05-29 14:29:17 +00:00
// 2019-05-29: OpenGL: Desktop GL only: Added support for large mesh (64K+ vertices), enable ImGuiBackendFlags_RendererHasVtxOffset flag.
2019-04-30 20:28:29 +00:00
// 2019-04-30: OpenGL: Added support for special ImDrawCallback_ResetRenderState callback to reset render state.
2019-03-29 15:17:04 +00:00
// 2019-03-29: OpenGL: Not calling glBindBuffer more than necessary in the render loop.
2020-08-03 19:19:12 +00:00
// 2019-03-15: OpenGL: Added a GL call + comments in ImGui_ImplOpenGL3_Init() to detect uninitialized GL function loaders early.
2019-03-03 22:32:40 +00:00
// 2019-03-03: OpenGL: Fix support for ES 2.0 (WebGL 1.0).
2019-02-20 13:31:19 +00:00
// 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.
2019-02-11 17:38:07 +00:00
// 2019-02-11: OpenGL: Projecting clipping rectangles correctly using draw_data->FramebufferScale to allow multi-viewports for retina display.
2019-02-01 14:13:54 +00:00
// 2019-02-01: OpenGL: Using GLSL 410 shaders for any version over 410 (e.g. 430, 450).
2018-11-30 17:18:15 +00:00
// 2018-11-30: Misc: Setting up io.BackendRendererName so it can be displayed in the About Window.
2019-02-20 13:31:19 +00:00
// 2018-11-13: OpenGL: Support for GL 4.5's glClipControl(GL_UPPER_LEFT) / GL_CLIP_ORIGIN.
2018-08-28 13:56:03 +00:00
// 2018-08-29: OpenGL: Added support for more OpenGL loaders: glew and glad, with comments indicative that any loader can be used.
2018-08-09 15:42:53 +00:00
// 2018-08-09: OpenGL: Default to OpenGL ES 3 on iOS and Android. GLSL version default to "#version 300 ES".
2018-07-30 12:00:53 +00:00
// 2018-07-30: OpenGL: Support for GLSL 300 ES and 410 core. Fixes for Emscripten compilation.
2018-07-10 16:29:57 +00:00
// 2018-07-10: OpenGL: Support for more GLSL versions (based on the GLSL version string). Added error output when shaders fail to compile/link.
2018-06-08 17:37:33 +00:00
// 2018-06-08: Misc: Extracted imgui_impl_opengl3.cpp/.h away from the old combined GLFW/SDL+OpenGL3 examples.
// 2018-06-08: OpenGL: Use draw_data->DisplayPos and draw_data->DisplaySize to setup projection matrix and clipping rectangle.
// 2018-05-25: OpenGL: Removed unnecessary backup/restore of GL_ELEMENT_ARRAY_BUFFER_BINDING since this is part of the VAO state.
// 2018-05-14: OpenGL: Making the call to glBindSampler() optional so 3.2 context won't fail if the function is a NULL pointer.
// 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".
// 2018-02-23: OpenGL: Create the VAO in the render function so the setup can more easily be used with multiple shared GL context.
// 2018-02-16: Misc: Obsoleted the io.RenderDrawListsFn callback and exposed ImGui_ImplSdlGL3_RenderDrawData() in the .h file so you can call it yourself.
// 2018-01-07: OpenGL: Changed GLSL shader version from 330 to 150.
// 2017-09-01: OpenGL: Save and restore current bound sampler. Save and restore current polygon mode.
// 2017-05-01: OpenGL: Fixed save and restore of current blend func state.
// 2017-05-01: OpenGL: Fixed save and restore of current GL_ACTIVE_TEXTURE.
// 2016-09-05: OpenGL: Fixed save and restore of current scissor rectangle.
// 2016-07-29: OpenGL: Explicitly setting GL_UNPACK_ROW_LENGTH to reduce issues because SDL changes it. (#752)
2018-07-10 16:29:57 +00:00
//----------------------------------------
// OpenGL GLSL GLSL
// version version string
//----------------------------------------
// 2.0 110 "#version 110"
2019-03-13 10:35:34 +00:00
// 2.1 120 "#version 120"
2019-03-03 22:14:30 +00:00
// 3.0 130 "#version 130"
// 3.1 140 "#version 140"
2018-07-10 16:29:57 +00:00
// 3.2 150 "#version 150"
2019-03-03 22:14:30 +00:00
// 3.3 330 "#version 330 core"
// 4.0 400 "#version 400 core"
2018-07-30 11:52:18 +00:00
// 4.1 410 "#version 410 core"
2019-03-03 22:14:30 +00:00
// 4.2 420 "#version 410 core"
// 4.3 430 "#version 430 core"
// ES 2.0 100 "#version 100" = WebGL 1.0
// ES 3.0 300 "#version 300 es" = WebGL 2.0
2018-07-10 16:29:57 +00:00
//----------------------------------------
2018-06-08 17:37:33 +00:00
# if defined(_MSC_VER) && !defined(_CRT_SECURE_NO_WARNINGS)
# define _CRT_SECURE_NO_WARNINGS
# endif
# include "imgui.h"
# include "imgui_impl_opengl3.h"
2018-07-10 14:09:34 +00:00
# include <stdio.h>
2018-07-11 10:23:46 +00:00
# if defined(_MSC_VER) && _MSC_VER <= 1500 // MSVC 2008 or earlier
# include <stddef.h> // intptr_t
# else
# include <stdint.h> // intptr_t
# endif
2018-07-09 09:32:20 +00:00
2019-09-22 21:19:04 +00:00
// GL includes
2019-03-03 22:32:40 +00:00
# if defined(IMGUI_IMPL_OPENGL_ES2)
# include <GLES2/gl2.h>
2021-06-25 02:55:32 +00:00
# if defined(__EMSCRIPTEN__)
# ifndef GL_GLEXT_PROTOTYPES
# define GL_GLEXT_PROTOTYPES
# endif
# include <GLES2/gl2ext.h>
# endif
2019-03-03 22:32:40 +00:00
# elif defined(IMGUI_IMPL_OPENGL_ES3)
2019-06-18 08:55:33 +00:00
# if (defined(__APPLE__) && (TARGET_OS_IOS || TARGET_OS_TV))
2019-10-25 09:56:36 +00:00
# include <OpenGLES/ES3/gl.h> // Use GL ES 3
2019-06-18 08:55:33 +00:00
# else
2019-10-25 09:56:36 +00:00
# include <GLES3/gl3.h> // Use GL ES 3
2019-06-18 08:55:33 +00:00
# endif
2018-07-30 11:52:18 +00:00
# else
2019-03-03 22:14:30 +00:00
// About Desktop OpenGL function loaders:
// Modern desktop OpenGL doesn't have a standard portable header file to load OpenGL function pointers.
// Helper libraries are often used for this purpose! Here we are supporting a few common ones (gl3w, glew, glad).
// You may use another loader/header of your choice (glext, glLoadGen, etc.), or chose to manually implement your own.
2018-08-04 14:09:56 +00:00
# if defined(IMGUI_IMPL_OPENGL_LOADER_GL3W)
2020-03-24 17:42:18 +00:00
# include <GL/gl3w.h> // Needs to be initialized with gl3wInit() in user's code
2018-08-04 14:09:56 +00:00
# elif defined(IMGUI_IMPL_OPENGL_LOADER_GLEW)
2020-03-24 17:42:18 +00:00
# include <GL/glew.h> // Needs to be initialized with glewInit() in user's code.
2018-08-04 14:09:56 +00:00
# elif defined(IMGUI_IMPL_OPENGL_LOADER_GLAD)
2020-03-24 17:42:18 +00:00
# include <glad/glad.h> // Needs to be initialized with gladLoadGL() in user's code.
2020-07-01 21:13:59 +00:00
# elif defined(IMGUI_IMPL_OPENGL_LOADER_GLAD2)
# include <glad/gl.h> // Needs to be initialized with gladLoadGL(...) or gladLoaderLoadGL() in user's code.
2020-03-24 17:42:18 +00:00
# elif defined(IMGUI_IMPL_OPENGL_LOADER_GLBINDING2)
2020-04-23 20:58:45 +00:00
# ifndef GLFW_INCLUDE_NONE
2020-03-24 17:42:18 +00:00
# define GLFW_INCLUDE_NONE // GLFW including OpenGL headers causes ambiguity or multiple definition errors.
2020-04-23 20:58:45 +00:00
# endif
2020-03-24 17:42:18 +00:00
# include <glbinding/Binding.h> // Needs to be initialized with glbinding::Binding::initialize() in user's code.
# include <glbinding/gl/gl.h>
using namespace gl ;
# elif defined(IMGUI_IMPL_OPENGL_LOADER_GLBINDING3)
2020-04-23 20:58:45 +00:00
# ifndef GLFW_INCLUDE_NONE
2020-03-24 17:42:18 +00:00
# define GLFW_INCLUDE_NONE // GLFW including OpenGL headers causes ambiguity or multiple definition errors.
2020-04-23 20:58:45 +00:00
# endif
2020-03-24 17:42:18 +00:00
# include <glbinding/glbinding.h> // Needs to be initialized with glbinding::initialize() in user's code.
# include <glbinding/gl/gl.h>
2020-01-07 13:32:34 +00:00
using namespace gl ;
2018-08-04 14:09:56 +00:00
# else
# include IMGUI_IMPL_OPENGL_LOADER_CUSTOM
# endif
2018-07-30 12:00:53 +00:00
# endif
2018-06-08 17:37:33 +00:00
2021-06-25 02:55:32 +00:00
// Vertex arrays are not supported on ES2/WebGL1 unless Emscripten which uses an extension
# ifndef IMGUI_IMPL_OPENGL_ES2
# define IMGUI_IMPL_OPENGL_USE_VERTEX_ARRAY
# elif defined(__EMSCRIPTEN__)
# define IMGUI_IMPL_OPENGL_USE_VERTEX_ARRAY
# define glBindVertexArray glBindVertexArrayOES
# define glGenVertexArrays glGenVertexArraysOES
# define glDeleteVertexArrays glDeleteVertexArraysOES
# define GL_VERTEX_ARRAY_BINDING GL_VERTEX_ARRAY_BINDING_OES
# endif
2019-10-25 09:56:36 +00:00
// Desktop GL 3.2+ has glDrawElementsBaseVertex() which GL ES and WebGL don't have.
2020-09-17 07:33:48 +00:00
# if !defined(IMGUI_IMPL_OPENGL_ES2) && !defined(IMGUI_IMPL_OPENGL_ES3) && defined(GL_VERSION_3_2)
# define IMGUI_IMPL_OPENGL_MAY_HAVE_VTX_OFFSET
# endif
// Desktop GL 3.3+ has glBindSampler()
# if !defined(IMGUI_IMPL_OPENGL_ES2) && !defined(IMGUI_IMPL_OPENGL_ES3) && defined(GL_VERSION_3_3)
# define IMGUI_IMPL_OPENGL_MAY_HAVE_BIND_SAMPLER
2019-05-29 13:53:36 +00:00
# endif
2020-10-20 08:00:26 +00:00
// Desktop GL 3.1+ has GL_PRIMITIVE_RESTART state
# if !defined(IMGUI_IMPL_OPENGL_ES2) && !defined(IMGUI_IMPL_OPENGL_ES3) && defined(GL_VERSION_3_1)
# define IMGUI_IMPL_OPENGL_MAY_HAVE_PRIMITIVE_RESTART
# endif
2021-05-24 21:38:50 +00:00
// Desktop GL use extension detection
# if !defined(IMGUI_IMPL_OPENGL_ES2) && !defined(IMGUI_IMPL_OPENGL_ES3)
# define IMGUI_IMPL_OPENGL_MAY_HAVE_EXTENSIONS
# endif
2018-06-08 17:37:33 +00:00
// OpenGL Data
2020-04-12 16:01:10 +00:00
static GLuint g_GlVersion = 0 ; // Extracted at runtime using GL_MAJOR_VERSION, GL_MINOR_VERSION queries (e.g. 320 for GL 3.2)
2019-10-25 09:56:36 +00:00
static char g_GlslVersionString [ 32 ] = " " ; // Specified by user or detected based on compile time GL settings.
2018-06-08 17:37:33 +00:00
static GLuint g_FontTexture = 0 ;
2021-06-19 18:04:16 +00:00
static GLuint g_ShaderHandle = 0 ;
2020-06-05 10:04:55 +00:00
static GLint g_AttribLocationTex = 0 , g_AttribLocationProjMtx = 0 ; // Uniforms location
static GLuint g_AttribLocationVtxPos = 0 , g_AttribLocationVtxUV = 0 , g_AttribLocationVtxColor = 0 ; // Vertex attributes location
2018-06-08 17:37:33 +00:00
static unsigned int g_VboHandle = 0 , g_ElementsHandle = 0 ;
2021-05-24 21:38:50 +00:00
static bool g_HasClipOrigin = false ;
2018-06-08 17:37:33 +00:00
// Functions
bool ImGui_ImplOpenGL3_Init ( const char * glsl_version )
{
2020-04-12 16:01:10 +00:00
// Query for GL version (e.g. 320 for GL 3.2)
2019-10-25 09:40:50 +00:00
# if !defined(IMGUI_IMPL_OPENGL_ES2)
2020-10-15 03:39:08 +00:00
GLint major = 0 ;
GLint minor = 0 ;
2019-10-25 09:56:36 +00:00
glGetIntegerv ( GL_MAJOR_VERSION , & major ) ;
glGetIntegerv ( GL_MINOR_VERSION , & minor ) ;
2020-10-15 03:39:08 +00:00
if ( major = = 0 & & minor = = 0 )
{
// Query GL_VERSION in desktop GL 2.x, the string will start with "<major>.<minor>"
const char * gl_version = ( const char * ) glGetString ( GL_VERSION ) ;
sscanf ( gl_version , " %d.%d " , & major , & minor ) ;
}
2020-06-05 10:04:55 +00:00
g_GlVersion = ( GLuint ) ( major * 100 + minor * 10 ) ;
2019-10-25 09:40:50 +00:00
# else
2020-04-12 16:01:10 +00:00
g_GlVersion = 200 ; // GLES 2
2019-10-25 09:40:50 +00:00
# endif
2020-10-12 15:34:22 +00:00
// Setup backend capabilities flags
2018-11-30 17:18:15 +00:00
ImGuiIO & io = ImGui : : GetIO ( ) ;
io . BackendRendererName = " imgui_impl_opengl3 " ;
2020-09-17 07:33:48 +00:00
# ifdef IMGUI_IMPL_OPENGL_MAY_HAVE_VTX_OFFSET
2020-04-12 16:01:10 +00:00
if ( g_GlVersion > = 320 )
2019-10-25 09:40:50 +00:00
io . BackendFlags | = ImGuiBackendFlags_RendererHasVtxOffset ; // We can honor the ImDrawCmd::VtxOffset field, allowing for large meshes.
2019-05-29 14:29:17 +00:00
# endif
2018-11-30 17:18:15 +00:00
2020-01-06 14:21:33 +00:00
// Store GLSL version string so we can refer to it later in case we recreate shaders.
2019-10-25 09:56:36 +00:00
// Note: GLSL version is NOT the same as GL version. Leave this to NULL if unsure.
2019-03-03 22:32:40 +00:00
# if defined(IMGUI_IMPL_OPENGL_ES2)
if ( glsl_version = = NULL )
glsl_version = " #version 100 " ;
# elif defined(IMGUI_IMPL_OPENGL_ES3)
2018-08-09 15:42:53 +00:00
if ( glsl_version = = NULL )
glsl_version = " #version 300 es " ;
2020-05-08 15:29:14 +00:00
# elif defined(__APPLE__)
if ( glsl_version = = NULL )
glsl_version = " #version 150 " ;
2018-08-09 15:42:53 +00:00
# else
2018-06-08 17:37:33 +00:00
if ( glsl_version = = NULL )
2018-07-10 16:29:57 +00:00
glsl_version = " #version 130 " ;
2018-08-09 15:42:53 +00:00
# endif
2018-07-10 16:29:57 +00:00
IM_ASSERT ( ( int ) strlen ( glsl_version ) + 2 < IM_ARRAYSIZE ( g_GlslVersionString ) ) ;
strcpy ( g_GlslVersionString , glsl_version ) ;
strcat ( g_GlslVersionString , " \n " ) ;
2018-11-30 17:18:15 +00:00
2020-08-03 19:19:12 +00:00
// Debugging construct to make it easily visible in the IDE and debugger which GL loader has been selected.
2019-09-22 21:19:04 +00:00
// The code actually never uses the 'gl_loader' variable! It is only here so you can read it!
2019-10-15 13:20:27 +00:00
// If auto-detection fails or doesn't select the same GL loader file as used by your application,
2019-09-22 21:19:04 +00:00
// you are likely to get a crash below.
// You can explicitly select a loader by using '#define IMGUI_IMPL_OPENGL_LOADER_XXX' in imconfig.h or compiler command-line.
const char * gl_loader = " Unknown " ;
IM_UNUSED ( gl_loader ) ;
# if defined(IMGUI_IMPL_OPENGL_LOADER_GL3W)
gl_loader = " GL3W " ;
# elif defined(IMGUI_IMPL_OPENGL_LOADER_GLEW)
gl_loader = " GLEW " ;
# elif defined(IMGUI_IMPL_OPENGL_LOADER_GLAD)
gl_loader = " GLAD " ;
2020-07-01 21:13:59 +00:00
# elif defined(IMGUI_IMPL_OPENGL_LOADER_GLAD2)
gl_loader = " GLAD2 " ;
2020-02-20 14:49:15 +00:00
# elif defined(IMGUI_IMPL_OPENGL_LOADER_GLBINDING2)
gl_loader = " glbinding2 " ;
# elif defined(IMGUI_IMPL_OPENGL_LOADER_GLBINDING3)
gl_loader = " glbinding3 " ;
2020-03-24 17:42:18 +00:00
# elif defined(IMGUI_IMPL_OPENGL_LOADER_CUSTOM)
gl_loader = " custom " ;
# else
gl_loader = " none " ;
2019-09-22 21:19:04 +00:00
# endif
2020-08-03 19:19:12 +00:00
// Make an arbitrary GL call (we don't actually need the result)
2019-03-15 12:09:07 +00:00
// IF YOU GET A CRASH HERE: it probably means that you haven't initialized the OpenGL function loader used by this code.
// Desktop OpenGL 3/4 need a function loader. See the IMGUI_IMPL_OPENGL_LOADER_xxx explanation above.
GLint current_texture ;
glGetIntegerv ( GL_TEXTURE_BINDING_2D , & current_texture ) ;
2021-05-24 21:38:50 +00:00
// Detect extensions we support
g_HasClipOrigin = ( g_GlVersion > = 450 ) ;
# ifdef IMGUI_IMPL_OPENGL_MAY_HAVE_EXTENSIONS
GLint num_extensions = 0 ;
glGetIntegerv ( GL_NUM_EXTENSIONS , & num_extensions ) ;
for ( GLint i = 0 ; i < num_extensions ; i + + )
{
const char * extension = ( const char * ) glGetStringi ( GL_EXTENSIONS , i ) ;
2021-06-05 14:27:31 +00:00
if ( extension ! = NULL & & strcmp ( extension , " GL_ARB_clip_control " ) = = 0 )
2021-05-24 21:38:50 +00:00
g_HasClipOrigin = true ;
}
# endif
2018-06-08 17:37:33 +00:00
return true ;
}
void ImGui_ImplOpenGL3_Shutdown ( )
{
ImGui_ImplOpenGL3_DestroyDeviceObjects ( ) ;
}
void ImGui_ImplOpenGL3_NewFrame ( )
{
2019-09-16 10:08:23 +00:00
if ( ! g_ShaderHandle )
2018-06-08 17:37:33 +00:00
ImGui_ImplOpenGL3_CreateDeviceObjects ( ) ;
}
2019-04-30 20:15:59 +00:00
static void ImGui_ImplOpenGL3_SetupRenderState ( ImDrawData * draw_data , int fb_width , int fb_height , GLuint vertex_array_object )
{
// Setup render state: alpha-blending enabled, no face culling, no depth testing, scissor enabled, polygon fill
glEnable ( GL_BLEND ) ;
glBlendEquation ( GL_FUNC_ADD ) ;
2021-02-17 18:29:07 +00:00
glBlendFuncSeparate ( GL_SRC_ALPHA , GL_ONE_MINUS_SRC_ALPHA , GL_ONE , GL_ONE_MINUS_SRC_ALPHA ) ;
2019-04-30 20:15:59 +00:00
glDisable ( GL_CULL_FACE ) ;
glDisable ( GL_DEPTH_TEST ) ;
2021-01-03 14:55:12 +00:00
glDisable ( GL_STENCIL_TEST ) ;
2019-04-30 20:15:59 +00:00
glEnable ( GL_SCISSOR_TEST ) ;
2020-10-20 08:00:26 +00:00
# ifdef IMGUI_IMPL_OPENGL_MAY_HAVE_PRIMITIVE_RESTART
if ( g_GlVersion > = 310 )
glDisable ( GL_PRIMITIVE_RESTART ) ;
# endif
2019-04-30 20:15:59 +00:00
# ifdef GL_POLYGON_MODE
glPolygonMode ( GL_FRONT_AND_BACK , GL_FILL ) ;
# endif
2020-04-21 00:13:06 +00:00
// Support for GL 4.5 rarely used glClipControl(GL_UPPER_LEFT)
2021-04-06 10:36:52 +00:00
# if defined(GL_CLIP_ORIGIN)
2021-01-04 18:12:35 +00:00
bool clip_origin_lower_left = true ;
2021-05-24 21:38:50 +00:00
if ( g_HasClipOrigin )
2021-04-06 10:36:52 +00:00
{
GLenum current_clip_origin = 0 ; glGetIntegerv ( GL_CLIP_ORIGIN , ( GLint * ) & current_clip_origin ) ;
if ( current_clip_origin = = GL_UPPER_LEFT )
clip_origin_lower_left = false ;
}
2020-04-21 00:13:06 +00:00
# endif
2019-04-30 20:15:59 +00:00
// Setup viewport, orthographic projection matrix
2019-06-06 14:13:30 +00:00
// 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.
2019-04-30 20:15:59 +00:00
glViewport ( 0 , 0 , ( GLsizei ) fb_width , ( GLsizei ) fb_height ) ;
float L = draw_data - > DisplayPos . x ;
float R = draw_data - > DisplayPos . x + draw_data - > DisplaySize . x ;
float T = draw_data - > DisplayPos . y ;
float B = draw_data - > DisplayPos . y + draw_data - > DisplaySize . y ;
2021-04-06 10:36:52 +00:00
# if defined(GL_CLIP_ORIGIN)
2020-04-21 00:13:06 +00:00
if ( ! clip_origin_lower_left ) { float tmp = T ; T = B ; B = tmp ; } // Swap top and bottom if origin is upper left
2021-01-04 18:12:35 +00:00
# endif
2019-04-30 20:15:59 +00:00
const float ortho_projection [ 4 ] [ 4 ] =
{
{ 2.0f / ( R - L ) , 0.0f , 0.0f , 0.0f } ,
{ 0.0f , 2.0f / ( T - B ) , 0.0f , 0.0f } ,
{ 0.0f , 0.0f , - 1.0f , 0.0f } ,
{ ( R + L ) / ( L - R ) , ( T + B ) / ( B - T ) , 0.0f , 1.0f } ,
} ;
glUseProgram ( g_ShaderHandle ) ;
glUniform1i ( g_AttribLocationTex , 0 ) ;
glUniformMatrix4fv ( g_AttribLocationProjMtx , 1 , GL_FALSE , & ortho_projection [ 0 ] [ 0 ] ) ;
2021-01-04 18:12:35 +00:00
2020-09-17 07:33:48 +00:00
# ifdef IMGUI_IMPL_OPENGL_MAY_HAVE_BIND_SAMPLER
if ( g_GlVersion > = 330 )
2020-09-10 18:02:45 +00:00
glBindSampler ( 0 , 0 ) ; // We use combined texture/sampler state. Applications using GL 3.3 may set that otherwise.
2019-04-30 20:15:59 +00:00
# endif
2021-01-04 18:12:35 +00:00
2019-04-30 20:15:59 +00:00
( void ) vertex_array_object ;
2021-06-25 02:55:32 +00:00
# ifdef IMGUI_IMPL_OPENGL_USE_VERTEX_ARRAY
2019-04-30 20:15:59 +00:00
glBindVertexArray ( vertex_array_object ) ;
# endif
// Bind vertex/index buffers and setup attributes for ImDrawVert
glBindBuffer ( GL_ARRAY_BUFFER , g_VboHandle ) ;
glBindBuffer ( GL_ELEMENT_ARRAY_BUFFER , g_ElementsHandle ) ;
glEnableVertexAttribArray ( g_AttribLocationVtxPos ) ;
glEnableVertexAttribArray ( g_AttribLocationVtxUV ) ;
glEnableVertexAttribArray ( g_AttribLocationVtxColor ) ;
glVertexAttribPointer ( g_AttribLocationVtxPos , 2 , GL_FLOAT , GL_FALSE , sizeof ( ImDrawVert ) , ( GLvoid * ) IM_OFFSETOF ( ImDrawVert , pos ) ) ;
glVertexAttribPointer ( g_AttribLocationVtxUV , 2 , GL_FLOAT , GL_FALSE , sizeof ( ImDrawVert ) , ( GLvoid * ) IM_OFFSETOF ( ImDrawVert , uv ) ) ;
glVertexAttribPointer ( g_AttribLocationVtxColor , 4 , GL_UNSIGNED_BYTE , GL_TRUE , sizeof ( ImDrawVert ) , ( GLvoid * ) IM_OFFSETOF ( ImDrawVert , col ) ) ;
}
2018-06-08 17:37:33 +00:00
// OpenGL3 Render function.
2020-10-12 11:13:09 +00:00
// Note that this implementation is little overcomplicated because we are saving/setting up/restoring every OpenGL state explicitly.
// This is in order to be able to run within an OpenGL engine that doesn't do so.
2018-06-08 17:37:33 +00:00
void ImGui_ImplOpenGL3_RenderDrawData ( ImDrawData * draw_data )
{
// Avoid rendering when minimized, scale coordinates for retina displays (screen coordinates != framebuffer coordinates)
2019-02-11 17:38:07 +00:00
int fb_width = ( int ) ( draw_data - > DisplaySize . x * draw_data - > FramebufferScale . x ) ;
int fb_height = ( int ) ( draw_data - > DisplaySize . y * draw_data - > FramebufferScale . y ) ;
2018-06-08 17:37:33 +00:00
if ( fb_width < = 0 | | fb_height < = 0 )
return ;
// Backup GL state
GLenum last_active_texture ; glGetIntegerv ( GL_ACTIVE_TEXTURE , ( GLint * ) & last_active_texture ) ;
glActiveTexture ( GL_TEXTURE0 ) ;
2020-06-05 10:04:55 +00:00
GLuint last_program ; glGetIntegerv ( GL_CURRENT_PROGRAM , ( GLint * ) & last_program ) ;
GLuint last_texture ; glGetIntegerv ( GL_TEXTURE_BINDING_2D , ( GLint * ) & last_texture ) ;
2020-09-17 07:33:48 +00:00
# ifdef IMGUI_IMPL_OPENGL_MAY_HAVE_BIND_SAMPLER
GLuint last_sampler ; if ( g_GlVersion > = 330 ) { glGetIntegerv ( GL_SAMPLER_BINDING , ( GLint * ) & last_sampler ) ; } else { last_sampler = 0 ; }
2018-08-04 14:09:56 +00:00
# endif
2020-06-05 10:04:55 +00:00
GLuint last_array_buffer ; glGetIntegerv ( GL_ARRAY_BUFFER_BINDING , ( GLint * ) & last_array_buffer ) ;
2021-06-25 02:55:32 +00:00
# ifdef IMGUI_IMPL_OPENGL_USE_VERTEX_ARRAY
2020-06-05 10:04:55 +00:00
GLuint last_vertex_array_object ; glGetIntegerv ( GL_VERTEX_ARRAY_BINDING , ( GLint * ) & last_vertex_array_object ) ;
2019-03-03 22:32:40 +00:00
# endif
2018-07-30 12:00:53 +00:00
# ifdef GL_POLYGON_MODE
GLint last_polygon_mode [ 2 ] ; glGetIntegerv ( GL_POLYGON_MODE , last_polygon_mode ) ;
# endif
2018-06-08 17:37:33 +00:00
GLint last_viewport [ 4 ] ; glGetIntegerv ( GL_VIEWPORT , last_viewport ) ;
GLint last_scissor_box [ 4 ] ; glGetIntegerv ( GL_SCISSOR_BOX , last_scissor_box ) ;
GLenum last_blend_src_rgb ; glGetIntegerv ( GL_BLEND_SRC_RGB , ( GLint * ) & last_blend_src_rgb ) ;
GLenum last_blend_dst_rgb ; glGetIntegerv ( GL_BLEND_DST_RGB , ( GLint * ) & last_blend_dst_rgb ) ;
GLenum last_blend_src_alpha ; glGetIntegerv ( GL_BLEND_SRC_ALPHA , ( GLint * ) & last_blend_src_alpha ) ;
GLenum last_blend_dst_alpha ; glGetIntegerv ( GL_BLEND_DST_ALPHA , ( GLint * ) & last_blend_dst_alpha ) ;
GLenum last_blend_equation_rgb ; glGetIntegerv ( GL_BLEND_EQUATION_RGB , ( GLint * ) & last_blend_equation_rgb ) ;
GLenum last_blend_equation_alpha ; glGetIntegerv ( GL_BLEND_EQUATION_ALPHA , ( GLint * ) & last_blend_equation_alpha ) ;
GLboolean last_enable_blend = glIsEnabled ( GL_BLEND ) ;
GLboolean last_enable_cull_face = glIsEnabled ( GL_CULL_FACE ) ;
GLboolean last_enable_depth_test = glIsEnabled ( GL_DEPTH_TEST ) ;
2021-01-03 14:55:12 +00:00
GLboolean last_enable_stencil_test = glIsEnabled ( GL_STENCIL_TEST ) ;
2018-06-08 17:37:33 +00:00
GLboolean last_enable_scissor_test = glIsEnabled ( GL_SCISSOR_TEST ) ;
2020-10-20 08:00:26 +00:00
# ifdef IMGUI_IMPL_OPENGL_MAY_HAVE_PRIMITIVE_RESTART
2020-10-23 09:25:26 +00:00
GLboolean last_enable_primitive_restart = ( g_GlVersion > = 310 ) ? glIsEnabled ( GL_PRIMITIVE_RESTART ) : GL_FALSE ;
2020-10-20 08:00:26 +00:00
# endif
2018-06-08 17:37:33 +00:00
2019-04-30 20:15:59 +00:00
// Setup desired GL state
2019-03-29 15:17:04 +00:00
// Recreate the VAO every time (this is to easily allow multiple GL contexts to be rendered to. VAO are not shared among GL contexts)
// The renderer would actually work without any VAO bound, but then our VertexAttrib calls would overwrite the default one currently bound.
GLuint vertex_array_object = 0 ;
2021-06-25 02:55:32 +00:00
# ifdef IMGUI_IMPL_OPENGL_USE_VERTEX_ARRAY
2019-03-29 15:17:04 +00:00
glGenVertexArrays ( 1 , & vertex_array_object ) ;
2019-03-03 22:32:40 +00:00
# endif
2019-04-30 20:15:59 +00:00
ImGui_ImplOpenGL3_SetupRenderState ( draw_data , fb_width , fb_height , vertex_array_object ) ;
2018-06-08 17:37:33 +00:00
2019-02-11 17:38:07 +00:00
// Will project scissor/clipping rectangles into framebuffer space
ImVec2 clip_off = draw_data - > DisplayPos ; // (0,0) unless using multi-viewports
ImVec2 clip_scale = draw_data - > FramebufferScale ; // (1,1) unless using retina display which are often (2,2)
// Render command lists
2018-06-08 17:37:33 +00:00
for ( int n = 0 ; n < draw_data - > CmdListsCount ; n + + )
{
const ImDrawList * cmd_list = draw_data - > CmdLists [ n ] ;
2019-03-29 15:17:04 +00:00
// Upload vertex/index buffers
2020-06-05 10:04:55 +00:00
glBufferData ( GL_ARRAY_BUFFER , ( GLsizeiptr ) cmd_list - > VtxBuffer . Size * ( int ) sizeof ( ImDrawVert ) , ( const GLvoid * ) cmd_list - > VtxBuffer . Data , GL_STREAM_DRAW ) ;
glBufferData ( GL_ELEMENT_ARRAY_BUFFER , ( GLsizeiptr ) cmd_list - > IdxBuffer . Size * ( int ) sizeof ( ImDrawIdx ) , ( const GLvoid * ) cmd_list - > IdxBuffer . Data , GL_STREAM_DRAW ) ;
2018-06-08 17:37:33 +00:00
for ( int cmd_i = 0 ; cmd_i < cmd_list - > CmdBuffer . Size ; cmd_i + + )
{
const ImDrawCmd * pcmd = & cmd_list - > CmdBuffer [ cmd_i ] ;
2019-04-30 20:15:59 +00:00
if ( pcmd - > UserCallback ! = NULL )
2018-06-08 17:37:33 +00:00
{
2019-04-30 20:15:59 +00:00
// User callback, registered via ImDrawList::AddCallback()
// (ImDrawCallback_ResetRenderState is a special callback value used by the user to request the renderer to reset render state.)
if ( pcmd - > UserCallback = = ImDrawCallback_ResetRenderState )
ImGui_ImplOpenGL3_SetupRenderState ( draw_data , fb_width , fb_height , vertex_array_object ) ;
else
pcmd - > UserCallback ( cmd_list , pcmd ) ;
2018-06-08 17:37:33 +00:00
}
else
{
2019-02-11 17:38:07 +00:00
// Project scissor/clipping rectangles into framebuffer space
ImVec4 clip_rect ;
clip_rect . x = ( pcmd - > ClipRect . x - clip_off . x ) * clip_scale . x ;
clip_rect . y = ( pcmd - > ClipRect . y - clip_off . y ) * clip_scale . y ;
clip_rect . z = ( pcmd - > ClipRect . z - clip_off . x ) * clip_scale . x ;
clip_rect . w = ( pcmd - > ClipRect . w - clip_off . y ) * clip_scale . y ;
2018-06-08 17:37:33 +00:00
if ( clip_rect . x < fb_width & & clip_rect . y < fb_height & & clip_rect . z > = 0.0f & & clip_rect . w > = 0.0f )
{
// Apply scissor/clipping rectangle
2020-04-21 00:13:06 +00:00
glScissor ( ( int ) clip_rect . x , ( int ) ( fb_height - clip_rect . w ) , ( int ) ( clip_rect . z - clip_rect . x ) , ( int ) ( clip_rect . w - clip_rect . y ) ) ;
2018-06-08 17:37:33 +00:00
// Bind texture, Draw
2021-02-07 11:36:54 +00:00
glBindTexture ( GL_TEXTURE_2D , ( GLuint ) ( intptr_t ) pcmd - > GetTexID ( ) ) ;
2020-09-17 07:33:48 +00:00
# ifdef IMGUI_IMPL_OPENGL_MAY_HAVE_VTX_OFFSET
2020-04-12 16:01:10 +00:00
if ( g_GlVersion > = 320 )
2019-10-25 09:40:50 +00:00
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 ) ;
else
2019-05-29 13:53:36 +00:00
# endif
2019-10-25 09:56:36 +00:00
glDrawElements ( GL_TRIANGLES , ( GLsizei ) pcmd - > ElemCount , sizeof ( ImDrawIdx ) = = 2 ? GL_UNSIGNED_SHORT : GL_UNSIGNED_INT , ( void * ) ( intptr_t ) ( pcmd - > IdxOffset * sizeof ( ImDrawIdx ) ) ) ;
2018-06-08 17:37:33 +00:00
}
}
}
}
2019-03-29 15:17:04 +00:00
// Destroy the temporary VAO
2021-06-25 02:55:32 +00:00
# ifdef IMGUI_IMPL_OPENGL_USE_VERTEX_ARRAY
2019-03-29 15:17:04 +00:00
glDeleteVertexArrays ( 1 , & vertex_array_object ) ;
2019-03-03 22:32:40 +00:00
# endif
2018-06-08 17:37:33 +00:00
// Restore modified GL state
glUseProgram ( last_program ) ;
glBindTexture ( GL_TEXTURE_2D , last_texture ) ;
2020-09-17 07:33:48 +00:00
# ifdef IMGUI_IMPL_OPENGL_MAY_HAVE_BIND_SAMPLER
if ( g_GlVersion > = 330 )
2020-09-10 18:02:45 +00:00
glBindSampler ( 0 , last_sampler ) ;
2018-07-30 13:38:13 +00:00
# endif
2018-06-08 17:37:33 +00:00
glActiveTexture ( last_active_texture ) ;
2021-06-25 02:55:32 +00:00
# ifdef IMGUI_IMPL_OPENGL_USE_VERTEX_ARRAY
2019-03-29 15:17:04 +00:00
glBindVertexArray ( last_vertex_array_object ) ;
2019-03-03 22:32:40 +00:00
# endif
2018-06-08 17:37:33 +00:00
glBindBuffer ( GL_ARRAY_BUFFER , last_array_buffer ) ;
glBlendEquationSeparate ( last_blend_equation_rgb , last_blend_equation_alpha ) ;
glBlendFuncSeparate ( last_blend_src_rgb , last_blend_dst_rgb , last_blend_src_alpha , last_blend_dst_alpha ) ;
if ( last_enable_blend ) glEnable ( GL_BLEND ) ; else glDisable ( GL_BLEND ) ;
if ( last_enable_cull_face ) glEnable ( GL_CULL_FACE ) ; else glDisable ( GL_CULL_FACE ) ;
if ( last_enable_depth_test ) glEnable ( GL_DEPTH_TEST ) ; else glDisable ( GL_DEPTH_TEST ) ;
2021-01-03 14:55:12 +00:00
if ( last_enable_stencil_test ) glEnable ( GL_STENCIL_TEST ) ; else glDisable ( GL_STENCIL_TEST ) ;
2018-06-08 17:37:33 +00:00
if ( last_enable_scissor_test ) glEnable ( GL_SCISSOR_TEST ) ; else glDisable ( GL_SCISSOR_TEST ) ;
2020-10-20 08:00:26 +00:00
# ifdef IMGUI_IMPL_OPENGL_MAY_HAVE_PRIMITIVE_RESTART
2020-10-23 09:25:26 +00:00
if ( g_GlVersion > = 310 ) { if ( last_enable_primitive_restart ) glEnable ( GL_PRIMITIVE_RESTART ) ; else glDisable ( GL_PRIMITIVE_RESTART ) ; }
2020-10-20 08:00:26 +00:00
# endif
2018-07-30 12:00:53 +00:00
# ifdef GL_POLYGON_MODE
glPolygonMode ( GL_FRONT_AND_BACK , ( GLenum ) last_polygon_mode [ 0 ] ) ;
# endif
2018-06-08 17:37:33 +00:00
glViewport ( last_viewport [ 0 ] , last_viewport [ 1 ] , ( GLsizei ) last_viewport [ 2 ] , ( GLsizei ) last_viewport [ 3 ] ) ;
glScissor ( last_scissor_box [ 0 ] , last_scissor_box [ 1 ] , ( GLsizei ) last_scissor_box [ 2 ] , ( GLsizei ) last_scissor_box [ 3 ] ) ;
}
bool ImGui_ImplOpenGL3_CreateFontsTexture ( )
{
// Build texture atlas
ImGuiIO & io = ImGui : : GetIO ( ) ;
unsigned char * pixels ;
int width , height ;
2019-11-20 10:58:25 +00:00
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.
2018-06-08 17:37:33 +00:00
// Upload texture to graphics system
GLint last_texture ;
glGetIntegerv ( GL_TEXTURE_BINDING_2D , & last_texture ) ;
glGenTextures ( 1 , & g_FontTexture ) ;
glBindTexture ( GL_TEXTURE_2D , g_FontTexture ) ;
glTexParameteri ( GL_TEXTURE_2D , GL_TEXTURE_MIN_FILTER , GL_LINEAR ) ;
glTexParameteri ( GL_TEXTURE_2D , GL_TEXTURE_MAG_FILTER , GL_LINEAR ) ;
2019-03-03 22:32:40 +00:00
# ifdef GL_UNPACK_ROW_LENGTH
2018-06-08 17:37:33 +00:00
glPixelStorei ( GL_UNPACK_ROW_LENGTH , 0 ) ;
2019-03-03 22:32:40 +00:00
# endif
2018-06-08 17:37:33 +00:00
glTexImage2D ( GL_TEXTURE_2D , 0 , GL_RGBA , width , height , 0 , GL_RGBA , GL_UNSIGNED_BYTE , pixels ) ;
// Store our identifier
2021-02-03 17:30:26 +00:00
io . Fonts - > SetTexID ( ( ImTextureID ) ( intptr_t ) g_FontTexture ) ;
2018-06-08 17:37:33 +00:00
// Restore state
glBindTexture ( GL_TEXTURE_2D , last_texture ) ;
return true ;
}
void ImGui_ImplOpenGL3_DestroyFontsTexture ( )
{
if ( g_FontTexture )
{
ImGuiIO & io = ImGui : : GetIO ( ) ;
glDeleteTextures ( 1 , & g_FontTexture ) ;
2021-02-03 17:30:26 +00:00
io . Fonts - > SetTexID ( 0 ) ;
2018-06-08 17:37:33 +00:00
g_FontTexture = 0 ;
}
}
2018-10-25 15:31:16 +00:00
// 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.
2018-07-10 14:09:34 +00:00
static bool CheckShader ( GLuint handle , const char * desc )
{
GLint status = 0 , log_length = 0 ;
glGetShaderiv ( handle , GL_COMPILE_STATUS , & status ) ;
glGetShaderiv ( handle , GL_INFO_LOG_LENGTH , & log_length ) ;
2018-10-06 09:35:05 +00:00
if ( ( GLboolean ) status = = GL_FALSE )
2018-07-10 14:09:34 +00:00
fprintf ( stderr , " ERROR: ImGui_ImplOpenGL3_CreateDeviceObjects: failed to compile %s! \n " , desc ) ;
2019-05-27 08:47:18 +00:00
if ( log_length > 1 )
2018-07-10 14:09:34 +00:00
{
ImVector < char > buf ;
buf . resize ( ( int ) ( log_length + 1 ) ) ;
glGetShaderInfoLog ( handle , log_length , NULL , ( GLchar * ) buf . begin ( ) ) ;
fprintf ( stderr , " %s \n " , buf . begin ( ) ) ;
}
2018-10-06 09:35:05 +00:00
return ( GLboolean ) status = = GL_TRUE ;
2018-07-10 14:09:34 +00:00
}
2018-10-25 15:31:16 +00:00
// If you get an error please report on GitHub. You may try different GL context version or GLSL version.
2018-07-10 14:09:34 +00:00
static bool CheckProgram ( GLuint handle , const char * desc )
{
GLint status = 0 , log_length = 0 ;
glGetProgramiv ( handle , GL_LINK_STATUS , & status ) ;
glGetProgramiv ( handle , GL_INFO_LOG_LENGTH , & log_length ) ;
2018-10-07 16:14:24 +00:00
if ( ( GLboolean ) status = = GL_FALSE )
2018-10-25 15:31:16 +00:00
fprintf ( stderr , " ERROR: ImGui_ImplOpenGL3_CreateDeviceObjects: failed to link %s! (with GLSL '%s') \n " , desc , g_GlslVersionString ) ;
2019-05-27 08:47:18 +00:00
if ( log_length > 1 )
2018-07-10 14:09:34 +00:00
{
ImVector < char > buf ;
buf . resize ( ( int ) ( log_length + 1 ) ) ;
glGetProgramInfoLog ( handle , log_length , NULL , ( GLchar * ) buf . begin ( ) ) ;
fprintf ( stderr , " %s \n " , buf . begin ( ) ) ;
}
2018-10-07 16:14:24 +00:00
return ( GLboolean ) status = = GL_TRUE ;
2018-07-10 14:09:34 +00:00
}
2018-06-08 17:37:33 +00:00
bool ImGui_ImplOpenGL3_CreateDeviceObjects ( )
{
// Backup GL state
2019-03-03 22:32:40 +00:00
GLint last_texture , last_array_buffer ;
2018-06-08 17:37:33 +00:00
glGetIntegerv ( GL_TEXTURE_BINDING_2D , & last_texture ) ;
glGetIntegerv ( GL_ARRAY_BUFFER_BINDING , & last_array_buffer ) ;
2021-06-25 02:55:32 +00:00
# ifdef IMGUI_IMPL_OPENGL_USE_VERTEX_ARRAY
2019-03-03 22:32:40 +00:00
GLint last_vertex_array ;
2018-06-08 17:37:33 +00:00
glGetIntegerv ( GL_VERTEX_ARRAY_BINDING , & last_vertex_array ) ;
2019-03-03 22:32:40 +00:00
# endif
2018-06-08 17:37:33 +00:00
2018-07-10 16:29:57 +00:00
// Parse GLSL version string
int glsl_version = 130 ;
sscanf ( g_GlslVersionString , " #version %d " , & glsl_version ) ;
const GLchar * vertex_shader_glsl_120 =
" uniform mat4 ProjMtx; \n "
" attribute vec2 Position; \n "
" attribute vec2 UV; \n "
" attribute vec4 Color; \n "
" varying vec2 Frag_UV; \n "
" varying vec4 Frag_Color; \n "
" void main() \n "
" { \n "
" Frag_UV = UV; \n "
" Frag_Color = Color; \n "
" gl_Position = ProjMtx * vec4(Position.xy,0,1); \n "
" } \n " ;
const GLchar * vertex_shader_glsl_130 =
2018-06-08 17:37:33 +00:00
" uniform mat4 ProjMtx; \n "
" in vec2 Position; \n "
" in vec2 UV; \n "
" in vec4 Color; \n "
" out vec2 Frag_UV; \n "
" out vec4 Frag_Color; \n "
" void main() \n "
" { \n "
2018-07-10 16:29:57 +00:00
" Frag_UV = UV; \n "
" Frag_Color = Color; \n "
" gl_Position = ProjMtx * vec4(Position.xy,0,1); \n "
2018-06-08 17:37:33 +00:00
" } \n " ;
2018-07-30 11:52:18 +00:00
const GLchar * vertex_shader_glsl_300_es =
" precision mediump float; \n "
" layout (location = 0) in vec2 Position; \n "
" layout (location = 1) in vec2 UV; \n "
" layout (location = 2) in vec4 Color; \n "
" uniform mat4 ProjMtx; \n "
" out vec2 Frag_UV; \n "
" out vec4 Frag_Color; \n "
" void main() \n "
" { \n "
" Frag_UV = UV; \n "
" Frag_Color = Color; \n "
" gl_Position = ProjMtx * vec4(Position.xy,0,1); \n "
" } \n " ;
const GLchar * vertex_shader_glsl_410_core =
" layout (location = 0) in vec2 Position; \n "
" layout (location = 1) in vec2 UV; \n "
" layout (location = 2) in vec4 Color; \n "
" uniform mat4 ProjMtx; \n "
" out vec2 Frag_UV; \n "
" out vec4 Frag_Color; \n "
" void main() \n "
" { \n "
" Frag_UV = UV; \n "
" Frag_Color = Color; \n "
" gl_Position = ProjMtx * vec4(Position.xy,0,1); \n "
" } \n " ;
2018-07-10 16:29:57 +00:00
const GLchar * fragment_shader_glsl_120 =
" #ifdef GL_ES \n "
" precision mediump float; \n "
" #endif \n "
" uniform sampler2D Texture; \n "
" varying vec2 Frag_UV; \n "
" varying vec4 Frag_Color; \n "
" void main() \n "
" { \n "
" gl_FragColor = Frag_Color * texture2D(Texture, Frag_UV.st); \n "
" } \n " ;
const GLchar * fragment_shader_glsl_130 =
2018-06-08 17:37:33 +00:00
" uniform sampler2D Texture; \n "
" in vec2 Frag_UV; \n "
" in vec4 Frag_Color; \n "
" out vec4 Out_Color; \n "
" void main() \n "
" { \n "
2018-07-10 16:29:57 +00:00
" Out_Color = Frag_Color * texture(Texture, Frag_UV.st); \n "
2018-06-08 17:37:33 +00:00
" } \n " ;
2018-07-30 11:52:18 +00:00
const GLchar * fragment_shader_glsl_300_es =
" precision mediump float; \n "
" uniform sampler2D Texture; \n "
" in vec2 Frag_UV; \n "
" in vec4 Frag_Color; \n "
" layout (location = 0) out vec4 Out_Color; \n "
" void main() \n "
" { \n "
" Out_Color = Frag_Color * texture(Texture, Frag_UV.st); \n "
" } \n " ;
const GLchar * fragment_shader_glsl_410_core =
" in vec2 Frag_UV; \n "
" in vec4 Frag_Color; \n "
" uniform sampler2D Texture; \n "
" layout (location = 0) out vec4 Out_Color; \n "
" void main() \n "
" { \n "
" Out_Color = Frag_Color * texture(Texture, Frag_UV.st); \n "
" } \n " ;
2018-07-10 16:29:57 +00:00
// Select shaders matching our GLSL versions
const GLchar * vertex_shader = NULL ;
const GLchar * fragment_shader = NULL ;
2018-07-30 12:00:53 +00:00
if ( glsl_version < 130 )
{
vertex_shader = vertex_shader_glsl_120 ;
fragment_shader = fragment_shader_glsl_120 ;
}
2019-02-01 14:13:54 +00:00
else if ( glsl_version > = 410 )
2018-07-30 11:52:18 +00:00
{
vertex_shader = vertex_shader_glsl_410_core ;
fragment_shader = fragment_shader_glsl_410_core ;
}
2018-07-30 12:00:53 +00:00
else if ( glsl_version = = 300 )
2018-07-30 11:52:18 +00:00
{
vertex_shader = vertex_shader_glsl_300_es ;
fragment_shader = fragment_shader_glsl_300_es ;
}
2018-07-10 16:29:57 +00:00
else
{
vertex_shader = vertex_shader_glsl_130 ;
fragment_shader = fragment_shader_glsl_130 ;
}
// Create shaders
const GLchar * vertex_shader_with_version [ 2 ] = { g_GlslVersionString , vertex_shader } ;
2021-06-19 18:04:16 +00:00
GLuint vert_handle = glCreateShader ( GL_VERTEX_SHADER ) ;
glShaderSource ( vert_handle , 2 , vertex_shader_with_version , NULL ) ;
glCompileShader ( vert_handle ) ;
CheckShader ( vert_handle , " vertex shader " ) ;
2018-07-10 14:09:34 +00:00
2018-07-10 16:29:57 +00:00
const GLchar * fragment_shader_with_version [ 2 ] = { g_GlslVersionString , fragment_shader } ;
2021-06-19 18:04:16 +00:00
GLuint frag_handle = glCreateShader ( GL_FRAGMENT_SHADER ) ;
glShaderSource ( frag_handle , 2 , fragment_shader_with_version , NULL ) ;
glCompileShader ( frag_handle ) ;
CheckShader ( frag_handle , " fragment shader " ) ;
2018-07-10 14:09:34 +00:00
2021-06-19 18:04:16 +00:00
// Link
2018-07-10 14:09:34 +00:00
g_ShaderHandle = glCreateProgram ( ) ;
2021-06-19 18:04:16 +00:00
glAttachShader ( g_ShaderHandle , vert_handle ) ;
glAttachShader ( g_ShaderHandle , frag_handle ) ;
2018-06-08 17:37:33 +00:00
glLinkProgram ( g_ShaderHandle ) ;
2018-07-10 14:09:34 +00:00
CheckProgram ( g_ShaderHandle , " shader program " ) ;
2018-06-08 17:37:33 +00:00
2021-06-19 18:04:16 +00:00
glDetachShader ( g_ShaderHandle , vert_handle ) ;
glDetachShader ( g_ShaderHandle , frag_handle ) ;
glDeleteShader ( vert_handle ) ;
glDeleteShader ( frag_handle ) ;
2018-06-08 17:37:33 +00:00
g_AttribLocationTex = glGetUniformLocation ( g_ShaderHandle , " Texture " ) ;
g_AttribLocationProjMtx = glGetUniformLocation ( g_ShaderHandle , " ProjMtx " ) ;
2020-06-05 10:04:55 +00:00
g_AttribLocationVtxPos = ( GLuint ) glGetAttribLocation ( g_ShaderHandle , " Position " ) ;
g_AttribLocationVtxUV = ( GLuint ) glGetAttribLocation ( g_ShaderHandle , " UV " ) ;
g_AttribLocationVtxColor = ( GLuint ) glGetAttribLocation ( g_ShaderHandle , " Color " ) ;
2018-06-08 17:37:33 +00:00
2018-07-10 14:09:34 +00:00
// Create buffers
2018-06-08 17:37:33 +00:00
glGenBuffers ( 1 , & g_VboHandle ) ;
glGenBuffers ( 1 , & g_ElementsHandle ) ;
ImGui_ImplOpenGL3_CreateFontsTexture ( ) ;
// Restore modified GL state
glBindTexture ( GL_TEXTURE_2D , last_texture ) ;
glBindBuffer ( GL_ARRAY_BUFFER , last_array_buffer ) ;
2021-06-25 02:55:32 +00:00
# ifdef IMGUI_IMPL_OPENGL_USE_VERTEX_ARRAY
2018-06-08 17:37:33 +00:00
glBindVertexArray ( last_vertex_array ) ;
2019-03-03 22:32:40 +00:00
# endif
2018-06-08 17:37:33 +00:00
return true ;
}
void ImGui_ImplOpenGL3_DestroyDeviceObjects ( )
{
2019-09-16 10:08:23 +00:00
if ( g_VboHandle ) { glDeleteBuffers ( 1 , & g_VboHandle ) ; g_VboHandle = 0 ; }
if ( g_ElementsHandle ) { glDeleteBuffers ( 1 , & g_ElementsHandle ) ; g_ElementsHandle = 0 ; }
if ( g_ShaderHandle ) { glDeleteProgram ( g_ShaderHandle ) ; g_ShaderHandle = 0 ; }
2018-06-08 17:37:33 +00:00
ImGui_ImplOpenGL3_DestroyFontsTexture ( ) ;
}