Desktop version of dashboard

README.md

@@ -32,6 +32,11 @@ Open `KinectV2 Dashboard` from SteamVR dashboard to gain access to available set
   * **Toggle tracking:** Disable or enable tracking entirely.
   * **Interpolation type:** Sets specific interpolation between Kinect frames. More info is available at [Wikipedia's article](https://en.wikipedia.org/wiki/Interpolation).
   * **Kinect relay device state:** Shows if specific virtual base station is present.
+
+## Usage with desktop version of dashboard
+If you're owner of AMD GPU with latest drivers, you're in luck. Latest drivers breaks functionality of OpenGL.  
+If `KinectV1 Dashboard` overlay is empty, you have to use desktop version of dashboard included in release.  
+Before you launch `kinect_dash_desktop` from `SteamVR/drivers/kinectV2/bin/win##`, you have to kill `kinect_dash` process from task manager/CMD/PowerShell console.
 
 ## Building
 * Install [Kinect for Windows SDK 2.0](https://www.microsoft.com/en-us/download/details.aspx?id=44561).

kinect_dash/Core/Core.cpp

@@ -35,16 +35,16 @@ bool Core::Intitialize()
             m_sfmlManager = new SfmlManager(this);
             m_guiManager = new GuiManager(this);
 
+#ifndef DASHBOARD_DESKTOP
             m_vrManager->SetOverlayTexture(m_guiManager->GetRenderTargetTextureName());
+#endif
 
             m_valid = true;
             m_active = true;
         }
         catch(std::exception &l_exception)
         {
-#ifdef _DEBUG
             MessageBoxA(NULL, l_exception.what(), "KinectV2 Dashboard", MB_OK | MB_ICONEXCLAMATION);
-#endif
         }
     }
     return m_valid;
@@ -53,17 +53,17 @@ void Core::Terminate()
 {
     if(m_valid)
     {
-        delete m_guiManager; 
+        delete m_guiManager;
         m_guiManager = nullptr;
 
-        delete m_sfmlManager; 
+        delete m_sfmlManager;
         m_sfmlManager = nullptr;
 
-        delete m_vrManager; 
+        delete m_vrManager;
         m_vrManager = nullptr;
 
         m_configManager->Save();
-        delete m_configManager; 
+        delete m_configManager;
         m_configManager = nullptr;
 
         m_valid = false;
@@ -77,7 +77,9 @@ bool Core::DoPulse()
         m_active = (m_active && m_vrManager->DoPulse());
         m_active = (m_active && m_sfmlManager->DoPulse());
 
+#ifndef DASHBOARD_DESKTOP
         std::this_thread::sleep_for(g_threadSleep);
+#endif
     }
     return m_active;
 }

kinect_dash/Managers/ConfigManager.cpp

@@ -33,7 +33,7 @@ const std::vector<std::string> g_boneNames
     "HandTipLeft", "ThumbLeft",
     "HandTipRight", "ThumbRight"
 };
-const size_t g_bonesCount = g_boneNames.size();
+extern const size_t g_bonesCount = g_boneNames.size();
 
 const char* g_settingsPath = "..\\..\\resources\\settings.xml";
 

kinect_dash/Managers/GuiManager.cpp

@@ -3,6 +3,7 @@
 #include "Core/Core.h"
 #include "Managers/ConfigManager.h"
 #include "Managers/GuiManager.h"
+#include "Managers/SfmlManager.h"
 #include "Managers/VRManager.h"
 
 #include "Gui/GuiScreen.h"
@@ -13,6 +14,8 @@
 #include "Gui/GuiSeparator.h"
 #include "Gui/GuiRadioButton.h"
 
+extern const size_t g_bonesCount;
+
 const std::string g_boneNames[]
 {
     "Spine (Base)", "Spine (Middle)", "Neck", "Head",
@@ -54,11 +57,15 @@ GuiManager::GuiManager(Core *f_core)
 {
     m_core = f_core;
 
+#ifndef DASHBOARD_DESKTOP
     m_renderTexture = new sf::RenderTexture();
     if(!m_renderTexture->create(1024, 512)) throw std::runtime_error("Unable to create render target for GUI overlay");
 
     sf::Window l_dummyWindow; // imgui-sfml checks only window focus
     ImGui::SFML::Init(l_dummyWindow, *m_renderTexture, false);
+#else
+    ImGui::SFML::Init(*m_core->GetSfmlManager()->GetWindow(), sf::Vector2f(1024.f, 512.f), false);
+#endif
 
     sf::Event l_event;
     l_event.type = sf::Event::EventType::GainedFocus;
@@ -98,7 +105,7 @@ GuiManager::GuiManager(Core *f_core)
     m_trackersWindow->SetSize(sf::Vector2f(658, 214));
     m_screen->Add(m_trackersWindow);
 
-    for(size_t i = 0U; i < 25U; i++)
+    for(size_t i = 0U; i < g_bonesCount; i++)
     {
         m_trackersButtons.push_back(new GuiButton(g_boneNames[i].c_str()));
 
@@ -110,7 +117,6 @@ GuiManager::GuiManager(Core *f_core)
         m_trackersButtons[i]->SetClickCallback(std::bind(&GuiManager::OnTrackerToggle, this, std::placeholders::_1, i));
 
         m_trackersWindow->Add(m_trackersButtons[i]);
-
     }
 
     // Calibration info
@@ -140,6 +146,7 @@ GuiManager::GuiManager(Core *f_core)
     m_settingsButtons.push_back(new GuiButton("Start calibration"));
     m_settingsButtons[SettingsButton::SB_StartCalibration]->SetPosition(sf::Vector2f(16.f, 48.f));
     m_settingsButtons[SettingsButton::SB_StartCalibration]->SetSize(sf::Vector2f(294.f, 32.f));
+    m_settingsButtons[SettingsButton::SB_StartCalibration]->SetColor(g_untoggledColor);
     m_settingsButtons[SettingsButton::SB_StartCalibration]->SetClickCallback(std::bind(&GuiManager::OnCalibrationStart, this, std::placeholders::_1));
     m_settingsWindow->Add(m_settingsButtons[SettingsButton::SB_StartCalibration]);
 
@@ -193,42 +200,52 @@ GuiManager::~GuiManager()
     delete m_calibrationWindow;
 
     // Trackers toggle
-    for(size_t i = 0U; i < 25U; i++) delete m_trackersButtons[i];
+    for(size_t i = 0U; i < g_bonesCount; i++) delete m_trackersButtons[i];
     m_trackersButtons.clear();
     delete m_trackersWindow;
 
     // Screen
     delete m_screen;
     ImGui::SFML::Shutdown();
 
+#ifndef DASHBOARD_DESKTOP
     delete m_renderTexture;
+#endif
 }
 
 void GuiManager::Render()
 {
+#ifndef DASHBOARD_DESKTOP
     if(m_core->GetVRManager()->IsOverlayVisible())
     {
+#endif
         // Update calibration info
         for(size_t i = 0U; i < 4; i++) m_calibrationFields[i * 2]->SetText(std::to_string(m_core->GetConfigManager()->GetBaseRotation()[i]));
         for(size_t i = 0U; i < 3; i++) m_calibrationFields[i * 2 + 1]->SetText(std::to_string(m_core->GetConfigManager()->GetBasePosition()[i]));
 
         // Update gui elements
         m_screen->Update();
 
+#ifndef DASHBOARD_DESKTOP
         m_renderTexture->setActive(true);
         m_renderTexture->clear();
+#endif
         m_screen->Render();
+#ifndef DASHBOARD_DESKTOP
         m_renderTexture->display();
         m_renderTexture->setActive(false);
     }
+#endif
 }
 
+#ifndef DASHBOARD_DESKTOP
 unsigned int GuiManager::GetRenderTargetTextureName() const
 {
     unsigned int l_result = 0U;
     if(m_renderTexture) l_result = m_renderTexture->getTexture().getNativeHandle();
     return l_result;
 }
+#endif
 
 void GuiManager::ReceiveMouseMove(float f_x, float f_y)
 {

kinect_dash/Managers/GuiManager.h

@@ -16,7 +16,9 @@ class GuiManager final
     friend class VRManager;
     Core *m_core;
 
+#ifndef DASHBOARD_DESKTOP
     sf::RenderTexture *m_renderTexture;
+#endif
 
     // Render target is needed
     GuiScreen *m_screen;
@@ -49,11 +51,13 @@ class GuiManager final
     explicit GuiManager(Core *f_core);
     ~GuiManager();
 
+#ifndef DASHBOARD_DESKTOP
     unsigned int GetRenderTargetTextureName() const;
+#endif
 
-    void Render(); // GlfwManager call only
+    void Render(); // SfmlManager call only
 
-    // VRManager only
+    // VRManager/SfmlManager only
     void ReceiveMouseMove(float f_x, float f_y);
     void ReceiveMouseClick(bool f_left, bool f_press);
 };

kinect_dash/Managers/SfmlManager.cpp

@@ -10,25 +10,69 @@ SfmlManager::SfmlManager(Core *f_core)
 {
     m_core = f_core;
 
-    //const sf::ContextSettings l_contextSettings(0U, 0U, 0U, 3U, 0U, sf::ContextSettings::Core, false);
-    //m_context = new sf::Context(l_contextSettings, 2U, 2U);
-    m_context = new sf::Context();
-    if(!m_context->setActive(true)) throw std::runtime_error("Unable to bind SFML context");
+    // AMD sucks at OpenGL implementation
+    const sf::ContextSettings l_contextSettings(16U, 8U, 0U, 2U, 1U, sf::ContextSettings::Default, false);
+#ifdef DASHBOARD_DESKTOP
+    const sf::VideoMode l_mode(1024U, 512U);
+    m_window = new sf::RenderWindow(l_mode, "KinectV2 Dashboard", sf::Style::Titlebar | sf::Style::Close, l_contextSettings);
+    if(!m_window->setActive(true)) throw std::runtime_error("Unable to create SFML window");
+    m_window->setFramerateLimit(30U);
+
+    std::memset(&m_event, 0, sizeof(sf::Event));
+#else
+    m_context = new sf::Context(l_contextSettings, 1024U, 512U);
+    if(!m_context->setActive(true)) throw std::runtime_error("Unable to create SFML context");
+#endif
 
     m_active = true;
 }
 
 SfmlManager::~SfmlManager()
 {
+#ifdef DASHBOARD_DESKTOP
+    m_window->close();
+    delete m_window;
+#else
     delete m_context;
+#endif
+}
+
+#ifdef DASHBOARD_DESKTOP
+sf::RenderWindow* SfmlManager::GetWindow() const
+{
+    return m_window;
 }
+#endif
 
 bool SfmlManager::DoPulse()
 {
     if(m_active)
     {
-        // GUI render
+#ifdef DASHBOARD_DESKTOP
+        while(m_window->pollEvent(m_event))
+        {
+            switch(m_event.type)
+            {
+                case sf::Event::EventType::Closed:
+                    m_active = false;
+                    break;
+                case sf::Event::EventType::MouseMoved:
+                    m_core->GetGuiManager()->ReceiveMouseMove(static_cast<float>(m_event.mouseMove.x), static_cast<float>(m_event.mouseMove.y));
+                    break;
+                case sf::Event::EventType::MouseButtonPressed: case sf::Event::EventType::MouseButtonReleased:
+                    m_core->GetGuiManager()->ReceiveMouseClick(m_event.mouseButton.button == sf::Mouse::Button::Left, m_event.type == sf::Event::EventType::MouseButtonPressed);
+                    break;
+            }
+        }
+#endif
+        // Frame pass
+#ifdef DASHBOARD_DESKTOP
+        m_window->clear();
+#endif
         m_core->GetGuiManager()->Render();
+#ifdef DASHBOARD_DESKTOP
+        m_window->display();
+#endif
     }
     return m_active;
 }

kinect_dash/Managers/SfmlManager.h

@@ -7,12 +7,20 @@ class SfmlManager final
     friend Core;
     Core *m_core;
 
+#ifdef DASHBOARD_DESKTOP
+    sf::RenderWindow *m_window;
+    sf::Event m_event;
+#else
     sf::Context *m_context;
+#endif
     bool m_active;
 
     SfmlManager(const SfmlManager &that) = delete;
     SfmlManager& operator=(const SfmlManager &that) = delete;
 public:
+    #ifdef DASHBOARD_DESKTOP
+    sf::RenderWindow* GetWindow() const;
+#endif
 protected:
     explicit SfmlManager(Core *f_core);
     ~SfmlManager();

kinect_dash/Managers/VRManager.cpp

@@ -20,6 +20,7 @@ VRManager::VRManager(Core *f_core)
         throw std::runtime_error(l_errorString);
     }
 
+#ifndef DASHBOARD_DESKTOP
     // Create overlays
     vr::VROverlay()->CreateDashboardOverlay("kinect_dash.dashboard", "KinectV2 Dashboard", &m_dashboardOverlay, &m_dashboardOverlayThumbnail);
     if((m_dashboardOverlay != vr::k_ulOverlayHandleInvalid) && (m_dashboardOverlayThumbnail != vr::k_ulOverlayHandleInvalid))
@@ -38,6 +39,7 @@ VRManager::VRManager(Core *f_core)
         m_dashboardTexture.eType = vr::TextureType_OpenGL;
         m_dashboardTexture.handle = nullptr;
     }
+#endif
 
     vr::VROverlay()->CreateOverlay("kinect_dash.notify", "KinectV2 Calibration", &m_notificationOverlay);
     m_notification = 0;
@@ -69,8 +71,10 @@ VRManager::~VRManager()
 {
     if(m_notificationOverlay != vr::k_ulOverlayHandleInvalid) vr::VROverlay()->DestroyOverlay(m_notificationOverlay);
     if(m_notification != 0) vr::VRNotifications()->RemoveNotification(m_notification);
+#ifndef DASHBOARD_DESKTOP
     if(m_dashboardOverlay != vr::k_ulOverlayHandleInvalid) vr::VROverlay()->DestroyOverlay(m_dashboardOverlay);
     if(m_dashboardOverlayThumbnail != vr::k_ulOverlayHandleInvalid) vr::VROverlay()->DestroyOverlay(m_dashboardOverlayThumbnail);
+#endif
     vr::VR_Shutdown();
 }
 
@@ -136,6 +140,7 @@ bool VRManager::DoPulse()
         }
     }
 
+#ifndef DASHBOARD_DESKTOP
     while(vr::VROverlay()->PollNextOverlayEvent(m_dashboardOverlay, &m_event, sizeof(vr::VREvent_t)))
     {
         switch(m_event.eventType)
@@ -150,11 +155,14 @@ bool VRManager::DoPulse()
             } break;
         }
     }
+#endif
 
     if(m_leftHand == vr::k_unTrackedDeviceIndexInvalid) m_leftHand = m_vrSystem->GetTrackedDeviceIndexForControllerRole(vr::TrackedControllerRole_LeftHand);
     if(m_rightHand == vr::k_unTrackedDeviceIndexInvalid) m_rightHand = m_vrSystem->GetTrackedDeviceIndexForControllerRole(vr::TrackedControllerRole_RightHand);
 
+#ifndef DASHBOARD_DESKTOP
     if(IsOverlayVisible()) vr::VROverlay()->SetOverlayTexture(m_dashboardOverlay, &m_dashboardTexture);
+#endif
 
     // Calibration helper update
     if(m_calibrationHelper->IsCalibrationActive())
@@ -185,6 +193,8 @@ bool VRManager::IsKinectDevicePresent() const
 {
     return (m_kinectDevice != vr::k_unTrackedDeviceIndexInvalid);
 }
+
+#ifndef DASHBOARD_DESKTOP
 bool VRManager::IsOverlayVisible() const
 {
     bool l_result = false;
@@ -199,6 +209,7 @@ void VRManager::SetOverlayTexture(unsigned int f_name)
 {
     if(m_dashboardOverlay != vr::k_ulOverlayHandleInvalid) m_dashboardTexture.handle = reinterpret_cast<void*>(static_cast<uintptr_t>(f_name));;
 }
+#endif
 
 void VRManager::SendTrackerToggle(size_t f_index)
 {