mirror/openmw-tes3mp
1
0
Fork 1
mirror of https://github.com/TES3MP/openmw-tes3mp.git synced 2025-03-31 16:06:42 +00:00
Code Issues Releases Wiki Activity

Revert "Drop MyGUI 3.4 requirement. Manage layer and widget focus manually."

Browse source 
This reverts commit 259330ab14.
This commit is contained in:
Mads Buvik Sandvei 2020-11-30 22:52:56 +01:00
parent 74a91c4e33
commit f7ceee7a5e
7 changed files with 112 additions and 169 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

5
apps/openmw/mwgui/keyboardnavigation.cpp
View file

@ -179,11 +179,6 @@ void KeyboardNavigation::setDefaultFocus(MyGUI::Widget *window, MyGUI::Widget *d
void KeyboardNavigation::setModalWindow(MyGUI::Widget *window)
{
mModalWindow = window;
#ifdef USE_OPENXR
if (MWBase::Environment::get().getVrMode())
MWVR::Environment::get().getGUIManager()->notifyModalWindow(window);
#endif
}
void KeyboardNavigation::setEnabled(bool enabled)

19
apps/openmw/mwgui/layout.cpp
View file

@ -83,6 +83,25 @@ namespace MWGui
window->setCaptionWithReplacing(title);
}
void Layout::setLayerPick(bool pick)
{
#if MYGUI_VERSION >= MYGUI_DEFINE_VERSION(3,4,0)
MyGUI::ILayer* layer = mMainWidget->getLayer();
// MyGUI exposes pick on the implementations of ILayer only, but not ILayer itself.
auto* oLayer = layer->castType<MyGUI::OverlappedLayer>(false);
auto* sLayer = layer->castType<MyGUI::SharedLayer>(false);
if (oLayer)
oLayer->setPick(pick);
if (sLayer)
sLayer->setPick(pick);
#else
#ifdef USE_OPENXR
#error "MyGUI version 3.4.0 or greater required to build for VR"
#endif
throw std::logic_error("Not implemented");
#endif
}
MyGUI::Widget* Layout::getWidget(const std::string &_name)
{
for (MyGUI::Widget* widget : mListWindowRoot)

3
apps/openmw/mwgui/layout.hpp
View file

@ -64,6 +64,9 @@ namespace MWGui
// NOTE: this assume that mMainWidget is of type Window.
void setTitle(const std::string& title);
/// \note Affects the layer, not just the widget.
void setLayerPick(bool pick);
MyGUI::Widget* mMainWidget;
protected:

17
apps/openmw/mwgui/tooltips.cpp
View file

@ -25,11 +25,6 @@
#include "itemmodel.hpp"
#ifdef USE_OPENXR
#include "../mwvr/vrenvironment.hpp"
#include "../mwvr/vrgui.hpp"
#endif
namespace MWGui
{
std::string ToolTips::sSchoolNames[] = {"#{sSchoolAlteration}", "#{sSchoolConjuration}", "#{sSchoolDestruction}", "#{sSchoolIllusion}", "#{sSchoolMysticism}", "#{sSchoolRestoration}"};
@ -61,7 +56,9 @@ namespace MWGui
mDynamicToolTipBox->setNeedMouseFocus(false);
mMainWidget->setNeedMouseFocus(false);
mDelay = Settings::Manager::getFloat("tooltip delay", "GUI");
// Tooltip delay is not useful in vr as a player cannot be perfectly still.
if (!MWBase::Environment::get().getVrMode())
mDelay = Settings::Manager::getFloat("tooltip delay", "GUI");
mRemainingDelay = mDelay;
for (unsigned int i=0; i < mMainWidget->getChildCount(); ++i)
@ -161,13 +158,7 @@ namespace MWGui
if (mRemainingDelay > 0)
return;
MyGUI::Widget* focus = nullptr;
#ifdef USE_OPENXR
if (MWBase::Environment::get().getVrMode())
focus = MWVR::Environment::get().getGUIManager()->focusWidget();
else
#endif
focus = MyGUI::InputManager::getInstance().getMouseFocusWidget();
MyGUI::Widget* focus = MyGUI::InputManager::getInstance().getMouseFocusWidget();
if (focus == 0)
return;

4
apps/openmw/mwgui/windowmanagerimp.cpp
View file

@ -1781,7 +1781,7 @@ namespace MWGui
#ifdef USE_OPENXR
auto* vrGuiManager = MWVR::Environment::get().getGUIManager();
vrGuiManager->insertLayer(mVideoBackground->getLayer());
vrGuiManager->insertLayer(mVideoBackground->getLayer()->getName());
#endif
bool cursorWasVisible = mCursorVisible;
@ -1834,7 +1834,7 @@ namespace MWGui
updateVisible();
#ifdef USE_OPENXR
vrGuiManager->removeLayer(mVideoBackground->getLayer());
vrGuiManager->removeLayer(mVideoBackground->getLayer()->getName());
#endif
mVideoBackground->setVisible(false);
mVideoEnabled = false;

205
apps/openmw/mwvr/vrgui.cpp
View file

@ -41,7 +41,6 @@
#include <MyGUI_InputManager.h>
#include <MyGUI_WidgetManager.h>
#include <MyGUI_Window.h>
#include <MyGUI_Button.h>
namespace osg
{
@ -148,12 +147,11 @@ namespace MWVR
VRGUILayer::VRGUILayer(
osg::ref_ptr<osg::Group> geometryRoot,
osg::ref_ptr<osg::Group> cameraRoot,
MyGUI::ILayer* layer,
std::string layerName,
LayerConfig config,
VRGUIManager* parent)
: mConfig(config)
, mLayerName(layer->getName())
, mMyGUILayer(layer)
, mLayerName(layerName)
, mGeometryRoot(geometryRoot)
, mCameraRoot(cameraRoot)
{
@ -456,8 +454,7 @@ namespace MWVR
osg::Vec2(1,1),
sizingMode,
TrackingMode::Menu,
extraLayers,
false
extraLayers
};
}
@ -524,8 +521,7 @@ namespace MWVR
osg::Vec2(1,1),
SizingMode::Auto,
TrackingMode::HudLeftHand,
"",
true
""
};
LayerConfig statusHUDConfig = LayerConfig
{
@ -540,8 +536,7 @@ namespace MWVR
defaultConfig.myGUIViewSize,
SizingMode::Auto,
TrackingMode::HudLeftHand,
"",
false
""
};
LayerConfig popupConfig = LayerConfig
@ -557,12 +552,9 @@ namespace MWVR
defaultConfig.myGUIViewSize,
SizingMode::Auto,
TrackingMode::HudRightHand,
"",
false
""
};
mLayerConfigs = std::map<std::string, LayerConfig>
{
{"DefaultConfig", defaultConfig},
@ -613,10 +605,9 @@ namespace MWVR
mSideBySideLayers[i]->setAngle(low + static_cast<float>(i) * sSideBySideAzimuthInterval);
}
void VRGUIManager::insertLayer(MyGUI::ILayer* layer)
void VRGUIManager::insertLayer(const std::string& name)
{
LayerConfig config{};
const auto& name = layer->getName();
auto configIt = mLayerConfigs.find(name);
if (configIt != mLayerConfigs.end())
{
@ -628,25 +619,25 @@ namespace MWVR
config = mLayerConfigs["DefaultConfig"];
}
auto vrlayer = std::shared_ptr<VRGUILayer>(new VRGUILayer(
auto layer = std::shared_ptr<VRGUILayer>(new VRGUILayer(
mGUIGeometriesRoot,
mGUICamerasRoot,
layer,
name,
config,
this
));
mLayers[name] = vrlayer;
mLayers[name] = layer;
vrlayer->mGeometry->setUserData(new VRGUILayerUserData(mLayers[name]));
layer->mGeometry->setUserData(new VRGUILayerUserData(mLayers[name]));
if (config.sideBySide)
{
mSideBySideLayers.push_back(vrlayer);
mSideBySideLayers.push_back(layer);
updateSideBySideLayers();
}
if (config.trackingMode == TrackingMode::Menu)
vrlayer->updateTracking(mHeadPose);
layer->updateTracking(mHeadPose);
}
void VRGUIManager::insertWidget(MWGui::Layout* widget)
@ -657,24 +648,32 @@ namespace MWVR
auto it = mLayers.find(name);
if (it == mLayers.end())
{
insertLayer(layer);
insertLayer(name);
it = mLayers.find(name);
if (it == mLayers.end())
{
Log(Debug::Error) << "Failed to insert layer " << name;
return;
}
}
it->second->insertWidget(widget);
if (it->second.get() != mFocusLayer)
widget->setLayerPick(false);
}
void VRGUIManager::removeLayer(MyGUI::ILayer* layer)
void VRGUIManager::removeLayer(const std::string& name)
{
auto it = mLayers.find(layer->getName());
auto it = mLayers.find(name);
if (it == mLayers.end())
return;
auto vrlayer = it->second;
auto layer = it->second;
for (auto it2 = mSideBySideLayers.begin(); it2 < mSideBySideLayers.end(); it2++)
{
if (*it2 == vrlayer)
if (*it2 == layer)
{
mSideBySideLayers.erase(it2);
updateSideBySideLayers();
@ -690,8 +689,9 @@ namespace MWVR
void VRGUIManager::removeWidget(MWGui::Layout* widget)
{
auto* layer = widget->mMainWidget->getLayer();
auto name = layer->getName();
auto it = mLayers.find(layer->getName());
auto it = mLayers.find(name);
if (it == mLayers.end())
{
//Log(Debug::Warning) << "Tried to remove widget from nonexistent layer " << name;
@ -701,7 +701,7 @@ namespace MWVR
it->second->removeWidget(widget);
if (it->second->widgetCount() == 0)
{
removeLayer(layer);
removeLayer(name);
}
}
@ -710,12 +710,14 @@ namespace MWVR
auto* layer = widget->mMainWidget->getLayer();
auto name = layer->getName();
Log(Debug::Verbose) << "setVisible (" << name << "): " << visible;
if (layerBlacklist.find(name) != layerBlacklist.end())
{
Log(Debug::Verbose) << "setVisible (" << name << "): ignored";
Log(Debug::Verbose) << "Blacklisted";
// Never pick an invisible layer
widget->setLayerPick(false);
return;
}
Log(Debug::Verbose) << "setVisible (" << name << "): " << visible;
if (visible)
insertWidget(widget);
@ -810,84 +812,34 @@ namespace MWVR
if (layer == mFocusLayer)
return;
setFocusWidget(nullptr);
if (mFocusLayer)
{
mFocusLayer->mWidgets.front()->setLayerPick(false);
}
mFocusLayer = layer;
if (mFocusLayer)
{
Log(Debug::Verbose) << "Set focus layer to " << mFocusLayer->mWidgets.front()->mMainWidget->getLayer()->getName();
mFocusLayer->mWidgets.front()->setLayerPick(true);
}
else
{
Log(Debug::Verbose) << "Set focus layer to null";
}
}
void VRGUIManager::setFocusWidget(MyGUI::Widget* widget)
{
// TODO: This relies on MyGUI internal functions and may break on any future version.
if (widget == mFocusWidget)
return;
// TODO: This relies on MyGUI internal functions and may break on any future version.
if (validateFocusWidget())
if (mFocusWidget)
mFocusWidget->_riseMouseLostFocus(widget);
if (widget)
widget->_riseMouseSetFocus(mFocusWidget);
mFocusWidget = widget;
}
// MyGUI may delete the focusWidget.
// Call this and check the result before dereferencing mFocusWidget
bool VRGUIManager::validateFocusWidget()
{
if (mFocusWidget)
{
auto* cursorWidget = widgetFromGuiCursor(mGuiCursor.x(), mGuiCursor.y());
// If the focus widget is no longer seen at the coordinate it was last seen
// it may have been deleted by mygui.
// In theory, notifyWidgetUnlinked() should catch all cases but doesn't.
if (cursorWidget != mFocusWidget)
{
mFocusWidget = nullptr;
return false;
}
return true;
}
return false;
}
bool VRGUIManager::focusIsModalWindow()
{
if (mFocusLayer)
for (auto* window : mFocusLayer->mWidgets)
if (mModalWindow == window->mMainWidget)
return true;
return false;
}
MyGUI::Widget* VRGUIManager::widgetFromGuiCursor(int x, int y)
{
if (mFocusLayer)
{
if (
mFocusLayer->mConfig.ignoreModality
|| !mModalWindow
|| focusIsModalWindow()
)
{
MyGUI::ILayerItem* widget = nullptr;
// Give popup layer priority as dropdown menus appear on the separate popup layer.
auto* popupLayer = MyGUI::LayerManager::getInstance().getByName("Popup");
if (popupLayer)
widget = popupLayer->getLayerItemByPoint(x, y);
if (!widget)
widget = mFocusLayer->mMyGUILayer->getLayerItemByPoint(x, y);
return static_cast<MyGUI::Widget*>(widget);
}
}
return nullptr;
}
void VRGUIManager::updateGuiCursor(int x, int y)
{
setFocusWidget(widgetFromGuiCursor(x, y));
mGuiCursor.x() = x;
mGuiCursor.y() = y;
}
void VRGUIManager::configUpdated(const std::string& layer)
{
auto it = mLayers.find(layer);
@ -897,45 +849,22 @@ namespace MWVR
}
}
bool VRGUIManager::injectMouseClick(bool onPress)
{
// TODO: This relies on MyGUI internal functions and may break on any future version.
if (validateFocusWidget())
{
if (onPress)
{
mFocusWidget->_riseMouseButtonPressed(mGuiCursor.x(), mGuiCursor.y(), MyGUI::MouseButton::Left);
MyGUI::Button* b = mFocusWidget->castType<MyGUI::Button>(false);
if (b && b->getEnabled())
{
MWBase::Environment::get().getWindowManager()->playSound("Menu Click");
}
}
else
{
mFocusWidget->_riseMouseButtonReleased(mGuiCursor.x(), mGuiCursor.y(), MyGUI::MouseButton::Left);
// Some widgets are invalidated before returning from _riseMouseButtonReleased
if (validateFocusWidget())
mFocusWidget->_riseMouseButtonClick();
}
return true;
}
return false;
}
void VRGUIManager::notifyWidgetUnlinked(MyGUI::Widget* widget)
{
if (widget == mFocusWidget)
{
mFocusWidget = nullptr;
}
}
void VRGUIManager::notifyModalWindow(MyGUI::Widget* window)
bool VRGUIManager::injectMouseClick(bool onPress)
{
mModalWindow = window;
// TODO: This relies on a MyGUI internal functions and may break un any future version.
if (mFocusWidget)
{
if(onPress)
mFocusWidget->_riseMouseButtonClick();
return true;
}
return false;
}
void VRGUIManager::processChangedSettings(const std::set<std::pair<std::string, std::string>>& changed)
@ -976,8 +905,26 @@ namespace MWVR
y = bottom - height * y;
}
mGuiCursor.x() = (int)x;
mGuiCursor.y() = (int)y;
MyGUI::InputManager::getInstance().injectMouseMove((int)x, (int)y, 0);
MWBase::Environment::get().getWindowManager()->setCursorActive(true);
updateGuiCursor((int)x, (int)y);
// The virtual keyboard must be interactive regardless of modals
// This could be generalized with another config entry, but i don't think any other
// widgets/layers need it so i'm hardcoding it for the VirtualKeyboard for now.
if (
mFocusLayer
&& mFocusLayer->mLayerName == "VirtualKeyboard"
&& MyGUI::InputManager::getInstance().isModalAny())
{
auto* widget = MyGUI::LayerManager::getInstance().getWidgetFromPoint((int)x, (int)y);
setFocusWidget(widget);
}
else
setFocusWidget(nullptr);
}
}

28
apps/openmw/mwvr/vrgui.hpp
View file

@ -1,5 +1,5 @@
#ifndef VRGUI_HPP
#define VRGUI_HPP
#ifndef OPENXR_MENU_HPP
#define OPENXR_MENU_HPP
#include <map>
#include <set>
@ -25,7 +25,6 @@ namespace MWGui
{
class Layout;
class WindowBase;
class ILayer;
}
struct XrCompositionLayerQuad;
@ -64,7 +63,6 @@ namespace MWVR
SizingMode sizingMode; //!< How to size the layer
TrackingMode trackingMode; //!< Tracking mode
std::string extraLayers; //!< Additional layers to draw (list separated by any non-alphabetic)
bool ignoreModality; //!< Layer input should be enabled even if another modal window is active
bool operator<(const LayerConfig& rhs) const { return priority < rhs.priority; }
};
@ -80,7 +78,7 @@ namespace MWVR
VRGUILayer(
osg::ref_ptr<osg::Group> geometryRoot,
osg::ref_ptr<osg::Group> cameraRoot,
MyGUI::ILayer* layer,
std::string layerName,
LayerConfig config,
VRGUIManager* parent);
~VRGUILayer();
@ -104,7 +102,6 @@ namespace MWVR
Pose mTrackedPose{};
LayerConfig mConfig;
std::string mLayerName;
MyGUI::ILayer* mMyGUILayer;
std::vector<MWGui::Layout*> mWidgets;
osg::ref_ptr<osg::Group> mGeometryRoot;
osg::ref_ptr<osg::Geometry> mGeometry{ new osg::Geometry };
@ -142,10 +139,10 @@ namespace MWVR
void setVisible(MWGui::Layout*, bool visible);
/// Insert the given layer quad if it isn't already
void insertLayer(MyGUI::ILayer* layer);
void insertLayer(const std::string& name);
/// Remove the given layer quad
void removeLayer(MyGUI::ILayer* layer);
void removeLayer(const std::string& name);
/// Update layer quads based on current camera
void updateTracking(void);
@ -165,16 +162,12 @@ namespace MWVR
/// Inject mouse click if applicable
bool injectMouseClick(bool onPress);
/// Notify VRGUIManager that a widget has been unlinked
/// Notify that widget is about to be destroyed.
void notifyWidgetUnlinked(MyGUI::Widget* widget);
/// Notify VRGUIManager that a window is modal
void notifyModalWindow(MyGUI::Widget* window);
/// Currently focus widget according to VR
MyGUI::Widget* focusWidget() { return mFocusWidget; }
/// Update settings where applicable
void processChangedSettings(const std::set< std::pair<std::string, std::string> >& changed);
private:
void computeGuiCursor(osg::Vec3 hitPoint);
void updateSideBySideLayers();
@ -182,10 +175,6 @@ namespace MWVR
void removeWidget(MWGui::Layout* widget);
void setFocusLayer(VRGUILayer* layer);
void setFocusWidget(MyGUI::Widget* widget);
bool validateFocusWidget();
bool focusIsModalWindow();
MyGUI::Widget* widgetFromGuiCursor(int x, int y);
void updateGuiCursor(int x, int y);
void configUpdated(const std::string& layer);
osg::ref_ptr<osgViewer::Viewer> mOsgViewer{ nullptr };
@ -201,7 +190,6 @@ namespace MWVR
osg::Vec2i mGuiCursor{};
VRGUILayer* mFocusLayer{ nullptr };
MyGUI::Widget* mFocusWidget{ nullptr };
MyGUI::Widget* mModalWindow{ nullptr };
osg::observer_ptr<osg::Camera> mCamera{ nullptr };
std::map<std::string, LayerConfig> mLayerConfigs{};
};