323 lines
13 KiB
C++
323 lines
13 KiB
C++
#include "mousemanager.hpp"
|
|
|
|
#include <MyGUI_Button.h>
|
|
#include <MyGUI_InputManager.h>
|
|
#include <MyGUI_RenderManager.h>
|
|
|
|
#include <components/lua_ui/input.hpp>
|
|
#include <components/sdlutil/sdlinputwrapper.hpp>
|
|
#include <components/sdlutil/sdlmappings.hpp>
|
|
#include <components/settings/values.hpp>
|
|
|
|
#include "../mwbase/environment.hpp"
|
|
#include "../mwbase/inputmanager.hpp"
|
|
#include "../mwbase/luamanager.hpp"
|
|
#include "../mwbase/windowmanager.hpp"
|
|
#include "../mwbase/world.hpp"
|
|
|
|
#include "../mwgui/settingswindow.hpp"
|
|
|
|
#include "../mwworld/player.hpp"
|
|
|
|
#include "actions.hpp"
|
|
#include "bindingsmanager.hpp"
|
|
|
|
namespace MWInput
|
|
{
|
|
MouseManager::MouseManager(
|
|
BindingsManager* bindingsManager, SDLUtil::InputWrapper* inputWrapper, SDL_Window* window)
|
|
: mBindingsManager(bindingsManager)
|
|
, mInputWrapper(inputWrapper)
|
|
, mGuiCursorX(0)
|
|
, mGuiCursorY(0)
|
|
, mMouseWheel(0)
|
|
, mMouseLookEnabled(false)
|
|
, mGuiCursorEnabled(true)
|
|
, mCursorMode(MWBase::CursorMode::Free)
|
|
, mLastWarpX(-1)
|
|
, mLastWarpY(-1)
|
|
, mMouseMoveX(0)
|
|
, mMouseMoveY(0)
|
|
{
|
|
int w, h;
|
|
SDL_GetWindowSize(window, &w, &h);
|
|
|
|
float uiScale = MWBase::Environment::get().getWindowManager()->getScalingFactor();
|
|
mGuiCursorX = w / (2.f * uiScale);
|
|
mGuiCursorY = h / (2.f * uiScale);
|
|
}
|
|
|
|
void MouseManager::mouseMoved(const SDLUtil::MouseMotionEvent& arg)
|
|
{
|
|
mBindingsManager->mouseMoved(arg);
|
|
|
|
MWBase::InputManager* input = MWBase::Environment::get().getInputManager();
|
|
input->setJoystickLastUsed(false);
|
|
input->resetIdleTime();
|
|
|
|
if (mGuiCursorEnabled)
|
|
{
|
|
input->setGamepadGuiCursorEnabled(true);
|
|
|
|
// We keep track of our own mouse position, so that moving the mouse while in
|
|
// game mode does not move the position of the GUI cursor
|
|
MWBase::WindowManager* winMgr = MWBase::Environment::get().getWindowManager();
|
|
float uiScale = winMgr->getScalingFactor();
|
|
mGuiCursorX = static_cast<float>(arg.x) / uiScale;
|
|
mGuiCursorY = static_cast<float>(arg.y) / uiScale;
|
|
|
|
if (arg.zrel != 0)
|
|
mMouseWheel = static_cast<int>(arg.z);
|
|
|
|
MyGUI::InputManager::getInstance().injectMouseMove(
|
|
static_cast<int>(mGuiCursorX), static_cast<int>(mGuiCursorY), mMouseWheel);
|
|
|
|
winMgr->setCursorActive(true);
|
|
|
|
// Check if this movement is from our recent mouse warp
|
|
bool isFromWarp = (mLastWarpX >= 0 && mLastWarpY >= 0 && std::abs(mGuiCursorX - mLastWarpX) < 0.5f
|
|
&& std::abs(mGuiCursorY - mLastWarpY) < 0.5f);
|
|
|
|
if (Settings::gui().mControllerMenus && !winMgr->getCursorVisible()
|
|
&& (std::abs(arg.xrel) > 1 || std::abs(arg.yrel) > 1) && !isFromWarp)
|
|
{
|
|
// Unhide the cursor if it was hidden to show a controller tooltip.
|
|
winMgr->setControllerTooltipVisible(false);
|
|
winMgr->setCursorVisible(true);
|
|
}
|
|
|
|
// Clear warp tracking after processing
|
|
mLastWarpX = -1;
|
|
mLastWarpY = -1;
|
|
}
|
|
|
|
if (mMouseLookEnabled && !input->controlsDisabled())
|
|
{
|
|
MWBase::World* world = MWBase::Environment::get().getWorld();
|
|
|
|
const float cameraSensitivity = Settings::input().mCameraSensitivity;
|
|
float x = arg.xrel * cameraSensitivity * (Settings::input().mInvertXAxis ? -1 : 1) / 256.f;
|
|
float y = arg.yrel * cameraSensitivity * (Settings::input().mInvertYAxis ? -1 : 1)
|
|
* Settings::input().mCameraYMultiplier / 256.f;
|
|
|
|
float rot[3];
|
|
rot[0] = -y;
|
|
rot[1] = 0.0f;
|
|
rot[2] = -x;
|
|
|
|
// Only actually turn player when we're not in vanity mode
|
|
if (!world->vanityRotateCamera(rot) && input->getControlSwitch("playerlooking"))
|
|
{
|
|
MWWorld::Player& player = world->getPlayer();
|
|
player.yaw(x);
|
|
player.pitch(y);
|
|
}
|
|
else if (!input->getControlSwitch("playerlooking"))
|
|
MWBase::Environment::get().getWorld()->disableDeferredPreviewRotation();
|
|
}
|
|
}
|
|
|
|
void MouseManager::mouseReleased(const SDL_MouseButtonEvent& arg, Uint8 id)
|
|
{
|
|
MWBase::Environment::get().getInputManager()->setJoystickLastUsed(false);
|
|
|
|
if (mBindingsManager->isDetectingBindingState())
|
|
{
|
|
mBindingsManager->mouseReleased(arg, id);
|
|
}
|
|
else
|
|
{
|
|
bool guiMode = mGuiCursorEnabled;
|
|
guiMode = MyGUI::InputManager::getInstance().injectMouseRelease(static_cast<int>(mGuiCursorX),
|
|
static_cast<int>(mGuiCursorY), SDLUtil::sdlMouseButtonToMyGui(id))
|
|
&& guiMode;
|
|
|
|
if (mBindingsManager->isDetectingBindingState())
|
|
return; // don't allow same mouseup to bind as initiated bind
|
|
|
|
mBindingsManager->setPlayerControlsEnabled(mGuiCursorEnabled ? false : !guiMode);
|
|
// A press may have opened the GUI, so the release still needs to clear its binding.
|
|
mBindingsManager->mouseReleased(arg, id);
|
|
}
|
|
|
|
MWBase::Environment::get().getLuaManager()->inputEvent(
|
|
{ MWBase::LuaManager::InputEvent::MouseButtonReleased, arg.button });
|
|
}
|
|
|
|
void MouseManager::mouseWheelMoved(const SDL_MouseWheelEvent& arg)
|
|
{
|
|
MWBase::InputManager* input = MWBase::Environment::get().getInputManager();
|
|
if (mBindingsManager->isDetectingBindingState() || (!mGuiCursorEnabled && !input->controlsDisabled()))
|
|
{
|
|
mBindingsManager->mouseWheelMoved(arg);
|
|
}
|
|
|
|
input->setJoystickLastUsed(false);
|
|
MWBase::Environment::get().getLuaManager()->inputEvent({ MWBase::LuaManager::InputEvent::MouseWheel,
|
|
MWBase::LuaManager::InputEvent::WheelChange{ arg.x, arg.y } });
|
|
|
|
if (mGuiCursorEnabled)
|
|
{
|
|
if (MyGUI::Widget* widget = MyGUI::InputManager::getInstance().getMouseFocusWidget())
|
|
LuaUi::dispatchMouseWheel(widget, mGuiCursorX, mGuiCursorY, arg.preciseX, arg.preciseY);
|
|
}
|
|
}
|
|
|
|
void MouseManager::mousePressed(const SDL_MouseButtonEvent& arg, Uint8 id)
|
|
{
|
|
MWBase::InputManager* input = MWBase::Environment::get().getInputManager();
|
|
input->setJoystickLastUsed(false);
|
|
bool guiMode = false;
|
|
|
|
if (id == SDL_BUTTON_LEFT || id == SDL_BUTTON_RIGHT) // MyGUI only uses these mouse events
|
|
{
|
|
guiMode = mGuiCursorEnabled;
|
|
guiMode = MyGUI::InputManager::getInstance().injectMousePress(static_cast<int>(mGuiCursorX),
|
|
static_cast<int>(mGuiCursorY), SDLUtil::sdlMouseButtonToMyGui(id))
|
|
&& guiMode;
|
|
if (MyGUI::InputManager::getInstance().getMouseFocusWidget() != nullptr)
|
|
{
|
|
MyGUI::Button* b
|
|
= MyGUI::InputManager::getInstance().getMouseFocusWidget()->castType<MyGUI::Button>(false);
|
|
if (b && b->getEnabled() && id == SDL_BUTTON_LEFT)
|
|
{
|
|
MWBase::Environment::get().getWindowManager()->playSound(ESM::RefId::stringRefId("Menu Click"));
|
|
}
|
|
}
|
|
MWBase::Environment::get().getWindowManager()->setCursorActive(true);
|
|
}
|
|
|
|
mBindingsManager->setPlayerControlsEnabled(mGuiCursorEnabled ? false : !guiMode);
|
|
|
|
// Keep menu bindings such as Inventory active, but don't send gameplay bindings when Lua frees the cursor.
|
|
// Don't trigger any mouse bindings while in settings menu or while input controls are disabled.
|
|
if ((!mGuiCursorEnabled || MWBase::Environment::get().getWindowManager()->isGuiMode())
|
|
&& !MWBase::Environment::get().getWindowManager()->isSettingsWindowVisible() && !input->controlsDisabled())
|
|
mBindingsManager->mousePressed(arg, id);
|
|
MWBase::Environment::get().getLuaManager()->inputEvent(
|
|
{ MWBase::LuaManager::InputEvent::MouseButtonPressed, arg.button });
|
|
}
|
|
|
|
void MouseManager::updateCursorMode()
|
|
{
|
|
bool wasRelative = mInputWrapper->getMouseRelative();
|
|
bool isRelative = mCursorMode == MWBase::CursorMode::Locked;
|
|
|
|
// Relative mode locks the cursor and disables mouse acceleration. The other
|
|
// modes use normal system cursor movement.
|
|
mInputWrapper->setMouseRelative(isRelative);
|
|
|
|
// Relative mode always confines the pointer. Confined mode does so without
|
|
// using relative input, while Free mode allows the pointer to leave the window.
|
|
mInputWrapper->setGrabPointer(mCursorMode != MWBase::CursorMode::Free);
|
|
|
|
// we switched to non-relative mode, move our cursor to where the in-game
|
|
// cursor is
|
|
if (!isRelative && wasRelative != isRelative)
|
|
{
|
|
warpMouse();
|
|
}
|
|
}
|
|
|
|
void MouseManager::update(float dt)
|
|
{
|
|
SDL_GetRelativeMouseState(&mMouseMoveX, &mMouseMoveY);
|
|
|
|
if (!mMouseLookEnabled)
|
|
return;
|
|
|
|
float xAxis = mBindingsManager->getActionValue(A_LookLeftRight) * 2.0f - 1.0f;
|
|
float yAxis = mBindingsManager->getActionValue(A_LookUpDown) * 2.0f - 1.0f;
|
|
if (xAxis == 0 && yAxis == 0)
|
|
return;
|
|
|
|
const float cameraSensitivity = Settings::input().mCameraSensitivity;
|
|
const float rot[3] = {
|
|
-yAxis * dt * 1000.0f * cameraSensitivity * (Settings::input().mInvertYAxis ? -1 : 1)
|
|
* Settings::input().mCameraYMultiplier / 256.f,
|
|
0.0f,
|
|
-xAxis * dt * 1000.0f * cameraSensitivity * (Settings::input().mInvertXAxis ? -1 : 1) / 256.f,
|
|
};
|
|
|
|
// Only actually turn player when we're not in vanity mode
|
|
bool playerLooking = MWBase::Environment::get().getInputManager()->getControlSwitch("playerlooking");
|
|
if (!MWBase::Environment::get().getWorld()->vanityRotateCamera(rot) && playerLooking)
|
|
{
|
|
MWWorld::Player& player = MWBase::Environment::get().getWorld()->getPlayer();
|
|
player.yaw(-rot[2]);
|
|
player.pitch(-rot[0]);
|
|
}
|
|
else if (!playerLooking)
|
|
MWBase::Environment::get().getWorld()->disableDeferredPreviewRotation();
|
|
|
|
MWBase::Environment::get().getInputManager()->resetIdleTime();
|
|
}
|
|
|
|
bool MouseManager::injectMouseButtonPress(Uint8 button)
|
|
{
|
|
return MyGUI::InputManager::getInstance().injectMousePress(
|
|
static_cast<int>(mGuiCursorX), static_cast<int>(mGuiCursorY), SDLUtil::sdlMouseButtonToMyGui(button));
|
|
}
|
|
|
|
bool MouseManager::injectMouseButtonRelease(Uint8 button)
|
|
{
|
|
return MyGUI::InputManager::getInstance().injectMouseRelease(
|
|
static_cast<int>(mGuiCursorX), static_cast<int>(mGuiCursorY), SDLUtil::sdlMouseButtonToMyGui(button));
|
|
}
|
|
|
|
void MouseManager::injectMouseMove(float xMove, float yMove, float mouseWheelMove)
|
|
{
|
|
mGuiCursorX += xMove;
|
|
mGuiCursorY += yMove;
|
|
mMouseWheel += static_cast<int>(mouseWheelMove);
|
|
|
|
const MyGUI::IntSize& viewSize = MyGUI::RenderManager::getInstance().getViewSize();
|
|
mGuiCursorX = std::clamp<float>(mGuiCursorX, 0.f, viewSize.width - 1.f);
|
|
mGuiCursorY = std::clamp<float>(mGuiCursorY, 0.f, viewSize.height - 1.f);
|
|
|
|
MyGUI::InputManager::getInstance().injectMouseMove(
|
|
static_cast<int>(mGuiCursorX), static_cast<int>(mGuiCursorY), mMouseWheel);
|
|
}
|
|
|
|
void MouseManager::setCursorPosition(const osg::Vec2f& position)
|
|
{
|
|
const MyGUI::IntSize& viewSize = MyGUI::RenderManager::getInstance().getViewSize();
|
|
mGuiCursorX = std::clamp(position.x(), 0.f, static_cast<float>(viewSize.width - 1));
|
|
mGuiCursorY = std::clamp(position.y(), 0.f, static_cast<float>(viewSize.height - 1));
|
|
MyGUI::InputManager::getInstance().injectMouseMove(
|
|
static_cast<int>(mGuiCursorX), static_cast<int>(mGuiCursorY), mMouseWheel);
|
|
|
|
if (!mInputWrapper->getMouseRelative())
|
|
{
|
|
mLastWarpX = mGuiCursorX;
|
|
mLastWarpY = mGuiCursorY;
|
|
warpMouse();
|
|
}
|
|
|
|
MWBase::Environment::get().getWindowManager()->setCursorActive(true);
|
|
}
|
|
|
|
void MouseManager::warpMouse()
|
|
{
|
|
float guiUiScale = Settings::gui().mScalingFactor;
|
|
mInputWrapper->warpMouse(
|
|
static_cast<int>(mGuiCursorX * guiUiScale), static_cast<int>(mGuiCursorY * guiUiScale));
|
|
}
|
|
|
|
void MouseManager::warpMouseToWidget(MyGUI::Widget* widget)
|
|
{
|
|
float widgetX = widget->getAbsoluteCoord().left + widget->getWidth() / 2.f;
|
|
float widgetY = widget->getAbsoluteCoord().top + widget->getHeight() / 4.f;
|
|
if (std::abs(mGuiCursorX - widgetX) > 1 || std::abs(mGuiCursorY - widgetY) > 1)
|
|
{
|
|
mGuiCursorX = widgetX;
|
|
mGuiCursorY = widgetY;
|
|
// Remember where we warped to so we can ignore movement from this warp
|
|
mLastWarpX = widgetX;
|
|
mLastWarpY = widgetY;
|
|
warpMouse();
|
|
}
|
|
}
|
|
|
|
}
|