Updated ImGui

ChangeLog.md

 
 ## OpenRaider (0.1.4) xythobuz <xythobuz@xythobuz.de>
 
+    [ 20150801 ]
+    * Updated to current Imgui version (now using indexed rendering)
+
     [ 20150429 ]
     * Fixed the new BoundingBox rendering approach
     * Fixed portal rendering method, no longer checking portals behind player.

include/UI.h

 
 #include "system/Shader.h"
 
-struct ImDrawList;
+struct ImDrawData;
 
 class UI {
   public:
     static void handleControllerAxis(float value, KeyboardButton axis);
     static void handleControllerButton(KeyboardButton button, bool released);
 
-    static void renderImGui(ImDrawList** const draw_lists, int count);
+    static void renderImGui(ImDrawData* draw_data);
 
   private:
     static bool visible;
     static Shader imguiShader;
     static const char* imguiShaderVertex;
     static const char* imguiShaderFragment;
+    static unsigned int vboHandle, elementHandle;
 };
 
 #endif

include/global.h

     abort();
 }
 
-#define orAssert(x) { \
+#define orAssert(x) do { \
     auto assertEvalTemp = x; \
     if (!assertEvalTemp) \
         orAssertImplementation(#x, assertEvalTemp, true, __FILE__, __LINE__); \
-}
+} while (0)
 
-#define orAssertEqual(x, y) { \
+#define orAssertEqual(x, y) do { \
     auto assertEvalTemp = x; \
     auto assertEvalTemp2 = y; \
     if (assertEvalTemp != assertEvalTemp2) \
         orAssertImplementation(#x " == " #y, assertEvalTemp, assertEvalTemp2, \
                                   __FILE__, __LINE__, "!="); \
-}
+} while (0)
 
-#define orAssertNotEqual(x, y) { \
+#define orAssertNotEqual(x, y) do { \
     auto assertEvalTemp = x; \
     auto assertEvalTemp2 = y; \
     if (assertEvalTemp == assertEvalTemp2) \
         orAssertImplementation(#x " != " #y, assertEvalTemp, assertEvalTemp2, \
                                   __FILE__, __LINE__, "=="); \
-}
+} while (0)
 
-#define orAssertLessThan(x, y) { \
+#define orAssertLessThan(x, y) do { \
     auto assertEvalTemp = x; \
     auto assertEvalTemp2 = y; \
     if (assertEvalTemp >= assertEvalTemp2) \
         orAssertImplementation(#x " < " #y, assertEvalTemp, assertEvalTemp2, \
                                   __FILE__, __LINE__, ">="); \
-}
+} while (0)
 
-#define orAssertLessThanEqual(x, y) { \
+#define orAssertLessThanEqual(x, y) do { \
     auto assertEvalTemp = x; \
     auto assertEvalTemp2 = y; \
     if (assertEvalTemp > assertEvalTemp2) \
         orAssertImplementation(#x " <= " #y, assertEvalTemp, assertEvalTemp2, \
                                   __FILE__, __LINE__, ">"); \
-}
+} while (0)
 
-#define orAssertGreaterThan(x, y) { \
+#define orAssertGreaterThan(x, y) do { \
     auto assertEvalTemp = x; \
     auto assertEvalTemp2 = y; \
     if (assertEvalTemp <= assertEvalTemp2) \
         orAssertImplementation(#x " > " #y, assertEvalTemp, assertEvalTemp2, \
                                   __FILE__, __LINE__, "<="); \
-}
+} while (0)
 
-#define orAssertGreaterThanEqual(x, y) { \
+#define orAssertGreaterThanEqual(x, y) do { \
     auto assertEvalTemp = x; \
     auto assertEvalTemp2 = y; \
     if (assertEvalTemp < assertEvalTemp2) \
         orAssertImplementation(#x " >= " #y, assertEvalTemp, assertEvalTemp2, \
                                   __FILE__, __LINE__, "<"); \
-}
+} while (0)
 
 #else // NDEBUG
 
 
 // Fall back to the default C assert
 #include <cassert>
+#define orAssert(x) assert(x)
 #define orAssertEqual(x, y) assert((x) == (y))
 #define orAssertNotEqual(x, y) assert((x) != (y))
 #define orAssertLessThan(x, y) assert((x) < (y))

include/system/Shader.h

     int addUniform(const char* name);
     unsigned int getUniform(int n);
 
+    int getAttrib(const char* name);
+
     void loadUniform(int uni, glm::vec2 vec);
     void loadUniform(int uni, glm::vec4 vec);
     void loadUniform(int uni, glm::mat4 mat);

src/Console.cpp

             logToTTY = logToClipboard = logToFile = false;
         }
         if (scrollToBottom) {
-            ImGui::SetScrollPosHere();
+            ImGui::SetScrollHere();
             scrollToBottom = false;
         }
         ImGui::EndChild();

src/SoundManager.cpp

         ImGui::SliderInt("##soundslide", &index, 0, soundMap.size() - 1);
         ImGui::PopItemWidth();
         ImGui::SameLine();
-        if (ImGui::Button("+##soundplus", ImVec2(0, 0), true)) {
+        if (ImGui::Button("+##soundplus", ImVec2(0, 0))) {
             if (index < (soundMap.size() - 1))
                 index++;
             else
                 index = 0;
         }
         ImGui::SameLine();
-        if (ImGui::Button("-##soundminus", ImVec2(0, 0), true)) {
+        if (ImGui::Button("-##soundminus", ImVec2(0, 0))) {
             if (index > 0)
                 index--;
             else

src/TextureManager.cpp

         ImGui::SliderInt("##texslide", &index, 0, TextureManager::numTextures(
                              game ? TextureStorage::GAME : TextureStorage::SYSTEM) - 1);
         ImGui::SameLine();
-        if (ImGui::Button("+##texplus", ImVec2(0, 0), true)) {
+        if (ImGui::Button("+##texplus", ImVec2(0, 0))) {
             if (index < (numTextures(
                              game ? TextureStorage::GAME : TextureStorage::SYSTEM) - 1))
                 index++;
                 index = 0;
         }
         ImGui::SameLine();
-        if (ImGui::Button("-##texminus", ImVec2(0, 0), true)) {
+        if (ImGui::Button("-##texminus", ImVec2(0, 0))) {
             if (index > 0)
                 index--;
             else
             ImGui::SliderInt("##tileslide", &index, 0, numTiles() - 1);
             ImGui::PopItemWidth();
             ImGui::SameLine();
-            if (ImGui::Button("+##tileplus", ImVec2(0, 0), true)) {
+            if (ImGui::Button("+##tileplus", ImVec2(0, 0))) {
                 if (index < (numTiles() - 1))
                     index++;
                 else
                     index = 0;
             }
             ImGui::SameLine();
-            if (ImGui::Button("-##tileminus", ImVec2(0, 0), true)) {
+            if (ImGui::Button("-##tileminus", ImVec2(0, 0))) {
                 if (index > 0)
                     index--;
                 else
                 tile = getFirstTileAnimation(index);
             }
             ImGui::SameLine();
-            if (ImGui::Button("+##animplus", ImVec2(0, 0), true)) {
+            if (ImGui::Button("+##animplus", ImVec2(0, 0))) {
                 if (index < (numAnimatedTiles() - 1))
                     index++;
                 else
                 tile = getFirstTileAnimation(index);
             }
             ImGui::SameLine();
-            if (ImGui::Button("-##animminus", ImVec2(0, 0), true)) {
+            if (ImGui::Button("-##animminus", ImVec2(0, 0))) {
                 if (index > 0)
                     index--;
                 else
                 sprite = 0;
             }
             ImGui::SameLine();
-            if (ImGui::Button("+##spriteplus", ImVec2(0, 0), true)) {
+            if (ImGui::Button("+##spriteplus", ImVec2(0, 0))) {
                 if (index < (World::sizeSpriteSequence() - 1))
                     index++;
                 else
                 sprite = 0;
             }
             ImGui::SameLine();
-            if (ImGui::Button("-##spriteminus", ImVec2(0, 0), true)) {
+            if (ImGui::Button("-##spriteminus", ImVec2(0, 0))) {
                 if (index > 0)
                     index--;
                 else

src/UI.cpp

 #include <glbinding/gl/gl.h>
 #include <glm/gtc/matrix_transform.hpp>
 
+#define OFFSETOF(TYPE, ELEMENT) (&(static_cast<TYPE *>(nullptr)->ELEMENT))
+
 Shader UI::imguiShader;
 bool UI::visible = false;
 unsigned int UI::fontTex;
 std::string UI::iniFilename;
 std::string UI::logFilename;
 bool UI::metaKeyIsActive = false;
+unsigned int UI::vboHandle = 0;
+unsigned int UI::elementHandle = 0;
 
 std::list<std::tuple<KeyboardButton, bool>> UI::keyboardEvents;
 std::list<std::tuple<unsigned int, unsigned int, KeyboardButton, bool>> UI::clickEvents;
     io.DisplaySize = ImVec2(s.x, s.y);
 }
 
+static int attribPos, attribUV, attribCol;
+
 int UI::initialize() {
     if (imguiShader.compile(imguiShaderVertex, imguiShaderFragment) < 0)
         return -1;
     if (imguiShader.addUniform("textureSampler") < 0)
         return -3;
 
+    attribPos = imguiShader.getAttrib("vertexPosition_screen");
+    attribUV = imguiShader.getAttrib("vertexUV");
+    attribCol = imguiShader.getAttrib("vertexColor");
+
     iniFilename = RunTime::getBaseDir() + "/imgui.ini";
     logFilename = RunTime::getBaseDir() + "/imgui_log.txt";
 
     auto bm = TextureManager::getBufferManager(fontTex, TextureStorage::SYSTEM);
     io.Fonts->TexID = bm;
 
+    gl::glGenBuffers(1, &vboHandle);
+    gl::glGenBuffers(1, &elementHandle);
+
     // Set up OpenRaider style
+    /*
     ImGuiStyle& style = ImGui::GetStyle();
     style.Colors[ImGuiCol_Text]                 = ImVec4(0.90f, 0.90f, 0.90f, 1.00f);
     style.Colors[ImGuiCol_WindowBg]             = ImVec4(0.00f, 0.00f, 0.00f, 1.00f);
     style.TouchExtraPadding                     = ImVec2(0, 0);
     style.IndentSpacing                         = 3;
     style.ScrollbarWidth                        = 10;
+    */
 
     return 0;
 }
 
 void UI::shutdown() {
     ImGui::Shutdown();
+
+    gl::glDeleteBuffers(1, &vboHandle);
+    gl::glDeleteBuffers(1, &elementHandle);
 }
 
 void UI::handleKeyboard(KeyboardButton key, bool pressed) {
     }
 }
 
-void UI::renderImGui(ImDrawList** const cmd_lists, int cmd_lists_count) {
-    if (cmd_lists_count == 0)
+void UI::renderImGui(ImDrawData* draw_data) {
+    if (draw_data->CmdListsCount == 0)
         return;
 
-    static ShaderBuffer vert, uv, col;
-
     gl::glEnable(gl::GL_SCISSOR_TEST);
     Shader::set2DState(true);
 
+    gl::glEnableVertexAttribArray(attribPos);
+    gl::glEnableVertexAttribArray(attribUV);
+    gl::glEnableVertexAttribArray(attribCol);
+
+    gl::glBindBuffer(gl::GL_ARRAY_BUFFER, vboHandle);
+
+    gl::glVertexAttribPointer(attribPos, 2, gl::GL_FLOAT, gl::GL_FALSE, sizeof(ImDrawVert), OFFSETOF(ImDrawVert, pos));
+    gl::glVertexAttribPointer(attribUV, 2, gl::GL_FLOAT, gl::GL_FALSE, sizeof(ImDrawVert), OFFSETOF(ImDrawVert, uv));
+    gl::glVertexAttribPointer(attribCol, 4, gl::GL_UNSIGNED_BYTE, gl::GL_TRUE, sizeof(ImDrawVert), OFFSETOF(ImDrawVert, col));
+
     imguiShader.use();
     imguiShader.loadUniform(0, Window::getSize());
-    vert.bindBuffer(0, 2);
-    uv.bindBuffer(1, 2);
-    col.bindBuffer(2, 4);
-
-    /*! \fixme Don't copy data
-     * The GL calls and the shaders can probably be slightly altered
-     * to avoid copying all the vertices, uvs and colors again here.
-     */
-
-    for (int i = 0; i < cmd_lists_count; i++) {
-        auto& commands = cmd_lists[i]->commands;
-        auto& buffer = cmd_lists[i]->vtx_buffer;
-
-        int offset = 0;
-        for (int n = 0; n < commands.size(); n++) {
-            std::vector<glm::vec2> vertices;
-            std::vector<glm::vec2> uvs;
-            std::vector<glm::vec4> colors;
-
-            for (int v = 0; v < commands[n].vtx_count; v++) {
-                vertices.push_back(glm::vec2(buffer[offset + v].pos.x, buffer[offset + v].pos.y));
-                uvs.push_back(glm::vec2(buffer[offset + v].uv.x, buffer[offset + v].uv.y));
-
-                float r, g, b, a;
-                a = ((buffer[offset + v].col & 0xFF000000) >> 24) / 255.0f;
-                b = ((buffer[offset + v].col & 0x00FF0000) >> 16) / 255.0f;
-                g = ((buffer[offset + v].col & 0x0000FF00) >> 8) / 255.0f;
-                r = (buffer[offset + v].col & 0x000000FF) / 255.0f;
-                colors.push_back(glm::vec4(r, g, b, a));
-            }
 
-            offset += commands[n].vtx_count;
+    for (int i = 0; i < draw_data->CmdListsCount; i++) {
+        const ImDrawList* cmd_list = draw_data->CmdLists[i];
+        const ImDrawIdx* idx_buffer_offset = 0;
 
-            vert.bufferData(vertices);
-            uv.bufferData(uvs);
-            col.bufferData(colors);
+        gl::glBindBuffer(gl::GL_ARRAY_BUFFER, vboHandle);
+        gl::glBufferData(gl::GL_ARRAY_BUFFER, cmd_list->VtxBuffer.size() * sizeof(ImDrawVert), &cmd_list->VtxBuffer.front(), gl::GL_STREAM_DRAW);
 
-            auto bm = static_cast<BufferManager*>(commands[n].texture_id);
-            orAssert(bm != nullptr);
-            imguiShader.loadUniform(1, bm->getTextureID(), bm->getTextureStorage());
+        gl::glBindBuffer(gl::GL_ELEMENT_ARRAY_BUFFER, elementHandle);
+        gl::glBufferData(gl::GL_ELEMENT_ARRAY_BUFFER, cmd_list->IdxBuffer.size() * sizeof(ImDrawIdx), &cmd_list->IdxBuffer.front(), gl::GL_STREAM_DRAW);
 
-            gl::glScissor(commands[n].clip_rect.x,
-                      Window::getSize().y - commands[n].clip_rect.w,
-                      commands[n].clip_rect.z - commands[n].clip_rect.x,
-                      commands[n].clip_rect.w - commands[n].clip_rect.y);
+        for (const ImDrawCmd* pcmd = cmd_list->CmdBuffer.begin(); pcmd != cmd_list->CmdBuffer.end(); pcmd++) {
+            if (pcmd->UserCallback) {
+                pcmd->UserCallback(cmd_list, pcmd);
+                Log::get(LOG_INFO) << "renderImGui: did not draw (Callback)" << Log::endl;
+            } else {
+                auto bm = static_cast<BufferManager*>(pcmd->TextureId);
+                orAssert(bm != nullptr);
+                imguiShader.loadUniform(1, bm->getTextureID(), bm->getTextureStorage());
+
+                gl::glScissor(pcmd->ClipRect.x,
+                              Window::getSize().y - pcmd->ClipRect.w,
+                              pcmd->ClipRect.z - pcmd->ClipRect.x,
+                              pcmd->ClipRect.w - pcmd->ClipRect.y);
 
-            gl::glDrawArrays(gl::GL_TRIANGLES, 0, vertices.size());
+                gl::glDrawElements(gl::GL_TRIANGLES, pcmd->ElemCount, gl::GL_UNSIGNED_SHORT, idx_buffer_offset);
+            }
+            idx_buffer_offset += pcmd->ElemCount;
         }
     }
 
-    vert.unbind(0);
-    uv.unbind(1);
-    col.unbind(2);
+    gl::glDisableVertexAttribArray(attribPos);
+    gl::glDisableVertexAttribArray(attribUV);
+    gl::glDisableVertexAttribArray(attribCol);
 
     Shader::set2DState(false);
     gl::glDisable(gl::GL_SCISSOR_TEST);

src/deps/imgui/imconfig.h

 
 #pragma once
 
-//---- Define your own ImVector<> type if you don't want to use the provided implementation defined in imgui.h
-//#include <vector>
-//#define ImVector  std::vector
-//#define ImVector  MyVector
-
 //---- Define assertion handler. Defaults to calling assert().
 #include "global.h"
-#define IM_ASSERT(_EXPR)  orAssert(_EXPR)
+#define IM_ASSERT(_EXPR) orAssert(_EXPR)
 
 //---- Define attributes of all API symbols declarations, e.g. for DLL under Windows.
 //#define IMGUI_API __declspec( dllexport )
 //---- Don't implement help and test window functionality (ShowUserGuide()/ShowStyleEditor()/ShowTestWindow() methods will be empty)
 //#define IMGUI_DISABLE_TEST_WINDOWS
 
+//---- Don't define obsolete functions names
+//#define IMGUI_DISABLE_OBSOLETE_FUNCTIONS
+
 //---- Implement STB libraries in a namespace to avoid conflicts
 //#define IMGUI_STB_NAMESPACE     ImStb
 

src/deps/imgui/stb_textedit.h

+// [ImGui] this is a slightly modified version of stb_truetype.h 1.4
+// [ImGui] we made a fix for using the END key on multi-line text edit, see https://github.com/ocornut/imgui/issues/275
+
 // stb_textedit.h - v1.4  - public domain - Sean Barrett
 // Development of this library was sponsored by RAD Game Tools
 //
          stb_textedit_move_to_first(state);
          stb_textedit_find_charpos(&find, str, state->cursor, state->single_line);
          state->cursor = find.first_char + find.length;
+         if (find.length > 0 && STB_TEXTEDIT_GETCHAR(str, state->cursor-1) == STB_TEXTEDIT_NEWLINE)
+            state->cursor--;
          state->has_preferred_x = 0;
          break;
       }
          stb_textedit_prep_selection_at_cursor(state);
          stb_textedit_find_charpos(&find, str, state->cursor, state->single_line);
          state->cursor = state->select_end = find.first_char + find.length;
+         if (find.length > 0 && STB_TEXTEDIT_GETCHAR(str, state->cursor-1) == STB_TEXTEDIT_NEWLINE)
+            state->cursor = state->select_end = state->cursor - 1;
          state->has_preferred_x = 0;
          break;
       }

src/system/Shader.cpp

         gl::glDeleteProgram(programID);
 }
 
+int Shader::getAttrib(const char* name) {
+    orAssert(programID >= 0);
+    orAssert(name != nullptr);
+    orAssert(name[0] != '\0');
+    return gl::glGetAttribLocation(programID, name);
+}
+
 int Shader::addUniform(const char* name) {
     orAssert(programID >= 0);
     int r = gl::glGetUniformLocation(programID, name);
     gl::glDepthFunc(gl::GL_LESS);
 
     gl::glEnable(gl::GL_BLEND);
+    gl::glBlendEquation(gl::GL_FUNC_ADD);
     gl::glBlendFunc(gl::GL_SRC_ALPHA, gl::GL_ONE_MINUS_SRC_ALPHA);
 
     gl::glPointSize(5.0f);