2018-02-22 06:05:17 +08:00
// ImGui Renderer for: OpenGL3 (modern OpenGL with shaders / programmatic pipeline)
// This needs to be used along with a Platform Binding (e.g. GLFW, SDL, Win32, custom..)
// (Note: We are using GL3W as a helper library to access OpenGL functions since there is no standard header to access modern OpenGL functions easily. Alternatives are GLEW, Glad, etc..)
2018-03-19 22:20:47 +08:00
// Implemented features:
2018-06-13 02:18:51 +08:00
// [X] Renderer: User texture binding. Use 'GLuint' OpenGL texture identifier as void*/ImTextureID. Read the FAQ about ImTextureID in imgui.cpp.
2018-06-12 22:24:24 +08:00
// [X] Renderer: Multi-viewport support. Enable with 'io.ConfigFlags |= ImGuiConfigFlags_ViewportsEnable'.
2018-03-19 22:20:47 +08:00
2018-07-05 01:06:28 +08:00
// You can copy and use unmodified imgui_impl_* files in your project. See main.cpp for an example of using this.
// If you are new to dear imgui, read examples/README.txt and read the documentation at the top of imgui.cpp.
// https://github.com/ocornut/imgui
2018-02-19 04:09:28 +08:00
// CHANGELOG
// (minor and older changes stripped away, please see git history for details)
2018-03-19 05:19:02 +08:00
// 2018-XX-XX: Platform: Added support for multiple windows via the ImGuiPlatformIO interface.
2018-07-11 00:29:57 +08: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-09 01:37:33 +08: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 18:44:56 +08:00
// 2018-05-25: OpenGL: Removed unnecessary backup/restore of GL_ELEMENT_ARRAY_BUFFER_BINDING since this is part of the VAO state.
2018-05-17 21:03:56 +08:00
// 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-07 03:02:40 +08:00
// 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-27 01:22:36 +08:00
// 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-20 23:18:02 +08:00
// 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-02-19 04:09:28 +08:00
2018-07-11 00:29:57 +08:00
//----------------------------------------
// OpenGL GLSL GLSL
// version version string
//----------------------------------------
// 2.0 110 "#version 110"
// 2.1 120
// 3.0 130
// 3.1 140
// 3.2 150 "#version 150"
// 3.3 330
// 4.0 400
// 4.1 410
// 4.2 420
// 4.3 430
// ES 2.0 100 "#version 100"
// ES 3.0 300 "#version 300 es"
//----------------------------------------
2018-03-07 02:48:30 +08:00
# if defined(_MSC_VER) && !defined(_CRT_SECURE_NO_WARNINGS)
# define _CRT_SECURE_NO_WARNINGS
# endif
2018-01-29 21:38:46 +08:00
# include "imgui.h"
2018-02-17 04:38:38 +08:00
# include "imgui_impl_opengl3.h"
2018-07-10 22:09:34 +08:00
# include <stdio.h>
2018-07-11 18:23:46 +08: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 17:32:20 +08:00
# include <GL/gl3w.h> // This example is using gl3w to access OpenGL functions. You may use another OpenGL loader/header such as: glew, glext, glad, glLoadGen, etc.
2018-06-12 01:52:40 +08:00
//#include <glew.h>
2018-07-09 17:32:20 +08:00
//#include <glext.h>
//#include <glad/glad.h>
2018-02-17 04:38:38 +08:00
2018-02-20 23:18:02 +08:00
// OpenGL Data
2018-07-11 00:29:57 +08:00
static char g_GlslVersionString [ 32 ] = " " ;
2015-03-09 23:02:22 +08:00
static GLuint g_FontTexture = 0 ;
2018-07-10 22:09:34 +08:00
static GLuint g_ShaderHandle = 0 , g_VertHandle = 0 , g_FragHandle = 0 ;
2015-03-09 20:16:29 +08:00
static int g_AttribLocationTex = 0 , g_AttribLocationProjMtx = 0 ;
static int g_AttribLocationPosition = 0 , g_AttribLocationUV = 0 , g_AttribLocationColor = 0 ;
2018-02-27 01:22:36 +08:00
static unsigned int g_VboHandle = 0 , g_ElementsHandle = 0 ;
2015-03-09 19:59:23 +08:00
2018-02-28 06:27:41 +08:00
// Forward Declarations
static void ImGui_ImplOpenGL3_InitPlatformInterface ( ) ;
static void ImGui_ImplOpenGL3_ShutdownPlatformInterface ( ) ;
2018-02-17 05:01:48 +08:00
// Functions
2018-03-07 03:02:40 +08:00
bool ImGui_ImplOpenGL3_Init ( const char * glsl_version )
2018-02-17 04:38:38 +08:00
{
2018-05-25 18:44:56 +08:00
// Store GLSL version string so we can refer to it later in case we recreate shaders. Note: GLSL version is NOT the same as GL version. Leave this to NULL if unsure.
2018-03-07 03:02:40 +08:00
if ( glsl_version = = NULL )
2018-07-11 00:29:57 +08:00
glsl_version = " #version 130 " ;
IM_ASSERT ( ( int ) strlen ( glsl_version ) + 2 < IM_ARRAYSIZE ( g_GlslVersionString ) ) ;
strcpy ( g_GlslVersionString , glsl_version ) ;
strcat ( g_GlslVersionString , " \n " ) ;
2018-03-07 03:02:40 +08:00
2018-03-21 05:14:34 +08:00
// Setup back-end capabilities flags
2018-03-07 19:35:26 +08:00
ImGuiIO & io = ImGui : : GetIO ( ) ;
2018-03-21 05:14:34 +08:00
io . BackendFlags | = ImGuiBackendFlags_RendererHasViewports ; // We can create multi-viewports on the Renderer side (optional)
2018-04-11 01:21:52 +08:00
if ( io . ConfigFlags & ImGuiConfigFlags_ViewportsEnable )
2018-03-07 19:35:26 +08:00
ImGui_ImplOpenGL3_InitPlatformInterface ( ) ;
2018-06-10 21:04:09 +08:00
2018-02-17 04:38:38 +08:00
return true ;
}
void ImGui_ImplOpenGL3_Shutdown ( )
{
2018-02-28 06:27:41 +08:00
ImGui_ImplOpenGL3_ShutdownPlatformInterface ( ) ;
2018-02-17 04:38:38 +08:00
ImGui_ImplOpenGL3_DestroyDeviceObjects ( ) ;
}
void ImGui_ImplOpenGL3_NewFrame ( )
{
if ( ! g_FontTexture )
ImGui_ImplOpenGL3_CreateDeviceObjects ( ) ;
}
2018-02-17 02:18:16 +08:00
// OpenGL3 Render function.
// (this used to be set in io.RenderDrawListsFn and called by ImGui::Render(), but you can now call this directly from your main loop)
2017-09-01 22:55:04 +08:00
// Note that this implementation is little overcomplicated because we are saving/setting up/restoring every OpenGL state explicitly, in order to be able to run within any OpenGL engine that doesn't do so.
2018-02-17 04:38:38 +08:00
void ImGui_ImplOpenGL3_RenderDrawData ( ImDrawData * draw_data )
2015-03-09 19:59:23 +08:00
{
2016-03-06 17:46:57 +08:00
// Avoid rendering when minimized, scale coordinates for retina displays (screen coordinates != framebuffer coordinates)
ImGuiIO & io = ImGui : : GetIO ( ) ;
2018-03-13 06:15:40 +08:00
int fb_width = ( int ) ( draw_data - > DisplaySize . x * io . DisplayFramebufferScale . x ) ;
int fb_height = ( int ) ( draw_data - > DisplaySize . y * io . DisplayFramebufferScale . y ) ;
if ( fb_width < = 0 | | fb_height < = 0 )
2016-03-06 17:46:57 +08:00
return ;
draw_data - > ScaleClipRects ( io . DisplayFramebufferScale ) ;
2015-08-30 00:44:52 +08:00
// Backup GL state
2017-05-18 03:42:34 +08:00
GLenum last_active_texture ; glGetIntegerv ( GL_ACTIVE_TEXTURE , ( GLint * ) & last_active_texture ) ;
2017-04-27 00:16:59 +08:00
glActiveTexture ( GL_TEXTURE0 ) ;
2015-09-28 04:21:11 +08:00
GLint last_program ; glGetIntegerv ( GL_CURRENT_PROGRAM , & last_program ) ;
GLint last_texture ; glGetIntegerv ( GL_TEXTURE_BINDING_2D , & last_texture ) ;
2017-05-17 07:43:59 +08:00
GLint last_sampler ; glGetIntegerv ( GL_SAMPLER_BINDING , & last_sampler ) ;
2015-09-28 04:21:11 +08:00
GLint last_array_buffer ; glGetIntegerv ( GL_ARRAY_BUFFER_BINDING , & last_array_buffer ) ;
GLint last_vertex_array ; glGetIntegerv ( GL_VERTEX_ARRAY_BINDING , & last_vertex_array ) ;
2017-09-01 16:39:12 +08:00
GLint last_polygon_mode [ 2 ] ; glGetIntegerv ( GL_POLYGON_MODE , last_polygon_mode ) ;
2017-08-12 00:46:58 +08:00
GLint last_viewport [ 4 ] ; glGetIntegerv ( GL_VIEWPORT , last_viewport ) ;
GLint last_scissor_box [ 4 ] ; glGetIntegerv ( GL_SCISSOR_BOX , last_scissor_box ) ;
2017-05-18 03:42:34 +08:00
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 ) ;
2015-10-30 22:57:03 +08:00
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 ) ;
GLboolean last_enable_scissor_test = glIsEnabled ( GL_SCISSOR_TEST ) ;
2015-08-30 00:44:52 +08:00
2017-09-01 16:39:12 +08:00
// Setup render state: alpha-blending enabled, no face culling, no depth testing, scissor enabled, polygon fill
2015-03-09 19:59:23 +08:00
glEnable ( GL_BLEND ) ;
glBlendEquation ( GL_FUNC_ADD ) ;
glBlendFunc ( GL_SRC_ALPHA , GL_ONE_MINUS_SRC_ALPHA ) ;
glDisable ( GL_CULL_FACE ) ;
glDisable ( GL_DEPTH_TEST ) ;
glEnable ( GL_SCISSOR_TEST ) ;
2017-09-01 16:39:12 +08:00
glPolygonMode ( GL_FRONT_AND_BACK , GL_FILL ) ;
2015-03-09 19:59:23 +08:00
2015-10-30 22:44:47 +08:00
// Setup viewport, orthographic projection matrix
2018-06-10 21:04:09 +08:00
// Our visible imgui space lies from draw_data->DisplayPos (top left) to draw_data->DisplayPos+data_data->DisplaySize (bottom right). DisplayMin is (0,0) for single viewport apps.
2015-12-20 03:54:23 +08:00
glViewport ( 0 , 0 , ( GLsizei ) fb_width , ( GLsizei ) fb_height ) ;
2018-03-13 06:15:40 +08:00
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 ;
2015-03-09 19:59:23 +08:00
const float ortho_projection [ 4 ] [ 4 ] =
{
2018-02-19 04:09:28 +08:00
{ 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 } ,
2015-03-09 19:59:23 +08:00
} ;
2015-03-09 20:16:29 +08:00
glUseProgram ( g_ShaderHandle ) ;
glUniform1i ( g_AttribLocationTex , 0 ) ;
glUniformMatrix4fv ( g_AttribLocationProjMtx , 1 , GL_FALSE , & ortho_projection [ 0 ] [ 0 ] ) ;
2018-05-17 21:03:56 +08:00
if ( glBindSampler ) glBindSampler ( 0 , 0 ) ; // We use combined texture/sampler state. Applications using GL 3.3 may set that otherwise.
2015-03-09 19:59:23 +08:00
2018-02-27 01:22:36 +08:00
// Recreate the VAO every time
// (This is to easily allow multiple GL contexts. VAO are not shared among GL contexts, and we don't track creation/deletion of windows so we don't have an obvious key to use to cache them.)
GLuint vao_handle = 0 ;
glGenVertexArrays ( 1 , & vao_handle ) ;
glBindVertexArray ( vao_handle ) ;
glBindBuffer ( GL_ARRAY_BUFFER , g_VboHandle ) ;
glEnableVertexAttribArray ( g_AttribLocationPosition ) ;
glEnableVertexAttribArray ( g_AttribLocationUV ) ;
glEnableVertexAttribArray ( g_AttribLocationColor ) ;
glVertexAttribPointer ( g_AttribLocationPosition , 2 , GL_FLOAT , GL_FALSE , sizeof ( ImDrawVert ) , ( GLvoid * ) IM_OFFSETOF ( ImDrawVert , pos ) ) ;
glVertexAttribPointer ( g_AttribLocationUV , 2 , GL_FLOAT , GL_FALSE , sizeof ( ImDrawVert ) , ( GLvoid * ) IM_OFFSETOF ( ImDrawVert , uv ) ) ;
glVertexAttribPointer ( g_AttribLocationColor , 4 , GL_UNSIGNED_BYTE , GL_TRUE , sizeof ( ImDrawVert ) , ( GLvoid * ) IM_OFFSETOF ( ImDrawVert , col ) ) ;
// Draw
2018-06-09 01:37:33 +08:00
ImVec2 pos = draw_data - > DisplayPos ;
2015-07-08 10:17:07 +08:00
for ( int n = 0 ; n < draw_data - > CmdListsCount ; n + + )
2015-03-09 19:59:23 +08:00
{
2015-07-08 10:17:07 +08:00
const ImDrawList * cmd_list = draw_data - > CmdLists [ n ] ;
2015-07-19 23:56:14 +08:00
const ImDrawIdx * idx_buffer_offset = 0 ;
2015-04-10 04:05:35 +08:00
2015-07-08 22:27:36 +08:00
glBindBuffer ( GL_ARRAY_BUFFER , g_VboHandle ) ;
2016-11-12 01:40:13 +08:00
glBufferData ( GL_ARRAY_BUFFER , ( GLsizeiptr ) cmd_list - > VtxBuffer . Size * sizeof ( ImDrawVert ) , ( const GLvoid * ) cmd_list - > VtxBuffer . Data , GL_STREAM_DRAW ) ;
2015-07-08 22:27:36 +08:00
2015-07-19 23:56:14 +08:00
glBindBuffer ( GL_ELEMENT_ARRAY_BUFFER , g_ElementsHandle ) ;
2016-11-12 01:40:13 +08:00
glBufferData ( GL_ELEMENT_ARRAY_BUFFER , ( GLsizeiptr ) cmd_list - > IdxBuffer . Size * sizeof ( ImDrawIdx ) , ( const GLvoid * ) cmd_list - > IdxBuffer . Data , GL_STREAM_DRAW ) ;
2015-07-19 23:56:14 +08:00
2016-09-04 01:24:57 +08:00
for ( int cmd_i = 0 ; cmd_i < cmd_list - > CmdBuffer . Size ; cmd_i + + )
2015-03-09 19:59:23 +08:00
{
2016-09-04 01:24:57 +08:00
const ImDrawCmd * pcmd = & cmd_list - > CmdBuffer [ cmd_i ] ;
2015-07-08 10:17:07 +08:00
if ( pcmd - > UserCallback )
2015-03-09 23:26:58 +08:00
{
2018-02-19 04:09:28 +08:00
// User callback (registered via ImDrawList::AddCallback)
2015-07-08 10:17:07 +08:00
pcmd - > UserCallback ( cmd_list , pcmd ) ;
2015-03-09 23:26:58 +08:00
}
else
{
2018-06-09 01:37:33 +08:00
ImVec4 clip_rect = ImVec4 ( pcmd - > ClipRect . x - pos . x , pcmd - > ClipRect . y - pos . y , pcmd - > ClipRect . z - pos . x , pcmd - > ClipRect . w - pos . y ) ;
2018-02-19 04:09:28 +08: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
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 ) ) ;
// Bind texture, Draw
glBindTexture ( GL_TEXTURE_2D , ( GLuint ) ( intptr_t ) pcmd - > TextureId ) ;
glDrawElements ( GL_TRIANGLES , ( GLsizei ) pcmd - > ElemCount , sizeof ( ImDrawIdx ) = = 2 ? GL_UNSIGNED_SHORT : GL_UNSIGNED_INT , idx_buffer_offset ) ;
}
2015-03-09 23:26:58 +08:00
}
2015-07-19 23:56:14 +08:00
idx_buffer_offset + = pcmd - > ElemCount ;
2015-03-09 19:59:23 +08:00
}
}
2018-02-27 01:22:36 +08:00
glDeleteVertexArrays ( 1 , & vao_handle ) ;
2015-03-09 19:59:23 +08:00
2015-08-30 00:44:52 +08:00
// Restore modified GL state
2015-04-15 17:14:51 +08:00
glUseProgram ( last_program ) ;
glBindTexture ( GL_TEXTURE_2D , last_texture ) ;
2018-05-17 21:03:56 +08:00
if ( glBindSampler ) glBindSampler ( 0 , last_sampler ) ;
2017-04-27 00:16:59 +08:00
glActiveTexture ( last_active_texture ) ;
2016-02-15 17:55:20 +08:00
glBindVertexArray ( last_vertex_array ) ;
2015-08-30 00:44:52 +08:00
glBindBuffer ( GL_ARRAY_BUFFER , last_array_buffer ) ;
2015-10-30 22:57:03 +08:00
glBlendEquationSeparate ( last_blend_equation_rgb , last_blend_equation_alpha ) ;
2017-05-01 15:05:45 +08:00
glBlendFuncSeparate ( last_blend_src_rgb , last_blend_dst_rgb , last_blend_src_alpha , last_blend_dst_alpha ) ;
2015-10-30 22:57:03 +08:00
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 ) ;
if ( last_enable_scissor_test ) glEnable ( GL_SCISSOR_TEST ) ; else glDisable ( GL_SCISSOR_TEST ) ;
2018-02-20 23:18:02 +08:00
glPolygonMode ( GL_FRONT_AND_BACK , ( GLenum ) last_polygon_mode [ 0 ] ) ;
2015-10-30 22:44:47 +08:00
glViewport ( last_viewport [ 0 ] , last_viewport [ 1 ] , ( GLsizei ) last_viewport [ 2 ] , ( GLsizei ) last_viewport [ 3 ] ) ;
2016-09-06 05:39:52 +08:00
glScissor ( last_scissor_box [ 0 ] , last_scissor_box [ 1 ] , ( GLsizei ) last_scissor_box [ 2 ] , ( GLsizei ) last_scissor_box [ 3 ] ) ;
2015-03-09 19:59:23 +08:00
}
2018-02-17 04:38:38 +08:00
bool ImGui_ImplOpenGL3_CreateFontsTexture ( )
2015-03-09 19:59:23 +08:00
{
2015-09-09 21:15:17 +08:00
// Build texture atlas
2015-11-29 22:54:05 +08:00
ImGuiIO & io = ImGui : : GetIO ( ) ;
2015-03-09 19:59:23 +08:00
unsigned char * pixels ;
int width , height ;
2016-09-10 23:43:07 +08:00
io . Fonts - > GetTexDataAsRGBA32 ( & pixels , & width , & height ) ; // Load as RGBA 32-bits (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.
2015-03-09 19:59:23 +08:00
2015-11-29 22:54:05 +08:00
// Upload texture to graphics system
GLint last_texture ;
glGetIntegerv ( GL_TEXTURE_BINDING_2D , & last_texture ) ;
2015-03-09 23:02:22 +08:00
glGenTextures ( 1 , & g_FontTexture ) ;
glBindTexture ( GL_TEXTURE_2D , g_FontTexture ) ;
2015-03-09 19:59:23 +08:00
glTexParameteri ( GL_TEXTURE_2D , GL_TEXTURE_MIN_FILTER , GL_LINEAR ) ;
glTexParameteri ( GL_TEXTURE_2D , GL_TEXTURE_MAG_FILTER , GL_LINEAR ) ;
2018-02-17 06:19:38 +08:00
glPixelStorei ( GL_UNPACK_ROW_LENGTH , 0 ) ;
2015-03-09 19:59:23 +08:00
glTexImage2D ( GL_TEXTURE_2D , 0 , GL_RGBA , width , height , 0 , GL_RGBA , GL_UNSIGNED_BYTE , pixels ) ;
// Store our identifier
2015-03-09 23:02:22 +08:00
io . Fonts - > TexID = ( void * ) ( intptr_t ) g_FontTexture ;
2015-05-12 22:16:12 +08:00
2015-11-29 22:54:05 +08:00
// Restore state
glBindTexture ( GL_TEXTURE_2D , last_texture ) ;
return true ;
2015-03-09 19:59:23 +08:00
}
2018-02-17 04:38:38 +08:00
void ImGui_ImplOpenGL3_DestroyFontsTexture ( )
{
if ( g_FontTexture )
{
ImGuiIO & io = ImGui : : GetIO ( ) ;
glDeleteTextures ( 1 , & g_FontTexture ) ;
io . Fonts - > TexID = 0 ;
g_FontTexture = 0 ;
}
}
2018-07-10 22:09:34 +08:00
// If you get an error please report on github. You may try different GL context version or GLSL version.
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 ) ;
if ( status = = GL_FALSE )
fprintf ( stderr , " ERROR: ImGui_ImplOpenGL3_CreateDeviceObjects: failed to compile %s! \n " , desc ) ;
if ( log_length > 0 )
{
ImVector < char > buf ;
buf . resize ( ( int ) ( log_length + 1 ) ) ;
glGetShaderInfoLog ( handle , log_length , NULL , ( GLchar * ) buf . begin ( ) ) ;
fprintf ( stderr , " %s \n " , buf . begin ( ) ) ;
}
return status = = GL_TRUE ;
}
// If you get an error please report on github. You may try different GL context version or GLSL version.
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 ) ;
if ( status = = GL_FALSE )
fprintf ( stderr , " ERROR: ImGui_ImplOpenGL3_CreateDeviceObjects: failed to link %s! \n " , desc ) ;
if ( log_length > 0 )
{
ImVector < char > buf ;
buf . resize ( ( int ) ( log_length + 1 ) ) ;
glGetProgramInfoLog ( handle , log_length , NULL , ( GLchar * ) buf . begin ( ) ) ;
fprintf ( stderr , " %s \n " , buf . begin ( ) ) ;
}
return status = = GL_TRUE ;
}
2018-02-17 04:38:38 +08:00
bool ImGui_ImplOpenGL3_CreateDeviceObjects ( )
2015-03-09 19:59:23 +08:00
{
2015-08-30 00:44:52 +08:00
// Backup GL state
GLint last_texture , last_array_buffer , last_vertex_array ;
glGetIntegerv ( GL_TEXTURE_BINDING_2D , & last_texture ) ;
glGetIntegerv ( GL_ARRAY_BUFFER_BINDING , & last_array_buffer ) ;
glGetIntegerv ( GL_VERTEX_ARRAY_BINDING , & last_vertex_array ) ;
2018-07-11 00:29:57 +08: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 =
2015-03-09 19:59:23 +08: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-11 00:29:57 +08:00
" Frag_UV = UV; \n "
" Frag_Color = Color; \n "
" gl_Position = ProjMtx * vec4(Position.xy,0,1); \n "
2015-03-09 19:59:23 +08:00
" } \n " ;
2018-07-11 00:29:57 +08: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 =
2015-03-09 19:59:23 +08: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-11 00:29:57 +08:00
" Out_Color = Frag_Color * texture(Texture, Frag_UV.st); \n "
2015-03-09 19:59:23 +08:00
" } \n " ;
2018-07-11 00:29:57 +08:00
// Select shaders matching our GLSL versions
const GLchar * vertex_shader = NULL ;
const GLchar * fragment_shader = NULL ;
if ( glsl_version < 130 )
{
vertex_shader = vertex_shader_glsl_120 ;
fragment_shader = fragment_shader_glsl_120 ;
}
else
{
vertex_shader = vertex_shader_glsl_130 ;
fragment_shader = fragment_shader_glsl_130 ;
}
2018-03-07 02:48:30 +08:00
2018-07-11 00:29:57 +08:00
// Create shaders
const GLchar * vertex_shader_with_version [ 2 ] = { g_GlslVersionString , vertex_shader } ;
2015-03-09 20:16:29 +08:00
g_VertHandle = glCreateShader ( GL_VERTEX_SHADER ) ;
2018-03-07 02:48:30 +08:00
glShaderSource ( g_VertHandle , 2 , vertex_shader_with_version , NULL ) ;
2015-03-09 20:16:29 +08:00
glCompileShader ( g_VertHandle ) ;
2018-07-10 22:09:34 +08:00
CheckShader ( g_VertHandle , " vertex shader " ) ;
2018-07-11 00:29:57 +08:00
const GLchar * fragment_shader_with_version [ 2 ] = { g_GlslVersionString , fragment_shader } ;
2018-07-10 22:09:34 +08:00
g_FragHandle = glCreateShader ( GL_FRAGMENT_SHADER ) ;
glShaderSource ( g_FragHandle , 2 , fragment_shader_with_version , NULL ) ;
2015-03-09 20:16:29 +08:00
glCompileShader ( g_FragHandle ) ;
2018-07-10 22:09:34 +08:00
CheckShader ( g_FragHandle , " fragment shader " ) ;
g_ShaderHandle = glCreateProgram ( ) ;
2015-03-09 20:16:29 +08:00
glAttachShader ( g_ShaderHandle , g_VertHandle ) ;
glAttachShader ( g_ShaderHandle , g_FragHandle ) ;
glLinkProgram ( g_ShaderHandle ) ;
2018-07-10 22:09:34 +08:00
CheckProgram ( g_ShaderHandle , " shader program " ) ;
2015-03-09 20:16:29 +08:00
g_AttribLocationTex = glGetUniformLocation ( g_ShaderHandle , " Texture " ) ;
g_AttribLocationProjMtx = glGetUniformLocation ( g_ShaderHandle , " ProjMtx " ) ;
g_AttribLocationPosition = glGetAttribLocation ( g_ShaderHandle , " Position " ) ;
g_AttribLocationUV = glGetAttribLocation ( g_ShaderHandle , " UV " ) ;
g_AttribLocationColor = glGetAttribLocation ( g_ShaderHandle , " Color " ) ;
2018-07-10 22:09:34 +08:00
// Create buffers
2015-03-09 20:16:29 +08:00
glGenBuffers ( 1 , & g_VboHandle ) ;
2015-07-19 23:56:14 +08:00
glGenBuffers ( 1 , & g_ElementsHandle ) ;
2015-03-09 20:16:29 +08:00
2018-02-17 04:38:38 +08:00
ImGui_ImplOpenGL3_CreateFontsTexture ( ) ;
2015-03-09 23:02:22 +08:00
2015-08-30 00:44:52 +08:00
// Restore modified GL state
glBindTexture ( GL_TEXTURE_2D , last_texture ) ;
glBindBuffer ( GL_ARRAY_BUFFER , last_array_buffer ) ;
glBindVertexArray ( last_vertex_array ) ;
2015-03-09 23:02:22 +08:00
return true ;
2015-03-09 19:59:23 +08:00
}
2018-02-17 04:38:38 +08:00
void ImGui_ImplOpenGL3_DestroyDeviceObjects ( )
2015-11-09 06:52:25 +08:00
{
if ( g_VboHandle ) glDeleteBuffers ( 1 , & g_VboHandle ) ;
if ( g_ElementsHandle ) glDeleteBuffers ( 1 , & g_ElementsHandle ) ;
2018-02-27 01:22:36 +08:00
g_VboHandle = g_ElementsHandle = 0 ;
2015-11-09 06:52:25 +08:00
2016-10-01 20:59:28 +08:00
if ( g_ShaderHandle & & g_VertHandle ) glDetachShader ( g_ShaderHandle , g_VertHandle ) ;
if ( g_VertHandle ) glDeleteShader ( g_VertHandle ) ;
2015-11-09 06:52:25 +08:00
g_VertHandle = 0 ;
2016-10-01 20:59:28 +08:00
if ( g_ShaderHandle & & g_FragHandle ) glDetachShader ( g_ShaderHandle , g_FragHandle ) ;
if ( g_FragHandle ) glDeleteShader ( g_FragHandle ) ;
2015-11-09 06:52:25 +08:00
g_FragHandle = 0 ;
2016-10-01 20:59:28 +08:00
if ( g_ShaderHandle ) glDeleteProgram ( g_ShaderHandle ) ;
2015-11-09 06:52:25 +08:00
g_ShaderHandle = 0 ;
2018-02-17 04:38:38 +08:00
ImGui_ImplOpenGL3_DestroyFontsTexture ( ) ;
2015-03-09 19:59:23 +08:00
}
2018-02-28 06:27:41 +08:00
2018-03-19 01:44:57 +08:00
//--------------------------------------------------------------------------------------------------------
2018-04-24 23:09:50 +08:00
// MULTI-VIEWPORT / PLATFORM INTERFACE SUPPORT
// This is an _advanced_ and _optional_ feature, allowing the back-end to create and handle multiple viewports simultaneously.
// If you are new to dear imgui or creating a new binding for dear imgui, it is recommended that you completely ignore this section first..
2018-03-19 01:44:57 +08:00
//--------------------------------------------------------------------------------------------------------
2018-02-28 06:27:41 +08:00
2018-03-19 22:20:47 +08:00
static void ImGui_ImplOpenGL3_RenderWindow ( ImGuiViewport * viewport , void * )
2018-02-28 06:27:41 +08:00
{
2018-03-16 00:52:53 +08:00
if ( ! ( viewport - > Flags & ImGuiViewportFlags_NoRendererClear ) )
{
ImVec4 clear_color = ImVec4 ( 0.0f , 0.0f , 0.0f , 1.0f ) ;
glClearColor ( clear_color . x , clear_color . y , clear_color . z , clear_color . w ) ;
glClear ( GL_COLOR_BUFFER_BIT ) ;
}
2018-03-19 01:44:57 +08:00
ImGui_ImplOpenGL3_RenderDrawData ( viewport - > DrawData ) ;
2018-02-28 06:27:41 +08:00
}
2018-03-19 01:44:57 +08:00
static void ImGui_ImplOpenGL3_InitPlatformInterface ( )
2018-02-28 06:27:41 +08:00
{
2018-03-19 01:44:57 +08:00
ImGuiPlatformIO & platform_io = ImGui : : GetPlatformIO ( ) ;
platform_io . Renderer_RenderWindow = ImGui_ImplOpenGL3_RenderWindow ;
2018-02-28 06:27:41 +08:00
}
2018-03-19 01:44:57 +08:00
static void ImGui_ImplOpenGL3_ShutdownPlatformInterface ( )
2018-02-28 06:27:41 +08:00
{
2018-03-19 01:44:57 +08:00
ImGui : : DestroyPlatformWindows ( ) ;
2018-02-28 06:27:41 +08:00
}