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!
2022-05-03 18:53:47 +03:00
// [X] Renderer: Multi-viewport support (multiple windows). Enable with 'io.ConfigFlags |= ImGuiConfigFlags_ViewportsEnable'.
2018-03-19 17:20:47 +03:00
2021-06-24 18:34:23 +03:00
// You can use unmodified imgui_impl_* files in your project. See examples/ folder for examples of using this.
2021-05-27 14:59:35 +03: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.
2023-09-11 14:47:08 +03:00
// Learn about Dear ImGui:
// - FAQ https://dearimgui.com/faq
// - Getting Started https://dearimgui.com/getting-started
// - Documentation https://dearimgui.com/docs (same as your local docs/ folder).
// - Introduction, links and more at the top of imgui.cpp
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)
2024-02-14 16:32:17 +03:00
// 2024-XX-XX: Platform: Added support for multiple windows via the ImGuiPlatformIO interface.
2022-10-11 13:22:29 +03:00
// 2022-10-11: Using 'nullptr' instead of 'NULL' as per our switch to C++11.
2024-02-01 20:30:00 +03:00
// 2021-12-08: OpenGL: Fixed mishandling of the ImDrawCmd::IdxOffset field! This is an old bug but it never had an effect until some internal rendering changes in 1.86.
2021-06-28 17:52:10 +03:00
// 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).
2021-02-07 14:36:54 +03:00
// 2021-05-19: OpenGL: Replaced direct access to ImDrawCmd::TextureId with a call to ImDrawCmd::GetTexID(). (will become a requirement)
2021-01-04 21:12:35 +03:00
// 2021-01-03: OpenGL: Backup, setup and restore GL_SHADE_MODEL state, disable GL_STENCIL_TEST and disable GL_NORMAL_ARRAY client state to increase compatibility with legacy OpenGL applications.
2021-01-03 17:55:12 +03:00
// 2020-01-23: OpenGL: 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"
2023-07-13 12:27:52 +03:00
# ifndef IMGUI_DISABLE
2018-02-17 00:01:48 +03:00
# include "imgui_impl_opengl2.h"
2018-07-11 13:23:46 +03:00
# include <stdint.h> // intptr_t
2018-02-17 00:01:48 +03:00
2023-03-23 20:17:45 +03:00
// Clang/GCC warnings with -Weverything
# if defined(__clang__)
# pragma clang diagnostic push
# pragma clang diagnostic ignored "-Wunused-macros" // warning: macro is not used
# pragma clang diagnostic ignored "-Wnonportable-system-include-path"
# 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
2021-06-28 17:52:10 +03:00
struct ImGui_ImplOpenGL2_Data
{
GLuint FontTexture ;
2022-03-13 09:15:32 +03:00
ImGui_ImplOpenGL2_Data ( ) { memset ( ( void * ) this , 0 , sizeof ( * this ) ) ; }
2021-06-28 17:52:10 +03:00
} ;
2021-06-29 17:42:13 +03:00
// Backend data stored in io.BackendRendererUserData to allow support for multiple Dear ImGui contexts
// It is STRONGLY preferred that you use docking branch with multi-viewports (== single Dear ImGui context + multiple windows) instead of multiple Dear ImGui contexts.
2021-06-30 16:22:15 +03:00
static ImGui_ImplOpenGL2_Data * ImGui_ImplOpenGL2_GetBackendData ( )
{
2022-10-11 13:22:29 +03:00
return ImGui : : GetCurrentContext ( ) ? ( ImGui_ImplOpenGL2_Data * ) ImGui : : GetIO ( ) . BackendRendererUserData : nullptr ;
2021-06-30 16:22:15 +03:00
}
2018-02-17 00:01:48 +03:00
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 ( )
{
2018-03-21 00:18:18 +03:00
ImGuiIO & io = ImGui : : GetIO ( ) ;
2024-05-13 16:07:13 +03:00
IMGUI_CHECKVERSION ( ) ;
2022-10-11 13:22:29 +03:00
IM_ASSERT ( io . BackendRendererUserData = = nullptr & & " Already initialized a renderer backend! " ) ;
2021-06-28 17:52:10 +03:00
// Setup backend capabilities flags
2021-06-30 16:22:15 +03:00
ImGui_ImplOpenGL2_Data * bd = IM_NEW ( ImGui_ImplOpenGL2_Data ) ( ) ;
2021-06-28 17:52:10 +03:00
io . BackendRendererUserData = ( void * ) bd ;
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 ( ) ;
2021-06-28 17:52:10 +03:00
2018-02-17 00:01:48 +03:00
return true ;
}
void ImGui_ImplOpenGL2_Shutdown ( )
{
2021-06-30 16:22:15 +03:00
ImGui_ImplOpenGL2_Data * bd = ImGui_ImplOpenGL2_GetBackendData ( ) ;
2022-10-11 13:22:29 +03:00
IM_ASSERT ( bd ! = nullptr & & " No renderer backend to shutdown, or already shutdown? " ) ;
2021-09-20 19:43:05 +03:00
ImGuiIO & io = ImGui : : GetIO ( ) ;
2021-06-28 17:52:10 +03:00
2018-03-21 00:18:18 +03:00
ImGui_ImplOpenGL2_ShutdownPlatformInterface ( ) ;
2018-02-17 00:01:48 +03:00
ImGui_ImplOpenGL2_DestroyDeviceObjects ( ) ;
2022-10-11 13:22:29 +03:00
io . BackendRendererName = nullptr ;
io . BackendRendererUserData = nullptr ;
2023-04-19 17:40:18 +03:00
io . BackendFlags & = ~ ImGuiBackendFlags_RendererHasViewports ;
2021-06-30 16:22:15 +03:00
IM_DELETE ( bd ) ;
2018-02-17 00:01:48 +03:00
}
void ImGui_ImplOpenGL2_NewFrame ( )
{
2021-06-28 17:52:10 +03:00
ImGui_ImplOpenGL2_Data * bd = ImGui_ImplOpenGL2_GetBackendData ( ) ;
2024-05-07 17:53:03 +03:00
IM_ASSERT ( bd ! = nullptr & & " Context or backend not initialized! Did you call ImGui_ImplOpenGL2_Init()? " ) ;
2021-06-29 18:53:41 +03:00
2021-06-28 17:52:10 +03:00
if ( ! bd - > FontTexture )
2018-02-17 00:01:48 +03:00
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 ) ;
2021-02-17 21:29:07 +03:00
//glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE_MINUS_SRC_ALPHA); // In order to composite our output buffer we need to preserve alpha
2018-02-17 00:01:48 +03:00
glDisable ( GL_CULL_FACE ) ;
glDisable ( GL_DEPTH_TEST ) ;
2021-01-03 17:55:12 +03:00
glDisable ( GL_STENCIL_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 ) ;
2021-01-03 17:55:12 +03:00
glDisableClientState ( GL_NORMAL_ARRAY ) ;
2018-02-17 00:01:48 +03:00
glEnable ( GL_TEXTURE_2D ) ;
glPolygonMode ( GL_FRONT_AND_BACK , GL_FILL ) ;
2021-01-03 17:55:12 +03:00
glShadeModel ( GL_SMOOTH ) ;
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!!),
2021-01-03 17:55:12 +03:00
// you may need to backup/reset/restore other state, e.g. for current shader using the commented lines below.
// (DO NOT MODIFY THIS FILE! Add the code in your calling function)
// GLint last_program;
// glGetIntegerv(GL_CURRENT_PROGRAM, &last_program);
// glUseProgram(0);
// ImGui_ImplOpenGL2_RenderDrawData(...);
// glUseProgram(last_program)
// There are potentially many more states you could need to clear/setup that we can't access from default headers.
// e.g. glBindBuffer(GL_ARRAY_BUFFER, 0), glDisable(GL_TEXTURE_CUBE_MAP).
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 ) ;
2021-01-03 17:55:12 +03:00
GLint last_shade_model ; glGetIntegerv ( GL_SHADE_MODEL , & last_shade_model ) ;
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 ;
2023-11-09 18:44:39 +03:00
glVertexPointer ( 2 , GL_FLOAT , sizeof ( ImDrawVert ) , ( const GLvoid * ) ( ( const char * ) vtx_buffer + offsetof ( ImDrawVert , pos ) ) ) ;
glTexCoordPointer ( 2 , GL_FLOAT , sizeof ( ImDrawVert ) , ( const GLvoid * ) ( ( const char * ) vtx_buffer + offsetof ( ImDrawVert , uv ) ) ) ;
glColorPointer ( 4 , GL_UNSIGNED_BYTE , sizeof ( ImDrawVert ) , ( const GLvoid * ) ( ( const char * ) vtx_buffer + offsetof ( ImDrawVert , col ) ) ) ;
2018-02-17 00:01:48 +03:00
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
2021-08-24 18:03:52 +03:00
ImVec2 clip_min ( ( pcmd - > ClipRect . x - clip_off . x ) * clip_scale . x , ( pcmd - > ClipRect . y - clip_off . y ) * clip_scale . y ) ;
ImVec2 clip_max ( ( pcmd - > ClipRect . z - clip_off . x ) * clip_scale . x , ( pcmd - > ClipRect . w - clip_off . y ) * clip_scale . y ) ;
2021-11-30 23:48:29 +03:00
if ( clip_max . x < = clip_min . x | | clip_max . y < = clip_min . y )
2021-08-24 18:03:52 +03:00
continue ;
// Apply scissor/clipping rectangle (Y is inverted in OpenGL)
2022-10-11 13:22:29 +03:00
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 ) ) ;
2021-08-24 18:03:52 +03:00
// Bind texture, Draw
glBindTexture ( GL_TEXTURE_2D , ( GLuint ) ( intptr_t ) pcmd - > GetTexID ( ) ) ;
2021-12-08 18:26:52 +03:00
glDrawElements ( GL_TRIANGLES , ( GLsizei ) pcmd - > ElemCount , sizeof ( ImDrawIdx ) = = 2 ? GL_UNSIGNED_SHORT : GL_UNSIGNED_INT , idx_buffer + pcmd - > IdxOffset ) ;
2018-02-17 00:01:48 +03:00
}
}
}
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 ] ) ;
2021-01-03 17:55:12 +03:00
glShadeModel ( last_shade_model ) ;
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 ( ) ;
2021-06-28 17:52:10 +03:00
ImGui_ImplOpenGL2_Data * bd = ImGui_ImplOpenGL2_GetBackendData ( ) ;
2018-02-17 00:01:48 +03:00
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
2022-04-07 15:28:08 +03:00
// (Bilinear sampling is required by default. Set 'io.Fonts->Flags |= ImFontAtlasFlags_NoBakedLines' or 'style.AntiAliasedLinesUseTex = false' to allow point/nearest sampling)
2018-02-17 00:01:48 +03:00
GLint last_texture ;
glGetIntegerv ( GL_TEXTURE_BINDING_2D , & last_texture ) ;
2021-06-28 17:52:10 +03:00
glGenTextures ( 1 , & bd - > FontTexture ) ;
glBindTexture ( GL_TEXTURE_2D , bd - > FontTexture ) ;
2018-02-17 00:01:48 +03:00
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
2021-06-28 17:52:10 +03:00
io . Fonts - > SetTexID ( ( ImTextureID ) ( intptr_t ) bd - > FontTexture ) ;
2018-02-17 00:01:48 +03:00
// Restore state
glBindTexture ( GL_TEXTURE_2D , last_texture ) ;
return true ;
}
void ImGui_ImplOpenGL2_DestroyFontsTexture ( )
{
2021-06-28 17:52:10 +03:00
ImGuiIO & io = ImGui : : GetIO ( ) ;
ImGui_ImplOpenGL2_Data * bd = ImGui_ImplOpenGL2_GetBackendData ( ) ;
if ( bd - > FontTexture )
2018-02-17 00:01:48 +03:00
{
2021-06-28 17:52:10 +03:00
glDeleteTextures ( 1 , & bd - > FontTexture ) ;
2021-02-03 20:30:26 +03:00
io . Fonts - > SetTexID ( 0 ) ;
2021-06-28 17:52:10 +03:00
bd - > FontTexture = 0 ;
2018-02-17 00:01:48 +03:00
}
}
bool ImGui_ImplOpenGL2_CreateDeviceObjects ( )
{
return ImGui_ImplOpenGL2_CreateFontsTexture ( ) ;
}
void ImGui_ImplOpenGL2_DestroyDeviceObjects ( )
{
ImGui_ImplOpenGL2_DestroyFontsTexture ( ) ;
}
2018-03-21 00:18:18 +03:00
2023-07-21 00:18:47 +03:00
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
}
2023-03-29 19:41:41 +03:00
2023-07-13 12:27:52 +03:00
//-----------------------------------------------------------------------------
2023-03-23 20:17:45 +03:00
# if defined(__clang__)
# pragma clang diagnostic pop
# endif
2023-07-13 12:27:52 +03:00
# endif // #ifndef IMGUI_DISABLE