diff --git a/engine/includes/adapters/desktopadaptor.h b/engine/includes/adapters/desktopadaptor.h index a955243c8..4bbbfd9ce 100644 --- a/engine/includes/adapters/desktopadaptor.h +++ b/engine/includes/adapters/desktopadaptor.h @@ -5,6 +5,7 @@ struct GLFWwindow; struct GLFWmonitor; +struct GLFWcursor; class DesktopAdaptor : public PlatformAdaptor { public: @@ -38,6 +39,7 @@ class DesktopAdaptor : public PlatformAdaptor { bool mouseReleased(int button) const override; void mouseLockCursor(bool lock) override; + void mouseSetCursor(Input::CursorShape shape) override; uint32_t screenWidth() const override; uint32_t screenHeight() const override; @@ -79,6 +81,7 @@ class DesktopAdaptor : public PlatformAdaptor { static std::unordered_map s_keys; static std::unordered_map s_mouseButtons; + static std::unordered_map s_mouseCursors; static Vector4 s_mousePosition; static Vector4 s_oldMousePosition; diff --git a/engine/includes/adapters/platformadaptor.h b/engine/includes/adapters/platformadaptor.h index 5671f41db..6b228e191 100644 --- a/engine/includes/adapters/platformadaptor.h +++ b/engine/includes/adapters/platformadaptor.h @@ -44,6 +44,7 @@ class ENGINE_EXPORT PlatformAdaptor { virtual bool mousePressed(int code) const; virtual bool mouseReleased(int code) const; virtual void mouseLockCursor(bool lock); + virtual void mouseSetCursor(Input::CursorShape shape); virtual uint32_t joystickCount() const; virtual uint32_t joystickButtons(int index) const; diff --git a/engine/includes/editor/editorplatform.h b/engine/includes/editor/editorplatform.h index 37fddb027..c40ff50aa 100644 --- a/engine/includes/editor/editorplatform.h +++ b/engine/includes/editor/editorplatform.h @@ -4,6 +4,7 @@ #include #include #include +#include #include @@ -25,6 +26,7 @@ class ENGINE_EXPORT EditorPlatform : public PlatformAdaptor { void setScreenSize(const QSize &size); bool isMouseLocked() const; + QCursor mouseCursor() const; void setMousePosition(const QPoint &position); void setMouseDelta(const QPoint &position); void setMouseScrollDelta(float delta); @@ -59,6 +61,8 @@ class ENGINE_EXPORT EditorPlatform : public PlatformAdaptor { Vector4 mousePosition() const override; void mouseLockCursor(bool lock) override; + void mouseSetCursor(Input::CursorShape shape) override; + Vector4 mouseDelta() const override; float mouseScrollDelta() const override; @@ -81,9 +85,11 @@ class ENGINE_EXPORT EditorPlatform : public PlatformAdaptor { Vector4 m_mousePosition; - float m_mouseScrollDelta; + float m_mouseScrollDelta = 0.0f; + + Qt::CursorShape m_mouseCursor = Qt::ArrowCursor; - bool m_mouseLock; + bool m_mouseLock = false; static bool s_appActive; diff --git a/engine/includes/editor/editortool.h b/engine/includes/editor/editortool.h index a33443ce6..1977b9a0f 100644 --- a/engine/includes/editor/editortool.h +++ b/engine/includes/editor/editortool.h @@ -3,8 +3,7 @@ #include -#include -#include +#include class ENGINE_EXPORT EditorTool { public: @@ -28,13 +27,9 @@ class ENGINE_EXPORT EditorTool { virtual QWidget *panel(); - Qt::CursorShape cursor() const; - protected: VariantList m_propertiesCache; - Qt::CursorShape m_cursor; - }; #endif // EDITORTOOL_H diff --git a/engine/includes/editor/viewport/cameracontroller.h b/engine/includes/editor/viewport/cameracontroller.h index 70b017fcb..328e8078f 100644 --- a/engine/includes/editor/viewport/cameracontroller.h +++ b/engine/includes/editor/viewport/cameracontroller.h @@ -83,11 +83,6 @@ class ENGINE_EXPORT CameraController : public QObject { void resetCamera(); -signals: - void setCursor(const QCursor &cursor); - - void unsetCursor(); - public slots: virtual void onOrthographic(bool flag); diff --git a/engine/includes/input.h b/engine/includes/input.h index ff49ecfeb..96b0207ac 100644 --- a/engine/includes/input.h +++ b/engine/includes/input.h @@ -161,13 +161,25 @@ class ENGINE_EXPORT Input { }; enum TouchState { - TOUCH_HOVER = 0, + TOUCH_HOVER = 0, TOUCH_BEGAN, TOUCH_MOVED, TOUCH_ENDED, TOUCH_CANCELLED }; + enum CursorShape { + CURSOR_ARROW = 0, + CURSOR_CROSS, + CURSOR_IBEAM, + CURSOR_HAND, + CURSOR_HORSIZE, + CURSOR_VERSIZE, + CURSOR_FDIAGSIZE, + CURSOR_BDIAGSIZE, + CURSOR_ALLSIZE, + }; + public: static void init(PlatformAdaptor *platform); @@ -187,6 +199,7 @@ class ENGINE_EXPORT Input { static float mouseScrollDelta(); static void mouseLockCursor(bool lock); + static void mouseSetCursor(CursorShape shape); static uint32_t joystickCount(); static uint32_t joystickButtons(uint32_t index); diff --git a/engine/src/adapters/desktopadaptor.cpp b/engine/src/adapters/desktopadaptor.cpp index 3647e692a..c8c1888ad 100644 --- a/engine/src/adapters/desktopadaptor.cpp +++ b/engine/src/adapters/desktopadaptor.cpp @@ -52,6 +52,7 @@ TString DesktopAdaptor::s_inputString; std::unordered_map DesktopAdaptor::s_keys; std::unordered_map DesktopAdaptor::s_mouseButtons; +std::unordered_map DesktopAdaptor::s_mouseCursors; DesktopAdaptor::DesktopAdaptor() : m_window(nullptr), @@ -275,6 +276,37 @@ void DesktopAdaptor::mouseLockCursor(bool lock) { glfwSetInputMode(m_window, GLFW_CURSOR, lock ? GLFW_CURSOR_DISABLED : GLFW_CURSOR_NORMAL); } +void DesktopAdaptor::mouseSetCursor(Input::CursorShape shape) { + GLFWcursor *cursor = nullptr; + + if(shape != Input::CURSOR_ARROW) { + auto it = s_mouseCursors.find(shape); + if(it == s_mouseCursors.end()) { + int glfwShape = 0; + switch(shape) { + case Input::CURSOR_ARROW: glfwShape = GLFW_ARROW_CURSOR; break; + case Input::CURSOR_CROSS: glfwShape = GLFW_CROSSHAIR_CURSOR; break; + case Input::CURSOR_IBEAM: glfwShape = GLFW_IBEAM_CURSOR; break; + case Input::CURSOR_HAND: glfwShape = GLFW_POINTING_HAND_CURSOR; break; + case Input::CURSOR_HORSIZE: glfwShape = GLFW_HRESIZE_CURSOR; break; + case Input::CURSOR_VERSIZE: glfwShape = GLFW_VRESIZE_CURSOR; break; + case Input::CURSOR_FDIAGSIZE: glfwShape = GLFW_RESIZE_NWSE_CURSOR; break; + case Input::CURSOR_BDIAGSIZE: glfwShape = GLFW_RESIZE_NESW_CURSOR; break; + case Input::CURSOR_ALLSIZE: glfwShape = GLFW_RESIZE_ALL_CURSOR; break; + default: break; + } + + if(glfwShape != 0) { + cursor = glfwCreateStandardCursor(glfwShape); + } + } else { + cursor = it->second; + } + } + + glfwSetCursor(m_window, cursor); +} + uint32_t DesktopAdaptor::screenWidth() const { return s_width; } diff --git a/engine/src/adapters/platformadaptor.cpp b/engine/src/adapters/platformadaptor.cpp index 1855c4afa..dcf9a46b8 100644 --- a/engine/src/adapters/platformadaptor.cpp +++ b/engine/src/adapters/platformadaptor.cpp @@ -58,6 +58,10 @@ void PlatformAdaptor::mouseLockCursor(bool lock) { A_UNUSED(lock); } +void PlatformAdaptor::mouseSetCursor(Input::CursorShape shape) { + A_UNUSED(shape); +} + uint32_t PlatformAdaptor::joystickCount() const { return 0; } diff --git a/engine/src/editor/editorplatform.cpp b/engine/src/editor/editorplatform.cpp index 1157606c4..b1564f6ca 100644 --- a/engine/src/editor/editorplatform.cpp +++ b/engine/src/editor/editorplatform.cpp @@ -139,10 +139,7 @@ Input::KeyCode mapToInput(int32_t key) { return (Input::KeyCode)map.value(key, Input::KEY_UNKNOWN); } -EditorPlatform::EditorPlatform() : - m_mouseScrollDelta(0.0f), - m_mouseLock(false) { - +EditorPlatform::EditorPlatform() { File::setHandler(new DefaultFileHandler); QObject::connect(qApp, &QGuiApplication::applicationStateChanged, [](Qt::ApplicationState state) { @@ -305,10 +302,6 @@ void EditorPlatform::setKeys(QKeyEvent *ev, bool release) { } } -bool EditorPlatform::isMouseLocked() const { - return m_mouseLock; -} - Vector4 EditorPlatform::mousePosition() const { return m_mousePosition; } @@ -321,10 +314,33 @@ float EditorPlatform::mouseScrollDelta() const { return m_mouseScrollDelta; } +bool EditorPlatform::isMouseLocked() const { + return m_mouseLock; +} + void EditorPlatform::mouseLockCursor(bool lock) { m_mouseLock = lock; } +QCursor EditorPlatform::mouseCursor() const { + return m_mouseCursor; +} + +void EditorPlatform::mouseSetCursor(Input::CursorShape shape) { + switch(shape) { + case Input::CURSOR_ARROW: m_mouseCursor = Qt::ArrowCursor; break; + case Input::CURSOR_CROSS: m_mouseCursor = Qt::CrossCursor; break; + case Input::CURSOR_IBEAM: m_mouseCursor = Qt::IBeamCursor; break; + case Input::CURSOR_HAND: m_mouseCursor = Qt::PointingHandCursor; break; + case Input::CURSOR_HORSIZE: m_mouseCursor = Qt::SizeHorCursor; break; + case Input::CURSOR_VERSIZE: m_mouseCursor = Qt::SizeVerCursor; break; + case Input::CURSOR_FDIAGSIZE: m_mouseCursor = Qt::SizeFDiagCursor; break; + case Input::CURSOR_BDIAGSIZE: m_mouseCursor = Qt::SizeBDiagCursor; break; + case Input::CURSOR_ALLSIZE: m_mouseCursor = Qt::SizeAllCursor; break; + default: break; + } +} + TString EditorPlatform::locationLocalDir() const { return QStandardPaths::writableLocation(QStandardPaths::ConfigLocation).toStdString(); } diff --git a/engine/src/editor/editortool.cpp b/engine/src/editor/editortool.cpp index cf979e2b1..17483a506 100644 --- a/engine/src/editor/editortool.cpp +++ b/engine/src/editor/editortool.cpp @@ -1,12 +1,5 @@ #include "editor/editortool.h" -#include "components/actor.h" -#include "components/transform.h" -#include "components/renderable.h" -#include "components/camera.h" - -#include "editor/viewport/handletools.h" - /*! \class EditorTool \brief The EditorTool class is an abstract base class that defines the interface for editor tools in the application. @@ -43,8 +36,7 @@ }; */ -EditorTool::EditorTool() : - m_cursor(Qt::ArrowCursor) { +EditorTool::EditorTool() { } @@ -116,9 +108,3 @@ void EditorTool::endControl() { void EditorTool::cancelControl() { } -/*! - Returns a cursor shape for the active tool action. -*/ -Qt::CursorShape EditorTool::cursor() const { - return m_cursor; -} diff --git a/engine/src/editor/viewport/viewport.cpp b/engine/src/editor/viewport/viewport.cpp index b9e7e579b..cc593bd79 100644 --- a/engine/src/editor/viewport/viewport.cpp +++ b/engine/src/editor/viewport/viewport.cpp @@ -131,9 +131,6 @@ CameraController *Viewport::controller() { void Viewport::setController(CameraController *ctrl) { m_controller = ctrl; - - connect(m_controller, &CameraController::setCursor, this, &Viewport::onCursorSet); - connect(m_controller, &CameraController::unsetCursor, this, &Viewport::onCursorUnset); } void Viewport::setWorld(World *world) { @@ -222,6 +219,7 @@ void Viewport::onDraw() { if(!m_gameView && m_controller) { m_controller->update(); } + onCursorSet(instance.mouseCursor()); instance.update(); } diff --git a/engine/src/input.cpp b/engine/src/input.cpp index 151886c7e..4f57f132d 100644 --- a/engine/src/input.cpp +++ b/engine/src/input.cpp @@ -93,6 +93,12 @@ float Input::mouseScrollDelta() { void Input::mouseLockCursor(bool lock) { s_pPlatform->mouseLockCursor(lock); } +/*! + Sets the cursor \a shape. +*/ +void Input::mouseSetCursor(CursorShape shape) { + s_pPlatform->mouseSetCursor(shape); +} /*! Returns the state of mouse \a button. Example code: diff --git a/modules/editor/grapheditor/editor/graph/graphcontroller.cpp b/modules/editor/grapheditor/editor/graph/graphcontroller.cpp index 46e6e5c8e..572de5a29 100644 --- a/modules/editor/grapheditor/editor/graph/graphcontroller.cpp +++ b/modules/editor/grapheditor/editor/graph/graphcontroller.cpp @@ -435,7 +435,7 @@ void GraphController::update() { NodeWidget *GraphController::hoveredNode(float mouseX, float mouseY) { NodeWidget *hovered = nullptr; - Qt::CursorShape shape = Qt::ArrowCursor; + for(auto node : m_graph->nodes()) { NodeWidget *widget = static_cast(node->widget()); if(widget) { @@ -443,22 +443,9 @@ NodeWidget *GraphController::hoveredNode(float mouseX, float mouseY) { if(rect->isHovered(mouseX, mouseY)) { hovered = widget; } - GroupWidget *group = dynamic_cast(widget); - if(group) { - Qt::CursorShape s = static_cast(group->cursorShape()); - if(s != Qt::ArrowCursor) { - shape = s; - } - } } } - if(shape != Qt::ArrowCursor) { - emit setCursor(QCursor(shape)); - } else { - emit unsetCursor(); - } - return hovered; } diff --git a/modules/editor/grapheditor/editor/graph/graphwidgets/groupwidget.cpp b/modules/editor/grapheditor/editor/graph/graphwidgets/groupwidget.cpp index 9cb061d0a..1eca96af8 100644 --- a/modules/editor/grapheditor/editor/graph/graphwidgets/groupwidget.cpp +++ b/modules/editor/grapheditor/editor/graph/graphwidgets/groupwidget.cpp @@ -1,7 +1,6 @@ #include "groupwidget.h" #include "../nodegroup.h" -#include "../graphcontroller.h" #include #include @@ -21,7 +20,6 @@ namespace { }; GroupWidget::GroupWidget() : - m_shape(Qt::ArrowCursor), m_resize(0) { } @@ -39,10 +37,6 @@ void GroupWidget::setSize(const Vector2 &size) { rect->setSize(size); } -int GroupWidget::cursorShape() const { - return m_shape; -} - void GroupWidget::update() { Widget::update(); @@ -52,7 +46,7 @@ void GroupWidget::update() { m_title->setColor(newColor); } - m_shape = Qt::ArrowCursor; + Input::CursorShape shape = Input::CURSOR_ARROW; Vector4 cursor = Input::mousePosition(); if(m_title) { @@ -71,33 +65,31 @@ void GroupWidget::update() { Vector2 c(cursor.x, cursor.y); - bool isMouse = Input::isMouseButton(Input::MOUSE_LEFT); - int resize = 0; if(Mathf::distanceToSegment(lb, lt, c) < sensor) { - m_shape = Qt::SizeHorCursor; + shape = Input::CURSOR_HORSIZE; resize |= POINT_L; } if(Mathf::distanceToSegment(rb, rt, c) < sensor) { - m_shape = Qt::SizeHorCursor; + shape = Input::CURSOR_HORSIZE; resize |= POINT_R; } if(Mathf::distanceToSegment(lt, rt, c) < sensor) { - m_shape = Qt::SizeVerCursor; + shape = Input::CURSOR_VERSIZE; resize |= POINT_T; } if(Mathf::distanceToSegment(lb, rb, c) < sensor) { - m_shape = Qt::SizeVerCursor; + shape = Input::CURSOR_VERSIZE; resize |= POINT_B; } if((resize & POINT_L && resize & POINT_T) || (resize & POINT_R && resize & POINT_B)) { - m_shape = Qt::SizeFDiagCursor; + shape = Input::CURSOR_FDIAGSIZE; } if((resize & POINT_L && resize & POINT_B) || (resize & POINT_R && resize & POINT_T)) { - m_shape = Qt::SizeBDiagCursor; + shape = Input::CURSOR_BDIAGSIZE; } if(m_resize != 0) { @@ -134,6 +126,10 @@ void GroupWidget::update() { m_resize = resize; } } + + if(shape != Input::CURSOR_ARROW) { + Input::mouseSetCursor(shape); + } } } diff --git a/modules/editor/grapheditor/editor/graph/graphwidgets/groupwidget.h b/modules/editor/grapheditor/editor/graph/graphwidgets/groupwidget.h index e04e93b81..e957fffff 100644 --- a/modules/editor/grapheditor/editor/graph/graphwidgets/groupwidget.h +++ b/modules/editor/grapheditor/editor/graph/graphwidgets/groupwidget.h @@ -19,8 +19,6 @@ class GroupWidget : public NodeWidget { public: GroupWidget(); - int cursorShape() const; - private: void update() override; @@ -30,8 +28,6 @@ class GroupWidget : public NodeWidget { void setSize(const Vector2 &size); private: - int m_shape; - int m_resize; }; diff --git a/modules/editor/texturetools/editor/spritecontroller.cpp b/modules/editor/texturetools/editor/spritecontroller.cpp index 927d8f19e..802d1fe78 100644 --- a/modules/editor/texturetools/editor/spritecontroller.cpp +++ b/modules/editor/texturetools/editor/spritecontroller.cpp @@ -65,20 +65,6 @@ Vector3 SpriteController::world() const { return m_world; } -void SpriteController::update() { - CameraController::update(); - - if(m_settings == nullptr) { - return; - } - - if(m_spriteTool->cursor() != Qt::ArrowCursor) { - emit setCursor(QCursor(m_spriteTool->cursor())); - } else { - emit unsetCursor(); - } -} - void SpriteController::drawHandles() { CameraController::drawHandles(); diff --git a/modules/editor/texturetools/editor/spritecontroller.h b/modules/editor/texturetools/editor/spritecontroller.h index 5e35b0822..e4c80a17b 100644 --- a/modules/editor/texturetools/editor/spritecontroller.h +++ b/modules/editor/texturetools/editor/spritecontroller.h @@ -40,8 +40,6 @@ class SpriteController : public CameraController { void updated(); private: - void update() override; - void drawHandles() override; private: diff --git a/modules/editor/texturetools/editor/tools/spritetool.cpp b/modules/editor/texturetools/editor/tools/spritetool.cpp index 8403fe1ef..949f7e9b0 100644 --- a/modules/editor/texturetools/editor/tools/spritetool.cpp +++ b/modules/editor/texturetools/editor/tools/spritetool.cpp @@ -59,7 +59,7 @@ void SpriteTool::cancelControl() { void SpriteTool::update(bool pivot, bool local, bool snap) { bool isDrag = m_controller->isDrag(); - Qt::CursorShape shape = Qt::ArrowCursor; + Input::CursorShape shape = Input::CURSOR_ARROW; m_currentPoint = m_controller->world(); @@ -167,21 +167,21 @@ void SpriteTool::update(bool pivot, bool local, bool snap) { if(m_borderAxes != 0 && m_borderAxes != (Handles::TOP | Handles::BOTTOM | Handles::LEFT | Handles::RIGHT)) { axes = m_borderAxes; } - shape = Qt::SizeAllCursor; + shape = Input::CURSOR_ALLSIZE; } if(axes == (Handles::TOP | Handles::RIGHT)) { - shape = Qt::SizeBDiagCursor; + shape = Input::CURSOR_BDIAGSIZE; } else if(axes == (Handles::TOP | Handles::LEFT)) { - shape = Qt::SizeFDiagCursor; + shape = Input::CURSOR_FDIAGSIZE; } else if(axes == (Handles::BOTTOM | Handles::RIGHT)) { - shape = Qt::SizeFDiagCursor; + shape = Input::CURSOR_FDIAGSIZE; } else if(axes == (Handles::BOTTOM | Handles::LEFT)) { - shape = Qt::SizeBDiagCursor; + shape = Input::CURSOR_BDIAGSIZE; } else if(axes == Handles::TOP || axes == Handles::BOTTOM) { - shape = Qt::SizeVerCursor; + shape = Input::CURSOR_VERSIZE; } else if(axes == Handles::LEFT || axes == Handles::RIGHT) { - shape = Qt::SizeHorCursor; + shape = Input::CURSOR_HORSIZE; } element = it.second; @@ -257,7 +257,7 @@ void SpriteTool::update(bool pivot, bool local, bool snap) { m_controller->undoRedo()->push(new DestroySprite(m_controller)); } - m_cursor = shape; + Input::mouseSetCursor(shape); } std::string SpriteTool::icon() const { diff --git a/modules/uikit/src/editor/tools/widgettool.cpp b/modules/uikit/src/editor/tools/widgettool.cpp index eb85d5cc6..0887e4ac4 100644 --- a/modules/uikit/src/editor/tools/widgettool.cpp +++ b/modules/uikit/src/editor/tools/widgettool.cpp @@ -1,6 +1,7 @@ #include "widgettool.h" #include +#include #include #include @@ -253,24 +254,24 @@ void WidgetTool::update(bool pivot, bool local, bool snap) { } } - Qt::CursorShape shape = Qt::ArrowCursor; + Input::CursorShape shape = Input::CURSOR_ARROW; if(Handles::s_Axes == (Handles::TOP | Handles::BOTTOM | Handles::LEFT | Handles::RIGHT)) { - shape = Qt::SizeAllCursor; + shape = Input::CURSOR_ALLSIZE; } else if(Handles::s_Axes == (Handles::TOP | Handles::RIGHT)) { - shape = Qt::SizeBDiagCursor; + shape = Input::CURSOR_BDIAGSIZE; } else if(Handles::s_Axes == (Handles::TOP | Handles::LEFT)) { - shape = Qt::SizeFDiagCursor; + shape = Input::CURSOR_FDIAGSIZE; } else if(Handles::s_Axes == (Handles::BOTTOM | Handles::RIGHT)) { - shape = Qt::SizeFDiagCursor; + shape = Input::CURSOR_FDIAGSIZE; } else if(Handles::s_Axes == (Handles::BOTTOM | Handles::LEFT)) { - shape = Qt::SizeBDiagCursor; + shape = Input::CURSOR_BDIAGSIZE; } else if(Handles::s_Axes == Handles::TOP || Handles::s_Axes == Handles::BOTTOM) { - shape = Qt::SizeVerCursor; + shape = Input::CURSOR_VERSIZE; } else if(Handles::s_Axes == Handles::LEFT || Handles::s_Axes == Handles::RIGHT) { - shape = Qt::SizeHorCursor; + shape = Input::CURSOR_HORSIZE; } - m_cursor = shape; + Input::mouseSetCursor(shape); } std::string WidgetTool::icon() const { diff --git a/modules/uikit/src/editor/widgetcontroller.cpp b/modules/uikit/src/editor/widgetcontroller.cpp index a5888234a..07c81a4c7 100644 --- a/modules/uikit/src/editor/widgetcontroller.cpp +++ b/modules/uikit/src/editor/widgetcontroller.cpp @@ -172,14 +172,6 @@ void WidgetController::update() { } } } - - if(m_widgetTool->cursor() != Qt::ArrowCursor) { - emit setCursor(QCursor(m_widgetTool->cursor())); - } else if(focusWidget) { - emit setCursor(QCursor(Qt::CrossCursor)); - } else { - emit unsetCursor(); - } } void WidgetController::cameraMove(const Vector3 &delta) { diff --git a/modules/vms/angel/src/bindings/angelinput.cpp b/modules/vms/angel/src/bindings/angelinput.cpp index c0b02580c..056316900 100644 --- a/modules/vms/angel/src/bindings/angelinput.cpp +++ b/modules/vms/angel/src/bindings/angelinput.cpp @@ -5,166 +5,183 @@ #include -const char *MouseButton("MouseButton"); -const char *JoystickButton("JoystickButton"); -const char *TouchState("TouchState"); -const char *KeyCode("KeyCode"); +namespace { + const char *gMouseButton("MouseButton"); + const char *gCursorShape("CursorShape"); + const char *gJoystickButton("JoystickButton"); + const char *gTouchState("TouchState"); + const char *gKeyCode("KeyCode"); +} void registerInput(asIScriptEngine *engine, bool generic) { engine->SetDefaultNamespace("Input"); - engine->RegisterEnum(KeyCode); - engine->RegisterEnumValue(KeyCode, "KEY_UNKNOWN", Input::KEY_UNKNOWN); - engine->RegisterEnumValue(KeyCode, "KEY_SPACE", Input::KEY_SPACE); - engine->RegisterEnumValue(KeyCode, "KEY_APOSTROPHE", Input::KEY_APOSTROPHE); - engine->RegisterEnumValue(KeyCode, "KEY_COMMA", Input::KEY_COMMA); - engine->RegisterEnumValue(KeyCode, "KEY_MINUS", Input::KEY_MINUS); - engine->RegisterEnumValue(KeyCode, "KEY_PERIOD", Input::KEY_PERIOD); - engine->RegisterEnumValue(KeyCode, "KEY_SLASH", Input::KEY_SLASH); - engine->RegisterEnumValue(KeyCode, "KEY_0", Input::KEY_0); - engine->RegisterEnumValue(KeyCode, "KEY_1", Input::KEY_1); - engine->RegisterEnumValue(KeyCode, "KEY_2", Input::KEY_2); - engine->RegisterEnumValue(KeyCode, "KEY_3", Input::KEY_3); - engine->RegisterEnumValue(KeyCode, "KEY_4", Input::KEY_4); - engine->RegisterEnumValue(KeyCode, "KEY_5", Input::KEY_5); - engine->RegisterEnumValue(KeyCode, "KEY_6", Input::KEY_6); - engine->RegisterEnumValue(KeyCode, "KEY_7", Input::KEY_7); - engine->RegisterEnumValue(KeyCode, "KEY_8", Input::KEY_8); - engine->RegisterEnumValue(KeyCode, "KEY_9", Input::KEY_9); - engine->RegisterEnumValue(KeyCode, "KEY_SEMICOLON", Input::KEY_SEMICOLON); - engine->RegisterEnumValue(KeyCode, "KEY_EQUAL", Input::KEY_EQUAL); - engine->RegisterEnumValue(KeyCode, "KEY_A", Input::KEY_A); - engine->RegisterEnumValue(KeyCode, "KEY_B", Input::KEY_B); - engine->RegisterEnumValue(KeyCode, "KEY_C", Input::KEY_C); - engine->RegisterEnumValue(KeyCode, "KEY_D", Input::KEY_D); - engine->RegisterEnumValue(KeyCode, "KEY_E", Input::KEY_E); - engine->RegisterEnumValue(KeyCode, "KEY_F", Input::KEY_F); - engine->RegisterEnumValue(KeyCode, "KEY_G", Input::KEY_G); - engine->RegisterEnumValue(KeyCode, "KEY_H", Input::KEY_H); - engine->RegisterEnumValue(KeyCode, "KEY_I", Input::KEY_I); - engine->RegisterEnumValue(KeyCode, "KEY_J", Input::KEY_J); - engine->RegisterEnumValue(KeyCode, "KEY_K", Input::KEY_K); - engine->RegisterEnumValue(KeyCode, "KEY_L", Input::KEY_L); - engine->RegisterEnumValue(KeyCode, "KEY_M", Input::KEY_M); - engine->RegisterEnumValue(KeyCode, "KEY_N", Input::KEY_N); - engine->RegisterEnumValue(KeyCode, "KEY_O", Input::KEY_O); - engine->RegisterEnumValue(KeyCode, "KEY_P", Input::KEY_P); - engine->RegisterEnumValue(KeyCode, "KEY_Q", Input::KEY_Q); - engine->RegisterEnumValue(KeyCode, "KEY_R", Input::KEY_R); - engine->RegisterEnumValue(KeyCode, "KEY_S", Input::KEY_S); - engine->RegisterEnumValue(KeyCode, "KEY_T", Input::KEY_T); - engine->RegisterEnumValue(KeyCode, "KEY_U", Input::KEY_U); - engine->RegisterEnumValue(KeyCode, "KEY_V", Input::KEY_V); - engine->RegisterEnumValue(KeyCode, "KEY_W", Input::KEY_W); - engine->RegisterEnumValue(KeyCode, "KEY_X", Input::KEY_X); - engine->RegisterEnumValue(KeyCode, "KEY_Y", Input::KEY_Y); - engine->RegisterEnumValue(KeyCode, "KEY_Z", Input::KEY_Z); - engine->RegisterEnumValue(KeyCode, "KEY_LEFT_BRACKET", Input::KEY_LEFT_BRACKET); - engine->RegisterEnumValue(KeyCode, "KEY_BACKSLASH", Input::KEY_BACKSLASH); - engine->RegisterEnumValue(KeyCode, "KEY_RIGHT_BRACKET", Input::KEY_RIGHT_BRACKET); - engine->RegisterEnumValue(KeyCode, "KEY_GRAVE_ACCENT", Input::KEY_GRAVE_ACCENT); - engine->RegisterEnumValue(KeyCode, "KEY_WORLD_1", Input::KEY_WORLD_1); - engine->RegisterEnumValue(KeyCode, "KEY_WORLD_2", Input::KEY_WORLD_2); - engine->RegisterEnumValue(KeyCode, "KEY_ESCAPE", Input::KEY_ESCAPE); - engine->RegisterEnumValue(KeyCode, "KEY_ENTER", Input::KEY_ENTER); - engine->RegisterEnumValue(KeyCode, "KEY_TAB", Input::KEY_TAB); - engine->RegisterEnumValue(KeyCode, "KEY_BACKSPACE", Input::KEY_BACKSPACE); - engine->RegisterEnumValue(KeyCode, "KEY_INSERT", Input::KEY_INSERT); - engine->RegisterEnumValue(KeyCode, "KEY_DELETE", Input::KEY_DELETE); - engine->RegisterEnumValue(KeyCode, "KEY_RIGHT", Input::KEY_RIGHT); - engine->RegisterEnumValue(KeyCode, "KEY_LEFT", Input::KEY_LEFT); - engine->RegisterEnumValue(KeyCode, "KEY_DOWN", Input::KEY_DOWN); - engine->RegisterEnumValue(KeyCode, "KEY_UP", Input::KEY_UP); - engine->RegisterEnumValue(KeyCode, "KEY_PAGE_UP", Input::KEY_PAGE_UP); - engine->RegisterEnumValue(KeyCode, "KEY_PAGE_DOWN", Input::KEY_PAGE_DOWN); - engine->RegisterEnumValue(KeyCode, "KEY_HOME", Input::KEY_HOME); - engine->RegisterEnumValue(KeyCode, "KEY_END", Input::KEY_END); - engine->RegisterEnumValue(KeyCode, "KEY_CAPS_LOCK", Input::KEY_CAPS_LOCK); - engine->RegisterEnumValue(KeyCode, "KEY_SCROLL_LOCK", Input::KEY_SCROLL_LOCK); - engine->RegisterEnumValue(KeyCode, "KEY_NUM_LOCK", Input::KEY_NUM_LOCK); - engine->RegisterEnumValue(KeyCode, "KEY_PRINT_SCREEN", Input::KEY_PRINT_SCREEN); - engine->RegisterEnumValue(KeyCode, "KEY_PAUSE", Input::KEY_PAUSE); - engine->RegisterEnumValue(KeyCode, "KEY_F1", Input::KEY_F1); - engine->RegisterEnumValue(KeyCode, "KEY_F2", Input::KEY_F2); - engine->RegisterEnumValue(KeyCode, "KEY_F3", Input::KEY_F3); - engine->RegisterEnumValue(KeyCode, "KEY_F4", Input::KEY_F4); - engine->RegisterEnumValue(KeyCode, "KEY_F5", Input::KEY_F5); - engine->RegisterEnumValue(KeyCode, "KEY_F6", Input::KEY_F6); - engine->RegisterEnumValue(KeyCode, "KEY_F7", Input::KEY_F7); - engine->RegisterEnumValue(KeyCode, "KEY_F8", Input::KEY_F8); - engine->RegisterEnumValue(KeyCode, "KEY_F9", Input::KEY_F9); - engine->RegisterEnumValue(KeyCode, "KEY_F10", Input::KEY_F10); - engine->RegisterEnumValue(KeyCode, "KEY_F11", Input::KEY_F11); - engine->RegisterEnumValue(KeyCode, "KEY_F12", Input::KEY_F12); - engine->RegisterEnumValue(KeyCode, "KEY_F13", Input::KEY_F13); - engine->RegisterEnumValue(KeyCode, "KEY_F14", Input::KEY_F14); - engine->RegisterEnumValue(KeyCode, "KEY_F15", Input::KEY_F15); - engine->RegisterEnumValue(KeyCode, "KEY_F16", Input::KEY_F16); - engine->RegisterEnumValue(KeyCode, "KEY_F17", Input::KEY_F17); - engine->RegisterEnumValue(KeyCode, "KEY_F18", Input::KEY_F18); - engine->RegisterEnumValue(KeyCode, "KEY_F19", Input::KEY_F19); - engine->RegisterEnumValue(KeyCode, "KEY_F20", Input::KEY_F20); - engine->RegisterEnumValue(KeyCode, "KEY_F21", Input::KEY_F21); - engine->RegisterEnumValue(KeyCode, "KEY_F22", Input::KEY_F22); - engine->RegisterEnumValue(KeyCode, "KEY_F23", Input::KEY_F23); - engine->RegisterEnumValue(KeyCode, "KEY_F24", Input::KEY_F24); - engine->RegisterEnumValue(KeyCode, "KEY_F25", Input::KEY_F25); - engine->RegisterEnumValue(KeyCode, "KEY_KP_0", Input::KEY_KP_0); - engine->RegisterEnumValue(KeyCode, "KEY_KP_1", Input::KEY_KP_1); - engine->RegisterEnumValue(KeyCode, "KEY_KP_2", Input::KEY_KP_2); - engine->RegisterEnumValue(KeyCode, "KEY_KP_3", Input::KEY_KP_3); - engine->RegisterEnumValue(KeyCode, "KEY_KP_4", Input::KEY_KP_4); - engine->RegisterEnumValue(KeyCode, "KEY_KP_5", Input::KEY_KP_5); - engine->RegisterEnumValue(KeyCode, "KEY_KP_6", Input::KEY_KP_6); - engine->RegisterEnumValue(KeyCode, "KEY_KP_7", Input::KEY_KP_7); - engine->RegisterEnumValue(KeyCode, "KEY_KP_8", Input::KEY_KP_8); - engine->RegisterEnumValue(KeyCode, "KEY_KP_9", Input::KEY_KP_9); - engine->RegisterEnumValue(KeyCode, "KEY_KP_DECIMAL", Input::KEY_KP_DECIMAL); - engine->RegisterEnumValue(KeyCode, "KEY_KP_DIVIDE", Input::KEY_KP_DIVIDE); - engine->RegisterEnumValue(KeyCode, "KEY_KP_MULTIPLY", Input::KEY_KP_MULTIPLY); - engine->RegisterEnumValue(KeyCode, "KEY_KP_SUBTRACT", Input::KEY_KP_SUBTRACT); - engine->RegisterEnumValue(KeyCode, "KEY_KP_ADD", Input::KEY_KP_ADD); - engine->RegisterEnumValue(KeyCode, "KEY_KP_ENTER", Input::KEY_KP_ENTER); - engine->RegisterEnumValue(KeyCode, "KEY_KP_EQUAL", Input::KEY_KP_EQUAL); - engine->RegisterEnumValue(KeyCode, "KEY_LEFT_SHIFT", Input::KEY_LEFT_SHIFT); - engine->RegisterEnumValue(KeyCode, "KEY_LEFT_CONTROL", Input::KEY_LEFT_CONTROL); - engine->RegisterEnumValue(KeyCode, "KEY_LEFT_ALT", Input::KEY_LEFT_ALT); - engine->RegisterEnumValue(KeyCode, "KEY_LEFT_SUPER", Input::KEY_LEFT_SUPER); - engine->RegisterEnumValue(KeyCode, "KEY_RIGHT_SHIFT", Input::KEY_RIGHT_SHIFT); - engine->RegisterEnumValue(KeyCode, "KEY_RIGHT_CONTROL", Input::KEY_RIGHT_CONTROL); - engine->RegisterEnumValue(KeyCode, "KEY_RIGHT_ALT", Input::KEY_RIGHT_ALT); - engine->RegisterEnumValue(KeyCode, "KEY_RIGHT_SUPER", Input::KEY_RIGHT_SUPER); - engine->RegisterEnumValue(KeyCode, "KEY_MENU", Input::KEY_MENU); - - engine->RegisterEnumValue(KeyCode, "MOUSE_LEFT", Input::MOUSE_LEFT); - engine->RegisterEnumValue(KeyCode, "MOUSE_RIGHT", Input::MOUSE_RIGHT); - engine->RegisterEnumValue(KeyCode, "MOUSE_MIDDLE", Input::MOUSE_MIDDLE); - engine->RegisterEnumValue(KeyCode, "MOUSE_BUTTON0", Input::MOUSE_BUTTON0); - engine->RegisterEnumValue(KeyCode, "MOUSE_BUTTON1", Input::MOUSE_BUTTON1); - engine->RegisterEnumValue(KeyCode, "MOUSE_BUTTON2", Input::MOUSE_BUTTON2); - engine->RegisterEnumValue(KeyCode, "MOUSE_BUTTON3", Input::MOUSE_BUTTON3); - engine->RegisterEnumValue(KeyCode, "MOUSE_BUTTON4", Input::MOUSE_BUTTON4); - - engine->RegisterEnumValue(KeyCode, "JOYSTICK_UP_ARROW", Input::JOYSTICK_UP_ARROW); - engine->RegisterEnumValue(KeyCode, "JOYSTICK_DOWN_ARROW", Input::JOYSTICK_DOWN_ARROW); - engine->RegisterEnumValue(KeyCode, "JOYSTICK_LEFT_ARROW", Input::JOYSTICK_LEFT_ARROW); - engine->RegisterEnumValue(KeyCode, "JOYSTICK_RIGHT_ARROW", Input::JOYSTICK_RIGHT_ARROW); - engine->RegisterEnumValue(KeyCode, "JOYSTICK_START", Input::JOYSTICK_START); - engine->RegisterEnumValue(KeyCode, "JOYSTICK_BACK", Input::JOYSTICK_BACK); - engine->RegisterEnumValue(KeyCode, "JOYSTICK_LEFT_THUMB", Input::JOYSTICK_LEFT_THUMB); - engine->RegisterEnumValue(KeyCode, "JOYSTICK_RIGHT_THUMB", Input::JOYSTICK_RIGHT_THUMB); - engine->RegisterEnumValue(KeyCode, "JOYSTICK_LEFT_SHOULDER", Input::JOYSTICK_LEFT_SHOULDER); - engine->RegisterEnumValue(KeyCode, "JOYSTICK_RIGHT_SHOULDER", Input::JOYSTICK_RIGHT_SHOULDER); - engine->RegisterEnumValue(KeyCode, "JOYSTICK_A", Input::JOYSTICK_A); - engine->RegisterEnumValue(KeyCode, "JOYSTICK_B", Input::JOYSTICK_B); - engine->RegisterEnumValue(KeyCode, "JOYSTICK_X", Input::JOYSTICK_X); - engine->RegisterEnumValue(KeyCode, "JOYSTICK_Y", Input::JOYSTICK_Y); - - engine->RegisterEnumValue(KeyCode, "TOUCH_HOVER", Input::TOUCH_HOVER); - engine->RegisterEnumValue(KeyCode, "TOUCH_BEGAN", Input::TOUCH_BEGAN); - engine->RegisterEnumValue(KeyCode, "TOUCH_MOVED", Input::TOUCH_MOVED); - engine->RegisterEnumValue(KeyCode, "TOUCH_ENDED", Input::TOUCH_ENDED); - engine->RegisterEnumValue(KeyCode, "TOUCH_CANCELLED", Input::TOUCH_CANCELLED); + engine->RegisterEnum(gKeyCode); + engine->RegisterEnumValue(gKeyCode, "KEY_UNKNOWN", Input::KEY_UNKNOWN); + engine->RegisterEnumValue(gKeyCode, "KEY_SPACE", Input::KEY_SPACE); + engine->RegisterEnumValue(gKeyCode, "KEY_APOSTROPHE", Input::KEY_APOSTROPHE); + engine->RegisterEnumValue(gKeyCode, "KEY_COMMA", Input::KEY_COMMA); + engine->RegisterEnumValue(gKeyCode, "KEY_MINUS", Input::KEY_MINUS); + engine->RegisterEnumValue(gKeyCode, "KEY_PERIOD", Input::KEY_PERIOD); + engine->RegisterEnumValue(gKeyCode, "KEY_SLASH", Input::KEY_SLASH); + engine->RegisterEnumValue(gKeyCode, "KEY_0", Input::KEY_0); + engine->RegisterEnumValue(gKeyCode, "KEY_1", Input::KEY_1); + engine->RegisterEnumValue(gKeyCode, "KEY_2", Input::KEY_2); + engine->RegisterEnumValue(gKeyCode, "KEY_3", Input::KEY_3); + engine->RegisterEnumValue(gKeyCode, "KEY_4", Input::KEY_4); + engine->RegisterEnumValue(gKeyCode, "KEY_5", Input::KEY_5); + engine->RegisterEnumValue(gKeyCode, "KEY_6", Input::KEY_6); + engine->RegisterEnumValue(gKeyCode, "KEY_7", Input::KEY_7); + engine->RegisterEnumValue(gKeyCode, "KEY_8", Input::KEY_8); + engine->RegisterEnumValue(gKeyCode, "KEY_9", Input::KEY_9); + engine->RegisterEnumValue(gKeyCode, "KEY_SEMICOLON", Input::KEY_SEMICOLON); + engine->RegisterEnumValue(gKeyCode, "KEY_EQUAL", Input::KEY_EQUAL); + engine->RegisterEnumValue(gKeyCode, "KEY_A", Input::KEY_A); + engine->RegisterEnumValue(gKeyCode, "KEY_B", Input::KEY_B); + engine->RegisterEnumValue(gKeyCode, "KEY_C", Input::KEY_C); + engine->RegisterEnumValue(gKeyCode, "KEY_D", Input::KEY_D); + engine->RegisterEnumValue(gKeyCode, "KEY_E", Input::KEY_E); + engine->RegisterEnumValue(gKeyCode, "KEY_F", Input::KEY_F); + engine->RegisterEnumValue(gKeyCode, "KEY_G", Input::KEY_G); + engine->RegisterEnumValue(gKeyCode, "KEY_H", Input::KEY_H); + engine->RegisterEnumValue(gKeyCode, "KEY_I", Input::KEY_I); + engine->RegisterEnumValue(gKeyCode, "KEY_J", Input::KEY_J); + engine->RegisterEnumValue(gKeyCode, "KEY_K", Input::KEY_K); + engine->RegisterEnumValue(gKeyCode, "KEY_L", Input::KEY_L); + engine->RegisterEnumValue(gKeyCode, "KEY_M", Input::KEY_M); + engine->RegisterEnumValue(gKeyCode, "KEY_N", Input::KEY_N); + engine->RegisterEnumValue(gKeyCode, "KEY_O", Input::KEY_O); + engine->RegisterEnumValue(gKeyCode, "KEY_P", Input::KEY_P); + engine->RegisterEnumValue(gKeyCode, "KEY_Q", Input::KEY_Q); + engine->RegisterEnumValue(gKeyCode, "KEY_R", Input::KEY_R); + engine->RegisterEnumValue(gKeyCode, "KEY_S", Input::KEY_S); + engine->RegisterEnumValue(gKeyCode, "KEY_T", Input::KEY_T); + engine->RegisterEnumValue(gKeyCode, "KEY_U", Input::KEY_U); + engine->RegisterEnumValue(gKeyCode, "KEY_V", Input::KEY_V); + engine->RegisterEnumValue(gKeyCode, "KEY_W", Input::KEY_W); + engine->RegisterEnumValue(gKeyCode, "KEY_X", Input::KEY_X); + engine->RegisterEnumValue(gKeyCode, "KEY_Y", Input::KEY_Y); + engine->RegisterEnumValue(gKeyCode, "KEY_Z", Input::KEY_Z); + engine->RegisterEnumValue(gKeyCode, "KEY_LEFT_BRACKET", Input::KEY_LEFT_BRACKET); + engine->RegisterEnumValue(gKeyCode, "KEY_BACKSLASH", Input::KEY_BACKSLASH); + engine->RegisterEnumValue(gKeyCode, "KEY_RIGHT_BRACKET", Input::KEY_RIGHT_BRACKET); + engine->RegisterEnumValue(gKeyCode, "KEY_GRAVE_ACCENT", Input::KEY_GRAVE_ACCENT); + engine->RegisterEnumValue(gKeyCode, "KEY_WORLD_1", Input::KEY_WORLD_1); + engine->RegisterEnumValue(gKeyCode, "KEY_WORLD_2", Input::KEY_WORLD_2); + engine->RegisterEnumValue(gKeyCode, "KEY_ESCAPE", Input::KEY_ESCAPE); + engine->RegisterEnumValue(gKeyCode, "KEY_ENTER", Input::KEY_ENTER); + engine->RegisterEnumValue(gKeyCode, "KEY_TAB", Input::KEY_TAB); + engine->RegisterEnumValue(gKeyCode, "KEY_BACKSPACE", Input::KEY_BACKSPACE); + engine->RegisterEnumValue(gKeyCode, "KEY_INSERT", Input::KEY_INSERT); + engine->RegisterEnumValue(gKeyCode, "KEY_DELETE", Input::KEY_DELETE); + engine->RegisterEnumValue(gKeyCode, "KEY_RIGHT", Input::KEY_RIGHT); + engine->RegisterEnumValue(gKeyCode, "KEY_LEFT", Input::KEY_LEFT); + engine->RegisterEnumValue(gKeyCode, "KEY_DOWN", Input::KEY_DOWN); + engine->RegisterEnumValue(gKeyCode, "KEY_UP", Input::KEY_UP); + engine->RegisterEnumValue(gKeyCode, "KEY_PAGE_UP", Input::KEY_PAGE_UP); + engine->RegisterEnumValue(gKeyCode, "KEY_PAGE_DOWN", Input::KEY_PAGE_DOWN); + engine->RegisterEnumValue(gKeyCode, "KEY_HOME", Input::KEY_HOME); + engine->RegisterEnumValue(gKeyCode, "KEY_END", Input::KEY_END); + engine->RegisterEnumValue(gKeyCode, "KEY_CAPS_LOCK", Input::KEY_CAPS_LOCK); + engine->RegisterEnumValue(gKeyCode, "KEY_SCROLL_LOCK", Input::KEY_SCROLL_LOCK); + engine->RegisterEnumValue(gKeyCode, "KEY_NUM_LOCK", Input::KEY_NUM_LOCK); + engine->RegisterEnumValue(gKeyCode, "KEY_PRINT_SCREEN", Input::KEY_PRINT_SCREEN); + engine->RegisterEnumValue(gKeyCode, "KEY_PAUSE", Input::KEY_PAUSE); + engine->RegisterEnumValue(gKeyCode, "KEY_F1", Input::KEY_F1); + engine->RegisterEnumValue(gKeyCode, "KEY_F2", Input::KEY_F2); + engine->RegisterEnumValue(gKeyCode, "KEY_F3", Input::KEY_F3); + engine->RegisterEnumValue(gKeyCode, "KEY_F4", Input::KEY_F4); + engine->RegisterEnumValue(gKeyCode, "KEY_F5", Input::KEY_F5); + engine->RegisterEnumValue(gKeyCode, "KEY_F6", Input::KEY_F6); + engine->RegisterEnumValue(gKeyCode, "KEY_F7", Input::KEY_F7); + engine->RegisterEnumValue(gKeyCode, "KEY_F8", Input::KEY_F8); + engine->RegisterEnumValue(gKeyCode, "KEY_F9", Input::KEY_F9); + engine->RegisterEnumValue(gKeyCode, "KEY_F10", Input::KEY_F10); + engine->RegisterEnumValue(gKeyCode, "KEY_F11", Input::KEY_F11); + engine->RegisterEnumValue(gKeyCode, "KEY_F12", Input::KEY_F12); + engine->RegisterEnumValue(gKeyCode, "KEY_F13", Input::KEY_F13); + engine->RegisterEnumValue(gKeyCode, "KEY_F14", Input::KEY_F14); + engine->RegisterEnumValue(gKeyCode, "KEY_F15", Input::KEY_F15); + engine->RegisterEnumValue(gKeyCode, "KEY_F16", Input::KEY_F16); + engine->RegisterEnumValue(gKeyCode, "KEY_F17", Input::KEY_F17); + engine->RegisterEnumValue(gKeyCode, "KEY_F18", Input::KEY_F18); + engine->RegisterEnumValue(gKeyCode, "KEY_F19", Input::KEY_F19); + engine->RegisterEnumValue(gKeyCode, "KEY_F20", Input::KEY_F20); + engine->RegisterEnumValue(gKeyCode, "KEY_F21", Input::KEY_F21); + engine->RegisterEnumValue(gKeyCode, "KEY_F22", Input::KEY_F22); + engine->RegisterEnumValue(gKeyCode, "KEY_F23", Input::KEY_F23); + engine->RegisterEnumValue(gKeyCode, "KEY_F24", Input::KEY_F24); + engine->RegisterEnumValue(gKeyCode, "KEY_F25", Input::KEY_F25); + engine->RegisterEnumValue(gKeyCode, "KEY_KP_0", Input::KEY_KP_0); + engine->RegisterEnumValue(gKeyCode, "KEY_KP_1", Input::KEY_KP_1); + engine->RegisterEnumValue(gKeyCode, "KEY_KP_2", Input::KEY_KP_2); + engine->RegisterEnumValue(gKeyCode, "KEY_KP_3", Input::KEY_KP_3); + engine->RegisterEnumValue(gKeyCode, "KEY_KP_4", Input::KEY_KP_4); + engine->RegisterEnumValue(gKeyCode, "KEY_KP_5", Input::KEY_KP_5); + engine->RegisterEnumValue(gKeyCode, "KEY_KP_6", Input::KEY_KP_6); + engine->RegisterEnumValue(gKeyCode, "KEY_KP_7", Input::KEY_KP_7); + engine->RegisterEnumValue(gKeyCode, "KEY_KP_8", Input::KEY_KP_8); + engine->RegisterEnumValue(gKeyCode, "KEY_KP_9", Input::KEY_KP_9); + engine->RegisterEnumValue(gKeyCode, "KEY_KP_DECIMAL", Input::KEY_KP_DECIMAL); + engine->RegisterEnumValue(gKeyCode, "KEY_KP_DIVIDE", Input::KEY_KP_DIVIDE); + engine->RegisterEnumValue(gKeyCode, "KEY_KP_MULTIPLY", Input::KEY_KP_MULTIPLY); + engine->RegisterEnumValue(gKeyCode, "KEY_KP_SUBTRACT", Input::KEY_KP_SUBTRACT); + engine->RegisterEnumValue(gKeyCode, "KEY_KP_ADD", Input::KEY_KP_ADD); + engine->RegisterEnumValue(gKeyCode, "KEY_KP_ENTER", Input::KEY_KP_ENTER); + engine->RegisterEnumValue(gKeyCode, "KEY_KP_EQUAL", Input::KEY_KP_EQUAL); + engine->RegisterEnumValue(gKeyCode, "KEY_LEFT_SHIFT", Input::KEY_LEFT_SHIFT); + engine->RegisterEnumValue(gKeyCode, "KEY_LEFT_CONTROL", Input::KEY_LEFT_CONTROL); + engine->RegisterEnumValue(gKeyCode, "KEY_LEFT_ALT", Input::KEY_LEFT_ALT); + engine->RegisterEnumValue(gKeyCode, "KEY_LEFT_SUPER", Input::KEY_LEFT_SUPER); + engine->RegisterEnumValue(gKeyCode, "KEY_RIGHT_SHIFT", Input::KEY_RIGHT_SHIFT); + engine->RegisterEnumValue(gKeyCode, "KEY_RIGHT_CONTROL", Input::KEY_RIGHT_CONTROL); + engine->RegisterEnumValue(gKeyCode, "KEY_RIGHT_ALT", Input::KEY_RIGHT_ALT); + engine->RegisterEnumValue(gKeyCode, "KEY_RIGHT_SUPER", Input::KEY_RIGHT_SUPER); + engine->RegisterEnumValue(gKeyCode, "KEY_MENU", Input::KEY_MENU); + + engine->RegisterEnum(gMouseButton); + engine->RegisterEnumValue(gMouseButton, "MOUSE_LEFT", Input::MOUSE_LEFT); + engine->RegisterEnumValue(gMouseButton, "MOUSE_RIGHT", Input::MOUSE_RIGHT); + engine->RegisterEnumValue(gMouseButton, "MOUSE_MIDDLE", Input::MOUSE_MIDDLE); + engine->RegisterEnumValue(gMouseButton, "MOUSE_BUTTON0", Input::MOUSE_BUTTON0); + engine->RegisterEnumValue(gMouseButton, "MOUSE_BUTTON1", Input::MOUSE_BUTTON1); + engine->RegisterEnumValue(gMouseButton, "MOUSE_BUTTON2", Input::MOUSE_BUTTON2); + engine->RegisterEnumValue(gMouseButton, "MOUSE_BUTTON3", Input::MOUSE_BUTTON3); + engine->RegisterEnumValue(gMouseButton, "MOUSE_BUTTON4", Input::MOUSE_BUTTON4); + + engine->RegisterEnum(gJoystickButton); + engine->RegisterEnumValue(gJoystickButton, "JOYSTICK_UP_ARROW", Input::JOYSTICK_UP_ARROW); + engine->RegisterEnumValue(gJoystickButton, "JOYSTICK_DOWN_ARROW", Input::JOYSTICK_DOWN_ARROW); + engine->RegisterEnumValue(gJoystickButton, "JOYSTICK_LEFT_ARROW", Input::JOYSTICK_LEFT_ARROW); + engine->RegisterEnumValue(gJoystickButton, "JOYSTICK_RIGHT_ARROW", Input::JOYSTICK_RIGHT_ARROW); + engine->RegisterEnumValue(gJoystickButton, "JOYSTICK_START", Input::JOYSTICK_START); + engine->RegisterEnumValue(gJoystickButton, "JOYSTICK_BACK", Input::JOYSTICK_BACK); + engine->RegisterEnumValue(gJoystickButton, "JOYSTICK_LEFT_THUMB", Input::JOYSTICK_LEFT_THUMB); + engine->RegisterEnumValue(gJoystickButton, "JOYSTICK_RIGHT_THUMB", Input::JOYSTICK_RIGHT_THUMB); + engine->RegisterEnumValue(gJoystickButton, "JOYSTICK_LEFT_SHOULDER", Input::JOYSTICK_LEFT_SHOULDER); + engine->RegisterEnumValue(gJoystickButton, "JOYSTICK_RIGHT_SHOULDER", Input::JOYSTICK_RIGHT_SHOULDER); + engine->RegisterEnumValue(gJoystickButton, "JOYSTICK_A", Input::JOYSTICK_A); + engine->RegisterEnumValue(gJoystickButton, "JOYSTICK_B", Input::JOYSTICK_B); + engine->RegisterEnumValue(gJoystickButton, "JOYSTICK_X", Input::JOYSTICK_X); + engine->RegisterEnumValue(gJoystickButton, "JOYSTICK_Y", Input::JOYSTICK_Y); + + engine->RegisterEnum(gTouchState); + engine->RegisterEnumValue(gTouchState, "TOUCH_HOVER", Input::TOUCH_HOVER); + engine->RegisterEnumValue(gTouchState, "TOUCH_BEGAN", Input::TOUCH_BEGAN); + engine->RegisterEnumValue(gTouchState, "TOUCH_MOVED", Input::TOUCH_MOVED); + engine->RegisterEnumValue(gTouchState, "TOUCH_ENDED", Input::TOUCH_ENDED); + engine->RegisterEnumValue(gTouchState, "TOUCH_CANCELLED", Input::TOUCH_CANCELLED); + + engine->RegisterEnum(gCursorShape); + engine->RegisterEnumValue(gCursorShape, "TOUCH_HOVER", Input::CURSOR_ARROW); + engine->RegisterEnumValue(gCursorShape, "CURSOR_CROSS", Input::CURSOR_CROSS); + engine->RegisterEnumValue(gCursorShape, "CURSOR_IBEAM", Input::CURSOR_IBEAM); + engine->RegisterEnumValue(gCursorShape, "CURSOR_HAND", Input::CURSOR_HAND); + engine->RegisterEnumValue(gCursorShape, "CURSOR_HORSIZE", Input::CURSOR_HORSIZE); + engine->RegisterEnumValue(gCursorShape, "CURSOR_VERSIZE", Input::CURSOR_VERSIZE); + engine->RegisterEnumValue(gCursorShape, "CURSOR_FDIAGSIZE", Input::CURSOR_FDIAGSIZE); + engine->RegisterEnumValue(gCursorShape, "CURSOR_BDIAGSIZE", Input::CURSOR_BDIAGSIZE); + engine->RegisterEnumValue(gCursorShape, "CURSOR_ALLSIZE", Input::CURSOR_ALLSIZE); engine->RegisterGlobalFunction("bool isKey(int)", generic ? WRAP_FN(Input::isKey) : asFUNCTION(Input::isKey), @@ -178,6 +195,16 @@ void registerInput(asIScriptEngine *engine, bool generic) { generic ? WRAP_FN(Input::isKeyUp) : asFUNCTION(Input::isKeyUp), generic ? asCALL_GENERIC : asCALL_CDECL); + + engine->RegisterGlobalFunction("string inputString()", + generic ? WRAP_FN(Input::inputString) : asFUNCTION(Input::inputString), + generic ? asCALL_GENERIC : asCALL_CDECL); + + engine->RegisterGlobalFunction("void setKeyboardVisible(bool)", + generic ? WRAP_FN(Input::setKeyboardVisible) : asFUNCTION(Input::setKeyboardVisible), + generic ? asCALL_GENERIC : asCALL_CDECL); + + engine->RegisterGlobalFunction("bool isMouseButton(int)", generic ? WRAP_FN(Input::isMouseButton) : asFUNCTION(Input::isMouseButton), generic ? asCALL_GENERIC : asCALL_CDECL); @@ -198,10 +225,19 @@ void registerInput(asIScriptEngine *engine, bool generic) { generic ? WRAP_FN(Input::mouseDelta) : asFUNCTION(Input::mouseDelta), generic ? asCALL_GENERIC : asCALL_CDECL); + engine->RegisterGlobalFunction("float mouseScrollDelta()", + generic ? WRAP_FN(Input::mouseScrollDelta) : asFUNCTION(Input::mouseScrollDelta), + generic ? asCALL_GENERIC : asCALL_CDECL); + engine->RegisterGlobalFunction("void mouseLockCursor(bool)", generic ? WRAP_FN(Input::mouseLockCursor) : asFUNCTION(Input::mouseLockCursor), generic ? asCALL_GENERIC : asCALL_CDECL); + engine->RegisterGlobalFunction("void mouseSetCursor(int)", + generic ? WRAP_FN(Input::mouseSetCursor) : asFUNCTION(Input::mouseSetCursor), + generic ? asCALL_GENERIC : asCALL_CDECL); + + engine->RegisterGlobalFunction("int joystickCount()", generic ? WRAP_FN(Input::joystickCount) : asFUNCTION(Input::joystickCount), generic ? asCALL_GENERIC : asCALL_CDECL); @@ -218,6 +254,7 @@ void registerInput(asIScriptEngine *engine, bool generic) { generic ? WRAP_FN(Input::joystickTriggers) : asFUNCTION(Input::joystickTriggers), generic ? asCALL_GENERIC : asCALL_CDECL); + engine->RegisterGlobalFunction("int touchCount()", generic ? WRAP_FN(Input::touchCount) : asFUNCTION(Input::touchCount), generic ? asCALL_GENERIC : asCALL_CDECL); diff --git a/worldeditor/src/screens/scenecomposer/objectcontroller.cpp b/worldeditor/src/screens/scenecomposer/objectcontroller.cpp index 292826445..972c93990 100644 --- a/worldeditor/src/screens/scenecomposer/objectcontroller.cpp +++ b/worldeditor/src/screens/scenecomposer/objectcontroller.cpp @@ -268,18 +268,9 @@ void ObjectController::update() { setDrag(false); } - for(auto it : m_selected) { + for(auto &it : m_selected) { updateComponents(it.object); } - - if(m_activeTool->cursor() != Qt::ArrowCursor) { - emit setCursor(QCursor(m_activeTool->cursor())); - } else if(!m_objectsList.empty()) { - emit setCursor(QCursor(Qt::CrossCursor)); - } else { - emit unsetCursor(); - } - } void ObjectController::updateComponents(Actor *parent) { @@ -357,7 +348,7 @@ void ObjectController::setDrag(bool drag) { void ObjectController::copySelected() { VariantList list; - for(auto it : m_selected) { + for(auto &it : m_selected) { if(it.object) { list.push_back(Engine::toVariant(it.object)); } diff --git a/worldeditor/src/screens/scenecomposer/tools/transformtool.cpp b/worldeditor/src/screens/scenecomposer/tools/transformtool.cpp index 5a6d53f3b..085b4032a 100644 --- a/worldeditor/src/screens/scenecomposer/tools/transformtool.cpp +++ b/worldeditor/src/screens/scenecomposer/tools/transformtool.cpp @@ -5,6 +5,7 @@ #include #include +#include #include "../objectcontroller.h" @@ -68,24 +69,24 @@ void TransformTool::update(bool center, bool local, bool snap) { } } - Qt::CursorShape shape = Qt::ArrowCursor; + Input::CursorShape shape = Input::CURSOR_ARROW; if(Handles::s_Axes == (Handles::TOP | Handles::BOTTOM | Handles::LEFT | Handles::RIGHT)) { - shape = Qt::SizeAllCursor; + shape = Input::CURSOR_ALLSIZE; } else if(Handles::s_Axes == (Handles::TOP | Handles::RIGHT)) { - shape = Qt::SizeBDiagCursor; + shape = Input::CURSOR_BDIAGSIZE; } else if(Handles::s_Axes == (Handles::TOP | Handles::LEFT)) { - shape = Qt::SizeFDiagCursor; + shape = Input::CURSOR_FDIAGSIZE; } else if(Handles::s_Axes == (Handles::BOTTOM | Handles::RIGHT)) { - shape = Qt::SizeFDiagCursor; + shape = Input::CURSOR_FDIAGSIZE; } else if(Handles::s_Axes == (Handles::BOTTOM | Handles::LEFT)) { - shape = Qt::SizeBDiagCursor; + shape = Input::CURSOR_BDIAGSIZE; } else if(Handles::s_Axes == Handles::TOP || Handles::s_Axes == Handles::BOTTOM) { - shape = Qt::SizeVerCursor; + shape = Input::CURSOR_VERSIZE; } else if(Handles::s_Axes == Handles::LEFT || Handles::s_Axes == Handles::RIGHT) { - shape = Qt::SizeHorCursor; + shape = Input::CURSOR_HORSIZE; } - m_cursor = shape; + Input::mouseSetCursor(shape); } }