2020-10-12 18:34:22 +03:00
// dear imgui: Renderer Backend for OpenGL2 (legacy OpenGL, fixed pipeline)
// This needs to be used along with a Platform Backend (e.g. GLFW, SDL, Win32, custom..)
2018-02-22 01:05:17 +03:00
2018-03-19 17:20:47 +03:00
// Implemented features:
2019-10-16 12:23:15 +03:00
// [X] Renderer: User texture binding. Use 'GLuint' OpenGL texture identifier as void*/ImTextureID. Read the FAQ about ImTextureID!
2018-06-15 20:48:51 +03:00
// [X] Renderer: Multi-viewport support. Enable with 'io.ConfigFlags |= ImGuiConfigFlags_ViewportsEnable'.
2018-03-19 17:20:47 +03:00
2020-10-14 13:22:53 +03:00
// You can copy and use unmodified imgui_impl_* files in your project. See examples/ folder for examples of using this.
// 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 20:06:28 +03:00
2018-02-17 00:01:48 +03:00
// **DO NOT USE THIS CODE IF YOUR CODE/ENGINE IS USING MODERN OPENGL (SHADERS, VBO, VAO, etc.)**
2018-02-22 01:05:17 +03:00
// **Prefer using the code in imgui_impl_opengl3.cpp**
2018-02-17 00:01:48 +03:00
// This code is mostly provided as a reference to learn how ImGui integration works, because it is shorter to read.
// If your code is using GL3+ context or any semi modern OpenGL calls, using this is likely to make everything more
// complicated, will require your code to reset every single OpenGL attributes to their initial state, and might
2019-01-20 19:56:17 +03:00
// confuse your GPU driver.
2018-02-17 00:01:48 +03:00
// The GL2 code is unable to reset attributes or even call e.g. "glUseProgram(0)" because they don't exist in that API.
2019-01-20 19:56:17 +03:00
// CHANGELOG
2018-02-18 23:09:28 +03:00
// (minor and older changes stripped away, please see git history for details)
2020-01-27 16:57:00 +03:00
// 2020-XX-XX: Platform: Added support for multiple windows via the ImGuiPlatformIO interface.
2020-01-23 18:20:10 +03:00
// 2020-01-23: OpenGL: Explicitly backup, setup and restore GL_TEXTURE_ENV to increase compatibility with legacy OpenGL applications.
2019-04-30 23:28:29 +03:00
// 2019-04-30: OpenGL: Added support for special ImDrawCallback_ResetRenderState callback to reset render state.
2019-02-11 20:38:07 +03:00
// 2019-02-11: OpenGL: Projecting clipping rectangles correctly using draw_data->FramebufferScale to allow multi-viewports for retina display.
2018-11-30 20:18:15 +03:00
// 2018-11-30: Misc: Setting up io.BackendRendererName so it can be displayed in the About Window.
2018-08-03 16:04:35 +03:00
// 2018-08-03: OpenGL: Disabling/restoring GL_LIGHTING and GL_COLOR_MATERIAL to increase compatibility with legacy OpenGL applications.
2018-06-08 20:37:33 +03:00
// 2018-06-08: Misc: Extracted imgui_impl_opengl2.cpp/.h away from the old combined GLFW/SDL+OpenGL2 examples.
// 2018-06-08: OpenGL: Use draw_data->DisplayPos and draw_data->DisplaySize to setup projection matrix and clipping rectangle.
2019-08-22 00:05:46 +03:00
// 2018-02-16: Misc: Obsoleted the io.RenderDrawListsFn callback and exposed ImGui_ImplOpenGL2_RenderDrawData() in the .h file so you can call it yourself.
2018-02-20 18:18:02 +03:00
// 2017-09-01: OpenGL: Save and restore current polygon mode.
// 2016-09-10: OpenGL: Uploading font texture as RGBA32 to increase compatibility with users shaders (not ideal).
// 2016-09-05: OpenGL: Fixed save and restore of current scissor rectangle.
2018-02-18 23:09:28 +03:00
2018-02-17 00:01:48 +03:00
# include "imgui.h"
# include "imgui_impl_opengl2.h"
2018-07-11 13:23:46 +03: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-02-17 00:01:48 +03:00
// Include OpenGL header (without an OpenGL loader) requires a bit of fiddling
# if defined(_WIN32) && !defined(APIENTRY)
# define APIENTRY __stdcall // It is customary to use APIENTRY for OpenGL function pointer declarations on all platforms. Additionally, the Windows OpenGL header needs APIENTRY.
# endif
# if defined(_WIN32) && !defined(WINGDIAPI)
# define WINGDIAPI __declspec(dllimport) // Some Windows OpenGL headers need this
# endif
# if defined(__APPLE__)
2019-02-11 21:09:54 +03:00
# define GL_SILENCE_DEPRECATION
2018-02-17 00:01:48 +03:00
# include <OpenGL/gl.h>
# else
2018-03-07 14:05:47 +03:00
# include <GL/gl.h>
2018-02-17 00:01:48 +03:00
# endif
2018-02-20 18:18:02 +03:00
// OpenGL Data
2018-02-17 00:01:48 +03:00
static GLuint g_FontTexture = 0 ;
2018-03-21 00:18:18 +03:00
// Forward Declarations
static void ImGui_ImplOpenGL2_InitPlatformInterface ( ) ;
static void ImGui_ImplOpenGL2_ShutdownPlatformInterface ( ) ;
2018-02-17 00:01:48 +03:00
// Functions
bool ImGui_ImplOpenGL2_Init ( )
{
2020-10-12 18:34:22 +03:00
// Setup backend capabilities flags
2018-03-21 00:18:18 +03:00
ImGuiIO & io = ImGui : : GetIO ( ) ;
2018-11-30 20:18:15 +03:00
io . BackendRendererName = " imgui_impl_opengl2 " ;
2019-06-06 17:16:18 +03:00
io . BackendFlags | = ImGuiBackendFlags_RendererHasViewports ; // We can create multi-viewports on the Renderer side (optional)
2018-04-10 20:21:52 +03:00
if ( io . ConfigFlags & ImGuiConfigFlags_ViewportsEnable )
2018-03-21 00:18:18 +03:00
ImGui_ImplOpenGL2_InitPlatformInterface ( ) ;
2018-02-17 00:01:48 +03:00
return true ;
}
void ImGui_ImplOpenGL2_Shutdown ( )
{
2018-03-21 00:18:18 +03:00
ImGui_ImplOpenGL2_ShutdownPlatformInterface ( ) ;
2018-02-17 00:01:48 +03:00
ImGui_ImplOpenGL2_DestroyDeviceObjects ( ) ;
}
void ImGui_ImplOpenGL2_NewFrame ( )
{
if ( ! g_FontTexture )
ImGui_ImplOpenGL2_CreateDeviceObjects ( ) ;
}
2019-04-30 23:15:59 +03:00
static void ImGui_ImplOpenGL2_SetupRenderState ( ImDrawData * draw_data , int fb_width , int fb_height )
2018-02-17 00:01:48 +03:00
{
// Setup render state: alpha-blending enabled, no face culling, no depth testing, scissor enabled, vertex/texcoord/color pointers, polygon fill.
glEnable ( GL_BLEND ) ;
glBlendFunc ( GL_SRC_ALPHA , GL_ONE_MINUS_SRC_ALPHA ) ;
glDisable ( GL_CULL_FACE ) ;
glDisable ( GL_DEPTH_TEST ) ;
2018-08-03 16:04:35 +03:00
glDisable ( GL_LIGHTING ) ;
glDisable ( GL_COLOR_MATERIAL ) ;
2018-02-17 00:01:48 +03:00
glEnable ( GL_SCISSOR_TEST ) ;
glEnableClientState ( GL_VERTEX_ARRAY ) ;
glEnableClientState ( GL_TEXTURE_COORD_ARRAY ) ;
glEnableClientState ( GL_COLOR_ARRAY ) ;
glEnable ( GL_TEXTURE_2D ) ;
glPolygonMode ( GL_FRONT_AND_BACK , GL_FILL ) ;
2020-01-23 18:20:10 +03:00
glTexEnvi ( GL_TEXTURE_ENV , GL_TEXTURE_ENV_MODE , GL_MODULATE ) ;
2019-01-20 20:10:52 +03:00
2019-04-03 18:23:31 +03:00
// If you are using this code with non-legacy OpenGL header/contexts (which you should not, prefer using imgui_impl_opengl3.cpp!!),
2019-01-20 20:10:52 +03:00
// you may need to backup/reset/restore current shader using the lines below. DO NOT MODIFY THIS FILE! Add the code in your calling function:
2019-04-03 18:23:31 +03:00
// GLint last_program;
2019-01-20 20:10:52 +03:00
// glGetIntegerv(GL_CURRENT_PROGRAM, &last_program);
// glUseProgram(0);
// ImGui_ImplOpenGL2_RenderDrawData(...);
// glUseProgram(last_program)
2018-02-17 00:01:48 +03:00
// Setup viewport, orthographic projection matrix
2019-06-06 17:16:18 +03: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.
2018-02-17 00:01:48 +03:00
glViewport ( 0 , 0 , ( GLsizei ) fb_width , ( GLsizei ) fb_height ) ;
glMatrixMode ( GL_PROJECTION ) ;
glPushMatrix ( ) ;
glLoadIdentity ( ) ;
2018-03-13 01:15:40 +03:00
glOrtho ( draw_data - > DisplayPos . x , draw_data - > DisplayPos . x + draw_data - > DisplaySize . x , draw_data - > DisplayPos . y + draw_data - > DisplaySize . y , draw_data - > DisplayPos . y , - 1.0f , + 1.0f ) ;
2018-02-17 00:01:48 +03:00
glMatrixMode ( GL_MODELVIEW ) ;
glPushMatrix ( ) ;
glLoadIdentity ( ) ;
2019-04-30 23:15:59 +03:00
}
// OpenGL2 Render function.
2020-10-12 14:13:09 +03: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.
2019-04-30 23:15:59 +03:00
void ImGui_ImplOpenGL2_RenderDrawData ( ImDrawData * draw_data )
{
// Avoid rendering when minimized, scale coordinates for retina displays (screen coordinates != framebuffer coordinates)
int fb_width = ( int ) ( draw_data - > DisplaySize . x * draw_data - > FramebufferScale . x ) ;
int fb_height = ( int ) ( draw_data - > DisplaySize . y * draw_data - > FramebufferScale . y ) ;
if ( fb_width = = 0 | | fb_height = = 0 )
return ;
// Backup GL state
GLint last_texture ; glGetIntegerv ( GL_TEXTURE_BINDING_2D , & last_texture ) ;
GLint last_polygon_mode [ 2 ] ; glGetIntegerv ( GL_POLYGON_MODE , last_polygon_mode ) ;
GLint last_viewport [ 4 ] ; glGetIntegerv ( GL_VIEWPORT , last_viewport ) ;
GLint last_scissor_box [ 4 ] ; glGetIntegerv ( GL_SCISSOR_BOX , last_scissor_box ) ;
2020-01-23 18:20:10 +03:00
GLint last_tex_env_mode ; glGetTexEnviv ( GL_TEXTURE_ENV , GL_TEXTURE_ENV_MODE , & last_tex_env_mode ) ;
2019-04-30 23:15:59 +03:00
glPushAttrib ( GL_ENABLE_BIT | GL_COLOR_BUFFER_BIT | GL_TRANSFORM_BIT ) ;
// Setup desired GL state
ImGui_ImplOpenGL2_SetupRenderState ( draw_data , fb_width , fb_height ) ;
2018-02-17 00:01:48 +03:00
2019-02-11 20:38:07 +03: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)
2018-02-17 00:01:48 +03:00
// Render command lists
for ( int n = 0 ; n < draw_data - > CmdListsCount ; n + + )
{
const ImDrawList * cmd_list = draw_data - > CmdLists [ n ] ;
const ImDrawVert * vtx_buffer = cmd_list - > VtxBuffer . Data ;
const ImDrawIdx * idx_buffer = cmd_list - > IdxBuffer . Data ;
glVertexPointer ( 2 , GL_FLOAT , sizeof ( ImDrawVert ) , ( const GLvoid * ) ( ( const char * ) vtx_buffer + IM_OFFSETOF ( ImDrawVert , pos ) ) ) ;
glTexCoordPointer ( 2 , GL_FLOAT , sizeof ( ImDrawVert ) , ( const GLvoid * ) ( ( const char * ) vtx_buffer + IM_OFFSETOF ( ImDrawVert , uv ) ) ) ;
glColorPointer ( 4 , GL_UNSIGNED_BYTE , sizeof ( ImDrawVert ) , ( const GLvoid * ) ( ( const char * ) vtx_buffer + IM_OFFSETOF ( ImDrawVert , col ) ) ) ;
for ( int cmd_i = 0 ; cmd_i < cmd_list - > CmdBuffer . Size ; cmd_i + + )
{
const ImDrawCmd * pcmd = & cmd_list - > CmdBuffer [ cmd_i ] ;
if ( pcmd - > UserCallback )
{
2019-04-30 23:15:59 +03: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_ImplOpenGL2_SetupRenderState ( draw_data , fb_width , fb_height ) ;
else
pcmd - > UserCallback ( cmd_list , pcmd ) ;
2018-02-17 00:01:48 +03:00
}
else
{
2019-02-11 20:38:07 +03: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-02-18 23:09:28 +03: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 ) ;
}
2018-02-17 00:01:48 +03:00
}
idx_buffer + = pcmd - > ElemCount ;
}
}
2019-04-30 23:15:59 +03:00
// Restore modified GL state
2018-02-17 00:01:48 +03:00
glDisableClientState ( GL_COLOR_ARRAY ) ;
glDisableClientState ( GL_TEXTURE_COORD_ARRAY ) ;
glDisableClientState ( GL_VERTEX_ARRAY ) ;
glBindTexture ( GL_TEXTURE_2D , ( GLuint ) last_texture ) ;
glMatrixMode ( GL_MODELVIEW ) ;
glPopMatrix ( ) ;
glMatrixMode ( GL_PROJECTION ) ;
glPopMatrix ( ) ;
glPopAttrib ( ) ;
2018-02-20 18:18:02 +03:00
glPolygonMode ( GL_FRONT , ( GLenum ) last_polygon_mode [ 0 ] ) ; glPolygonMode ( GL_BACK , ( GLenum ) last_polygon_mode [ 1 ] ) ;
2018-02-17 00:01:48 +03: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 ] ) ;
2020-01-23 18:20:10 +03:00
glTexEnvi ( GL_TEXTURE_ENV , GL_TEXTURE_ENV_MODE , last_tex_env_mode ) ;
2018-02-17 00:01:48 +03:00
}
bool ImGui_ImplOpenGL2_CreateFontsTexture ( )
{
// Build texture atlas
ImGuiIO & io = ImGui : : GetIO ( ) ;
unsigned char * pixels ;
int width , height ;
2019-11-20 13:58:25 +03: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-02-17 00:01:48 +03: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 ) ;
2018-02-17 00:22:10 +03:00
glPixelStorei ( GL_UNPACK_ROW_LENGTH , 0 ) ;
2018-02-17 00:01:48 +03:00
glTexImage2D ( GL_TEXTURE_2D , 0 , GL_RGBA , width , height , 0 , GL_RGBA , GL_UNSIGNED_BYTE , pixels ) ;
// Store our identifier
2018-08-09 18:49:48 +03:00
io . Fonts - > TexID = ( ImTextureID ) ( intptr_t ) g_FontTexture ;
2018-02-17 00:01:48 +03:00
// Restore state
glBindTexture ( GL_TEXTURE_2D , last_texture ) ;
return true ;
}
void ImGui_ImplOpenGL2_DestroyFontsTexture ( )
{
if ( g_FontTexture )
{
ImGuiIO & io = ImGui : : GetIO ( ) ;
glDeleteTextures ( 1 , & g_FontTexture ) ;
io . Fonts - > TexID = 0 ;
g_FontTexture = 0 ;
}
}
bool ImGui_ImplOpenGL2_CreateDeviceObjects ( )
{
return ImGui_ImplOpenGL2_CreateFontsTexture ( ) ;
}
void ImGui_ImplOpenGL2_DestroyDeviceObjects ( )
{
ImGui_ImplOpenGL2_DestroyFontsTexture ( ) ;
}
2018-03-21 00:18:18 +03:00
//--------------------------------------------------------------------------------------------------------
2018-04-24 18:09:50 +03:00
// MULTI-VIEWPORT / PLATFORM INTERFACE SUPPORT
2020-10-14 15:43:45 +03:00
// This is an _advanced_ and _optional_ feature, allowing the backend to create and handle multiple viewports simultaneously.
2018-04-24 18:09:50 +03:00
// 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-21 00:18:18 +03:00
//--------------------------------------------------------------------------------------------------------
static void ImGui_ImplOpenGL2_RenderWindow ( ImGuiViewport * viewport , void * )
{
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 ) ;
}
ImGui_ImplOpenGL2_RenderDrawData ( viewport - > DrawData ) ;
}
static void ImGui_ImplOpenGL2_InitPlatformInterface ( )
{
ImGuiPlatformIO & platform_io = ImGui : : GetPlatformIO ( ) ;
platform_io . Renderer_RenderWindow = ImGui_ImplOpenGL2_RenderWindow ;
}
static void ImGui_ImplOpenGL2_ShutdownPlatformInterface ( )
{
2020-03-06 19:53:09 +03:00
ImGui : : DestroyPlatformWindows ( ) ;
2018-03-21 00:18:18 +03:00
}