Updated imgui. Can now display linked lib versions.

ChangeLog.md

 
 ## OpenRaider (0.1.4) xythobuz <xythobuz@xythobuz.de>
 
+    [ 20140318 ]
+    * Updated imgui to version 1.36
+    * Can now display all compiled/linked library versions
+
     [ 20140313 ]
     * Renderer now limits room list size
     * Updated Doxyfile template to current Doxygen version

include/system/Shader.h

 #ifndef _SHADER_H_
 #define _SHADER_H_
 
+#include <string>
 #include <vector>
 
 #include "TextureManager.h"
                        glm::mat4 MVP, GLenum mode = GL_TRIANGLES, ShaderTexture* target = nullptr,
                        Shader& shader = colorShader);
 
+    static std::string getVersion(bool linked);
+
   private:
     int programID;
     std::vector<unsigned int> uniforms;

include/system/Sound.h

 #ifndef _SOUND_H_
 #define _SOUND_H_
 
+#include <string>
+
 class Sound {
   public:
     static int initialize();
 
     static void setVolume(float vol = 1.0f);
     static float getVolume();
+
+    static std::string getVersion(bool linked);
 };
 
 #endif

include/system/SoundAL.h

 #ifndef _SOUND_AL_H_
 #define _SOUND_AL_H_
 
+#include <string>
 #include <vector>
 
 class SoundAL {
     static void setVolume(float vol);
     static float getVolume();
 
+    static std::string getVersion(bool linked);
+
   private:
     static bool init;
     static bool enabled;

include/system/Window.h

 #ifndef _WINDOW_H_
 #define _WINDOW_H_
 
+#include <string>
 #include <glm/gtc/type_precision.hpp>
 
 class Window {
     static const char* getClipboard();
 
     static void inputPositionCallback(int x, int y);
+
+    static std::string getVersion(bool linked);
 };
 
 #endif

include/system/WindowGLFW.h

 #ifndef _WINDOW_GLFW_H_
 #define _WINDOW_GLFW_H_
 
+#include <string>
 #include <glm/gtc/type_precision.hpp>
 
 class GLFWwindow;
 
     static void inputPositionCallback(int x, int y);
 
+    static std::string getVersion(bool linked);
+
   private:
     static void errorCallback(int error, const char* desc);
     static void sizeCallback(GLFWwindow* w, int width, int height);

include/system/WindowSDL.h

 #ifndef _WINDOW_SDL_H_
 #define _WINDOW_SDL_H_
 
+#include <string>
 #include <glm/gtc/type_precision.hpp>
 
 #include "SDL.h"
 
     static void inputPositionCallback(int x, int y);
 
+    static std::string getVersion(bool linked);
+
   private:
     static glm::i32vec2 size;
     static bool fullscreen;

src/UI.cpp

 #include "SoundManager.h"
 #include "TextureManager.h"
 #include "World.h"
+#include "system/Sound.h"
 #include "system/Window.h"
 #include "utils/time.h"
 #include "UI.h"
     style.ItemSpacing                           = ImVec2(2, 2);
     style.ItemInnerSpacing                      = ImVec2(1, 1);
     style.TouchExtraPadding                     = ImVec2(0, 0);
-    style.TreeNodeSpacing                       = 3;
+    style.IndentSpacing                       = 3;
     style.ScrollbarWidth                        = 10;
 
     return 0;
 
             auto window = ImGui::GetWindowSize();
             auto screen = Window::getSize();
-            ImGui::SetWindowPos(ImVec2(10, screen.y - window.y - 10));
+            //ImGui::SetWindowPos(ImVec2(10, screen.y - window.y - 10));
         }
         ImGui::End();
     }
         TextureManager::display();
         SoundManager::display();
 
+        if (ImGui::CollapsingHeader("Library Versions")) {
+            ImGui::TextWrapped("%s", VERSION);
+            ImGui::Separator();
+            ImGui::TextWrapped("ImGui v%s", IMGUI_VERSION);
+            ImGui::TextWrapped("%s", Window::getVersion(false).c_str());
+            ImGui::TextWrapped("%s", Shader::getVersion(false).c_str());
+            ImGui::TextWrapped("%s", Sound::getVersion(false).c_str());
+            ImGui::TextWrapped("GLM v%d.%d.%d", (GLM_VERSION / 100),
+                               ((GLM_VERSION % 100) / 10), (GLM_VERSION % 10));
+            ImGui::Separator();
+            ImGui::TextWrapped("ImGui v%s", ImGui::GetVersion());
+            ImGui::TextWrapped("%s", Window::getVersion(true).c_str());
+            ImGui::TextWrapped("%s", Shader::getVersion(true).c_str());
+            ImGui::TextWrapped("%s", Sound::getVersion(true).c_str());
+        }
+
         if (ImGui::CollapsingHeader("ImGui/Debug UI Help")) {
             ImGui::ShowUserGuide();
             ImGui::Separator();
     io.KeysDown[key] = pressed;
     io.KeyCtrl = io.KeysDown[leftctrlKey] | io.KeysDown[rightctrlKey];
     io.KeyShift = io.KeysDown[leftshiftKey] | io.KeysDown[rightshiftKey];
+    io.KeyAlt = io.KeysDown[leftaltKey] | io.KeysDown[rightaltKey];
 
     keyboardEvents.push_back(std::make_tuple(key, pressed));
 

src/deps/imgui/imgui.h

-// ImGui library v1.35
+// ImGui library v1.37 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
 #include <string.h>         // memset, memmove
 
+#define IMGUI_VERSION       "1.37 WIP"
+
 // Define assertion handler.
 #ifndef IM_ASSERT
 #include <assert.h>
     IMGUI_API bool          BeginChild(const char* str_id, const ImVec2& size = ImVec2(0,0), bool border = false, ImGuiWindowFlags extra_flags = 0);            // size==0.0f: use remaining window size, size<0.0f: use remaining window size minus abs(size). on each axis.
     IMGUI_API bool          BeginChild(ImGuiID id, const ImVec2& size = ImVec2(0,0), bool border = false, ImGuiWindowFlags extra_flags = 0);                    // "
     IMGUI_API void          EndChild();
-    IMGUI_API bool          GetWindowIsFocused();
     IMGUI_API ImVec2        GetContentRegionMax();                                              // window or current column boundaries, in windows coordinates
     IMGUI_API ImVec2        GetWindowContentRegionMin();                                        // window boundaries, in windows coordinates
     IMGUI_API ImVec2        GetWindowContentRegionMax();
     IMGUI_API void          EndTooltip();
 
     // Layout
+    IMGUI_API void          BeginGroup();
+    IMGUI_API void          EndGroup();
     IMGUI_API void          Separator();                                                        // horizontal line
-    IMGUI_API void          SameLine(int column_x = 0, int spacing_w = -1);                     // call between widgets to layout them horizontally
-    IMGUI_API void          Spacing();
+    IMGUI_API void          SameLine(int column_x = 0, int spacing_w = -1);                     // call between widgets or groups to layout them horizontally
+    IMGUI_API void          Spacing();                                                          // add vertical spacing
+    IMGUI_API void          Indent();                                                           // move content position toward the right by style.IndentSpacing pixels
+    IMGUI_API void          Unindent();                                                         // move content position back to the left (cancel Indent)
     IMGUI_API void          Columns(int count = 1, const char* id = NULL, bool border=true);    // setup number of columns
     IMGUI_API void          NextColumn();                                                       // next column
     IMGUI_API int           GetColumnIndex();                                                   // get current column index
     IMGUI_API bool          SliderInt2(const char* label, int v[2], int v_min, int v_max, const char* display_format = "%.0f");
     IMGUI_API bool          SliderInt3(const char* label, int v[3], int v_min, int v_max, const char* display_format = "%.0f");
     IMGUI_API bool          SliderInt4(const char* label, int v[4], int v_min, int v_max, const char* display_format = "%.0f");
+    IMGUI_API bool          VSliderFloat(const char* label, const ImVec2& size, float* v, float v_min, float v_max, const char* display_format = "%.3f", float power = 1.0f);
+    IMGUI_API bool          VSliderInt(const char* label, const ImVec2& size, int* v, int v_min, int v_max, const char* display_format = "%.0f");
     IMGUI_API void          PlotLines(const char* label, const float* values, int values_count, int values_offset = 0, const char* overlay_text = NULL, float scale_min = FLT_MAX, float scale_max = FLT_MAX, ImVec2 graph_size = ImVec2(0,0), size_t stride = sizeof(float));
     IMGUI_API void          PlotLines(const char* label, float (*values_getter)(void* data, int idx), void* data, int values_count, int values_offset = 0, const char* overlay_text = NULL, float scale_min = FLT_MAX, float scale_max = FLT_MAX, ImVec2 graph_size = ImVec2(0,0));
     IMGUI_API void          PlotHistogram(const char* label, const float* values, int values_count, int values_offset = 0, const char* overlay_text = NULL, float scale_min = FLT_MAX, float scale_max = FLT_MAX, ImVec2 graph_size = ImVec2(0,0), size_t stride = sizeof(float));
     IMGUI_API bool          InputFloat3(const char* label, float v[3], int decimal_precision = -1);
     IMGUI_API bool          InputFloat4(const char* label, float v[4], int decimal_precision = -1);
     IMGUI_API bool          InputInt(const char* label, int* v, int step = 1, int step_fast = 100, ImGuiInputTextFlags extra_flags = 0);
+    IMGUI_API bool          InputInt2(const char* label, int v[2]);
+    IMGUI_API bool          InputInt3(const char* label, int v[3]);
+    IMGUI_API bool          InputInt4(const char* label, int v[4]);
     IMGUI_API bool          Combo(const char* label, int* current_item, const char** items, int items_count, int height_in_items = -1);
     IMGUI_API bool          Combo(const char* label, int* current_item, const char* items_separated_by_zeros, int height_in_items = -1);      // separate items with \0, end item-list with \0\0
     IMGUI_API bool          Combo(const char* label, int* current_item, bool (*items_getter)(void* data, int idx, const char** out_text), void* data, int items_count, int height_in_items = -1);
 
     // Utilities
     IMGUI_API bool          IsItemHovered();                                                    // was the last item hovered by mouse?
+    IMGUI_API bool          IsItemHoveredRectOnly();                                            // was the last item hovered by mouse? even if another item is active while we are hovering this.
     IMGUI_API bool          IsItemActive();                                                     // was the last item active? (e.g. button being held, text field being edited- items that don't interact will always return false)
     IMGUI_API bool          IsAnyItemActive();                                                  // 
-    IMGUI_API ImVec2        GetItemBoxMin();                                                    // get bounding box of last item
-    IMGUI_API ImVec2        GetItemBoxMax();                                                    // get bounding box of last item
+    IMGUI_API ImVec2        GetItemActiveDragDelta();                                           // mouse delta from the time the item first got active
+    IMGUI_API ImVec2        GetItemRectMin();                                                   // get bounding rect of last item
+    IMGUI_API ImVec2        GetItemRectMax();                                                   // "
+    IMGUI_API ImVec2        GetItemRectSize();                                                  // "
+    IMGUI_API bool          IsWindowFocused();                                                  // is current window focused (differentiate child windows from each others)
+    IMGUI_API bool          IsRootWindowFocused();                                              // is current root window focused
+    IMGUI_API bool          IsRootWindowOrAnyChildFocused();                                    // is current root window or any of its child (including current window) focused
     IMGUI_API bool          IsClipped(const ImVec2& item_size);                                 // to perform coarse clipping on user's side (as an optimization)
     IMGUI_API bool          IsKeyPressed(int key_index, bool repeat = true);                    // key_index into the keys_down[512] array, imgui doesn't know the semantic of each entry
     IMGUI_API bool          IsMouseClicked(int button, bool repeat = false);
     IMGUI_API bool          IsMouseDoubleClicked(int button);
     IMGUI_API bool          IsMouseHoveringWindow();                                            // is mouse hovering current window ("window" in API names always refer to current window)
     IMGUI_API bool          IsMouseHoveringAnyWindow();                                         // is mouse hovering any active imgui window
-    IMGUI_API bool          IsMouseHoveringBox(const ImVec2& box_min, const ImVec2& box_max);   // is mouse hovering given bounding box
+    IMGUI_API bool          IsMouseHoveringRect(const ImVec2& rect_min, const ImVec2& rect_max);// is mouse hovering given bounding rect
     IMGUI_API bool          IsPosHoveringAnyWindow(const ImVec2& pos);                          // is given position hovering any active imgui window
     IMGUI_API ImVec2        GetMousePos();                                                      // shortcut to ImGui::GetIO().MousePos provided by user, to be consistent with other calls
     IMGUI_API float         GetTime();
     IMGUI_API int           GetFrameCount();
     IMGUI_API const char*   GetStyleColName(ImGuiCol idx);
+    IMGUI_API ImVec2        CalcItemRectClosestPoint(const ImVec2& pos, bool on_edge = false, float outward = +0.0f);   // utility to find the closest point the last item bounding rectangle edge. useful to visually link items.
     IMGUI_API ImVec2        CalcTextSize(const char* text, const char* text_end = NULL, bool hide_text_after_double_hash = false, float wrap_width = -1.0f);
     IMGUI_API void          CalcListClipping(int items_count, float items_height, int* out_items_display_start, int* out_items_display_end);    // helper to manually clip large list of items. see comments in implementation.
 
     IMGUI_API void          ColorConvertHSVtoRGB(float h, float s, float v, float& out_r, float& out_g, float& out_b);
 
     // Internal state access - if you want to share ImGui state between modules (e.g. DLL) or allocate it yourself
+    IMGUI_API const char*   GetVersion();
     IMGUI_API void*         GetInternalState();
     IMGUI_API size_t        GetInternalStateSize();
     IMGUI_API void          SetInternalState(void* state, bool construct = false);
 
     // Obsolete (will be removed)
-    IMGUI_API void          GetDefaultFontData(const void** fnt_data, unsigned int* fnt_size, const void** png_data, unsigned int* png_size);
-    static inline void      OpenNextNode(bool open) { ImGui::SetNextTreeNodeOpened(open, 0); }
+    IMGUI_API void          GetDefaultFontData(const void** fnt_data, unsigned int* fnt_size, const void** png_data, unsigned int* png_size);   // OBSOLETE
+    static inline void      OpenNextNode(bool open) { ImGui::SetNextTreeNodeOpened(open, 0); }  // OBSOLETE
+    static inline bool      GetWindowIsFocused() { return ImGui::IsWindowFocused(); }   // OBSOLETE
+    static inline ImVec2    GetItemBoxMin() { return GetItemRectMin(); }    // OBSOLETE
+    static inline ImVec2    GetItemBoxMax() { return GetItemRectMax(); }    // OBSOLETE
+    static inline bool      IsMouseHoveringBox(const ImVec2& rect_min, const ImVec2& rect_max) { return IsMouseHoveringRect(rect_min, rect_max); }  // OBSOLETE
 
 } // namespace ImGui
 
     ImGuiStyleVar_FrameRounding,       // float
     ImGuiStyleVar_ItemSpacing,         // ImVec2
     ImGuiStyleVar_ItemInnerSpacing,    // ImVec2
-    ImGuiStyleVar_TreeNodeSpacing      // float
+    ImGuiStyleVar_IndentSpacing,       // float
+    ImGuiStyleVar_GrabMinSize          // float
 };
 
 // Enumeration for ColorEditMode()
     float       FrameRounding;              // Radius of frame corners rounding. Set to 0.0f to have rectangular frame (used by most widgets).
     ImVec2      ItemSpacing;                // Horizontal and vertical spacing between widgets/lines
     ImVec2      ItemInnerSpacing;           // Horizontal and vertical spacing between within elements of a composed widget (e.g. a slider and its label)
-    ImVec2      TouchExtraPadding;          // Expand bounding box for touch-based system where touch position is not accurate enough (unnecessary for mouse inputs). Unfortunately we don't sort widgets so priority on overlap will always be given to the first widget running. So dont grow this too much!
+    ImVec2      TouchExtraPadding;          // Expand reactive bounding box for touch-based system where touch position is not accurate enough. Unfortunately we don't sort widgets so priority on overlap will always be given to the first widget. So don't grow this too much!
     ImVec2      AutoFitPadding;             // Extra space after auto-fit (double-clicking on resize grip)
     float       WindowFillAlphaDefault;     // Default alpha of window background, if not specified in ImGui::Begin()
-    float       TreeNodeSpacing;            // Horizontal spacing when entering a tree node
+    float       IndentSpacing;              // Horizontal indentation when e.g. entering a tree node
     float       ColumnsMinSpacing;          // Minimum horizontal spacing between two columns
     float       ScrollbarWidth;             // Width of the vertical scrollbar
     float       GrabMinSize;                // Minimum width/height of a slider or scrollbar grab
     bool        MouseDrawCursor;            // Request ImGui to draw a mouse cursor for you (if you are on a platform without a mouse cursor).
     bool        KeyCtrl;                    // Keyboard modifier pressed: Control
     bool        KeyShift;                   // Keyboard modifier pressed: Shift
+    bool        KeyAlt;                     // Keyboard modifier pressed: Alt
     bool        KeysDown[512];              // Keyboard keys that are pressed (in whatever storage order you naturally have access to keyboard data)
     ImWchar     InputCharacters[16+1];      // List of characters input (translated by user from keypress+keyboard state). Fill using AddInputCharacter() helper.
 
     ImVector<char>      Buf;
 
     ImGuiTextBuffer()   { Buf.push_back(0); }
-    ~ImGuiTextBuffer()  { }
     const char*         begin() const { return &Buf.front(); }
     const char*         end() const { return &Buf.back(); }      // Buf is zero-terminated, so end() will point on the zero-terminator
     size_t              size() const { return Buf.size()-1; }
     ImDrawList() { Clear(); }
     IMGUI_API void  Clear();
     IMGUI_API void  PushClipRect(const ImVec4& clip_rect);          // Scissoring. The values are x1, y1, x2, y2.
+    IMGUI_API void  PushClipRectFullScreen();
     IMGUI_API void  PopClipRect();
     IMGUI_API void  PushTextureID(const ImTextureID& texture_id);
     IMGUI_API void  PopTextureID();
 
     // Primitives   
-    IMGUI_API void  AddLine(const ImVec2& a, const ImVec2& b, ImU32 col);
+    IMGUI_API void  AddLine(const ImVec2& a, const ImVec2& b, ImU32 col, float half_thickness = 0.50f);
     IMGUI_API void  AddRect(const ImVec2& a, const ImVec2& b, ImU32 col, float rounding = 0.0f, int rounding_corners=0x0F);
     IMGUI_API void  AddRectFilled(const ImVec2& a, const ImVec2& b, ImU32 col, float rounding = 0.0f, int rounding_corners=0x0F);
     IMGUI_API void  AddTriangleFilled(const ImVec2& a, const ImVec2& b, const ImVec2& c, ImU32 col);
     IMGUI_API void  AddCircle(const ImVec2& centre, float radius, ImU32 col, int num_segments = 12);
     IMGUI_API void  AddCircleFilled(const ImVec2& centre, float radius, ImU32 col, int num_segments = 12);
     IMGUI_API void  AddArc(const ImVec2& center, float rad, ImU32 col, int a_min, int a_max, bool tris = false, const ImVec2& third_point_offset = ImVec2(0,0));
-    IMGUI_API void  AddText(ImFont* font, float font_size, const ImVec2& pos, ImU32 col, const char* text_begin, const char* text_end = NULL, float wrap_width = 0.0f, const ImVec2* cpu_clip_max = NULL);
+    IMGUI_API void  AddText(const ImFont* font, float font_size, const ImVec2& pos, ImU32 col, const char* text_begin, const char* text_end = NULL, float wrap_width = 0.0f, const ImVec2* cpu_clip_max = NULL);
     IMGUI_API void  AddImage(ImTextureID user_texture_id, const ImVec2& a, const ImVec2& b, const ImVec2& uv0, const ImVec2& uv1, ImU32 col = 0xFFFFFFFF);
 
     // Advanced
     IMGUI_API void  ReserveVertices(unsigned int vtx_count);
     IMGUI_API void  AddVtx(const ImVec2& pos, ImU32 col);
     IMGUI_API void  AddVtxUV(const ImVec2& pos, ImU32 col, const ImVec2& uv);
-    IMGUI_API void  AddVtxLine(const ImVec2& a, const ImVec2& b, ImU32 col);
+    IMGUI_API void  AddVtxLine(const ImVec2& a, const ImVec2& b, ImU32 col, float half_thickness = 0.50f);
     IMGUI_API void  UpdateClipRect();
     IMGUI_API void  UpdateTextureID();
 };
     IMGUI_API void              SetTexID(void* id)  { TexID = id; }
 
     // Helpers to retrieve list of common Unicode ranges (2 value per range, values are inclusive, zero-terminated list)
-    // (Those functions could be static, aren't so simple use case doesn't have to refer to the ImFontAtlas:: type ever if in their code)
+    // (Those functions could be static but aren't so most users don't have to refer to the ImFontAtlas:: name ever if in their code; just using io.Fonts->)
     IMGUI_API const ImWchar*    GetGlyphRangesDefault();    // Basic Latin, Extended Latin
     IMGUI_API const ImWchar*    GetGlyphRangesJapanese();   // Default + Hiragana, Katakana, Half-Width, Selection of 1946 Ideographs
     IMGUI_API const ImWchar*    GetGlyphRangesChinese();    // Japanese + full set of about 21000 CJK Unified Ideographs

src/system/Shader.cpp

  * \author xythobuz
  */
 
+#include <sstream>
+
 #include "global.h"
 #include "Log.h"
 #include "system/Window.h"
 
 // ----------------------------------------------------------------------------
 
+std::string Shader::getVersion(bool linked) {
+    std::ostringstream str;
+    if (!linked) {
+        str << "OpenGL v" << glGetString(GL_VERSION);
+    } else {
+        str << "OpenGL " << glGetString(GL_SHADING_LANGUAGE_VERSION) << " "
+            << glGetString(GL_RENDERER) << " (" << glGetString(GL_VENDOR) << ")";
+    }
+    return str.str();
+}
+
 Shader Shader::textShader;
 Shader Shader::textureShader;
 Shader Shader::colorShader;
 unsigned int Shader::vertexArrayID = 0;
 
 int Shader::initialize() {
-    Log::get(LOG_DEBUG) << "GL Ven.: " << glGetString(GL_VENDOR) << Log::endl;
-    Log::get(LOG_DEBUG) << "GL Ren.: " << glGetString(GL_RENDERER) << Log::endl;
-    Log::get(LOG_DEBUG) << "GL Ver.: " << glGetString(GL_VERSION) << Log::endl;
-    Log::get(LOG_DEBUG) << "GLSL V.: " << glGetString(GL_SHADING_LANGUAGE_VERSION) << Log::endl;
-
     glGenVertexArrays(1, &vertexArrayID);
     glBindVertexArray(vertexArrayID);
 

src/system/Sound.cpp

 #endif
 }
 
+std::string Sound::getVersion(bool linked) {
+#ifdef USING_AL
+    return SoundAL::getVersion(linked);
+#else
+    return "none";
+#endif
+}
+

src/system/SoundAL.cpp

 #endif
 
 #include <AL/alut.h>
+#include <sstream>
 
 #include "global.h"
 #include "Log.h"
     return volume;
 }
 
+std::string SoundAL::getVersion(bool linked) {
+    std::ostringstream str;
+    if (!linked) {
+        str << "OpenAL v" << alGetString(AL_VERSION) << "; ALUT v"
+            << ALUT_API_MAJOR_VERSION << "." << ALUT_API_MINOR_VERSION;
+    } else {
+        str << "OpenAL " << alGetString(AL_RENDERER) << " (" << alGetString(AL_VENDOR)
+            << "); ALUT v" << alutGetMajorVersion() << "." << alutGetMinorVersion();
+    }
+    return str.str();
+}
+

src/system/Window.cpp

 #endif
 }
 
+std::string Window::getVersion(bool linked) {
+    std::string ret;
+
+#ifdef USING_SDL
+    ret = WindowSDL::getVersion(linked);
+#elif defined(USING_GLFW)
+    ret = WindowGLFW::getVersion(linked);
+#endif
+
+    return ret;
+}
+

src/system/WindowGLFW.cpp

  * \author xythobuz
  */
 
+#include <sstream>
+
 #define GLFW_INCLUDE_NONE
 #include <GLFW/glfw3.h>
 
     return nullptr;
 }
 
+std::string WindowGLFW::getVersion(bool linked) {
+    if (linked) {
+        return std::string("GLFW v") + glfwGetVersionString();
+    } else {
+        std::ostringstream str;
+        str << "GLFW v" << GLFW_VERSION_MAJOR << "." << GLFW_VERSION_MINOR << "." << GLFW_VERSION_REVISION;
+        return str.str();
+    }
+}
+
 void WindowGLFW::inputPositionCallback(int x, int y) {
 
 }

src/system/WindowSDL.cpp

  * \author xythobuz
  */
 
+#include <sstream>
+
+#include "SDL_revision.h"
+
 #include "global.h"
 #include "Log.h"
 #include "RunTime.h"
     SDL_SetTextInputRect(&rect);
 }
 
+std::string WindowSDL::getVersion(bool linked) {
+    SDL_version vers;
+
+    if (linked) {
+        SDL_GetVersion(&vers);
+    } else {
+        SDL_VERSION(&vers);
+    }
+
+    std::ostringstream str;
+    str << "SDL2 v" << int(vers.major) << "." << int(vers.minor) << "." << int(vers.patch);
+    if (linked) {
+        return str.str() + " (" + SDL_GetRevision() + ")";
+    } else {
+        return str.str() + " (" + SDL_REVISION + ")";
+    }
+}
+