Imgui update, debugging

CMakeLists.txt

     set (WARNINGS "${WARNINGS} -Wno-padded -Wno-packed")
     set (WARNINGS "${WARNINGS} -Wno-global-constructors -Wno-exit-time-destructors")
     set (WARNINGS "${WARNINGS} -Wno-documentation-unknown-command -Wno-c++98-compat-pedantic")
+    set (WARNINGS "${WARNINGS} -Wno-date-time -Wno-unused-variable")
     set (WARNINGS "${WARNINGS} -Wno-shorten-64-to-32 -Wno-sign-compare -Wno-sign-conversion")
     set (OpenRaider_CXX_FLAGS "${OpenRaider_CXX_FLAGS} -std=c++11")
-    set (OpenRaider_CXX_FLAGS_DEBUG "${OpenRaider_CXX_FLAGS_DEBUG} -g -O0 -ftrapv")
-    set (OpenRaider_CXX_FLAGS_RELEASE "${OpenRaider_CXX_FLAGS_RELEASE} -O2 -fomit-frame-pointer")
-    set (OpenRaider_CXX_FLAGS_RELEASE "${OpenRaider_CXX_FLAGS_RELEASE} -ffast-math -funroll-loops")
+    set (OpenRaider_CXX_FLAGS_DEBUG "${OpenRaider_CXX_FLAGS_DEBUG} -g -O0")
+    set (OpenRaider_CXX_FLAGS_RELEASE "${OpenRaider_CXX_FLAGS_RELEASE} -O2")
 elseif ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
     set (WARNINGS "${WARNINGS} -Wall -Wextra -Wpedantic")
     set (OpenRaider_CXX_FLAGS "${OpenRaider_CXX_FLAGS} -std=c++11")
-    set (OpenRaider_CXX_FLAGS_DEBUG "${OpenRaider_CXX_FLAGS_DEBUG} -g -O0 -ftrapv")
-    set (OpenRaider_CXX_FLAGS_RELEASE "${OpenRaider_CXX_FLAGS_RELEASE} -O2 -fomit-frame-pointer")
-    set (OpenRaider_CXX_FLAGS_RELEASE "${OpenRaider_CXX_FLAGS_RELEASE} -ffast-math -funroll-loops")
+    set (OpenRaider_CXX_FLAGS_DEBUG "${OpenRaider_CXX_FLAGS_DEBUG} -g -O0")
+    set (OpenRaider_CXX_FLAGS_RELEASE "${OpenRaider_CXX_FLAGS_RELEASE} -O2")
 elseif ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")
     # TODO Visual C++ compiler flags?
 endif()

src/Render.cpp

         // Check all portals leading from this room to somewhere else
         for (int i = 0; i < World::getRoom(room).sizePortals(); i++) {
             auto& portal = World::getRoom(room).getPortal(i);
-            auto& room = World::getRoom(portal.getAdjoiningRoom());
+            auto& r = World::getRoom(portal.getAdjoiningRoom());
 
             // Calculate the 2D screen-space bounding box of this portal
             glm::vec3 newMin, newMax;
             for (int c = 0; c < 4; c++) {
-                glm::vec3 vert = portal.getVertex(c);
-                glm::vec4 result = VP * glm::vec4(vert, 1.0f);
-                vert = glm::vec3(result) / result.w;
+                glm::vec3 port = portal.getVertex(c);
+                glm::vec4 result = VP * glm::vec4(port, 1.0f);
+                glm::vec3 vert = glm::vec3(result) / result.w;
+
+                ImGui::Text("%.2f %.2f %.2f", port.x, port.y, port.z);
+                ImGui::Text("%.2f %.2f %.2f %.2f", result.x, result.y, result.z, result.w);
+                ImGui::Text("%.2f %.2f %.2f", vert.x, vert.y, vert.z);
+                ImGui::Text("----");
 
                 if (c == 0) {
                     newMin = vert;
                 }
             }
 
+            //ImGui::Text("%.2f %.2f %.2f", newMin.x, newMin.y, newMin.z);
+            //ImGui::Text("%.2f %.2f %.2f", newMax.x, newMax.y, newMax.z);
+            //ImGui::Text("----");
+
             //! \fixme Currently also checking behind player, because Z is always 1.0f?!
             //if ((newMin.z > 0.0f) || (newMin.z < -1.0f) || (newMax.z > 0.0f) || (newMax.z < -1.0f)) {
             //    continue;
             //}
 
+            //! \fixme Need to check portal normal, only render if it points in our direction
+            //if (!normalFacingUs) {
+            //    continue;
+            //}
+
             // Check if the portal intersects the portal leading into this room
             if (!((min.x < newMax.x) && (max.x > newMin.x)
                 && (min.y < newMax.y) && (max.y > newMin.y))) {
             }
 
             // Check if the connected room is in our view frustum (could be visible)
-            if (!Camera::boxInFrustum(room.getBoundingBox())) {
-                continue;
+            if (!Camera::boxInFrustum(r.getBoundingBox())) {
+                //continue;
             }
 
             // Check if this room is already in the list...
             bool found = false;
             for (int n = 0; n < roomList.size(); n++) {
-                if (roomList.at(n).room == &room) {
+                if (roomList.at(n).room == &r) {
                     found = true;
                     break;
                 }

src/UI.cpp

     io.DisplaySize = ImVec2(Window::getSize().x, Window::getSize().y);
 
     static unsigned long lastTime = 0;
-    io.DeltaTime = ((float)(systemTimerGet() - lastTime)) / 1000.0f;
+    io.DeltaTime = (systemTimerGet() - lastTime) / 1000.0f;
     lastTime = systemTimerGet();
     if (io.DeltaTime <= 0.0f)
         io.DeltaTime = 1.0f / 60.0f;
 
         if (!(visible || Console::isVisible() || Menu::isVisible())) {
             for (int n = forwardAction; n < ActionEventCount; n++) {
-                if (RunTime::getKeyBinding((ActionEvents)n) == std::get<0>(i))
-                    Game::handleAction((ActionEvents)n, !std::get<1>(i));
+                auto ae = static_cast<ActionEvents>(n);
+                if (RunTime::getKeyBinding(ae) == std::get<0>(i))
+                    Game::handleAction(ae, !std::get<1>(i));
             }
         }
 
 
 void UI::handleMouseClick(unsigned int x, unsigned int y, KeyboardButton button, bool released) {
     ImGuiIO& io = ImGui::GetIO();
-    io.MousePos = ImVec2((float)x, (float)y);
+    io.MousePos = ImVec2(x, y);
     if (button == leftmouseKey) {
         io.MouseDown[0] = !released;
     } else if (button == rightmouseKey) {
 
 void UI::handleMouseMotion(int xrel, int yrel, int xabs, int yabs) {
     ImGuiIO& io = ImGui::GetIO();
-    io.MousePos = ImVec2((float)xabs, (float)yabs);
+    io.MousePos = ImVec2(xabs, yabs);
 
     motionEvents.push_back(std::make_tuple(xrel, yrel, xabs, yabs));
 }

src/commands/CommandBind.cpp

         char c = key[1];
         if (((c >= '0') && (c <= '9'))
             || ((c >= 'a') && (c <= 'z')))
-            return (KeyboardButton)c;
+            return static_cast<KeyboardButton>(c);
     } else if ((key.length() >= 3) && (key[0] == '\"') && (key[key.length() - 1] == '\"')) {
         // Special characters like tilde, esc, quote...
         key.erase(key.length() - 1); // Delete " at end

src/deps/imgui/imconfig.h

 //#define IMGUI_API __declspec( dllexport )
 //#define IMGUI_API __declspec( dllimport )
 
+//---- Include imgui_user.inl at the end of imgui.cpp so you can include code that extends ImGui using its private data/functions.
+#define IMGUI_INCLUDE_IMGUI_USER_INL
+
+//---- Include imgui_user.h at the end of imgui.h
+#define IMGUI_INCLUDE_IMGUI_USER_H
+
 //---- Don't implement default handlers for Windows (so as not to link with OpenClipboard() and others Win32 functions)
 //#define IMGUI_DISABLE_WIN32_DEFAULT_CLIPBOARD_FUNCS
 //#define IMGUI_DISABLE_WIN32_DEFAULT_IME_FUNCS
 //---- Don't implement help and test window functionality (ShowUserGuide()/ShowStyleEditor()/ShowTestWindow() methods will be empty)
 //#define IMGUI_DISABLE_TEST_WINDOWS
 
-//---- Include imgui_user.inl at the end of imgui.cpp so you can include code that extends ImGui using its private data/functions.
-#define IMGUI_INCLUDE_IMGUI_USER_INL
-
-//---- Include imgui_user.h at the end of imgui.h
-#define IMGUI_INCLUDE_IMGUI_USER_H
+//---- Implement STB libraries in a namespace to avoid conflicts
+//#define IMGUI_STB_NAMESPACE     ImStb
 
 //---- Define constructor and implicit cast operators to convert back<>forth from your math types and ImVec2/ImVec4.
 #define IM_VEC2_CLASS_EXTRA                                                \

src/deps/imgui/imgui.cpp

-// ImGui library v1.38 WIP
+// ImGui library v1.39 WIP
 // See ImGui::ShowTestWindow() for sample code.
 // Read 'Programmer guide' below for notes on how to setup ImGui in your codebase.
 // Get latest version at https://github.com/ocornut/imgui
  - API BREAKING CHANGES (read me when you update!)
  - FREQUENTLY ASKED QUESTIONS (FAQ), TIPS
    - Can I have multiple widgets with the same label? (Yes)
+   - How do I update to a newer version of ImGui?
    - Why is my text output blurry?
    - How can I load a different font than the default? 
    - How can I load multiple fonts?
       e.g. when displaying a single object that may change over time (1-1 relationship), using a static string as ID will preserve your node open/closed state when the targeted object change.
       e.g. when displaying a list of objects, using indices or pointers as ID will preserve the node open/closed state differently. experiment and see what makes more sense!
 
+ Q: How do I update to a newer version of ImGui?
+ A: Overwrite the following files:
+     imgui.cpp
+     imgui.h
+     stb_rect_pack.h
+     stb_textedit.h
+     stb_truetype.h
+    Check the "API BREAKING CHANGES" sections for a list of occasional API breaking changes.
+
  Q: Why is my text output blurry?
  A: In your Render function, try translating your projection matrix by (0.5f,0.5f) or (0.375f,0.375f)
 
 static void         ItemSize(ImVec2 size, float text_offset_y = 0.0f);
 static void         ItemSize(const ImRect& bb, float text_offset_y = 0.0f);
 static void         PushColumnClipRect(int column_index = -1);
-static bool         IsClippedEx(const ImRect& bb, bool clip_even_when_logged);
+static bool         IsClippedEx(const ImRect& bb, const ImGuiID* id, bool clip_even_when_logged);
 
 static bool         IsMouseHoveringRect(const ImRect& bb);
 static bool         IsKeyPressedMap(ImGuiKey key, bool repeat = true);
     ImGuiID                 ScalarAsInputTextId;                // Temporary text input when CTRL+clicking on a slider, etc.
     ImGuiStorage            ColorEditModeStorage;               // for user selection
     ImGuiID                 ActiveComboID;
+    ImVec2                  ActiveClickDeltaToCenter;
     float                   DragCurrentValue;                   // current dragged value, always float, not rounded by end-user precision settings
     ImVec2                  DragLastMouseDelta;
     float                   DragSpeedDefaultRatio;              // if speed == 0.0f, uses (max-min) * DragSpeedDefaultRatio
 
         ScalarAsInputTextId = 0;
         ActiveComboID = 0;
+        ActiveClickDeltaToCenter = ImVec2(0.0f, 0.0f);
         DragCurrentValue = 0.0f;
         DragLastMouseDelta = ImVec2(0.0f, 0.0f);
         DragSpeedDefaultRatio = 0.01f;
     return &it->val_f;
 }
 
+void** ImGuiStorage::GetVoidPtrRef(ImGuiID key, void* default_val)
+{
+    ImVector<Pair>::iterator it = LowerBound(Data, key);
+    if (it == Data.end() || it->key != key)
+        it = Data.insert(it, Pair(key, default_val));
+    return &it->val_p;
+}
+
 // FIXME-OPT: Wasting CPU because all SetInt() are preceeded by GetInt() calls so we should have the result from lower_bound already in place.
 // However we only use SetInt() on explicit user action (so that's maximum once a frame) so the optimisation isn't much needed.
 void ImGuiStorage::SetInt(ImU32 key, int val)
                 while (line < text_end)
                 {
                     const char* line_end = strchr(line, '\n');
-                    if (IsClippedEx(line_rect, false))
+                    if (IsClippedEx(line_rect, NULL, false))
                         break;
 
                     const ImVec2 line_size = CalcTextSize(line, line_end, false);
     return value;
 }
 
-static bool SliderBehavior(const ImRect& frame_bb, const ImRect& slider_bb, ImGuiID id, float* v, float v_min, float v_max, float power, int decimal_precision, bool horizontal)
+static bool SliderScalarBehavior(const ImRect& frame_bb, ImGuiID id, float* v, float v_min, float v_max, float power, int decimal_precision, bool horizontal)
 {
     ImGuiState& g = *GImGui;
     ImGuiWindow* window = GetCurrentWindow();
 
     const bool is_non_linear = fabsf(power - 1.0f) > 0.0001f;
 
-    const float slider_sz = horizontal ? slider_bb.GetWidth() : slider_bb.GetHeight();
+    const float padding = horizontal ? style.FramePadding.x : style.FramePadding.y;
+    const float slider_sz = horizontal ? (frame_bb.GetWidth() - padding * 2.0f) : (frame_bb.GetHeight() - padding * 2.0f);
     float grab_sz;
     if (decimal_precision > 0)
         grab_sz = ImMin(style.GrabMinSize, slider_sz);
     else
         grab_sz = ImMin(ImMax(1.0f * (slider_sz / (v_max-v_min+1.0f)), style.GrabMinSize), slider_sz);  // Integer sliders, if possible have the grab size represent 1 unit
     const float slider_usable_sz = slider_sz - grab_sz;
-    const float slider_usable_pos_min = (horizontal ? slider_bb.Min.x : slider_bb.Min.y) + grab_sz*0.5f;
-    const float slider_usable_pos_max = (horizontal ? slider_bb.Max.x : slider_bb.Max.y) - grab_sz*0.5f;
+    const float slider_usable_pos_min = (horizontal ? frame_bb.Min.x : frame_bb.Min.y) + padding + grab_sz*0.5f;
+    const float slider_usable_pos_max = (horizontal ? frame_bb.Max.x : frame_bb.Max.y) - padding - grab_sz*0.5f;
 
     bool value_changed = false;
 
                     // Negative: rescale to the negative range before powering
                     float a = 1.0f - (normalized_pos / linear_zero_pos);
                     a = powf(a, power);
-                    new_value = ImLerp(ImMin(v_max,0.f), v_min, a);
+                    new_value = ImLerp(ImMin(v_max,0.0f), v_min, a);
                 }
                 else
                 {
 
     const ImVec2 label_size = CalcTextSize(label, NULL, true);
     const ImRect frame_bb(window->DC.CursorPos, window->DC.CursorPos + ImVec2(w, label_size.y) + style.FramePadding*2.0f);
-    const ImRect inner_bb(frame_bb.Min + style.FramePadding, frame_bb.Max - style.FramePadding);
     const ImRect total_bb(frame_bb.Min, frame_bb.Max + ImVec2(label_size.x > 0.0f ? style.ItemInnerSpacing.x + label_size.x : 0.0f, 0.0f));
 
     // NB- we don't call ItemSize() yet because we may turn into a text edit box below
     ItemSize(total_bb, style.FramePadding.y);
 
     // Actual slider behavior + render grab
-    const bool value_changed = SliderBehavior(frame_bb, inner_bb, id, v, v_min, v_max, power, decimal_precision, true);
+    const bool value_changed = SliderScalarBehavior(frame_bb, id, v, v_min, v_max, power, decimal_precision, true);
 
     // Display value using user-provided display format so user can add prefix/suffix/decorations to the value.
     char value_buf[64];
     const char* value_buf_end = value_buf + ImFormatString(value_buf, IM_ARRAYSIZE(value_buf), display_format, *v);
     const ImVec2 value_text_size = CalcTextSize(value_buf, value_buf_end, true);
-    RenderTextClipped(ImVec2(ImMax(frame_bb.Min.x + style.FramePadding.x, inner_bb.GetCenter().x - value_text_size.x*0.5f), frame_bb.Min.y + style.FramePadding.y), value_buf, value_buf_end, &value_text_size, frame_bb.Max);
+    RenderTextClipped(ImVec2(ImMax(frame_bb.Min.x + style.FramePadding.x, frame_bb.GetCenter().x - value_text_size.x*0.5f), frame_bb.Min.y + style.FramePadding.y), value_buf, value_buf_end, &value_text_size, frame_bb.Max);
 
     if (label_size.x > 0.0f)
-        RenderText(ImVec2(frame_bb.Max.x + style.ItemInnerSpacing.x, inner_bb.Min.y), label);
+        RenderText(ImVec2(frame_bb.Max.x + style.ItemInnerSpacing.x, frame_bb.Min.y + style.FramePadding.y), label);
 
     return value_changed;
 }
 
     const ImVec2 label_size = CalcTextSize(label, NULL, true);
     const ImRect frame_bb(window->DC.CursorPos, window->DC.CursorPos + size);
-    const ImRect slider_bb(frame_bb.Min + style.FramePadding, frame_bb.Max - style.FramePadding);
     const ImRect bb(frame_bb.Min, frame_bb.Max + ImVec2(label_size.x > 0.0f ? style.ItemInnerSpacing.x + label_size.x : 0.0f, 0.0f));
 
     ItemSize(bb, style.FramePadding.y);
     }
 
     // Actual slider behavior + render grab
-    bool value_changed = SliderBehavior(frame_bb, slider_bb, id, v, v_min, v_max, power, decimal_precision, false);
+    bool value_changed = SliderScalarBehavior(frame_bb, id, v, v_min, v_max, power, decimal_precision, false);
 
     // Display value using user-provided display format so user can add prefix/suffix/decorations to the value.
     // For the vertical slider we allow centered text to overlap the frame padding
     char value_buf[64];
     char* value_buf_end = value_buf + ImFormatString(value_buf, IM_ARRAYSIZE(value_buf), display_format, *v);
     const ImVec2 value_text_size = CalcTextSize(value_buf, value_buf_end, true);
-    RenderTextClipped(ImVec2(ImMax(frame_bb.Min.x, slider_bb.GetCenter().x - value_text_size.x*0.5f), frame_bb.Min.y + style.FramePadding.y), value_buf, value_buf_end, &value_text_size, frame_bb.Max);
+    RenderTextClipped(ImVec2(ImMax(frame_bb.Min.x, frame_bb.GetCenter().x - value_text_size.x*0.5f), frame_bb.Min.y + style.FramePadding.y), value_buf, value_buf_end, &value_text_size, frame_bb.Max);
 
     if (label_size.x > 0.0f)
-        RenderText(ImVec2(frame_bb.Max.x + style.ItemInnerSpacing.x, slider_bb.Min.y), label);
+        RenderText(ImVec2(frame_bb.Max.x + style.ItemInnerSpacing.x, frame_bb.Min.y + style.FramePadding.y), label);
 
     return value_changed;
 }
 }
 
 // Add multiple sliders on 1 line for compact edition of multiple components
-static bool SliderFloatN(const char* label, float v[3], int components, float v_min, float v_max, const char* display_format, float power)
+static bool SliderFloatN(const char* label, float* v, int components, float v_min, float v_max, const char* display_format, float power)
 {
     ImGuiState& g = *GImGui;
     ImGuiWindow* window = GetCurrentWindow();
     return SliderFloatN(label, v, 4, v_min, v_max, display_format, power);
 }
 
-static bool SliderIntN(const char* label, int v[3], int components, int v_min, int v_max, const char* display_format)
+static bool SliderIntN(const char* label, int* v, int components, int v_min, int v_max, const char* display_format)
 {
     ImGuiState& g = *GImGui;
     ImGuiWindow* window = GetCurrentWindow();
 
     bool value_changed = false;
 
-    // Process clicking on the slider
+    // Process clicking on the drag
     if (g.ActiveId == id)
     {
         if (g.IO.MouseDown[0])
     return value_changed;
 }
 
+static bool DragFloatN(const char* label, float* v, int components, float v_speed, float v_min, float v_max, const char* display_format, float power)
+{
+    ImGuiState& g = *GImGui;
+    ImGuiWindow* window = GetCurrentWindow();
+    if (window->SkipItems)
+        return false;
+
+    const ImGuiStyle& style = g.Style;
+    const float w_full = ImGui::CalcItemWidth();
+    const float w_item_one  = ImMax(1.0f, (float)(int)((w_full - (style.FramePadding.x*2.0f + style.ItemInnerSpacing.x)*(components-1)) / (float)components));
+    const float w_item_last = ImMax(1.0f, (float)(int)(w_full - (w_item_one + style.FramePadding.x*2.0f + style.ItemInnerSpacing.x)*(components-1)));
+
+    bool value_changed = false;
+    ImGui::BeginGroup();
+    ImGui::PushID(label);
+    ImGui::PushItemWidth(w_item_one);
+    for (int i = 0; i < components; i++)
+    {
+        ImGui::PushID(i);
+        if (i + 1 == components)
+        {
+            ImGui::PopItemWidth();
+            ImGui::PushItemWidth(w_item_last);
+        }
+        value_changed |= ImGui::DragFloat("##v", &v[i], v_speed, v_min, v_max, display_format, power);
+        ImGui::SameLine(0, (int)style.ItemInnerSpacing.x);
+        ImGui::PopID();
+    }
+    ImGui::PopItemWidth();
+    ImGui::PopID();
+
+    ImGui::TextUnformatted(label, FindTextDisplayEnd(label));
+    ImGui::EndGroup();
+
+    return value_changed;
+}
+
+bool ImGui::DragFloat2(const char* label, float v[2], float v_speed, float v_min, float v_max, const char* display_format, float power)
+{
+    return DragFloatN(label, v, 2, v_speed, v_min, v_max, display_format, power);
+}
+
+bool ImGui::DragFloat3(const char* label, float v[2], float v_speed, float v_min, float v_max, const char* display_format, float power)
+{
+    return DragFloatN(label, v, 3, v_speed, v_min, v_max, display_format, power);
+}
+
+bool ImGui::DragFloat4(const char* label, float v[2], float v_speed, float v_min, float v_max, const char* display_format, float power)
+{
+    return DragFloatN(label, v, 4, v_speed, v_min, v_max, display_format, power);
+}
+
 // NB: v_speed is float to allow adjusting the drag speed with more precision
 bool ImGui::DragInt(const char* label, int* v, float v_speed, int v_min, int v_max, const char* display_format)
 {
     return value_changed;
 }
 
+static bool DragIntN(const char* label, int* v, int components, float v_speed, int v_min, int v_max, const char* display_format)
+{
+    ImGuiState& g = *GImGui;
+    ImGuiWindow* window = GetCurrentWindow();
+    if (window->SkipItems)
+        return false;
+
+    const ImGuiStyle& style = g.Style;
+    const float w_full = ImGui::CalcItemWidth();
+    const float w_item_one  = ImMax(1.0f, (float)(int)((w_full - (style.FramePadding.x*2.0f + style.ItemInnerSpacing.x)*(components-1)) / (float)components));
+    const float w_item_last = ImMax(1.0f, (float)(int)(w_full - (w_item_one + style.FramePadding.x*2.0f + style.ItemInnerSpacing.x)*(components-1)));
+
+    bool value_changed = false;
+    ImGui::BeginGroup();
+    ImGui::PushID(label);
+    ImGui::PushItemWidth(w_item_one);
+    for (int i = 0; i < components; i++)
+    {
+        ImGui::PushID(i);
+        if (i + 1 == components)
+        {
+            ImGui::PopItemWidth();
+            ImGui::PushItemWidth(w_item_last);
+        }
+        value_changed |= ImGui::DragInt("##v", &v[i], v_speed, v_min, v_max, display_format);
+        ImGui::SameLine(0, (int)style.ItemInnerSpacing.x);
+        ImGui::PopID();
+    }
+    ImGui::PopItemWidth();
+    ImGui::PopID();
+
+    ImGui::TextUnformatted(label, FindTextDisplayEnd(label));
+    ImGui::EndGroup();
+
+    return value_changed;
+}
+
+bool ImGui::DragInt2(const char* label, int v[2], float v_speed, int v_min, int v_max, const char* display_format)
+{
+    return DragIntN(label, v, 2, v_speed, v_min, v_max, display_format);
+}
+
+bool ImGui::DragInt3(const char* label, int v[3], float v_speed, int v_min, int v_max, const char* display_format)
+{
+    return DragIntN(label, v, 3, v_speed, v_min, v_max, display_format);
+}
+
+bool ImGui::DragInt4(const char* label, int v[4], float v_speed, int v_min, int v_max, const char* display_format)
+{
+    return DragIntN(label, v, 4, v_speed, v_min, v_max, display_format);
+}
+
 enum ImGuiPlotType
 {
     ImGuiPlotType_Lines,
     const ImVec2 size(size_arg.x != 0.0f ? size_arg.x : w, size_arg.y != 0.0f ? size_arg.y : label_size.y);
     ImRect bb(window->DC.CursorPos, window->DC.CursorPos + size);
     ItemSize(bb);
-    bb.Max.x += style.AutoFitPadding.x;
+    if (size_arg.x == 0.0f)
+        bb.Max.x += style.AutoFitPadding.x;
 
     // Selectables are meant to be tightly packed together. So for both rendering and collision we extend to compensate for spacing.
     ImRect bb_with_spacing = bb;
     ItemSize(bb.GetSize(), text_offset_y); 
 }
 
-static bool IsClippedEx(const ImRect& bb, bool clip_even_when_logged)
+static bool IsClippedEx(const ImRect& bb, const ImGuiID* id, bool clip_even_when_logged)
 {
     ImGuiState& g = *GImGui;
     ImGuiWindow* window = GetCurrentWindow();
 
     if (!bb.Overlaps(ImRect(window->ClipRectStack.back())))
     {
-        if (clip_even_when_logged || !g.LogEnabled)
-            return true;
+        if (!id || *id != GImGui->ActiveId)
+            if (clip_even_when_logged || !g.LogEnabled)
+                return true;
     }
     return false;
 }
 bool ImGui::IsRectClipped(const ImVec2& size)
 {
     ImGuiWindow* window = GetCurrentWindow();
-    return IsClippedEx(ImRect(window->DC.CursorPos, window->DC.CursorPos + size), true);
+    return IsClippedEx(ImRect(window->DC.CursorPos, window->DC.CursorPos + size), NULL, true);
 }
 
 static bool ItemAdd(const ImRect& bb, const ImGuiID* id)
     ImGuiWindow* window = GetCurrentWindow();
     window->DC.LastItemID = id ? *id : 0;
     window->DC.LastItemRect = bb;
-    if (IsClippedEx(bb, false))
+    if (IsClippedEx(bb, id, false))
     {
-        if (!id || *id != GImGui->ActiveId)
-        {
-            window->DC.LastItemHoveredAndUsable = window->DC.LastItemHoveredRect = false;
-            return false;
-        }
+        window->DC.LastItemHoveredAndUsable = window->DC.LastItemHoveredRect = false;
+        return false;
     }
 
     // This is a sensible default, but widgets are free to override it after calling ItemAdd()
         window->DC.CurrentLineTextBaseOffset = 0.0f;
 
         PushColumnClipRect();
-        ImGui::PushItemWidth(ImGui::GetColumnWidth() * 0.65f);
+        ImGui::PushItemWidth(ImGui::GetColumnWidth() * 0.65f);  // FIXME
     }
 }
 
     return window->DC.ColumnsCount;
 }
 
+static float GetDraggedColumnOffset(int column_index)
+{
+    // Active (dragged) column always follow mouse. The reason we need this is that dragging a column to the right edge of an auto-resizing
+    // window creates a feedback loop because we store normalized positions/ So while dragging we enforce absolute positioning
+    ImGuiState& g = *GImGui;
+    ImGuiWindow* window = GetCurrentWindow();
+    IM_ASSERT(g.ActiveId == window->DC.ColumnsSetID + ImGuiID(column_index));
+
+    float x = g.IO.MousePos.x + g.ActiveClickDeltaToCenter.x;
+    x -= window->Pos.x;
+    x = ImClamp(x, ImGui::GetColumnOffset(column_index-1)+g.Style.ColumnsMinSpacing, ImGui::GetColumnOffset(column_index+1)-g.Style.ColumnsMinSpacing);
+
+    return x;
+}
+
 float ImGui::GetColumnOffset(int column_index)
 {
     ImGuiState& g = *GImGui;
     if (column_index < 0)
         column_index = window->DC.ColumnsCurrent;
 
+    if (g.ActiveId)
+    {
+        const ImGuiID column_id = window->DC.ColumnsSetID + ImGuiID(column_index);
+        if (g.ActiveId == column_id)
+            return GetDraggedColumnOffset(column_index);
+    }
+
     // Read from cache
     IM_ASSERT(column_index < (int)window->DC.ColumnsOffsetsT.size());
     const float t = window->DC.ColumnsOffsetsT[column_index];
             const ImGuiID column_id = window->DC.ColumnsSetID + ImGuiID(i);
             const ImRect column_rect(ImVec2(x-4,y1),ImVec2(x+4,y2));
 
-            if (IsClippedEx(column_rect, false))
+            if (IsClippedEx(column_rect, &column_id, false))
                 continue;
 
             bool hovered, held;
 
             if (held)
             {
-                x -= window->Pos.x;
-                x = ImClamp(x + g.IO.MouseDelta.x, ImGui::GetColumnOffset(i-1)+g.Style.ColumnsMinSpacing, ImGui::GetColumnOffset(i+1)-g.Style.ColumnsMinSpacing);
+                if (g.ActiveIdIsJustActivated)
+                    g.ActiveClickDeltaToCenter.x = x - g.IO.MousePos.x;
+
+                x = GetDraggedColumnOffset(i);
                 SetColumnOffset(i, x);
-                x += window->Pos.x;
             }
         }
     }
             ImGui::InputFloat3("input float3", vec4a);
         }
 
-        /*
         {
             static int i1=50;
             static int i2=42;
             ImGui::DragInt("drag int", &i1, 1);
-            ImGui::DragInt("drag int 0..100", &i2, 1, 0, 100);
+            ImGui::SameLine();
+            ImGui::TextColored(ImColor(170,170,170,255), "(?)");
+            if (ImGui::IsItemHovered())
+                ImGui::SetTooltip("Click and drag to edit value.\nHold SHIFT/ALT for faster/slower edit.\nDouble-click or CTRL+click to input text");
+
+            ImGui::DragInt("drag int 0..100", &i2, 1, 0, 100, "%.0f%%");
 
             static float f1=1.00f;
             static float f2=0.0067f;
             ImGui::DragFloat("drag float", &f1, 1.0f);
-            ImGui::DragFloat("drag small float", &f2, 0.0001f, 0.0f, 0.0f, "%.06f");
+            ImGui::DragFloat("drag small float", &f2, 0.0001f, 0.0f, 0.0f, "%.06f ns");
         }
-        */
 
         {
             static int i1=0;
-            static int i2=42;
+            //static int i2=42;
             ImGui::SliderInt("slider int 0..3", &i1, 0, 3);
-            ImGui::SliderInt("slider int -100..100", &i2, -100, 100);
+            //ImGui::SliderInt("slider int -100..100", &i2, -100, 100);
 
-            static float f1=1.123f;
-            static float f2=0;
-            ImGui::SliderFloat("slider float", &f1, 0.0f, 2.0f);
+            static float f1=0.123f;
+            static float f2=0.0f;
+            ImGui::SliderFloat("slider float", &f1, 0.0f, 1.0f, "ratio = %.3f");
             ImGui::SliderFloat("slider log float", &f2, -10.0f, 10.0f, "%.4f", 3.0f);
             static float angle = 0.0f;
             ImGui::SliderAngle("slider angle", &angle);
             static int vec4i[4] = { 1, 5, 100, 255 };
 
             ImGui::InputFloat2("input float2", vec4f);
+            ImGui::DragFloat2("drag float2", vec4f, 0.01f, 0.0f, 1.0f);
             ImGui::SliderFloat2("slider float2", vec4f, 0.0f, 1.0f);
+            ImGui::DragInt2("drag int2", vec4i, 1, 0, 255);
             ImGui::InputInt2("input int2", vec4i);
             ImGui::SliderInt2("slider int2", vec4i, 0, 255);
 
             ImGui::InputFloat3("input float3", vec4f);
+            ImGui::DragFloat3("drag float3", vec4f, 0.01f, 0.0f, 1.0f);
             ImGui::SliderFloat3("slider float3", vec4f, 0.0f, 1.0f);
+            ImGui::DragInt3("drag int3", vec4i, 1, 0, 255);
             ImGui::InputInt3("input int3", vec4i);
             ImGui::SliderInt3("slider int3", vec4i, 0, 255);
 
             ImGui::InputFloat4("input float4", vec4f);
+            ImGui::DragFloat4("drag float4", vec4f, 0.01f, 0.0f, 1.0f);
             ImGui::SliderFloat4("slider float4", vec4f, 0.0f, 1.0f);
             ImGui::InputInt4("input int4", vec4i);
+            ImGui::DragInt4("drag int4", vec4i, 1, 0, 255);
             ImGui::SliderInt4("slider int4", vec4i, 0, 255);
 
             ImGui::Indent();

src/deps/imgui/imgui.h

-// ImGui library v1.38 WIP
+// ImGui library v1.39 WIP
 // See .cpp file for documentation.
 // See ImGui::ShowTestWindow() for sample code.
 // Read 'Programmer guide' in .cpp for notes on how to setup ImGui in your codebase.
 #include <stdlib.h>         // NULL, malloc, free, qsort, atoi
 #include <string.h>         // memset, memmove, memcpy, strlen, strchr, strcpy, strcmp
 
-#define IMGUI_VERSION       "1.38 WIP"
+#define IMGUI_VERSION       "1.39 WIP"
 
 // Define assertion handler.
 #ifndef IM_ASSERT
     IMGUI_API bool          VSliderInt(const char* label, const ImVec2& size, int* v, int v_min, int v_max, const char* display_format = "%.0f");
 
     // Widgets: Drags (tip: ctrl+click on a drag box to input text)
-    // ImGui 1.38+ work-in-progress, may change name or API.
-    IMGUI_API bool          DragFloat(const char* label, float* v, float v_speed = 1.0f, float v_min = 0.0f, float v_max = 0.0f, const char* display_format = "%.3f", float power = 1.0f);  // If v_max >= v_max we have no bound
-    IMGUI_API bool          DragInt(const char* label, int* v, float v_speed = 1.0f, int v_min = 0, int v_max = 0, const char* display_format = "%.0f");                                    // If v_max >= v_max we have no bound
+    IMGUI_API bool          DragFloat(const char* label, float* v, float v_speed = 1.0f, float v_min = 0.0f, float v_max = 0.0f, const char* display_format = "%.3f", float power = 1.0f);     // If v_max >= v_max we have no bound
+    IMGUI_API bool          DragFloat2(const char* label, float v[2], float v_speed = 1.0f, float v_min = 0.0f, float v_max = 0.0f, const char* display_format = "%.3f", float power = 1.0f);
+    IMGUI_API bool          DragFloat3(const char* label, float v[3], float v_speed = 1.0f, float v_min = 0.0f, float v_max = 0.0f, const char* display_format = "%.3f", float power = 1.0f);
+    IMGUI_API bool          DragFloat4(const char* label, float v[4], float v_speed = 1.0f, float v_min = 0.0f, float v_max = 0.0f, const char* display_format = "%.3f", float power = 1.0f);
+    IMGUI_API bool          DragInt(const char* label, int* v, float v_speed = 1.0f, int v_min = 0, int v_max = 0, const char* display_format = "%.0f");                                       // If v_max >= v_max we have no bound
+    IMGUI_API bool          DragInt2(const char* label, int v[2], float v_speed = 1.0f, int v_min = 0, int v_max = 0, const char* display_format = "%.0f");
+    IMGUI_API bool          DragInt3(const char* label, int v[3], float v_speed = 1.0f, int v_min = 0, int v_max = 0, const char* display_format = "%.0f");
+    IMGUI_API bool          DragInt4(const char* label, int v[4], float v_speed = 1.0f, int v_min = 0, int v_max = 0, const char* display_format = "%.0f");
 
     // Widgets: Input
     IMGUI_API bool          InputText(const char* label, char* buf, size_t buf_size, ImGuiInputTextFlags flags = 0, ImGuiTextEditCallback callback = NULL, void* user_data = NULL);
     // - You can also use this to quickly create temporary editable values during a session of using Edit&Continue, without restarting your application.
     IMGUI_API int*    GetIntRef(ImGuiID key, int default_val = 0);
     IMGUI_API float*  GetFloatRef(ImGuiID key, float default_val = 0);
+    IMGUI_API void**  GetVoidPtrRef(ImGuiID key, void* default_val = NULL);
 
     // Use on your own storage if you know only integer are being stored (open/close all tree nodes)
     IMGUI_API void    SetAllInt(int val);

src/loader/Loader.cpp

 
         case TR_3:
             return std::unique_ptr<Loader>(new LoaderTR3());
-    }
 
-    return nullptr;
+        case TR_UNKNOWN:
+        case TR_4:
+        case TR_5:
+            return nullptr;
+    }
 }
 
 Loader::~Loader() { }

src/loader/LoaderTR1.cpp

             tmp += (i - 1) * 16; // TODO ?
             BinaryMemory tree(tmp, (numMeshTrees * 4) - meshTree - ((i - 1) * 16));
 
-            flag = (char)tree.readU32();
+            flag = static_cast<char>(tree.readU32());
             offset.x = tree.read32();
             offset.y = tree.read32();
             offset.z = tree.read32();
             rotation[0] = (a & 0x3FF0) >> 4;
             rotation[1] = ((a & 0x000F) << 6) | ((b & 0xFC00) >> 10);
             rotation[2] = b & 0x03FF;
-            for (int i = 0; i < 3; i++)
-                rotation[i] = rotation[i] * 360.0f / 1024.0f;
+            for (int n = 0; n < 3; n++)
+                rotation[n] = rotation[n] * 360.0f / 1024.0f;
         }
 
         glm::vec3 rot(rotation[0], rotation[1], rotation[2]);

src/loader/LoaderTR2.cpp

 // ---- Rooms ----
 
 void LoaderTR2::loadRoomLights() {
-    int16_t intensity1 = file.read16();
-    int16_t intensity2 = file.read16();
+    int16_t roomIntensity1 = file.read16();
+    int16_t roomIntensity2 = file.read16();
     int16_t lightMode = file.read16();
 
     uint16_t numLights = file.readU16();
 
             // Fill bounding box
             if (v == 0) {
-                for (int i = 0; i < 2; i++) {
-                    bbox[i].x = vert.x;
-                    bbox[i].y = vert.y;
-                    bbox[i].z = vert.z;
+                for (int n = 0; n < 2; n++) {
+                    bbox[n].x = vert.x;
+                    bbox[n].y = vert.y;
+                    bbox[n].z = vert.z;
                 }
             } else {
                 if (vert.x < bbox[0].x)
             // There is a special value of the 'real' index, 2047 or 0x7FF.
 
             bool wall = false;
-            if ((((uint8_t)floor) == 0x81) || (((uint8_t)ceiling) == 0x81)) {
+            if (((floor & 0xFF) == 0x81) || ((ceiling & 0xFF) == 0x81)) {
                 wall = true;
             }
 
             char* tmp = reinterpret_cast<char*>(&meshTrees[0]) + meshTree; // TODO (meshTree * 4)?
             tmp += (i - 1) * 16; // TODO ?
             BinaryMemory tree(tmp, (numMeshTrees * 4) - meshTree - ((i - 1) * 16));
-            flag = (char)tree.readU32();
+            flag = static_cast<char>(tree.readU32());
             offset.x = tree.read32();
             offset.y = tree.read32();
             offset.z = tree.read32();
                     index = 2;
                 else if (a & 0x4000)
                     index = 1;
-                rotation[index] = ((float)(a & 0x03FF)) * 360.0f / 1024.0f;
+                rotation[index] = (static_cast<float>(a & 0x03FF)) * 360.0f / 1024.0f;
             } else {
                 // Three angles
                 uint16_t b = frame.readU16();
                 rotation[0] = (a & 0x3FF0) >> 4;
                 rotation[1] = ((a & 0x000F) << 6) | ((b & 0xFC00) >> 10);
                 rotation[2] = b & 0x03FF;
-                for (int i = 0; i < 3; i++)
-                    rotation[i] = rotation[i] * 360.0f / 1024.0f;
+                for (int n = 0; n < 3; n++)
+                    rotation[n] = rotation[n] * 360.0f / 1024.0f;
             }
         }
 
         // Bits 0-1: channel number?
         uint16_t unknown2 = file.readU16();
 
-        SoundManager::addSoundDetail(sample, ((float)volume) / 32767.0f);
+        SoundManager::addSoundDetail(sample, volume / 32767.0f);
     }
 
     if (numSoundDetails > 0)

src/loader/LoaderTR3.cpp

 }
 
 void LoaderTR3::loadRoomLights() {
-    int16_t intensity1 = file.read16();
-    int16_t intensity2 = file.read16();
+    int16_t roomIntensity1 = file.read16();
+    int16_t roomIntensity2 = file.read16();
 
     uint16_t numLights = file.readU16();
     for (unsigned int l = 0; l < numLights; l++) {

src/main.cpp

 #ifdef DEBUG
     std::cout << std::endl;
     std::cout << "Thanks for testing " << VERSION << std::endl;
+#if defined(__DATE__) && defined(__TIME__)
     std::cout << "Build date: " << __DATE__ << " @ " << __TIME__ << std::endl;
+#endif
     std::cout << "Build host: " << BUILD_HOST << std::endl;
     std::cout << "Web site  : http://github.com/xythobuz/OpenRaider" << std::endl;
     std::cout << "Contact   : xythobuz@xythobuz.de" << std::endl;

src/system/WindowSDL.cpp

 
             case SDL_TEXTINPUT:
             case SDL_TEXTEDITING:
-                if (event.text.text != nullptr)
-                    UI::handleText(event.text.text, (event.type == SDL_TEXTEDITING));
+                UI::handleText(event.text.text, (event.type == SDL_TEXTEDITING));
                 break;
 
             case SDL_KEYDOWN:

src/utils/Folder.cpp

     createFolderItems();
     for (unsigned long i = 0; i < fileCount(); i++) {
         if (func(getFile(i))) {
-            files.erase(files.begin() + (long)i--);
+            files.erase(files.begin() + i--);
         }
     }
 }

src/utils/pcx.cpp

     unsigned char* header = new unsigned char[128];
 
     // Basic validation
-    if (!file.read((char*)(&header[0]), 128)) {
+    if (!file.read(reinterpret_cast<char*>(&header[0]), 128)) {
         Log::get(LOG_ERROR) << "File not big enough for valid PCX header!" << Log::endl;
         delete [] header;
         return -1;
     unsigned char* header = new unsigned char[128];
 
     // Basic validation
-    if (!file.read((char*)(&header[0]), 128)) {
+    if (!file.read(reinterpret_cast<char*>(&header[0]), 128)) {
         Log::get(LOG_ERROR) << "File not big enough for valid PCX header!" << Log::endl;
         delete [] header;
         return -1;
         }
 
         for (unsigned int j = 0; j < n; j++)
-            buffer[b++] = (unsigned char)c;
+            buffer[b++] = static_cast<unsigned char>(c);
 
         i += n;
     }
         if ((c == 12) && file) {
             palette = new unsigned char[768];
             for (unsigned int i = 0; i < 768; i++) {
-                palette[i] = (unsigned char)file.get();
+                palette[i] = static_cast<unsigned char>(file.get());
                 if (!file) {
                     Log::get(LOG_ERROR) << "Could not read 256 color palette (" << i << ")" << Log::endl;
                     delete [] buffer;

src/utils/pixel.cpp

 
     unsigned char* image = new unsigned char[height * width * (bpp / 8)];
     for (unsigned int i = 0; i < (width * height); i++) {
-        image[i * (bpp / 8)] = (unsigned char)(rgba.r * 255);
-        image[(i * (bpp / 8)) + 1] = (unsigned char)(rgba.g * 255);
-        image[(i * (bpp / 8)) + 2] = (unsigned char)(rgba.b * 255);
+        image[i * (bpp / 8)] = static_cast<unsigned char>(rgba.r * 255);
+        image[(i * (bpp / 8)) + 1] = static_cast<unsigned char>(rgba.g * 255);
+        image[(i * (bpp / 8)) + 2] = static_cast<unsigned char>(rgba.b * 255);
         if (bpp == 32) {
-            image[(i * (bpp / 8)) + 3] = (unsigned char)(rgba.a * 255);
+            image[(i * (bpp / 8)) + 3] = static_cast<unsigned char>(rgba.a * 255);
         }
     }
     return image;
 
     // Copy user data to float format.
     for (unsigned int i = 0; i < original_height * original_width * components; ++i) {
-        tempin[i] = (float)image[i];
+        tempin[i] = image[i];
     }
 
     // Determine which filter to use by checking ratios.
     float sx;
     if (width > 1) {
-        sx = (float)(original_width - 1) / (float)(width - 1);
+        sx = (original_width - 1.0f) / (width - 1.0f);
     } else {
-        sx = (float)(original_width - 1);
+        sx = original_width - 1.0f;
     }
 
     float sy;
     if (height > 1) {
-        sy = (float)(original_height - 1) / (float)(height - 1);
+        sy = (original_height - 1.0f) / (height - 1.0f);
     } else {
-        sy = (float)(original_height - 1);
+        sy = original_height - 1.0f;
     }
 
     if (sx < 1.0 && sy < 1.0) { // Magnify both width and height: use weighted sample of 4 pixels
         for (unsigned int i = 0; i < height; ++i) {
-            unsigned int i0 = (unsigned int)(i * sy);
+            unsigned int i0 = static_cast<unsigned int>(i * sy);
             unsigned int i1 = i0 + 1;
 
             if (i1 >= original_height) {
             float alpha = i * sy - i0;
 
             for (unsigned int j = 0; j < width; ++j) {
-                unsigned int j0 = (unsigned int)(j * sx);
+                unsigned int j0 = static_cast<unsigned int>(j * sx);
                 unsigned int j1 = j0 + 1;
 
                 if (j1 >= original_width) {
         }
     } else { // Shrink width and/or height: use an unweighted box filter
         for (unsigned int i = 0; i < height; ++i) {
-            unsigned int i0 = (unsigned int)(i * sy);
+            unsigned int i0 = static_cast<unsigned int>(i * sy);
             unsigned int i1 = i0 + 1;
 
             if (i1 >= original_height) {
             }
 
             for (unsigned int j = 0; j < width; ++j) {
-                unsigned int j0 = (unsigned int)(j * sx);
+                unsigned int j0 = static_cast<unsigned int>(j * sx);
                 unsigned int j1 = j0 + 1;
 
                 if (j1 >= original_width) {
 
     // Copy to our results.
     for (unsigned int i = 0; i < height * width * components; ++i) {
-        timage[i] = (unsigned char)tempout[i];
+        timage[i] = static_cast<unsigned char>(tempout[i]);
     }
 
     // Delete our temp buffers.