ImGuiRendererOpenGL Class Reference

#include <ImGuiWrapper.h>

Inheritance diagram for ImGuiRendererOpenGL:

Public Member Functions
	ImGuiRendererOpenGL (ImGuiContext *context)
	~ImGuiRendererOpenGL ()
void	render (const SLRecti &viewportRect) override
Public Member Functions inherited from ImGuiRenderer
	ImGuiRenderer (ImGuiContext *context)
virtual	~ImGuiRenderer ()

Private Member Functions
void	printCompileErrors (SLint shaderHandle, const SLchar *src)
	Prints the compile errors in case of a GLSL compile failure. More...
void	createOpenGLObjects ()
	Creates all OpenGL objects for drawing the imGui. More...
void	deleteOpenGLObjects ()
	Deletes all OpenGL objects for drawing the imGui. More...

Private Attributes
unsigned int	_fontTexture {0}
	OpenGL texture id for font. More...
int	_progHandle {0}
	OpenGL handle for shader program. More...
int	_vertHandle {0}
	OpenGL handle for vertex shader. More...
int	_fragHandle {0}
	OpenGL handle for fragment shader. More...
int	_attribLocTex {0}
	OpenGL attribute location for texture. More...
int	_attribLocProjMtx {0}
	OpenGL attribute location for ??? More...
int	_attribLocPosition {0}
	OpenGL attribute location for vertex pos. More...
int	_attribLocUV {0}
	OpenGL attribute location for texture coords. More...
int	_attribLocColor {0}
	OpenGL attribute location for color. More...
unsigned int	_vboHandle {0}
	OpenGL handle for vertex buffer object. More...
unsigned int	_vaoHandle {0}
	OpenGL vertex array object handle. More...
unsigned int	_elementsHandle {0}
	OpenGL handle for vertex indexes. More...

Additional Inherited Members
Protected Attributes inherited from ImGuiRenderer
ImGuiContext *	_context

Detailed Description

Definition at line 50 of file ImGuiWrapper.h.

Constructor & Destructor Documentation

ImGuiRendererOpenGL()

ImGuiRendererOpenGL::ImGuiRendererOpenGL ( ImGuiContext *  context )

inline

Definition at line 53 of file ImGuiWrapper.h.

      : ImGuiRenderer(context)
    {
        // Attention: define your fonts before calling this function!
        createOpenGLObjects();
    }

~ImGuiRendererOpenGL()

ImGuiRendererOpenGL::~ImGuiRendererOpenGL ( )

inline

Definition at line 60 of file ImGuiWrapper.h.

    {
        deleteOpenGLObjects();
    }

Member Function Documentation

createOpenGLObjects()

void ImGuiRendererOpenGL::createOpenGLObjects ( )

private

Creates all OpenGL objects for drawing the imGui.

Definition at line 40 of file ImGuiWrapper.cpp.

{
    // 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);
 
    // Build version string as the first statement
    SLGLState* state         = SLGLState::instance();
    SLstring   verGLSL       = state->glSLVersionNO();
    SLstring   vertex_shader = "#version " + verGLSL;
    if (state->glIsES3()) vertex_shader += " es";
    vertex_shader +=
      "\n"
      "#ifdef GL_ES\n"
      "precision mediump float;\n"
      "#endif\n"
      "\n"
      "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"
      " Frag_UV = UV;\n"
      " Frag_Color = Color;\n"
      " gl_Position = ProjMtx * vec4(Position.xy,0,1);\n"
      "}\n";
 
    SLstring fragment_shader = "#version " + verGLSL;
    if (state->glIsES3()) fragment_shader += " es";
    fragment_shader +=
      "\n"
      "#ifdef GL_ES\n"
      "precision mediump float;\n"
      "#endif\n"
      "\n"
      "uniform sampler2D Texture;\n"
      "in vec2 Frag_UV;\n"
      "in vec4 Frag_Color;\n"
      "out vec4 Out_Color;\n"
      "void main()\n"
      "{\n"
      " Out_Color = Frag_Color * texture( Texture, Frag_UV.st);\n"
      "}\n";
 
    _vertHandle         = (SLint)glCreateShader(GL_VERTEX_SHADER);
    _fragHandle         = (SLint)glCreateShader(GL_FRAGMENT_SHADER);
    const char* srcVert = vertex_shader.c_str();
    const char* srcFrag = fragment_shader.c_str();
    glShaderSource((SLuint)_vertHandle, 1, &srcVert, nullptr);
    glShaderSource((SLuint)_fragHandle, 1, &srcFrag, nullptr);
    glCompileShader((SLuint)_vertHandle);
    printCompileErrors(_vertHandle, srcVert);
    glCompileShader((SLuint)_fragHandle);
    printCompileErrors(_fragHandle, srcFrag);
 
    _progHandle = (SLint)glCreateProgram();
    glAttachShader((SLuint)_progHandle, (SLuint)_vertHandle);
    glAttachShader((SLuint)_progHandle, (SLuint)_fragHandle);
    glLinkProgram((SLuint)_progHandle);
 
    GET_GL_ERROR;
 
    _attribLocTex      = glGetUniformLocation((SLuint)_progHandle, "Texture");
    _attribLocProjMtx  = glGetUniformLocation((SLuint)_progHandle, "ProjMtx");
    _attribLocPosition = glGetAttribLocation((SLuint)_progHandle, "Position");
    _attribLocUV       = glGetAttribLocation((SLuint)_progHandle, "UV");
    _attribLocColor    = glGetAttribLocation((SLuint)_progHandle, "Color");
 
    GET_GL_ERROR;
 
    glGenBuffers(1, &_vboHandle);
    glGenBuffers(1, &_elementsHandle);
 
    glGenVertexArrays(1, &_vaoHandle);
    glBindVertexArray(_vaoHandle);
    glBindBuffer(GL_ARRAY_BUFFER, _vboHandle);
    glEnableVertexAttribArray((SLuint)_attribLocPosition);
    glEnableVertexAttribArray((SLuint)_attribLocUV);
    glEnableVertexAttribArray((SLuint)_attribLocColor);
 
    GET_GL_ERROR;
 
#define OFFSETOF(TYPE, ELEMENT) ((size_t) & (((TYPE*)nullptr)->ELEMENT))
    glVertexAttribPointer((SLuint)_attribLocPosition,
                          2,
                          GL_FLOAT,
                          GL_FALSE,
                          sizeof(ImDrawVert),
                          (GLvoid*)OFFSETOF(ImDrawVert, pos));
    glVertexAttribPointer((SLuint)_attribLocUV,
                          2,
                          GL_FLOAT,
                          GL_FALSE,
                          sizeof(ImDrawVert),
                          (GLvoid*)OFFSETOF(ImDrawVert, uv));
    glVertexAttribPointer((SLuint)_attribLocColor,
                          4,
                          GL_UNSIGNED_BYTE,
                          GL_TRUE,
                          sizeof(ImDrawVert),
                          (GLvoid*)OFFSETOF(ImDrawVert, col));
#undef OFFSETOF
 
    GET_GL_ERROR;
 
    // Build texture atlas
    ImGuiIO& io = _context->IO;
    SLuchar* pixels;
    int      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.
    io.Fonts->GetTexDataAsRGBA32(&pixels, &width, &height);
 
    // Upload texture to graphics system
    glGetIntegerv(GL_TEXTURE_BINDING_2D, &last_texture);
    glGenTextures(1, &_fontTexture);
    glBindTexture(GL_TEXTURE_2D, _fontTexture);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, pixels);
 
    GET_GL_ERROR;
 
    // Store our identifier
    io.Fonts->TexID = (void*)(intptr_t)_fontTexture;
 
    // Restore state
    glBindTexture(GL_TEXTURE_2D, (SLuint)last_texture);
 
    // Restore modified GL state
    glBindTexture(GL_TEXTURE_2D, (SLuint)last_texture);
    glBindBuffer(GL_ARRAY_BUFFER, (SLuint)last_array_buffer);
    glBindVertexArray((SLuint)last_vertex_array);
 
    GET_GL_ERROR;
}

deleteOpenGLObjects()

void ImGuiRendererOpenGL::deleteOpenGLObjects ( )

private

Deletes all OpenGL objects for drawing the imGui.

Definition at line 187 of file ImGuiWrapper.cpp.

{
    if (_vaoHandle) glDeleteVertexArrays(1, &_vaoHandle);
    if (_vboHandle) glDeleteBuffers(1, &_vboHandle);
    if (_elementsHandle) glDeleteBuffers(1, &_elementsHandle);
    _vaoHandle = _vboHandle = _elementsHandle = 0;
 
    if (_progHandle && _vertHandle) glDetachShader((SLuint)_progHandle,
                                                   (SLuint)_vertHandle);
    if (_vertHandle) glDeleteShader((SLuint)_vertHandle);
    _vertHandle = 0;
 
    if (_progHandle && _fragHandle) glDetachShader((SLuint)_progHandle,
                                                   (SLuint)_fragHandle);
    if (_fragHandle) glDeleteShader((SLuint)_fragHandle);
    _fragHandle = 0;
 
    if (_progHandle) glDeleteProgram((SLuint)_progHandle);
    _progHandle = 0;
 
    if (_fontTexture)
    {
        glDeleteTextures(1, &_fontTexture);
        _context->IO.Fonts->TexID = nullptr;
        _fontTexture              = 0;
    }
}

printCompileErrors()

void ImGuiRendererOpenGL::printCompileErrors ( SLint  shaderHandle, const SLchar *  src  )

private

Prints the compile errors in case of a GLSL compile failure.

Definition at line 21 of file ImGuiWrapper.cpp.

{
    // Check compiler log
    SLint compileSuccess = 0;
    glGetShaderiv((SLuint)shaderHandle, GL_COMPILE_STATUS, &compileSuccess);
    if (compileSuccess == GL_FALSE)
    {
        GLchar log[512];
        glGetShaderInfoLog((SLuint)shaderHandle,
                           sizeof(log),
                           nullptr,
                           &log[0]);
        SL_LOG("*** COMPILER ERROR ***");
        SL_LOG("%s\n---", log);
        SL_LOG("%s", src);
    }
}

render()

void ImGuiRendererOpenGL::render ( const SLRecti &  viewportRect )

overridevirtual

Reimplemented from ImGuiRenderer.

Definition at line 215 of file ImGuiWrapper.cpp.

{
    ImGui::SetCurrentContext(_context);
    ImGui::Render();
    ImDrawData* draw_data = ImGui::GetDrawData();
 
    ImGuiIO& io = _context->IO;
 
    // Avoid rendering when minimized, scale coordinates for retina displays
    // (screen coordinates != framebuffer coordinates)
    int fbWidth  = (int)(io.DisplaySize.x * io.DisplayFramebufferScale.x);
    int fbHeight = (int)(io.DisplaySize.y * io.DisplayFramebufferScale.y);
    if (fbWidth == 0 || fbHeight == 0)
        return;
    draw_data->ScaleClipRects(io.DisplayFramebufferScale);
 
    // Backup GL state
    GLint last_active_texture;
    glGetIntegerv(GL_ACTIVE_TEXTURE, &last_active_texture);
    glActiveTexture(GL_TEXTURE0);
 
    GLint last_program;
    glGetIntegerv(GL_CURRENT_PROGRAM, &last_program);
    GLint last_texture;
    glGetIntegerv(GL_TEXTURE_BINDING_2D, &last_texture);
    GLint last_array_buffer;
    glGetIntegerv(GL_ARRAY_BUFFER_BINDING, &last_array_buffer);
    GLint last_element_array_buffer;
    glGetIntegerv(GL_ELEMENT_ARRAY_BUFFER_BINDING, &last_element_array_buffer);
    GLint last_vertex_array;
    glGetIntegerv(GL_VERTEX_ARRAY_BINDING, &last_vertex_array);
    GLint last_blend_src_rgb;
    glGetIntegerv(GL_BLEND_SRC_RGB, &last_blend_src_rgb);
    GLint last_blend_dst_rgb;
    glGetIntegerv(GL_BLEND_DST_RGB, &last_blend_dst_rgb);
    GLint last_blend_src_alpha;
    glGetIntegerv(GL_BLEND_SRC_ALPHA, &last_blend_src_alpha);
    GLint last_blend_dst_alpha;
    glGetIntegerv(GL_BLEND_DST_ALPHA, &last_blend_dst_alpha);
    GLint last_blend_equation_rgb;
    glGetIntegerv(GL_BLEND_EQUATION_RGB, &last_blend_equation_rgb);
    GLint last_blend_equation_alpha;
    glGetIntegerv(GL_BLEND_EQUATION_ALPHA, &last_blend_equation_alpha);
    GLint last_viewport[4];
    glGetIntegerv(GL_VIEWPORT, last_viewport);
    GLint last_scissor_box[4];
    glGetIntegerv(GL_SCISSOR_BOX, last_scissor_box);
 
    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);
 
    // Setup render state: alpha-blending enabled, no face culling, no depth testing, scissor enabled
    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);
 
    // Setup viewport
    if (viewportRect.isEmpty())
        glViewport(0,
                   0,
                   (GLsizei)fbWidth,
                   (GLsizei)fbHeight);
    else
        glViewport((GLsizei)(viewportRect.x * io.DisplayFramebufferScale.x),
                   (GLsizei)(viewportRect.y * io.DisplayFramebufferScale.y),
                   (GLsizei)(viewportRect.width * io.DisplayFramebufferScale.x),
                   (GLsizei)(viewportRect.height * io.DisplayFramebufferScale.y));
 
    // Setup orthographic projection matrix
    // clang-format off
    const float ortho_projection[4][4] =
    {
        {2.0f / io.DisplaySize.x, 0.0f,                     0.0f, 0.0f},
        {0.0f,                    2.0f / -io.DisplaySize.y, 0.0f, 0.0f},
        {0.0f,                    0.0f,                    -1.0f, 0.0f},
        {-1.0f,                   1.0f,                     0.0f, 1.0f},
    };
    // clang-format on
 
    glUseProgram((SLuint)_progHandle);
    glUniform1i(_attribLocTex, 0);
    glUniformMatrix4fv(_attribLocProjMtx, 1, GL_FALSE, &ortho_projection[0][0]);
    glBindVertexArray((SLuint)_vaoHandle);
 
    for (int n = 0; n < draw_data->CmdListsCount; n++)
    {
        const ImDrawList* cmd_list          = draw_data->CmdLists[n];
        const ImDrawIdx*  idx_buffer_offset = nullptr;
 
        glBindBuffer(GL_ARRAY_BUFFER, _vboHandle);
        glBufferData(GL_ARRAY_BUFFER,
                     (GLsizeiptr)cmd_list->VtxBuffer.Size * (GLsizeiptr)sizeof(ImDrawVert),
                     (const GLvoid*)cmd_list->VtxBuffer.Data,
                     GL_STREAM_DRAW);
 
        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, _elementsHandle);
        glBufferData(GL_ELEMENT_ARRAY_BUFFER,
                     (GLsizeiptr)cmd_list->IdxBuffer.Size * (GLsizeiptr)sizeof(ImDrawIdx),
                     (const GLvoid*)cmd_list->IdxBuffer.Data,
                     GL_STREAM_DRAW);
 
        for (int cmd_i = 0; cmd_i < cmd_list->CmdBuffer.Size; cmd_i++)
        {
            const ImDrawCmd* pcmd = &cmd_list->CmdBuffer[cmd_i];
            if (pcmd->UserCallback)
            {
                pcmd->UserCallback(cmd_list, pcmd);
            }
            else
            {
                glBindTexture(GL_TEXTURE_2D, (GLuint)(intptr_t)pcmd->TextureId);
 
                if (viewportRect.isEmpty())
                    glScissor((int)pcmd->ClipRect.x,
                              (int)(fbHeight - pcmd->ClipRect.w),
                              (int)(pcmd->ClipRect.z - pcmd->ClipRect.x),
                              (int)(pcmd->ClipRect.w - pcmd->ClipRect.y));
                else
                    glScissor((GLsizei)(viewportRect.x * io.DisplayFramebufferScale.x),
                              (GLsizei)(viewportRect.y * io.DisplayFramebufferScale.y),
                              (GLsizei)(viewportRect.width * io.DisplayFramebufferScale.x),
                              (GLsizei)(viewportRect.height * io.DisplayFramebufferScale.y));
 
                glDrawElements(GL_TRIANGLES,
                               (GLsizei)pcmd->ElemCount,
                               sizeof(ImDrawIdx) == 2 ? GL_UNSIGNED_SHORT : GL_UNSIGNED_INT,
                               idx_buffer_offset);
            }
            idx_buffer_offset += pcmd->ElemCount;
        }
    }
 
    // Restore modified GL state
    glUseProgram((SLuint)last_program);
    glBindTexture(GL_TEXTURE_2D, (SLuint)last_texture);
    glActiveTexture((SLuint)last_active_texture);
    glBindVertexArray((SLuint)last_vertex_array);
    glBindBuffer(GL_ARRAY_BUFFER, (SLuint)last_array_buffer);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, (SLuint)last_element_array_buffer);
    glBlendEquationSeparate((SLuint)last_blend_equation_rgb,
                            (SLuint)last_blend_equation_alpha);
    glBlendFuncSeparate((SLuint)last_blend_src_rgb,
                        (SLuint)last_blend_dst_rgb,
                        (SLuint)last_blend_src_alpha,
                        (SLuint)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);
 
    if (last_enable_scissor_test)
        glEnable(GL_SCISSOR_TEST);
    else
        glDisable(GL_SCISSOR_TEST);
 
    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]);
 
    ImGui::SetCurrentContext(nullptr);
}

Member Data Documentation

_attribLocColor

int ImGuiRendererOpenGL::_attribLocColor {0}

private

OpenGL attribute location for color.

Definition at line 80 of file ImGuiWrapper.h.

_attribLocPosition

int ImGuiRendererOpenGL::_attribLocPosition {0}

private

OpenGL attribute location for vertex pos.

Definition at line 78 of file ImGuiWrapper.h.

_attribLocProjMtx

int ImGuiRendererOpenGL::_attribLocProjMtx {0}

private

OpenGL attribute location for ???

Definition at line 77 of file ImGuiWrapper.h.

_attribLocTex

int ImGuiRendererOpenGL::_attribLocTex {0}

private

OpenGL attribute location for texture.

Definition at line 76 of file ImGuiWrapper.h.

_attribLocUV

int ImGuiRendererOpenGL::_attribLocUV {0}

private

OpenGL attribute location for texture coords.

Definition at line 79 of file ImGuiWrapper.h.

_elementsHandle

unsigned int ImGuiRendererOpenGL::_elementsHandle {0}

private

OpenGL handle for vertex indexes.

Definition at line 83 of file ImGuiWrapper.h.

_fontTexture

unsigned int ImGuiRendererOpenGL::_fontTexture {0}

private

OpenGL texture id for font.

Definition at line 72 of file ImGuiWrapper.h.

_fragHandle

int ImGuiRendererOpenGL::_fragHandle {0}

private

OpenGL handle for fragment shader.

Definition at line 75 of file ImGuiWrapper.h.

_progHandle

int ImGuiRendererOpenGL::_progHandle {0}

private

OpenGL handle for shader program.

Definition at line 73 of file ImGuiWrapper.h.

_vaoHandle

unsigned int ImGuiRendererOpenGL::_vaoHandle {0}

private

OpenGL vertex array object handle.

Definition at line 82 of file ImGuiWrapper.h.

_vboHandle

unsigned int ImGuiRendererOpenGL::_vboHandle {0}

private

OpenGL handle for vertex buffer object.

Definition at line 81 of file ImGuiWrapper.h.

_vertHandle

int ImGuiRendererOpenGL::_vertHandle {0}

private

OpenGL handle for vertex shader.

Definition at line 74 of file ImGuiWrapper.h.

---

The documentation for this class was generated from the following files:

• ImGuiWrapper.h
• ImGuiWrapper.cpp