diff options
Diffstat (limited to 'core/os')
-rw-r--r-- | core/os/file_access.cpp | 21 | ||||
-rw-r--r-- | core/os/file_access.h | 1 | ||||
-rw-r--r-- | core/os/input.h | 4 | ||||
-rw-r--r-- | core/os/input_event.cpp | 984 | ||||
-rw-r--r-- | core/os/input_event.h | 311 | ||||
-rw-r--r-- | core/os/main_loop.cpp | 4 | ||||
-rw-r--r-- | core/os/main_loop.h | 2 | ||||
-rw-r--r-- | core/os/os.cpp | 2 | ||||
-rw-r--r-- | core/os/os.h | 5 |
9 files changed, 1030 insertions, 304 deletions
diff --git a/core/os/file_access.cpp b/core/os/file_access.cpp index 375121c0cc..805b66b983 100644 --- a/core/os/file_access.cpp +++ b/core/os/file_access.cpp @@ -252,6 +252,27 @@ double FileAccess::get_double() const { return m.d; }; +String FileAccess::get_token() const { + + CharString token; + + CharType c = get_8(); + + while (!eof_reached()) { + + if (c <= ' ') { + if (!token.empty()) + break; + } else { + token.push_back(c); + } + c = get_8(); + } + + token.push_back(0); + return String::utf8(token.get_data()); +} + String FileAccess::get_line() const { CharString line; diff --git a/core/os/file_access.h b/core/os/file_access.h index da15ddc544..6d3e491167 100644 --- a/core/os/file_access.h +++ b/core/os/file_access.h @@ -106,6 +106,7 @@ public: virtual int get_buffer(uint8_t *p_dst, int p_length) const; ///< get an array of bytes virtual String get_line() const; + virtual String get_token() const; virtual Vector<String> get_csv_line(String delim = ",") const; /**< use this for files WRITTEN in _big_ endian machines (ie, amiga/mac) diff --git a/core/os/input.h b/core/os/input.h index 4f26f097c2..6759c624e3 100644 --- a/core/os/input.h +++ b/core/os/input.h @@ -82,7 +82,7 @@ public: virtual int get_mouse_button_mask() const = 0; virtual void warp_mouse_pos(const Vector2 &p_to) = 0; - virtual Point2i warp_mouse_motion(const InputEventMouseMotion &p_motion, const Rect2 &p_rect) = 0; + virtual Point2i warp_mouse_motion(const Ref<InputEventMouseMotion> &p_motion, const Rect2 &p_rect) = 0; virtual Vector3 get_gravity() const = 0; virtual Vector3 get_accelerometer() const = 0; @@ -104,7 +104,7 @@ public: virtual int get_joy_button_index_from_string(String p_button) = 0; virtual int get_joy_axis_index_from_string(String p_axis) = 0; - virtual void parse_input_event(const InputEvent &p_event) = 0; + virtual void parse_input_event(const Ref<InputEvent> &p_event) = 0; Input(); }; diff --git a/core/os/input_event.cpp b/core/os/input_event.cpp index 474bc33b41..dbdf9628e3 100644 --- a/core/os/input_event.cpp +++ b/core/os/input_event.cpp @@ -34,275 +34,797 @@ * */ -bool InputEvent::operator==(const InputEvent &p_event) const { - if (type != p_event.type) { - return false; - } +void InputEvent::set_id(uint32_t p_id) { + id = p_id; +} - switch (type) { - /** Current clang-format style doesn't play well with the aligned return values of that switch. */ - /* clang-format off */ - case NONE: - return true; - case KEY: - return key.unicode == p_event.key.unicode - && key.scancode == p_event.key.scancode - && key.echo == p_event.key.echo - && key.pressed == p_event.key.pressed - && key.mod == p_event.key.mod; - case MOUSE_MOTION: - return mouse_motion.x == p_event.mouse_motion.x - && mouse_motion.y == p_event.mouse_motion.y - && mouse_motion.relative_x == p_event.mouse_motion.relative_x - && mouse_motion.relative_y == p_event.mouse_motion.relative_y - && mouse_motion.button_mask == p_event.mouse_motion.button_mask - && key.mod == p_event.key.mod; - case MOUSE_BUTTON: - return mouse_button.pressed == p_event.mouse_button.pressed - && mouse_button.x == p_event.mouse_button.x - && mouse_button.y == p_event.mouse_button.y - && mouse_button.button_index == p_event.mouse_button.button_index - && mouse_button.button_mask == p_event.mouse_button.button_mask - && key.mod == p_event.key.mod; - case JOYPAD_MOTION: - return joy_motion.axis == p_event.joy_motion.axis - && joy_motion.axis_value == p_event.joy_motion.axis_value; - case JOYPAD_BUTTON: - return joy_button.pressed == p_event.joy_button.pressed - && joy_button.button_index == p_event.joy_button.button_index - && joy_button.pressure == p_event.joy_button.pressure; - case SCREEN_TOUCH: - return screen_touch.pressed == p_event.screen_touch.pressed - && screen_touch.index == p_event.screen_touch.index - && screen_touch.x == p_event.screen_touch.x - && screen_touch.y == p_event.screen_touch.y; - case SCREEN_DRAG: - return screen_drag.index == p_event.screen_drag.index - && screen_drag.x == p_event.screen_drag.x - && screen_drag.y == p_event.screen_drag.y; - case ACTION: - return action.action == p_event.action.action - && action.pressed == p_event.action.pressed; - /* clang-format on */ - default: - ERR_PRINT("No logic to compare InputEvents of this type, this shouldn't happen."); - } +uint32_t InputEvent::get_id() const { + return id; +} + +void InputEvent::set_device(int p_device) { + device = p_device; +} + +int InputEvent::get_device() const { + return device; +} + +bool InputEvent::is_pressed() const { return false; } -InputEvent::operator String() const { - - String str = "Device " + itos(device) + " ID " + itos(ID) + " "; - - switch (type) { - - case NONE: { - - return "Event: None"; - } break; - case KEY: { - - str += "Event: Key "; - str = str + "Unicode: " + String::chr(key.unicode) + " Scan: " + itos(key.scancode) + " Echo: " + String(key.echo ? "True" : "False") + " Pressed" + String(key.pressed ? "True" : "False") + " Mod: "; - if (key.mod.shift) - str += "S"; - if (key.mod.control) - str += "C"; - if (key.mod.alt) - str += "A"; - if (key.mod.meta) - str += "M"; - - return str; - } break; - case MOUSE_MOTION: { - - str += "Event: Motion "; - str = str + " Pos: " + itos(mouse_motion.x) + "," + itos(mouse_motion.y) + " Rel: " + itos(mouse_motion.relative_x) + "," + itos(mouse_motion.relative_y) + " Mask: "; - for (int i = 0; i < 8; i++) { - - if ((1 << i) & mouse_motion.button_mask) - str += itos(i + 1); - } - str += " Mod: "; - if (key.mod.shift) - str += "S"; - if (key.mod.control) - str += "C"; - if (key.mod.alt) - str += "A"; - if (key.mod.meta) - str += "M"; - - return str; - } break; - case MOUSE_BUTTON: { - str += "Event: Button "; - str = str + "Pressed: " + itos(mouse_button.pressed) + " Pos: " + itos(mouse_button.x) + "," + itos(mouse_button.y) + " Button: " + itos(mouse_button.button_index) + " Mask: "; - for (int i = 0; i < 8; i++) { - - if ((1 << i) & mouse_button.button_mask) - str += itos(i + 1); - } - str += " Mod: "; - if (key.mod.shift) - str += "S"; - if (key.mod.control) - str += "C"; - if (key.mod.alt) - str += "A"; - if (key.mod.meta) - str += "M"; - - str += String(" DoubleClick: ") + (mouse_button.doubleclick ? "Yes" : "No"); - - return str; - - } break; - case JOYPAD_MOTION: { - str += "Event: JoypadMotion "; - str = str + "Axis: " + itos(joy_motion.axis) + " Value: " + rtos(joy_motion.axis_value); - return str; - - } break; - case JOYPAD_BUTTON: { - str += "Event: JoypadButton "; - str = str + "Pressed: " + itos(joy_button.pressed) + " Index: " + itos(joy_button.button_index) + " pressure " + rtos(joy_button.pressure); - return str; - - } break; - case SCREEN_TOUCH: { - str += "Event: ScreenTouch "; - str = str + "Pressed: " + itos(screen_touch.pressed) + " Index: " + itos(screen_touch.index) + " pos " + rtos(screen_touch.x) + "," + rtos(screen_touch.y); - return str; - - } break; - case SCREEN_DRAG: { - str += "Event: ScreenDrag "; - str = str + " Index: " + itos(screen_drag.index) + " pos " + rtos(screen_drag.x) + "," + rtos(screen_drag.y); - return str; - - } break; - case ACTION: { - str += "Event: Action: " + InputMap::get_singleton()->get_action_from_id(action.action) + " Pressed: " + itos(action.pressed); - return str; - - } break; - } - return ""; +bool InputEvent::is_action(const StringName &p_action) const { + + return InputMap::get_singleton()->event_is_action(Ref<InputEvent>((InputEvent *)this), p_action); } -void InputEvent::set_as_action(const String &p_action, bool p_pressed) { +bool InputEvent::is_action_pressed(const StringName &p_action) const { - type = ACTION; - action.action = InputMap::get_singleton()->get_action_id(p_action); - action.pressed = p_pressed; + return (is_pressed() && !is_echo() && is_action(p_action)); } +bool InputEvent::is_action_released(const StringName &p_action) const { -bool InputEvent::is_pressed() const { + return (!is_pressed() && is_action(p_action)); +} - switch (type) { +bool InputEvent::is_echo() const { - case KEY: return key.pressed; - case MOUSE_BUTTON: return mouse_button.pressed; - case JOYPAD_BUTTON: return joy_button.pressed; - case SCREEN_TOUCH: return screen_touch.pressed; - case JOYPAD_MOTION: return ABS(joy_motion.axis_value) > 0.5; - case ACTION: return action.pressed; - default: {} - } + return false; +} + +Ref<InputEvent> InputEvent::xformed_by(const Transform2D &p_xform, const Vector2 &p_local_ofs) const { + + return Ref<InputEvent>((InputEvent *)this); +} + +String InputEvent::as_text() const { + + return String(); +} + +bool InputEvent::action_match(const Ref<InputEvent> &p_event) const { return false; } -bool InputEvent::is_echo() const { +bool InputEvent::is_action_type() const { + + return false; +} + +#if 0 +if (String(p_method) == "is_action" && p_argidx == 0) { + + List<PropertyInfo> pinfo; + GlobalConfig::get_singleton()->get_property_list(&pinfo); + + for (List<PropertyInfo>::Element *E = pinfo.front(); E; E = E->next()) { + const PropertyInfo &pi = E->get(); + + if (!pi.name.begins_with("input/")) + continue; + + String name = pi.name.substr(pi.name.find("/") + 1, pi.name.length()); + result.insert("\"" + name + "\""); + } + +} else +#endif + +void InputEvent::_bind_methods() { + + ClassDB::bind_method(D_METHOD("set_id", "id"), &InputEvent::set_id); + ClassDB::bind_method(D_METHOD("get_id"), &InputEvent::get_id); + + ClassDB::bind_method(D_METHOD("set_device", "device"), &InputEvent::set_device); + ClassDB::bind_method(D_METHOD("get_device"), &InputEvent::get_device); + + ClassDB::bind_method(D_METHOD("is_pressed"), &InputEvent::is_pressed); + ClassDB::bind_method(D_METHOD("is_action", "action"), &InputEvent::is_action); + ClassDB::bind_method(D_METHOD("is_action_pressed", "action"), &InputEvent::is_action_pressed); + ClassDB::bind_method(D_METHOD("is_action_released", "action"), &InputEvent::is_action_released); + ClassDB::bind_method(D_METHOD("is_echo"), &InputEvent::is_echo); + + ClassDB::bind_method(D_METHOD("as_text"), &InputEvent::as_text); + + ClassDB::bind_method(D_METHOD("action_match", "event:InputEvent"), &InputEvent::action_match); + + ClassDB::bind_method(D_METHOD("is_action_type"), &InputEvent::is_action_type); + + ClassDB::bind_method(D_METHOD("xformed_by:InputEvent", "xform", "local_ofs"), &InputEvent::xformed_by, DEFVAL(Vector2())); +} + +InputEvent::InputEvent() { + + id = 0; + device = 0; +} + +////////////////// + +void InputEventWithModifiers::set_shift(bool p_enabled) { + + shift = p_enabled; +} + +bool InputEventWithModifiers::get_shift() const { + + return shift; +} + +void InputEventWithModifiers::set_alt(bool p_enabled) { + + alt = p_enabled; +} +bool InputEventWithModifiers::get_alt() const { + + return alt; +} + +void InputEventWithModifiers::set_control(bool p_enabled) { + + control = p_enabled; +} +bool InputEventWithModifiers::get_control() const { + + return control; +} + +void InputEventWithModifiers::set_metakey(bool p_enabled) { + + meta = p_enabled; +} +bool InputEventWithModifiers::get_metakey() const { + + return meta; +} + +void InputEventWithModifiers::set_command(bool p_enabled) { + + command = p_enabled; +} +bool InputEventWithModifiers::get_command() const { + + return command; +} + +void InputEventWithModifiers::_bind_methods() { + + ClassDB::bind_method(D_METHOD("set_alt", "enable"), &InputEventWithModifiers::set_alt); + ClassDB::bind_method(D_METHOD("get_alt"), &InputEventWithModifiers::get_alt); + + ClassDB::bind_method(D_METHOD("set_shift", "enable"), &InputEventWithModifiers::set_shift); + ClassDB::bind_method(D_METHOD("get_shift"), &InputEventWithModifiers::get_shift); + + ClassDB::bind_method(D_METHOD("set_control", "enable"), &InputEventWithModifiers::set_control); + ClassDB::bind_method(D_METHOD("get_control"), &InputEventWithModifiers::get_control); + + ClassDB::bind_method(D_METHOD("set_metakey", "enable"), &InputEventWithModifiers::set_metakey); + ClassDB::bind_method(D_METHOD("get_metakey"), &InputEventWithModifiers::get_metakey); + + ClassDB::bind_method(D_METHOD("set_command", "enable"), &InputEventWithModifiers::set_command); + ClassDB::bind_method(D_METHOD("get_command"), &InputEventWithModifiers::get_command); + + ADD_PROPERTY(PropertyInfo(Variant::BOOL, "alt"), "set_alt", "get_alt"); + ADD_PROPERTY(PropertyInfo(Variant::BOOL, "shift"), "set_shift", "get_shift"); + ADD_PROPERTY(PropertyInfo(Variant::BOOL, "control"), "set_control", "get_control"); + ADD_PROPERTY(PropertyInfo(Variant::BOOL, "meta"), "set_metakey", "get_metakey"); + ADD_PROPERTY(PropertyInfo(Variant::BOOL, "command"), "set_command", "get_command"); +} + +InputEventWithModifiers::InputEventWithModifiers() { + + alt = false; + shift = false; + control = false; + meta = false; +} + +////////////////////////////////// + +void InputEventKey::set_pressed(bool p_pressed) { - return (type == KEY && key.echo); + pressed = p_pressed; } -bool InputEvent::is_action(const String &p_action) const { +bool InputEventKey::is_pressed() const { - return InputMap::get_singleton()->event_is_action(*this, p_action); + return pressed; } -bool InputEvent::is_action_pressed(const String &p_action) const { +void InputEventKey::set_scancode(uint32_t p_scancode) { - return is_action(p_action) && is_pressed() && !is_echo(); + scancode = p_scancode; } +uint32_t InputEventKey::get_scancode() const { -bool InputEvent::is_action_released(const String &p_action) const { + return scancode; +} + +void InputEventKey::set_unicode(uint32_t p_unicode) { + + unicode = p_unicode; +} +uint32_t InputEventKey::get_unicode() const { + + return unicode; +} - return is_action(p_action) && !is_pressed(); +void InputEventKey::set_echo(bool p_enable) { + + echo = p_enable; +} +bool InputEventKey::is_echo() const { + + return echo; } uint32_t InputEventKey::get_scancode_with_modifiers() const { uint32_t sc = scancode; - if (mod.control) + if (get_control()) sc |= KEY_MASK_CTRL; - if (mod.alt) + if (get_alt()) sc |= KEY_MASK_ALT; - if (mod.shift) + if (get_shift()) sc |= KEY_MASK_SHIFT; - if (mod.meta) + if (get_metakey()) sc |= KEY_MASK_META; return sc; } -InputEvent InputEvent::xform_by(const Transform2D &p_xform) const { - - InputEvent ev = *this; - - switch (ev.type) { - - case InputEvent::MOUSE_BUTTON: { - - Vector2 g = p_xform.xform(Vector2(ev.mouse_button.global_x, ev.mouse_button.global_y)); - Vector2 l = p_xform.xform(Vector2(ev.mouse_button.x, ev.mouse_button.y)); - ev.mouse_button.x = l.x; - ev.mouse_button.y = l.y; - ev.mouse_button.global_x = g.x; - ev.mouse_button.global_y = g.y; - - } break; - case InputEvent::MOUSE_MOTION: { - - Vector2 g = p_xform.xform(Vector2(ev.mouse_motion.global_x, ev.mouse_motion.global_y)); - Vector2 l = p_xform.xform(Vector2(ev.mouse_motion.x, ev.mouse_motion.y)); - Vector2 r = p_xform.basis_xform(Vector2(ev.mouse_motion.relative_x, ev.mouse_motion.relative_y)); - Vector2 s = p_xform.basis_xform(Vector2(ev.mouse_motion.speed_x, ev.mouse_motion.speed_y)); - ev.mouse_motion.x = l.x; - ev.mouse_motion.y = l.y; - ev.mouse_motion.global_x = g.x; - ev.mouse_motion.global_y = g.y; - ev.mouse_motion.relative_x = r.x; - ev.mouse_motion.relative_y = r.y; - ev.mouse_motion.speed_x = s.x; - ev.mouse_motion.speed_y = s.y; - - } break; - case InputEvent::SCREEN_TOUCH: { - - Vector2 t = p_xform.xform(Vector2(ev.screen_touch.x, ev.screen_touch.y)); - ev.screen_touch.x = t.x; - ev.screen_touch.y = t.y; - - } break; - case InputEvent::SCREEN_DRAG: { - - Vector2 t = p_xform.xform(Vector2(ev.screen_drag.x, ev.screen_drag.y)); - Vector2 r = p_xform.basis_xform(Vector2(ev.screen_drag.relative_x, ev.screen_drag.relative_y)); - Vector2 s = p_xform.basis_xform(Vector2(ev.screen_drag.speed_x, ev.screen_drag.speed_y)); - ev.screen_drag.x = t.x; - ev.screen_drag.y = t.y; - ev.screen_drag.relative_x = r.x; - ev.screen_drag.relative_y = r.y; - ev.screen_drag.speed_x = s.x; - ev.screen_drag.speed_y = s.y; - } break; - } +bool InputEventKey::action_match(const Ref<InputEvent> &p_event) const { + + Ref<InputEventKey> key = p_event; + if (key.is_null()) + return false; + + uint32_t code = get_scancode_with_modifiers(); + uint32_t event_code = key->get_scancode_with_modifiers(); + + return get_scancode() == key->get_scancode() && (!key->is_pressed() || (code & event_code) == code); +} + +void InputEventKey::_bind_methods() { + + ClassDB::bind_method(D_METHOD("set_pressed", "pressed"), &InputEventKey::set_pressed); + + ClassDB::bind_method(D_METHOD("set_scancode", "scancode"), &InputEventKey::set_scancode); + ClassDB::bind_method(D_METHOD("get_scancode"), &InputEventKey::get_scancode); + + ClassDB::bind_method(D_METHOD("set_unicode", "unicode"), &InputEventKey::set_unicode); + ClassDB::bind_method(D_METHOD("get_unicode"), &InputEventKey::get_unicode); + + ClassDB::bind_method(D_METHOD("set_echo", "echo"), &InputEventKey::set_echo); + + ClassDB::bind_method(D_METHOD("get_scancode_with_modifiers"), &InputEventKey::get_scancode_with_modifiers); + + ADD_PROPERTY(PropertyInfo(Variant::BOOL, "pressed"), "set_pressed", "is_pressed"); + ADD_PROPERTY(PropertyInfo(Variant::INT, "scancode"), "set_scancode", "get_scancode"); + ADD_PROPERTY(PropertyInfo(Variant::INT, "unicode"), "set_unicode", "get_unicode"); + ADD_PROPERTY(PropertyInfo(Variant::INT, "echo"), "set_echo", "is_echo"); +} + +InputEventKey::InputEventKey() { + + pressed = false; + scancode = 0; + unicode = 0; ///unicode + echo = false; +} + +//////////////////////////////////////// + +void InputEventMouse::set_button_mask(int p_mask) { + + button_mask = p_mask; +} +int InputEventMouse::get_button_mask() const { + + return button_mask; +} + +void InputEventMouse::set_position(const Vector2 &p_pos) { + + pos = p_pos; +} +Vector2 InputEventMouse::get_position() const { + + return pos; +} + +void InputEventMouse::set_global_position(const Vector2 &p_global_pos) { + + global_pos = p_global_pos; +} +Vector2 InputEventMouse::get_global_position() const { + + return global_pos; +} + +void InputEventMouse::_bind_methods() { + + ClassDB::bind_method(D_METHOD("set_button_mask", "button_mask"), &InputEventMouse::set_button_mask); + ClassDB::bind_method(D_METHOD("get_button_mask"), &InputEventMouse::get_button_mask); + + ClassDB::bind_method(D_METHOD("set_position", "position"), &InputEventMouse::set_position); + ClassDB::bind_method(D_METHOD("get_position"), &InputEventMouse::get_position); + + ClassDB::bind_method(D_METHOD("set_global_position", "global_position"), &InputEventMouse::set_global_position); + ClassDB::bind_method(D_METHOD("get_global_position"), &InputEventMouse::get_global_position); + + ADD_PROPERTY(PropertyInfo(Variant::INT, "button_mask"), "set_button_mask", "get_button_mask"); + ADD_PROPERTY(PropertyInfo(Variant::VECTOR2, "position"), "set_position", "get_position"); + ADD_PROPERTY(PropertyInfo(Variant::VECTOR2, "global_position"), "set_global_position", "get_global_position"); +} + +InputEventMouse::InputEventMouse() { + + button_mask = 0; +} + +/////////////////////////////////////// + +void InputEventMouseButton::set_factor(float p_factor) { + + factor = p_factor; +} + +float InputEventMouseButton::get_factor() { + + return factor; +} + +void InputEventMouseButton::set_button_index(int p_index) { + + button_index = p_index; +} +int InputEventMouseButton::get_button_index() const { + + return button_index; +} + +void InputEventMouseButton::set_pressed(bool p_pressed) { + + pressed = p_pressed; +} +bool InputEventMouseButton::is_pressed() const { + + return pressed; +} + +void InputEventMouseButton::set_doubleclick(bool p_doubleclick) { + + doubleclick = p_doubleclick; +} +bool InputEventMouseButton::is_doubleclick() const { + + return doubleclick; +} + +Ref<InputEvent> InputEventMouseButton::xformed_by(const Transform2D &p_xform, const Vector2 &p_local_ofs) const { + + Vector2 g = p_xform.xform(get_global_position()); + Vector2 l = p_xform.xform(get_position() + p_local_ofs); + + Ref<InputEventMouseButton> mb; + mb.instance(); + + mb->set_id(get_id()); + mb->set_device(get_device()); + + mb->set_alt(get_alt()); + mb->set_shift(get_shift()); + mb->set_control(get_control()); + mb->set_metakey(get_metakey()); + + mb->set_position(l); + mb->set_global_position(g); + + mb->set_button_mask(get_button_mask()); + mb->set_pressed(pressed); + mb->set_doubleclick(doubleclick); + mb->set_factor(factor); + mb->set_button_index(button_index); + + return mb; +} + +bool InputEventMouseButton::action_match(const Ref<InputEvent> &p_event) const { + + Ref<InputEventMouseButton> mb = p_event; + if (mb.is_null()) + return false; + + return mb->button_index == button_index; +} + +void InputEventMouseButton::_bind_methods() { + + ClassDB::bind_method(D_METHOD("set_factor", "factor"), &InputEventMouseButton::set_factor); + ClassDB::bind_method(D_METHOD("get_factor"), &InputEventMouseButton::get_factor); + + ClassDB::bind_method(D_METHOD("set_button_index", "button_index"), &InputEventMouseButton::set_button_index); + ClassDB::bind_method(D_METHOD("get_button_index"), &InputEventMouseButton::get_button_index); + + ClassDB::bind_method(D_METHOD("set_pressed", "pressed"), &InputEventMouseButton::set_pressed); + // ClassDB::bind_method(D_METHOD("is_pressed"), &InputEventMouseButton::is_pressed); + + ClassDB::bind_method(D_METHOD("set_doubleclick", "doubleclick"), &InputEventMouseButton::set_doubleclick); + ClassDB::bind_method(D_METHOD("is_doubleclick"), &InputEventMouseButton::is_doubleclick); + + ADD_PROPERTY(PropertyInfo(Variant::REAL, "factor"), "set_factor", "get_factor"); + ADD_PROPERTY(PropertyInfo(Variant::INT, "button_index"), "set_button_index", "get_button_index"); + ADD_PROPERTY(PropertyInfo(Variant::BOOL, "pressed"), "set_pressed", "is_pressed"); + ADD_PROPERTY(PropertyInfo(Variant::BOOL, "doubleclick"), "set_doubleclick", "is_doubleclick"); +} + +InputEventMouseButton::InputEventMouseButton() { + + factor = 1; + button_index = 0; + pressed = false; + doubleclick = false; +} + +//////////////////////////////////////////// + +void InputEventMouseMotion::set_relative(const Vector2 &p_relative) { + + relative = p_relative; +} +Vector2 InputEventMouseMotion::get_relative() const { + + return relative; +} + +void InputEventMouseMotion::set_speed(const Vector2 &p_speed) { + + speed = p_speed; +} +Vector2 InputEventMouseMotion::get_speed() const { + + return speed; +} + +Ref<InputEvent> InputEventMouseMotion::xformed_by(const Transform2D &p_xform, const Vector2 &p_local_ofs) const { + + Vector2 g = p_xform.xform(get_global_position()); + Vector2 l = p_xform.xform(get_position() + p_local_ofs); + Vector2 r = p_xform.basis_xform(get_relative()); + Vector2 s = p_xform.basis_xform(get_speed()); + + Ref<InputEventMouseMotion> mm; + mm.instance(); + + mm->set_id(get_id()); + mm->set_device(get_device()); + + mm->set_alt(get_alt()); + mm->set_shift(get_shift()); + mm->set_control(get_control()); + mm->set_metakey(get_metakey()); + + mm->set_position(l); + mm->set_global_position(g); + + mm->set_button_mask(get_button_mask()); + mm->set_relative(r); + mm->set_speed(s); + + return mm; +} + +void InputEventMouseMotion::_bind_methods() { + + ClassDB::bind_method(D_METHOD("set_relative", "relative"), &InputEventMouseMotion::set_relative); + ClassDB::bind_method(D_METHOD("get_relative"), &InputEventMouseMotion::get_relative); + + ClassDB::bind_method(D_METHOD("set_speed", "speed"), &InputEventMouseMotion::set_speed); + ClassDB::bind_method(D_METHOD("get_speed"), &InputEventMouseMotion::get_speed); + + ADD_PROPERTY(PropertyInfo(Variant::VECTOR2, "relative"), "set_relative", "get_relative"); + ADD_PROPERTY(PropertyInfo(Variant::VECTOR2, "speed"), "set_speed", "get_speed"); +} + +InputEventMouseMotion::InputEventMouseMotion() { +} + +//////////////////////////////////////// + +void InputEventJoypadMotion::set_axis(int p_axis) { + + axis = p_axis; +} + +int InputEventJoypadMotion::get_axis() const { + + return axis; +} + +void InputEventJoypadMotion::set_axis_value(float p_value) { + + axis_value = p_value; +} +float InputEventJoypadMotion::get_axis_value() const { + + return axis_value; +} + +bool InputEventJoypadMotion::action_match(const Ref<InputEvent> &p_event) const { + + Ref<InputEventJoypadMotion> jm = p_event; + if (jm.is_null()) + return false; + + return (axis == jm->axis && (axis_value < 0) == (jm->axis_value < 0)); +} + +void InputEventJoypadMotion::_bind_methods() { + + ClassDB::bind_method(D_METHOD("set_axis", "axis"), &InputEventJoypadMotion::set_axis); + ClassDB::bind_method(D_METHOD("get_axis"), &InputEventJoypadMotion::get_axis); + + ClassDB::bind_method(D_METHOD("set_axis_value", "axis_value"), &InputEventJoypadMotion::set_axis_value); + ClassDB::bind_method(D_METHOD("get_axis_value"), &InputEventJoypadMotion::get_axis_value); + + ADD_PROPERTY(PropertyInfo(Variant::INT, "axis"), "set_axis", "get_axis"); + ADD_PROPERTY(PropertyInfo(Variant::REAL, "axis_value"), "set_axis_value", "get_axis_value"); +} + +InputEventJoypadMotion::InputEventJoypadMotion() { + + axis = 0; + axis_value = 0; +} +///////////////////////////////// + +void InputEventJoypadButton::set_button_index(int p_index) { + + button_index = p_index; +} + +int InputEventJoypadButton::get_button_index() const { + + return button_index; +} + +void InputEventJoypadButton::set_pressed(bool p_pressed) { + + pressed = p_pressed; +} +bool InputEventJoypadButton::is_pressed() const { + + return pressed; +} + +void InputEventJoypadButton::set_pressure(float p_pressure) { + + pressure = p_pressure; +} +float InputEventJoypadButton::get_pressure() const { + + return pressure; +} + +bool InputEventJoypadButton::action_match(const Ref<InputEvent> &p_event) const { + + Ref<InputEventJoypadButton> jb = p_event; + if (jb.is_null()) + return false; + + return button_index == jb->button_index; +} + +void InputEventJoypadButton::_bind_methods() { + + ClassDB::bind_method(D_METHOD("set_button_index", "button_index"), &InputEventJoypadButton::set_button_index); + ClassDB::bind_method(D_METHOD("get_button_index"), &InputEventJoypadButton::get_button_index); + + ClassDB::bind_method(D_METHOD("set_pressure", "pressure"), &InputEventJoypadButton::set_pressure); + ClassDB::bind_method(D_METHOD("get_pressure"), &InputEventJoypadButton::get_pressure); + + ClassDB::bind_method(D_METHOD("set_pressed", "pressed"), &InputEventJoypadButton::set_pressed); + // ClassDB::bind_method(D_METHOD("is_pressed"), &InputEventJoypadButton::is_pressed); + + ADD_PROPERTY(PropertyInfo(Variant::INT, "button_index"), "set_button_index", "get_button_index"); + ADD_PROPERTY(PropertyInfo(Variant::REAL, "pressure"), "set_pressure", "get_pressure"); + ADD_PROPERTY(PropertyInfo(Variant::BOOL, "pressed"), "set_pressed", "is_pressed"); +} + +InputEventJoypadButton::InputEventJoypadButton() { + + button_index = 0; + pressure = 0; + pressed = false; +} + +////////////////////////////////////////////// + +void InputEventScreenTouch::set_index(int p_index) { + + index = p_index; +} +int InputEventScreenTouch::get_index() const { + + return index; +} + +void InputEventScreenTouch::set_position(const Vector2 &p_pos) { + + pos = p_pos; +} +Vector2 InputEventScreenTouch::get_position() const { + + return pos; +} + +void InputEventScreenTouch::set_pressed(bool p_pressed) { + + pressed = p_pressed; +} +bool InputEventScreenTouch::is_pressed() const { + + return pressed; +} + +Ref<InputEvent> InputEventScreenTouch::xformed_by(const Transform2D &p_xform, const Vector2 &p_local_ofs) const { + + Ref<InputEventScreenTouch> st; + st.instance(); + st->set_id(get_id()); + st->set_device(get_device()); + st->set_index(index); + st->set_position(p_xform.xform(pos + p_local_ofs)); + st->set_pressed(pressed); + + return st; +} + +void InputEventScreenTouch::_bind_methods() { + + ClassDB::bind_method(D_METHOD("set_index", "index"), &InputEventScreenTouch::set_index); + ClassDB::bind_method(D_METHOD("get_index"), &InputEventScreenTouch::get_index); + + ClassDB::bind_method(D_METHOD("set_position", "pos"), &InputEventScreenTouch::set_position); + ClassDB::bind_method(D_METHOD("get_position"), &InputEventScreenTouch::get_position); + + ClassDB::bind_method(D_METHOD("set_pressed", "pressed"), &InputEventScreenTouch::set_pressed); + //ClassDB::bind_method(D_METHOD("is_pressed"),&InputEventScreenTouch::is_pressed); + + ADD_PROPERTY(PropertyInfo(Variant::INT, "index"), "set_index", "get_index"); + ADD_PROPERTY(PropertyInfo(Variant::VECTOR2, "position"), "set_position", "get_position"); + ADD_PROPERTY(PropertyInfo(Variant::BOOL, "pressed"), "set_pressed", "is_pressed"); +} + +InputEventScreenTouch::InputEventScreenTouch() { + + index = 0; + pressed = false; +} + +///////////////////////////// + +void InputEventScreenDrag::set_index(int p_index) { + + index = p_index; +} + +int InputEventScreenDrag::get_index() const { + + return index; +} + +void InputEventScreenDrag::set_position(const Vector2 &p_pos) { + + pos = p_pos; +} +Vector2 InputEventScreenDrag::get_position() const { + + return pos; +} + +void InputEventScreenDrag::set_relative(const Vector2 &p_relative) { + + relative = p_relative; +} +Vector2 InputEventScreenDrag::get_relative() const { + + return relative; +} + +void InputEventScreenDrag::set_speed(const Vector2 &p_speed) { + + speed = p_speed; +} +Vector2 InputEventScreenDrag::get_speed() const { + + return speed; +} + +Ref<InputEvent> InputEventScreenDrag::xformed_by(const Transform2D &p_xform, const Vector2 &p_local_ofs) const { + + Ref<InputEventScreenDrag> sd; + + sd.instance(); + + sd->set_id(get_id()); + sd->set_device(get_device()); + + sd->set_index(index); + sd->set_position(p_xform.xform(pos + p_local_ofs)); + sd->set_relative(p_xform.basis_xform(relative)); + sd->set_speed(p_xform.basis_xform(speed)); + + return sd; +} + +void InputEventScreenDrag::_bind_methods() { + + ClassDB::bind_method(D_METHOD("set_index", "index"), &InputEventScreenDrag::set_index); + ClassDB::bind_method(D_METHOD("get_index"), &InputEventScreenDrag::get_index); + + ClassDB::bind_method(D_METHOD("set_position", "position"), &InputEventScreenDrag::set_position); + ClassDB::bind_method(D_METHOD("get_position"), &InputEventScreenDrag::get_position); + + ClassDB::bind_method(D_METHOD("set_relative", "relative"), &InputEventScreenDrag::set_relative); + ClassDB::bind_method(D_METHOD("get_relative"), &InputEventScreenDrag::get_relative); + + ClassDB::bind_method(D_METHOD("set_speed", "speed"), &InputEventScreenDrag::set_speed); + ClassDB::bind_method(D_METHOD("get_speed"), &InputEventScreenDrag::get_speed); + + ADD_PROPERTY(PropertyInfo(Variant::INT, "index"), "set_index", "get_index"); + ADD_PROPERTY(PropertyInfo(Variant::VECTOR2, "position"), "set_position", "get_position"); + ADD_PROPERTY(PropertyInfo(Variant::VECTOR2, "relative"), "set_relative", "get_relative"); + ADD_PROPERTY(PropertyInfo(Variant::VECTOR2, "speed"), "set_speed", "get_speed"); +} + +InputEventScreenDrag::InputEventScreenDrag() { + + index = 0; +} +///////////////////////////// + +void InputEventAction::set_action(const StringName &p_action) { + + action = p_action; +} +StringName InputEventAction::get_action() const { + + return action; +} + +void InputEventAction::set_pressed(bool p_pressed) { + + pressed = p_pressed; +} +bool InputEventAction::is_pressed() const { + + return pressed; +} + +bool InputEventAction::is_action(const StringName &p_action) const { + + return action == p_action; +} + +void InputEventAction::_bind_methods() { + + ClassDB::bind_method(D_METHOD("set_action", "action"), &InputEventAction::set_action); + ClassDB::bind_method(D_METHOD("get_action"), &InputEventAction::get_action); + + ClassDB::bind_method(D_METHOD("set_pressed", "pressed"), &InputEventAction::set_pressed); + //ClassDB::bind_method(D_METHOD("is_pressed"), &InputEventAction::is_pressed); + + // ClassDB::bind_method(D_METHOD("is_action", "name"), &InputEventAction::is_action); + + ADD_PROPERTY(PropertyInfo(Variant::STRING, "action"), "set_action", "get_action"); + ADD_PROPERTY(PropertyInfo(Variant::BOOL, "pressed"), "set_pressed", "is_pressed"); +} - return ev; +InputEventAction::InputEventAction() { + pressed = false; } diff --git a/core/os/input_event.h b/core/os/input_event.h index eb5c5685e5..6a694df345 100644 --- a/core/os/input_event.h +++ b/core/os/input_event.h @@ -32,6 +32,7 @@ #include "math_2d.h" #include "os/copymem.h" +#include "resource.h" #include "typedefs.h" #include "ustring.h" /** @@ -137,7 +138,40 @@ enum { * Input Modifier Status * for keyboard/mouse events. */ -struct InputModifierState { + +class InputEvent : public Resource { + GDCLASS(InputEvent, Resource) + + uint32_t id; + int device; + +protected: + static void _bind_methods(); + +public: + void set_id(uint32_t p_id); + uint32_t get_id() const; + + void set_device(int p_device); + int get_device() const; + + virtual bool is_pressed() const; + virtual bool is_action(const StringName &p_action) const; + virtual bool is_action_pressed(const StringName &p_action) const; + virtual bool is_action_released(const StringName &p_action) const; + virtual bool is_echo() const; + virtual String as_text() const; + + virtual Ref<InputEvent> xformed_by(const Transform2D &p_xform, const Vector2 &p_local_ofs = Vector2()) const; + + virtual bool action_match(const Ref<InputEvent> &p_event) const; + virtual bool is_action_type() const; + + InputEvent(); +}; + +class InputEventWithModifiers : public InputEvent { + GDCLASS(InputEventWithModifiers, InputEvent) bool shift; bool alt; @@ -157,122 +191,267 @@ struct InputModifierState { #endif - bool operator==(const InputModifierState &rvalue) const { +protected: + static void _bind_methods(); + +public: + void set_shift(bool p_enabled); + bool get_shift() const; + + void set_alt(bool p_enabled); + bool get_alt() const; + + void set_control(bool p_enabled); + bool get_control() const; + + void set_metakey(bool p_enabled); + bool get_metakey() const; - return ((shift == rvalue.shift) && (alt == rvalue.alt) && (control == rvalue.control) && (meta == rvalue.meta)); - } + void set_command(bool p_enabled); + bool get_command() const; + + InputEventWithModifiers(); }; -struct InputEventKey { +class InputEventKey : public InputEventWithModifiers { - InputModifierState mod; + GDCLASS(InputEventKey, InputEventWithModifiers) bool pressed; /// otherwise release uint32_t scancode; ///< check keyboard.h , KeyCode enum, without modifier masks uint32_t unicode; ///unicode + bool echo; /// true if this is an echo key + +protected: + static void _bind_methods(); + +public: + void set_pressed(bool p_pressed); + virtual bool is_pressed() const; + + void set_scancode(uint32_t p_scancode); + uint32_t get_scancode() const; + + void set_unicode(uint32_t p_unicode); + uint32_t get_unicode() const; + + void set_echo(bool p_enable); + virtual bool is_echo() const; + uint32_t get_scancode_with_modifiers() const; - bool echo; /// true if this is an echo key + virtual bool action_match(const Ref<InputEvent> &p_event) const; + + virtual bool is_action_type() const { return true; } + + InputEventKey(); }; -struct InputEventMouse { +class InputEventMouse : public InputEventWithModifiers { + + GDCLASS(InputEventMouse, InputEventWithModifiers) - InputModifierState mod; int button_mask; - float x, y; - float global_x, global_y; - int pointer_index; + + Vector2 pos; + Vector2 global_pos; + +protected: + static void _bind_methods(); + +public: + void set_button_mask(int p_mask); + int get_button_mask() const; + + void set_position(const Vector2 &p_pos); + Vector2 get_position() const; + + void set_global_position(const Vector2 &p_global_pos); + Vector2 get_global_position() const; + + InputEventMouse(); }; -struct InputEventMouseButton : public InputEventMouse { +class InputEventMouseButton : public InputEventMouse { + + GDCLASS(InputEventMouseButton, InputEventMouse) + float factor; int button_index; bool pressed; //otherwise released bool doubleclick; //last even less than doubleclick time + +protected: + static void _bind_methods(); + +public: + void set_factor(float p_factor); + float get_factor(); + + void set_button_index(int p_index); + int get_button_index() const; + + void set_pressed(bool p_pressed); + virtual bool is_pressed() const; + + void set_doubleclick(bool p_doubleclick); + bool is_doubleclick() const; + + virtual Ref<InputEvent> xformed_by(const Transform2D &p_xform, const Vector2 &p_local_ofs = Vector2()) const; + virtual bool action_match(const Ref<InputEvent> &p_event) const; + + virtual bool is_action_type() const { return true; } + + InputEventMouseButton(); }; -struct InputEventMouseMotion : public InputEventMouse { +class InputEventMouseMotion : public InputEventMouse { + + GDCLASS(InputEventMouseMotion, InputEventMouse) + Vector2 relative; + Vector2 speed; + +protected: + static void _bind_methods(); + +public: + void set_relative(const Vector2 &p_relative); + Vector2 get_relative() const; + + void set_speed(const Vector2 &p_speed); + Vector2 get_speed() const; + + virtual Ref<InputEvent> xformed_by(const Transform2D &p_xform, const Vector2 &p_local_ofs = Vector2()) const; - float relative_x, relative_y; - float speed_x, speed_y; + InputEventMouseMotion(); }; -struct InputEventJoypadMotion { +class InputEventJoypadMotion : public InputEvent { + GDCLASS(InputEventJoypadMotion, InputEvent) int axis; ///< Joypad axis float axis_value; ///< -1 to 1 + +protected: + static void _bind_methods(); + +public: + void set_axis(int p_axis); + int get_axis() const; + + void set_axis_value(float p_value); + float get_axis_value() const; + + virtual bool action_match(const Ref<InputEvent> &p_event) const; + + virtual bool is_action_type() const { return true; } + + InputEventJoypadMotion(); }; -struct InputEventJoypadButton { +class InputEventJoypadButton : public InputEvent { + GDCLASS(InputEventJoypadButton, InputEvent) int button_index; bool pressed; float pressure; //0 to 1 -}; +protected: + static void _bind_methods(); + +public: + void set_button_index(int p_index); + int get_button_index() const; + + void set_pressed(bool p_pressed); + virtual bool is_pressed() const; + + void set_pressure(float p_pressure); + float get_pressure() const; -struct InputEventScreenTouch { + virtual bool action_match(const Ref<InputEvent> &p_event) const; + virtual bool is_action_type() const { return true; } + + InputEventJoypadButton(); +}; + +class InputEventScreenTouch : public InputEvent { + GDCLASS(InputEventScreenTouch, InputEvent) int index; - float x, y; + Vector2 pos; bool pressed; + +protected: + static void _bind_methods(); + +public: + void set_index(int p_index); + int get_index() const; + + void set_position(const Vector2 &p_pos); + Vector2 get_position() const; + + void set_pressed(bool p_pressed); + virtual bool is_pressed() const; + + virtual Ref<InputEvent> xformed_by(const Transform2D &p_xform, const Vector2 &p_local_ofs = Vector2()) const; + + InputEventScreenTouch(); }; -struct InputEventScreenDrag { +class InputEventScreenDrag : public InputEvent { + + GDCLASS(InputEventScreenDrag, InputEvent) int index; - float x, y; - float relative_x, relative_y; - float speed_x, speed_y; + Vector2 pos; + Vector2 relative; + Vector2 speed; + +protected: + static void _bind_methods(); + +public: + void set_index(int p_index); + int get_index() const; + + void set_position(const Vector2 &p_pos); + Vector2 get_position() const; + + void set_relative(const Vector2 &p_relative); + Vector2 get_relative() const; + + void set_speed(const Vector2 &p_speed); + Vector2 get_speed() const; + + virtual Ref<InputEvent> xformed_by(const Transform2D &p_xform, const Vector2 &p_local_ofs = Vector2()) const; + + InputEventScreenDrag(); }; -struct InputEventAction { +class InputEventAction : public InputEvent { + + GDCLASS(InputEventAction, InputEvent) - int action; + StringName action; bool pressed; -}; -struct InputEvent { - - enum Type { - NONE, - KEY, - MOUSE_MOTION, - MOUSE_BUTTON, - JOYPAD_MOTION, - JOYPAD_BUTTON, - SCREEN_TOUCH, - SCREEN_DRAG, - ACTION, - TYPE_MAX - }; +protected: + static void _bind_methods(); - uint32_t ID; - int type; - int device; +public: + void set_action(const StringName &p_action); + StringName get_action() const; - union { - InputEventMouseMotion mouse_motion; - InputEventMouseButton mouse_button; - InputEventJoypadMotion joy_motion; - InputEventJoypadButton joy_button; - InputEventKey key; - InputEventScreenTouch screen_touch; - InputEventScreenDrag screen_drag; - InputEventAction action; - }; + void set_pressed(bool p_pressed); + virtual bool is_pressed() const; + + virtual bool is_action(const StringName &p_action) const; + + virtual bool is_action_type() const { return true; } - bool is_pressed() const; - bool is_action(const String &p_action) const; - bool is_action_pressed(const String &p_action) const; - bool is_action_released(const String &p_action) const; - bool is_echo() const; - void set_as_action(const String &p_action, bool p_pressed); - - InputEvent xform_by(const Transform2D &p_xform) const; - bool operator==(const InputEvent &p_event) const; - operator String() const; - InputEvent() { zeromem(this, sizeof(InputEvent)); } + InputEventAction(); }; #endif diff --git a/core/os/main_loop.cpp b/core/os/main_loop.cpp index 9f8fcccd82..248f5537c6 100644 --- a/core/os/main_loop.cpp +++ b/core/os/main_loop.cpp @@ -39,7 +39,7 @@ void MainLoop::_bind_methods() { ClassDB::bind_method(D_METHOD("idle", "delta"), &MainLoop::idle); ClassDB::bind_method(D_METHOD("finish"), &MainLoop::finish); - BIND_VMETHOD(MethodInfo("_input_event", PropertyInfo(Variant::INPUT_EVENT, "ev"))); + BIND_VMETHOD(MethodInfo("_input_event", PropertyInfo(Variant::OBJECT, "ev", PROPERTY_HINT_RESOURCE_TYPE, "InputEvent"))); BIND_VMETHOD(MethodInfo("_input_text", PropertyInfo(Variant::STRING, "text"))); BIND_VMETHOD(MethodInfo("_initialize")); BIND_VMETHOD(MethodInfo("_iteration", PropertyInfo(Variant::REAL, "delta"))); @@ -73,7 +73,7 @@ void MainLoop::input_text(const String &p_text) { get_script_instance()->call("_input_text", p_text); } -void MainLoop::input_event(const InputEvent &p_event) { +void MainLoop::input_event(const Ref<InputEvent> &p_event) { if (get_script_instance()) get_script_instance()->call("_input_event", p_event); diff --git a/core/os/main_loop.h b/core/os/main_loop.h index a53137afa4..23b352468e 100644 --- a/core/os/main_loop.h +++ b/core/os/main_loop.h @@ -59,7 +59,7 @@ public: NOTIFICATION_TRANSLATION_CHANGED = 10, }; - virtual void input_event(const InputEvent &p_event); + virtual void input_event(const Ref<InputEvent> &p_event); virtual void input_text(const String &p_text); virtual void init(); diff --git a/core/os/os.cpp b/core/os/os.cpp index e323e03829..8bee725813 100644 --- a/core/os/os.cpp +++ b/core/os/os.cpp @@ -389,7 +389,7 @@ void OS::_ensure_data_dir() { memdelete(da); } -void OS::set_icon(const Image &p_icon) { +void OS::set_icon(const Ref<Image> &p_icon) { } String OS::get_model_name() const { diff --git a/core/os/os.h b/core/os/os.h index ff2a24f40d..11fe8b44e3 100644 --- a/core/os/os.h +++ b/core/os/os.h @@ -31,6 +31,7 @@ #define OS_H #include "engine.h" +#include "image.h" #include "list.h" #include "os/main_loop.h" #include "power.h" @@ -357,7 +358,7 @@ public: virtual void make_rendering_thread(); virtual void swap_buffers(); - virtual void set_icon(const Image &p_icon); + virtual void set_icon(const Ref<Image> &p_icon); virtual int get_exit_code() const; virtual void set_exit_code(int p_code); @@ -412,4 +413,6 @@ public: virtual ~OS(); }; +VARIANT_ENUM_CAST(PowerState); + #endif |