Added ImGui docking.

3rdparty/ocornut-imgui/imgui.h

@@ -22,7 +22,7 @@
 // Define assertion handler.
 #ifndef IM_ASSERT
 #include <assert.h>
-#define IM_ASSERT(_EXPR)    assert(_EXPR)
+#define IM_ASSERT(_EXPR, ...)    assert(_EXPR)
 #endif
 
 // Define attributes of all API symbols declarations, e.g. for DLL under Windows.

3rdparty/ocornut-imgui/imgui_wm.h

@@ -0,0 +1,314 @@
+/*
+ * Copyright 2011-2015 Branimir Karadzic. All rights reserved.
+ * License: http://www.opensource.org/licenses/BSD-2-Clause
+ */
+
+/*
+ * Based on ImWindow code from:
+ * https://github.com/thennequin/ImWindow
+ *
+ * MIT license:
+ * https://github.com/thennequin/ImWindow/blob/master/LICENSE
+ */
+
+#ifndef IMGUI_WM_H_HEADER_GUARD
+#define IMGUI_WM_H_HEADER_GUARD
+
+#include "imgui.h"
+
+typedef unsigned int ImU32;
+
+#ifndef ImwList
+#	include <list>
+#	define ImwList std::list
+#endif // ImList
+
+#ifndef ImwMap
+#	include <unordered_map>
+#	define ImwMap std::unordered_map
+#endif // ImMap
+
+namespace ImWindow
+{
+    enum EDockOrientation
+    {
+        E_DOCK_ORIENTATION_CENTER,
+        E_DOCK_ORIENTATION_TOP,
+        E_DOCK_ORIENTATION_LEFT,
+        E_DOCK_ORIENTATION_RIGHT,
+        E_DOCK_ORIENTATION_BOTTOM,
+    };
+
+    struct ImwId
+    {
+        ImwId();
+        ImU32 GetId() const;
+        const char* GetStr() const;
+    private:
+        ImU32      m_iId;
+        char       m_pId[11];
+        static int s_iNextId;
+    };
+
+    class ImwWindow
+    {
+        friend class ImwWindowManager;
+        friend class ImwContainer;
+    protected:
+        ImwWindow();
+        virtual					~ImwWindow();
+    public:
+        virtual void			OnGui() = 0;
+        virtual void			OnMenu() {};
+
+        const char*				GetId() const { return m_oId.GetStr(); }
+
+        void					Destroy();
+
+        void					SetTitle(const char* pTitle);
+        const char*				GetTitle() const;
+
+        const ImVec2&			GetLastPosition() const;
+        const ImVec2&			GetLastSize() const;
+    protected:
+
+        char*					m_pTitle;
+        ImwId					m_oId;
+
+        ImVec2					m_oLastPosition;
+        ImVec2					m_oLastSize;
+    };
+
+    typedef ImwList<ImwWindow*> ImwWindowList;
+
+    class ImwPlatformWindow;
+
+    class ImwContainer
+    {
+        friend class ImwPlatformWindow;
+
+    public:
+
+        void							Dock(ImwWindow* pWindow, EDockOrientation eOrientation = E_DOCK_ORIENTATION_CENTER);
+        bool							UnDock(ImwWindow* pWindow);
+
+        bool							IsEmpty();
+        bool							IsSplit();
+        bool							HasWindowTabbed();
+        ImwContainer*					HasWindow(const ImwWindow* pWindow);
+        ImwPlatformWindow*				GetPlatformWindowParent() const;
+        ImwContainer*					GetBestDocking(const ImVec2 oCursorPosInContainer, EDockOrientation& oOutOrientation, ImVec2& oOutAreaPos, ImVec2& oOutAreaSize);
+    protected:
+        ImwContainer(ImwContainer* pParent);
+        ImwContainer(ImwPlatformWindow* pParent);
+        ~ImwContainer();
+
+        void							CreateSplits();
+
+        void							Paint();
+
+        ImwContainer*					m_pParent;
+        ImwPlatformWindow*				m_pParentWindow;
+        ImwWindowList					m_lWindows;
+        ImwContainer*					m_pSplits[2];
+
+        float							m_fSplitRatio;
+        bool							m_bVerticalSplit;
+        int								m_iActiveWindow;
+
+        bool							m_bIsDrag;
+
+        ImVec2							m_oLastPosition;
+        ImVec2							m_oLastSize;
+    };
+
+    class ImwPlatformWindow
+    {
+        friend class ImwWindowManager;
+    public:
+        ImwPlatformWindow(bool bMainWindow, bool bIsDragWindow);
+        virtual								~ImwPlatformWindow();
+
+        virtual bool						Init(ImwPlatformWindow* pParent) = 0;
+
+        virtual const ImVec2&				GetPosition() const = 0;
+        virtual const ImVec2&				GetSize() const = 0;
+
+        virtual void						Show() = 0;
+        virtual void						Hide() = 0;
+        virtual void						SetSize(const ImVec2& size) = 0;
+        virtual void						SetPosition(const ImVec2& pos) = 0;
+        virtual void						SetTitle(const char* pTitle) = 0;
+
+        bool								IsMain();
+
+        void								Dock(ImwWindow* pWindow);
+        bool								UnDock(ImwWindow* pWindow);
+
+        ImwContainer*						GetContainer();
+        ImwContainer*						HasWindow(ImwWindow* pWindow);
+        bool								IsStateSet();
+    protected:
+        void								SetState();
+        void								RestoreState();
+        void								OnLoseFocus();
+        virtual void						PreUpdate() = 0;
+        virtual void						Paint();
+        virtual void						Destroy() = 0;
+        virtual void						StartDrag() = 0;
+        virtual void						StopDrag() = 0;
+        virtual bool						IsDraging() = 0;
+
+        void								PaintContainer();
+        void								OnClose();
+
+        ImwId								m_oId;
+        bool								m_bMain;
+        bool								m_bIsDragWindow;
+        ImwContainer*						m_pContainer;
+        void*								m_pState;
+        void*								m_pPreviousState;
+    };
+
+    typedef ImwList<ImwPlatformWindow*> ImwPlatformWindowList;
+
+    class ImwWindowManager
+    {
+        friend class ImwWindow;
+        friend class ImwPlatformWindow;
+        friend class ImwContainer;
+
+        enum EPlatformWindowAction
+        {
+            E_PLATFORM_WINDOW_ACTION_DESTOY			= 1,
+            E_PLATFORM_WINDOW_ACTION_SHOW			= 2,
+            E_PLATFORM_WINDOW_ACTION_HIDE			= 4,
+            E_PLATFORM_WINDOW_ACTION_SET_POSITION	= 8,
+            E_PLATFORM_WINDOW_ACTION_SET_SIZE		= 16,
+        };
+
+        struct PlatformWindowAction
+        {
+            ImwPlatformWindow*		m_pPlatformWindow;
+            unsigned int			m_iFlags;
+            ImVec2					m_oPosition;
+            ImVec2					m_oSize;
+        };
+
+        struct DockAction
+        {
+            ImwWindow*				m_pWindow;
+            // Is Dock or Float
+            bool					m_bFloat;
+            //For Docking
+            ImwWindow*				m_pWith;
+            EDockOrientation		m_eOrientation;
+            ImwPlatformWindow*		m_pToPlatformWindow;
+            ImwContainer*			m_pToContainer;
+            //For Floating
+            ImVec2					m_oPosition;
+            ImVec2					m_oSize;
+        };
+
+        struct DrawWindowAreaAction
+        {
+            DrawWindowAreaAction(ImwPlatformWindow* pWindow, const ImVec2& oRectPos, const ImVec2& oRectSize, const ImColor& oColor);
+            ImwPlatformWindow*		m_pWindow;
+            ImVec2					m_oRectPos;
+            ImVec2					m_oRectSize;
+            ImColor					m_oColor;
+        };
+
+    public:
+        struct Config
+        {
+            Config();
+            float					m_fDragMarginRatio;
+            float					m_fDragMarginSizeRatio;
+            ImColor					m_oHightlightAreaColor;
+        };
+
+        ImwWindowManager();
+        virtual								~ImwWindowManager();
+
+        bool								Init();
+        bool								Run();
+        void								Exit();
+
+        ImwPlatformWindow*					GetMainPlatformWindow();
+        Config&								GetConfig();
+
+        void								SetMainTitle(const char* pTitle);
+
+        void								Dock(ImwWindow* pWindow, EDockOrientation eOrientation = E_DOCK_ORIENTATION_CENTER, ImwPlatformWindow* pToPlatformWindow = NULL);
+        void								DockTo(ImwWindow* pWindow, EDockOrientation eOrientation = E_DOCK_ORIENTATION_CENTER, ImwContainer* pContainer = NULL);
+        void								DockWith(ImwWindow* pWindow, ImwWindow* pWithWindow, EDockOrientation eOrientation = E_DOCK_ORIENTATION_CENTER);
+        void								Float(ImwWindow* pWindow, const ImVec2& oPosition = ImVec2(-1, -1), const ImVec2& oSize = ImVec2(-1, -1));
+
+        const ImwWindowList&				GetWindowList() const;
+        ImwPlatformWindow*					GetCurrentPlatformWindow();
+        ImwPlatformWindow*					GetWindowParent(ImwWindow* pWindow);
+
+        void								Log(const char* pFormat, ...);
+        virtual void						LogFormatted(const char* pStr) = 0;;
+    protected:
+        virtual ImwPlatformWindow*			CreatePlatformWindow(bool bMain, ImwPlatformWindow* pParent, bool bDragWindow) = 0;
+        virtual void						InternalRun() = 0;
+        virtual ImVec2						GetCursorPos() = 0;
+        virtual bool						IsLeftClickDown() = 0;
+
+        void								AddWindow(ImwWindow* pWindow);
+        void								RemoveWindow(ImwWindow* pWindow);
+        void								DestroyWindow(ImwWindow* pWindow);
+
+        void								InternalDock(ImwWindow* pWindow, EDockOrientation eOrientation, ImwPlatformWindow* pToPlatformWindow);
+        void								InternalDockTo(ImwWindow* pWindow, EDockOrientation eOrientation, ImwContainer* pToContainer);
+        void								InternalDockWith(ImwWindow* pWindow, ImwWindow* pWithWindow, EDockOrientation eOrientation);
+        void								InternalFloat(ImwWindow* pWindow, ImVec2 oPosition, ImVec2 oSize);
+        void								InternalUnDock(ImwWindow* pWindow);
+        void								InternalDrag(ImwWindow* pWindow);
+
+        void								OnClosePlatformWindow(ImwPlatformWindow* pWindow);
+
+        void								DrawWindowArea(ImwPlatformWindow* pWindow, const ImVec2& oPos, const ImVec2& oSize, const ImColor& oColor);
+
+        void								PreUpdate();
+        void								Update();
+        void								UpdatePlatformwWindowActions();
+        void								UpdateDockActions();
+        void								UpdateOrphans();
+
+        void								Paint(ImwPlatformWindow* pWindow);
+
+        void								StartDragWindow(ImwWindow* pWindow);
+        void								StopDragWindow();
+        void								UpdateDragWindow();
+        ImwContainer*						GetBestDocking(ImwPlatformWindow* pPlatformWindow, const ImVec2 oCursorPos, EDockOrientation& oOutOrientation, ImVec2& oOutAreaPos, ImVec2& oOutAreaSize);
+
+        Config								m_oConfig;
+        ImwPlatformWindow*					m_pMainPlatformWindow;
+        ImwPlatformWindowList				m_lPlatformWindows;
+        ImwPlatformWindow*					m_pDragPlatformWindow;
+        ImwWindowList						m_lWindows;
+        ImwWindowList						m_lOrphanWindows;
+        ImwWindowList						m_lToDestroyWindows;
+        ImwPlatformWindowList				m_lToDestroyPlatformWindows;
+        ImwList<PlatformWindowAction*>		m_lPlatformWindowActions;
+        ImwList<DockAction*>				m_lDockActions;
+        ImwList<DrawWindowAreaAction>		m_lDrawWindowAreas;
+
+        ImwPlatformWindow*					m_pCurrentPlatformWindow;
+        ImwWindow*							m_pDraggedWindow;
+
+        ImVec2								m_oDragPreviewOffset;
+
+        // Static
+    public:
+        static ImwWindowManager*			GetInstance();
+
+    protected:
+        static ImwWindowManager*			s_pInstance;
+    };
+}
+
+#endif // IMGUI_WM_H_HEADER_GUARD

examples/common/imgui/imgui.h

@@ -28,6 +28,7 @@
 
 #include <bgfx/bgfx.h>
 #include <ocornut-imgui/imgui.h>
+#include <ocornut-imgui/imgui_wm.h>
 
 #define IMGUI_MBUT_LEFT   0x01
 #define IMGUI_MBUT_RIGHT  0x02

examples/common/imgui/ocornut_imgui.cpp

@@ -8,6 +8,7 @@
 #include <bx/fpumath.h>
 #include <bx/timer.h>
 #include <ocornut-imgui/imgui.h>
+#include <ocornut-imgui/imgui_wm.h>
 #include "imgui.h"
 #include "ocornut_imgui.h"
 #include <stb/stb_image.c>
@@ -20,6 +21,142 @@
 #include "vs_ocornut_imgui.bin.h"
 #include "fs_ocornut_imgui.bin.h"
 
+class PlatformWindow : public ImWindow::ImwPlatformWindow
+{
+	typedef ImWindow::ImwPlatformWindow Super;
+
+public:
+	PlatformWindow(bool _mainWindow, bool _isDragWindow)
+		: ImWindow::ImwPlatformWindow(_mainWindow, _isDragWindow)
+		, m_pos(0.0f, 0.0f)
+		, m_size(0.0f, 0.0f)
+		, m_drag(false)
+	{
+	}
+
+	virtual ~PlatformWindow() BX_OVERRIDE
+	{
+	}
+
+	virtual bool Init(ImWindow::ImwPlatformWindow* /*_parent*/) BX_OVERRIDE
+	{
+		return true;
+	}
+
+	virtual const ImVec2& GetPosition() const BX_OVERRIDE
+	{
+		return m_pos;
+	}
+
+	virtual const ImVec2& GetSize() const BX_OVERRIDE
+	{
+		return m_size;
+	}
+
+	virtual void Show() BX_OVERRIDE
+	{
+	}
+
+	virtual void Hide() BX_OVERRIDE
+	{
+	}
+
+	virtual void SetSize(const ImVec2& _size) BX_OVERRIDE
+	{
+		m_size = _size;
+	}
+
+	virtual void SetPosition(const ImVec2& _pos) BX_OVERRIDE
+	{
+		m_pos = _pos;
+	}
+
+	virtual void SetTitle(const char* /*_title*/) BX_OVERRIDE
+	{
+	}
+
+	virtual void PreUpdate() BX_OVERRIDE
+	{
+	}
+
+	virtual void Paint() BX_OVERRIDE
+	{
+		if (!m_bIsDragWindow)
+		{
+			Super::Paint();
+		}
+	}
+
+	virtual void Destroy() BX_OVERRIDE
+	{
+	}
+
+	virtual void StartDrag() BX_OVERRIDE
+	{
+		m_drag = true;
+	}
+
+	virtual void StopDrag() BX_OVERRIDE
+	{
+		m_drag = false;
+	}
+
+	virtual bool IsDraging() BX_OVERRIDE
+	{
+		return m_drag;
+	}
+
+private:
+	ImVec2 m_pos;
+	ImVec2 m_size;
+	bool m_drag;
+};
+
+class WindowManager : public ImWindow::ImwWindowManager
+{
+	typedef ImWindow::ImwWindowManager Super;
+
+public:
+	WindowManager()
+	{
+	}
+
+	virtual ~WindowManager() BX_OVERRIDE
+	{
+	}
+
+protected:
+	virtual ImWindow::ImwPlatformWindow* CreatePlatformWindow(bool _main, ImWindow::ImwPlatformWindow* _parent, bool _isDragWindow) BX_OVERRIDE
+	{
+		PlatformWindow* window = new PlatformWindow(_main, _isDragWindow);
+		window->Init(_parent);
+		return static_cast<ImWindow::ImwPlatformWindow*>(window);
+	}
+
+	virtual void LogFormatted(const char* _str) BX_OVERRIDE
+	{
+		BX_TRACE("%s", _str); BX_UNUSED(_str);
+	}
+
+	virtual void InternalRun() BX_OVERRIDE
+	{
+		PreUpdate();
+		Update();
+	}
+
+	virtual ImVec2 GetCursorPos() BX_OVERRIDE
+	{
+		ImGuiIO& io = ImGui::GetIO();
+		return io.MousePos;
+	}
+
+	virtual bool IsLeftClickDown() BX_OVERRIDE
+	{
+		ImGuiIO& io = ImGui::GetIO();
+		return io.MouseDown[0];
+	}
+};
+
 struct OcornutImguiContext
 {
 	static void* memAlloc(size_t _size);
@@ -202,10 +339,15 @@ struct OcornutImguiContext
 
 		ImGuiStyle& style = ImGui::GetStyle();
 		style.FrameRounding = 4.0f;
+
+		m_wm = BX_NEW(m_allocator, WindowManager);
+		m_wm->Init();
 	}
 
 	void destroy()
 	{
+		m_wm->Exit();
+		BX_DELETE(m_allocator, m_wm);
 		ImGui::Shutdown();
 
 		bgfx::destroyUniform(s_tex);
@@ -270,6 +412,7 @@ struct OcornutImguiContext
 
 	void endFrame()
 	{
+		m_wm->Run();
 		ImGui::Render();
 	}
 
@@ -278,6 +421,7 @@ struct OcornutImguiContext
 	bgfx::ProgramHandle m_program;
 	bgfx::TextureHandle m_texture;
 	bgfx::UniformHandle s_tex;
+	WindowManager* m_wm;
 	int64_t m_last;
 	int32_t m_lastScroll;
 	uint8_t m_viewId;