SLGLImGui Class Reference

ImGui Interface class for forwarding all events to the ImGui Handlers. More...

#include <SLGLImGui.h>

Inheritance diagram for SLGLImGui:

Public Member Functions
	SLGLImGui (cbOnImGuiBuild buildCB, cbOnImGuiLoadConfig loadConfigCB, cbOnImGuiSaveConfig saveConfigCB, int dpi, SLIOBuffer fontDataProp, SLIOBuffer fontDataFixed)
	~SLGLImGui () override
void	init (const string &configPath) override
	Initializes OpenGL handles to zero and sets the ImGui key map. More...
void	onInitNewFrame (SLScene *s, SLSceneView *sv) override
	Inits a new frame for the ImGui system. More...
void	onResize (const SLRecti &viewportRect) override
	Callback if window got resized. More...
void	onPaint (const SLRecti &viewport) override
	Callback for main rendering for the ImGui GUI system. More...
void	onMouseDown (SLMouseButton button, SLint x, SLint y) override
	Callback on mouse button down event. More...
void	onMouseUp (SLMouseButton button, SLint x, SLint y) override
	Callback on mouse button up event. More...
void	onMouseMove (SLint xPos, SLint yPos) override
	Updates the mouse cursor position. More...
void	onMouseWheel (SLfloat yoffset) override
	Callback for the mouse scroll movement. More...
void	onKeyPress (SLKey key, SLKey mod) override
	Callback on key press event. More...
void	onKeyRelease (SLKey key, SLKey mod) override
	Callback on key release event. More...
void	onCharInput (SLuint c) override
	Callback on character input. More...
void	onClose () override
	Callback on closing the application. More...
void	renderExtraFrame (SLScene *s, SLSceneView *sv, SLint mouseX, SLint mouseY) override
	Renders an extra frame with the current mouse position. More...
bool	doNotDispatchKeyboard () override
	inform if user keyboard input was consumed by the ui More...
bool	doNotDispatchMouse () override
	inform if user mouse input was consumed by the ui More...
void	loadFonts (SLfloat fontPropDots, SLfloat fontFixedDots)
	Loads the proportional and fixed size font depending on the passed DPI. More...
void	drawMouseCursor (bool doDraw) override
	Turns on or off the mouse cursor drawing. More...
Public Member Functions inherited from SLUiInterface
virtual	~SLUiInterface ()

Static Public Attributes
static SLfloat	fontPropDots = 16.0f
	Default font size of proportional font. More...
static SLfloat	fontFixedDots = 13.0f
	Default font size of fixed size font. More...

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

Private Attributes
cbOnImGuiBuild	_build = nullptr
cbOnImGuiSaveConfig	_saveConfig = nullptr
SLfloat	_timeSec
	Time in seconds. More...
SLVec2f	_mousePosPX
	Mouse cursor position. More...
SLfloat	_mouseWheel
	Mouse wheel position. More...
SLbool	_mousePressed [3]
	Mouse button press state. More...
SLuint	_fontTexture
	OpenGL texture id for font. More...
SLint	_progHandle
	OpenGL handle for shader program. More...
SLint	_vertHandle
	OpenGL handle for vertex shader. More...
SLint	_fragHandle
	OpenGL handle for fragment shader. More...
SLint	_attribLocTex
	OpenGL attribute location for texture. More...
SLint	_attribLocProjMtx
	OpenGL attribute location for ??? More...
SLint	_attribLocPosition
	OpenGL attribute location for vertex pos. More...
SLint	_attribLocUV
	OpenGL attribute location for texture coords. More...
SLint	_attribLocColor
	OpenGL attribute location for color. More...
SLuint	_vboHandle
	OpenGL handle for vertex buffer object. More...
SLuint	_vaoHandle
	OpenGL vertex array object handle. More...
SLuint	_elementsHandle
	OpenGL handle for vertex indexes. More...
SLfloat	_fontPropDots
	Active font size of proportional font. More...
SLfloat	_fontFixedDots
	Active font size of fixed size font. More...
SLstring	_configPath
	Path to config files. More...
SLIOBuffer	_fontDataProp
	Raw data of proportional font file. More...
SLIOBuffer	_fontDataFixed
	Raw data of fixed size font file. More...

Detailed Description

ImGui Interface class for forwarding all events to the ImGui Handlers.

ImGui is a super easy GUI library for the rendering of a UI with OpenGL. For more information see: https://github.com/ocornut/imgui

This class provides only the interface into ImGui. In the event handlers of SLSceneView the according callback in ImGui is called.
There is no UI drawn with this class. It must be defined in another class that provides the build function. For the Demo apps this is done in the class SLDemoGui and the build function is passed e.g. in glfwMain function of the app-demo project.

The full call stack for rendering one frame is:

• The top-level onPaint of the app (Win, Linux, MacOS, Android or iOS)
  • slUpdateAndPaint: C-Interface function of SLProject
    • SLSceneView::onPaint: Main onPaint function of a sceneview
      • SLGLImGui::onInitNewFrame: Initializes a new GUI frame
        • ImGui::NewFrame()
        • SLGLImGui::build: The UI build function
      • ... normal scene rendering of SLProject
      • SLSceneView::draw2DGL:
        • ImGui::Render
          • SLGLImGui::onPaint(ImGui::GetDrawData())
          • SLDemoGui::buildDemoGui: Builds the full UI

Definition at line 62 of file SLGLImGui.h.

Constructor & Destructor Documentation

SLGLImGui()

SLGLImGui::SLGLImGui	(	cbOnImGuiBuild	buildCB,
		cbOnImGuiLoadConfig	loadConfigCB,
		cbOnImGuiSaveConfig	saveConfigCB,
		int	dpi,
		SLIOBuffer	fontDataProp,
		SLIOBuffer	fontDataFixed
	)

Definition at line 24 of file SLGLImGui.cpp.

{
    _build             = buildCB;
    _saveConfig        = saveConfigCB;
    _fontTexture       = 0;
    _progHandle        = 0;
    _vertHandle        = 0;
    _fragHandle        = 0;
    _attribLocTex      = 0;
    _attribLocProjMtx  = 0;
    _attribLocPosition = 0;
    _attribLocUV       = 0;
    _attribLocColor    = 0;
    _vboHandle         = 0;
    _vaoHandle         = 0;
    _elementsHandle    = 0;
    _fontPropDots      = 13.0f;
    _fontFixedDots     = 16.0f;
    _mouseWheel        = 0.0f;
    _mousePressed[0]   = false;
    _mousePressed[1]   = false;
    _mousePressed[2]   = false;
    _fontDataProp      = fontDataProp;
    _fontDataFixed     = fontDataFixed;
 
    // create imgui context
    ImGui::CreateContext();
 
    // set default style to get a good initial configuration
    ImGui::StyleColorsDark();
    ImGuiIO& io = ImGui::GetIO();
    io.ConfigFlags |= ImGuiConfigFlags_DockingEnable; // Enable Docking
    // io.ConfigFlags |= ImGuiConfigFlags_ViewportsEnable; // Enable Multi-Viewport / Platform Windows
 
    // load config
    if (loadConfigCB)
        loadConfigCB(dpi);
 
    // load GUI fonts depending on the resolution
    loadFonts(SLGLImGui::fontPropDots, SLGLImGui::fontFixedDots);
 
    // Scale for proportional and fixed size fonts
    SLfloat dpiScaleProp  = (float)dpi / 120.0f;
    SLfloat dpiScaleFixed = (float)dpi / 142.0f;
 
    // Default settings for the first time
    SLGLImGui::fontPropDots  = std::max(16.0f * dpiScaleProp, 16.0f);
    SLGLImGui::fontFixedDots = std::max(13.0f * dpiScaleFixed, 13.0f);
}

~SLGLImGui()

SLGLImGui::~SLGLImGui ( )

override

Definition at line 79 of file SLGLImGui.cpp.

{
    if (_saveConfig)
        _saveConfig();
 
    // Destroy imgui context after your last imgui call
    ImGui::DestroyContext();
}

Member Function Documentation

createOpenGLObjects()

void SLGLImGui::createOpenGLObjects ( )

private

Creates all OpenGL objects for drawing the imGui.

Definition at line 188 of file SLGLImGui.cpp.

{
    // Backup GL state
    GLint last_texture = -1, last_array_buffer = -1, last_vertex_array = -1;
    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 highp 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 highp 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;
 
    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));
 
    GET_GL_ERROR;
 
    // Build texture atlas
    ImGuiIO& io     = ImGui::GetIO();
    SLuchar* pixels = nullptr;
    int      width = -1, height = -1;
 
    // 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 SLGLImGui::deleteOpenGLObjects ( )

private

Deletes all OpenGL objects for drawing the imGui.

Definition at line 331 of file SLGLImGui.cpp.

{
#ifdef SL_EMSCRIPTEN
    // The WebGL context is apparently already destroyed when we call this function
    return;
#endif
 
    if (_vaoHandle)
        glDeleteVertexArrays(1, &_vaoHandle);
    _vaoHandle = 0;
 
    if (_vboHandle)
        glDeleteBuffers(1, &_vboHandle);
    _vboHandle = 0;
 
    if (_elementsHandle)
        glDeleteBuffers(1, &_elementsHandle);
    _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);
        ImGui::GetIO().Fonts->TexID = nullptr;
        _fontTexture                = 0;
    }
    GET_GL_ERROR;
}

doNotDispatchKeyboard()

bool SLGLImGui::doNotDispatchKeyboard ( )

inlineoverridevirtual

inform if user keyboard input was consumed by the ui

Reimplemented from SLUiInterface.

Definition at line 87 of file SLGLImGui.h.

{ return ImGui::GetIO().WantCaptureKeyboard; }

doNotDispatchMouse()

bool SLGLImGui::doNotDispatchMouse ( )

inlineoverridevirtual

inform if user mouse input was consumed by the ui

(e.g. the ui was hit by a mouse click. In this case the user input would not be forwarded to 3D scene graph)

Reimplemented from SLUiInterface.

Definition at line 88 of file SLGLImGui.h.

{ return ImGui::GetIO().WantCaptureMouse; }

drawMouseCursor()

void SLGLImGui::drawMouseCursor ( bool  doDraw )

inlineoverridevirtual

Turns on or off the mouse cursor drawing.

Reimplemented from SLUiInterface.

Definition at line 90 of file SLGLImGui.h.

{ ImGui::GetIO().MouseDrawCursor = doDraw; }

init()

void SLGLImGui::init ( const string &  configPath )

overridevirtual

Initializes OpenGL handles to zero and sets the ImGui key map.

Reimplemented from SLUiInterface.

Definition at line 89 of file SLGLImGui.cpp.

{
    _fontTexture       = 0;
    _progHandle        = 0;
    _vertHandle        = 0;
    _fragHandle        = 0;
    _attribLocTex      = 0;
    _attribLocProjMtx  = 0;
    _attribLocPosition = 0;
    _attribLocUV       = 0;
    _attribLocColor    = 0;
    _vboHandle         = 0;
    _vaoHandle         = 0;
    _elementsHandle    = 0;
    _fontPropDots      = 13.0f;
    _fontFixedDots     = 16.0f;
    _mouseWheel        = 0.0f;
    _mousePressed[0]   = false;
    _mousePressed[1]   = false;
    _mousePressed[2]   = false;
    _configPath        = configPath;
 
    ImGuiIO& io                    = ImGui::GetIO();
    io.IniSavingRate               = 1.0f;
    io.IniFilename                 = NULL; // Disable ini config saving because we handle that ourselves
    io.KeyMap[ImGuiKey_Tab]        = K_tab;
    io.KeyMap[ImGuiKey_LeftArrow]  = K_left;
    io.KeyMap[ImGuiKey_RightArrow] = K_right;
    io.KeyMap[ImGuiKey_UpArrow]    = K_up;
    io.KeyMap[ImGuiKey_DownArrow]  = K_down;
    io.KeyMap[ImGuiKey_PageUp]     = K_pageUp;
    io.KeyMap[ImGuiKey_PageDown]   = K_pageUp;
    io.KeyMap[ImGuiKey_Home]       = K_home;
    io.KeyMap[ImGuiKey_End]        = K_end;
    io.KeyMap[ImGuiKey_Delete]     = K_delete;
    io.KeyMap[ImGuiKey_Backspace]  = K_backspace;
    io.KeyMap[ImGuiKey_Enter]      = K_enter;
    io.KeyMap[ImGuiKey_Escape]     = K_esc;
    io.KeyMap[ImGuiKey_A]          = 'A';
    io.KeyMap[ImGuiKey_C]          = 'C';
    io.KeyMap[ImGuiKey_V]          = 'V';
    io.KeyMap[ImGuiKey_X]          = 'X';
    io.KeyMap[ImGuiKey_Y]          = 'Y';
    io.KeyMap[ImGuiKey_Z]          = 'Z';
 
    // The screen size is set again in onResize
    io.DisplaySize             = ImVec2(0, 0);
    io.DisplayFramebufferScale = ImVec2(1, 1);
 
#if defined(SL_OS_ANDROID) || defined(SL_OS_MACIOS) || defined(SL_EMSCRIPTEN)
    io.MouseDrawCursor = false;
#else
    io.MouseDrawCursor = true;
#endif
 
    // Change default style to show the widget border
    ImGuiStyle& style     = ImGui::GetStyle();
    style.FrameBorderSize = 1;
 
    // Load ImGui config from imgui.ini
    SLstring iniFile = configPath + "imgui.ini";
    if (SLFileStorage::exists(iniFile, IOK_config))
    {
        SLstring iniContents = SLFileStorage::readIntoString(iniFile,
                                                             IOK_config);
        ImGui::LoadIniSettingsFromMemory(iniContents.c_str(),
                                         iniContents.size());
    }
}

loadFonts()

void SLGLImGui::loadFonts	(	SLfloat	fontPropDots,
		SLfloat	fontFixedDots
	)

Loads the proportional and fixed size font depending on the passed DPI.

Definition at line 160 of file SLGLImGui.cpp.

{
    _fontPropDots  = fontPropDotsToLoad;
    _fontFixedDots = fontFixedDotsToLoad;
 
    ImGuiIO& io = ImGui::GetIO();
    io.Fonts->Clear();
 
    // Create copies of the font data because ImGUI takes ownerhip of the data.
    SLIOBuffer fontDataProp  = _fontDataProp.copy();
    SLIOBuffer fontDataFixed = _fontDataFixed.copy();
 
    // Load proportional font for menu and text displays
    io.Fonts->AddFontFromMemoryTTF(fontDataProp.data,
                                   static_cast<int>(fontDataProp.size),
                                   fontPropDotsToLoad);
 
    // Load fixed size font for statistics windows
    io.Fonts->AddFontFromMemoryTTF(fontDataFixed.data,
                                   static_cast<int>(fontDataFixed.size),
                                   fontFixedDotsToLoad);
 
    deleteOpenGLObjects();
    createOpenGLObjects();
}

onCharInput()

void SLGLImGui::onCharInput ( SLuint  c )

overridevirtual

Callback on character input.

Reimplemented from SLUiInterface.

Definition at line 689 of file SLGLImGui.cpp.

{
    ImGuiIO& io = ImGui::GetIO();
    if (c > 0 && c < 0x10000)
        io.AddInputCharacter((unsigned short)c);
}

onClose()

void SLGLImGui::onClose ( )

overridevirtual

Callback on closing the application.

Reimplemented from SLUiInterface.

Definition at line 697 of file SLGLImGui.cpp.

{
    deleteOpenGLObjects();
}

onInitNewFrame()

void SLGLImGui::onInitNewFrame ( SLScene *  s, SLSceneView *  sv  )

overridevirtual

Inits a new frame for the ImGui system.

Reimplemented from SLUiInterface.

Definition at line 399 of file SLGLImGui.cpp.

{
    // If no _build function is provided there is no ImGui
    // if (!_build) return;
 
    if ((SLint)SLGLImGui::fontPropDots != (SLint)_fontPropDots ||
        (SLint)SLGLImGui::fontFixedDots != (SLint)_fontFixedDots)
        loadFonts(SLGLImGui::fontPropDots, SLGLImGui::fontFixedDots);
 
    if (!_fontTexture)
        createOpenGLObjects();
 
    ImGuiIO& io = ImGui::GetIO();
 
    // Setup time step
    SLfloat nowSec = GlobalTimer::timeS();
    io.DeltaTime   = _timeSec > 0.0 ? nowSec - _timeSec : 1.0f / 60.0f;
    if (io.DeltaTime < 0) io.DeltaTime = 1.0f / 60.0f;
    _timeSec = nowSec;
 
    io.MouseWheel = _mouseWheel;
    _mouseWheel   = 0.0f;
 
    // Start the frame
    ImGui::NewFrame();
 
    // Save ImGui config to imgui.ini
    if (ImGui::GetIO().WantSaveIniSettings)
    {
        SLstring    iniFile = _configPath + "imgui.ini";
        size_t      iniContentsSize;
        const char* rawIniContents = ImGui::SaveIniSettingsToMemory(&iniContentsSize);
        SLstring    iniContents(rawIniContents, rawIniContents + iniContentsSize);
        SLFileStorage::writeString(iniFile, IOK_config, iniContents);
        ImGui::GetIO().WantSaveIniSettings = false;
    }
 
    // Call the _build function. The whole UI is constructed here
    // This function is provided by the top-level project.
    // For the SLProject demo apps this _build function is implemented in the
    // class SLDemoGui.
    if (_build)
        _build(s, sv);
}

onKeyPress()

void SLGLImGui::onKeyPress ( SLKey  key, SLKey  mod  )

overridevirtual

Callback on key press event.

Reimplemented from SLUiInterface.

Definition at line 669 of file SLGLImGui.cpp.

{
    ImGuiIO& io      = ImGui::GetIO();
    io.KeysDown[key] = true;
    io.KeyCtrl       = mod & K_ctrl ? true : false;
    io.KeyShift      = mod & K_shift ? true : false;
    io.KeyAlt        = mod & K_alt ? true : false;
}

onKeyRelease()

void SLGLImGui::onKeyRelease ( SLKey  key, SLKey  mod  )

overridevirtual

Callback on key release event.

Reimplemented from SLUiInterface.

Definition at line 679 of file SLGLImGui.cpp.

{
    ImGuiIO& io      = ImGui::GetIO();
    io.KeysDown[key] = false;
    io.KeyCtrl       = mod & K_ctrl ? true : false;
    io.KeyShift      = mod & K_shift ? true : false;
    io.KeyAlt        = mod & K_alt ? true : false;
}

onMouseDown()

void SLGLImGui::onMouseDown ( SLMouseButton  button, SLint  x, SLint  y  )

overridevirtual

Callback on mouse button down event.

Reimplemented from SLUiInterface.

Definition at line 633 of file SLGLImGui.cpp.

{
    ImGuiIO& io = ImGui::GetIO();
    io.MousePos = ImVec2((SLfloat)x, (SLfloat)y);
    if (button == MB_left) io.MouseDown[0] = true;
    if (button == MB_right) io.MouseDown[1] = true;
    if (button == MB_middle) io.MouseDown[2] = true;
    // SL_LOG("D");
}

onMouseMove()

void SLGLImGui::onMouseMove ( SLint  xPos, SLint  yPos  )

overridevirtual

Updates the mouse cursor position.

Reimplemented from SLUiInterface.

Definition at line 655 of file SLGLImGui.cpp.

{
    ImGui::GetIO().MousePos = ImVec2((SLfloat)xPos, (SLfloat)yPos);
    // SL_LOG("M");
}

onMouseUp()

void SLGLImGui::onMouseUp ( SLMouseButton  button, SLint  x, SLint  y  )

overridevirtual

Callback on mouse button up event.

Reimplemented from SLUiInterface.

Definition at line 644 of file SLGLImGui.cpp.

{
    ImGuiIO& io = ImGui::GetIO();
    io.MousePos = ImVec2((SLfloat)x, (SLfloat)y);
    if (button == MB_left) io.MouseDown[0] = false;
    if (button == MB_right) io.MouseDown[1] = false;
    if (button == MB_middle) io.MouseDown[2] = false;
    // SL_LOG("U\n");
}

onMouseWheel()

void SLGLImGui::onMouseWheel ( SLfloat  yoffset )

overridevirtual

Callback for the mouse scroll movement.

Reimplemented from SLUiInterface.

Definition at line 662 of file SLGLImGui.cpp.

{
    // Use fractional mouse wheel, 1.0 unit 5 lines.
    _mouseWheel += yoffset;
}

onPaint()

void SLGLImGui::onPaint ( const SLRecti &  viewport )

overridevirtual

Callback for main rendering for the ImGui GUI system.

Reimplemented from SLUiInterface.

Definition at line 453 of file SLGLImGui.cpp.

{
    ImGui::Render();
    ImDrawData* draw_data = ImGui::GetDrawData();
 
    ImGuiIO& io = ImGui::GetIO();
 
    // Avoid rendering when minimized, scale coordinates for retina displays
    // (screen coordinates != framebuffer coordinates)
    int fb_width  = (int)(io.DisplaySize.x * io.DisplayFramebufferScale.x);
    int fb_height = (int)(io.DisplaySize.y * io.DisplayFramebufferScale.y);
    if (fb_width == 0 || fb_height == 0) return;
    draw_data->ScaleClipRects(io.DisplayFramebufferScale);
 
    // Backup GL state
    GLint last_active_texture = -1;
    glGetIntegerv(GL_ACTIVE_TEXTURE, &last_active_texture);
    glActiveTexture(GL_TEXTURE0);
 
    GLint last_program = -1;
    glGetIntegerv(GL_CURRENT_PROGRAM, &last_program);
    GLint last_texture = -1;
    glGetIntegerv(GL_TEXTURE_BINDING_2D, &last_texture);
    GLint last_array_buffer = -1;
    glGetIntegerv(GL_ARRAY_BUFFER_BINDING, &last_array_buffer);
    GLint last_element_array_buffer = -1;
    glGetIntegerv(GL_ELEMENT_ARRAY_BUFFER_BINDING, &last_element_array_buffer);
    GLint last_vertex_array = -1;
    glGetIntegerv(GL_VERTEX_ARRAY_BINDING, &last_vertex_array);
    GLint last_blend_src_rgb = -1;
    glGetIntegerv(GL_BLEND_SRC_RGB, &last_blend_src_rgb);
    GLint last_blend_dst_rgb = -1;
    glGetIntegerv(GL_BLEND_DST_RGB, &last_blend_dst_rgb);
    GLint last_blend_src_alpha = -1;
    glGetIntegerv(GL_BLEND_SRC_ALPHA, &last_blend_src_alpha);
    GLint last_blend_dst_alpha = -1;
    glGetIntegerv(GL_BLEND_DST_ALPHA, &last_blend_dst_alpha);
    GLint last_blend_equation_rgb = -1;
    glGetIntegerv(GL_BLEND_EQUATION_RGB, &last_blend_equation_rgb);
    GLint last_blend_equation_alpha = -1;
    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)fb_width,
                   (GLsizei)fb_height);
    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)(fb_height - 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]);
}

onResize()

void SLGLImGui::onResize ( const SLRecti &  viewportRect )

overridevirtual

Callback if window got resized.

Reimplemented from SLUiInterface.

Definition at line 445 of file SLGLImGui.cpp.

{
    ImGuiIO& io                = ImGui::GetIO();
    io.DisplaySize             = ImVec2((SLfloat)viewportRect.width, (SLfloat)viewportRect.height);
    io.DisplayFramebufferScale = ImVec2(1, 1);
}

printCompileErrors()

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

private

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

Definition at line 380 of file SLGLImGui.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);
    }
}

renderExtraFrame()

void SLGLImGui::renderExtraFrame ( SLScene *  s, SLSceneView *  sv, SLint  mouseX, SLint  mouseY  )

overridevirtual

Renders an extra frame with the current mouse position.

Reimplemented from SLUiInterface.

Definition at line 703 of file SLGLImGui.cpp.

{
    // If ImGui _build function exists render the ImGui
    if (_build)
    {
        ImGui::GetIO().MousePos = ImVec2((SLfloat)mouseX, (SLfloat)mouseY);
        onInitNewFrame(s, sv);
        ImGui::Render();
        onPaint(sv->viewportRect());
    }
}

Member Data Documentation

_attribLocColor

SLint SLGLImGui::_attribLocColor

private

OpenGL attribute location for color.

Definition at line 120 of file SLGLImGui.h.

_attribLocPosition

SLint SLGLImGui::_attribLocPosition

private

OpenGL attribute location for vertex pos.

Definition at line 118 of file SLGLImGui.h.

_attribLocProjMtx

SLint SLGLImGui::_attribLocProjMtx

private

OpenGL attribute location for ???

Definition at line 117 of file SLGLImGui.h.

_attribLocTex

SLint SLGLImGui::_attribLocTex

private

OpenGL attribute location for texture.

Definition at line 116 of file SLGLImGui.h.

_attribLocUV

SLint SLGLImGui::_attribLocUV

private

OpenGL attribute location for texture coords.

Definition at line 119 of file SLGLImGui.h.

_build

cbOnImGuiBuild SLGLImGui::_build = nullptr

private

Definition at line 103 of file SLGLImGui.h.

_configPath

SLstring SLGLImGui::_configPath

private

Path to config files.

Definition at line 126 of file SLGLImGui.h.

_elementsHandle

SLuint SLGLImGui::_elementsHandle

private

OpenGL handle for vertex indexes.

Definition at line 123 of file SLGLImGui.h.

_fontDataFixed

SLIOBuffer SLGLImGui::_fontDataFixed

private

Raw data of fixed size font file.

Definition at line 128 of file SLGLImGui.h.

_fontDataProp

SLIOBuffer SLGLImGui::_fontDataProp

private

Raw data of proportional font file.

Definition at line 127 of file SLGLImGui.h.

_fontFixedDots

SLfloat SLGLImGui::_fontFixedDots

private

Active font size of fixed size font.

Definition at line 125 of file SLGLImGui.h.

_fontPropDots

SLfloat SLGLImGui::_fontPropDots

private

Active font size of proportional font.

Definition at line 124 of file SLGLImGui.h.

_fontTexture

SLuint SLGLImGui::_fontTexture

private

OpenGL texture id for font.

Definition at line 112 of file SLGLImGui.h.

_fragHandle

SLint SLGLImGui::_fragHandle

private

OpenGL handle for fragment shader.

Definition at line 115 of file SLGLImGui.h.

_mousePosPX

SLVec2f SLGLImGui::_mousePosPX

private

Mouse cursor position.

Definition at line 109 of file SLGLImGui.h.

_mousePressed

SLbool SLGLImGui::_mousePressed[3]

private

Mouse button press state.

Definition at line 111 of file SLGLImGui.h.

_mouseWheel

SLfloat SLGLImGui::_mouseWheel

private

Mouse wheel position.

Definition at line 110 of file SLGLImGui.h.

_progHandle

SLint SLGLImGui::_progHandle

private

OpenGL handle for shader program.

Definition at line 113 of file SLGLImGui.h.

_saveConfig

cbOnImGuiSaveConfig SLGLImGui::_saveConfig = nullptr

private

Definition at line 106 of file SLGLImGui.h.

_timeSec

SLfloat SLGLImGui::_timeSec

private

Time in seconds.

Definition at line 108 of file SLGLImGui.h.

_vaoHandle

SLuint SLGLImGui::_vaoHandle

private

OpenGL vertex array object handle.

Definition at line 122 of file SLGLImGui.h.

_vboHandle

SLuint SLGLImGui::_vboHandle

private

OpenGL handle for vertex buffer object.

Definition at line 121 of file SLGLImGui.h.

_vertHandle

SLint SLGLImGui::_vertHandle

private

OpenGL handle for vertex shader.

Definition at line 114 of file SLGLImGui.h.

fontFixedDots

SLfloat SLGLImGui::fontFixedDots = 13.0f

static

Default font size of fixed size font.

Definition at line 94 of file SLGLImGui.h.

fontPropDots

SLfloat SLGLImGui::fontPropDots = 16.0f

static

Default font size of proportional font.

Definition at line 93 of file SLGLImGui.h.

---

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

• SLGLImGui.h
• SLGLImGui.cpp