Files

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();
}
}
}