mirror of
https://github.com/Relintai/sfw.git
synced 2025-03-11 23:39:09 +01:00
Added input classes to the build and made them compile.
This commit is contained in:
parent
9aad8379a1
commit
116a7d0eaf
@ -63,6 +63,11 @@ ccache g++ -Wall -D_REENTRANT -g -Isfw -c sfw/render_core/texture.cpp -o sfw/ren
|
||||
ccache g++ -Wall -D_REENTRANT -g -Isfw -c sfw/render_core/image.cpp -o sfw/render_core/image.o
|
||||
ccache g++ -Wall -D_REENTRANT -g -Isfw -c sfw/render_core/render_state.cpp -o sfw/render_core/render_state.o
|
||||
ccache g++ -Wall -D_REENTRANT -g -Isfw -c sfw/render_core/input/keyboard.cpp -o sfw/render_core/input/keyboard.o
|
||||
ccache g++ -Wall -D_REENTRANT -g -Isfw -c sfw/render_core/input/default_controller_mappings.gen.cpp -o sfw/render_core/input/default_controller_mappings.gen.o
|
||||
ccache g++ -Wall -D_REENTRANT -g -Isfw -c sfw/render_core/input/input_event.cpp -o sfw/render_core/input/input_event.o
|
||||
ccache g++ -Wall -D_REENTRANT -g -Isfw -c sfw/render_core/input/input_map.cpp -o sfw/render_core/input/input_map.o
|
||||
ccache g++ -Wall -D_REENTRANT -g -Isfw -c sfw/render_core/input/input.cpp -o sfw/render_core/input/input.o
|
||||
ccache g++ -Wall -D_REENTRANT -g -Isfw -c sfw/render_core/input/shortcut.cpp -o sfw/render_core/input/shortcut.o
|
||||
|
||||
ccache g++ -Wall -D_REENTRANT -g -Isfw -c sfw/render_objects/camera_3d.cpp -o sfw/render_objects/camera_3d.o
|
||||
ccache g++ -Wall -D_REENTRANT -g -Isfw -c sfw/render_objects/object_3d.cpp -o sfw/render_objects/object_3d.o
|
||||
@ -94,7 +99,9 @@ ccache g++ -Wall -lm -ldl -lpthread -lX11 -D_REENTRANT -g sfw/core/aabb.o sfw/c
|
||||
sfw/render_core/application.o sfw/render_core/scene.o sfw/render_core/window.o \
|
||||
sfw/render_core/shader.o sfw/render_core/material.o sfw/render_core/mesh.o \
|
||||
sfw/render_core/mesh_utils.o sfw/render_core/texture.o \
|
||||
sfw/render_core/input/keyboard.o \
|
||||
sfw/render_core/input/input_event.o sfw/render_core/input/input_map.o \
|
||||
sfw/render_core/input/input.o sfw/render_core/input/shortcut.o \
|
||||
sfw/render_core/input/keyboard.o sfw/render_core/input/default_controller_mappings.gen.o \
|
||||
sfw/render_objects/camera_3d.o sfw/render_objects/object_3d.o sfw/render_objects/mesh_instance_3d.o \
|
||||
sfw/render_objects/object_2d.o \
|
||||
sfw/render_objects/sprite.o sfw/render_objects/tile_map.o \
|
||||
@ -102,5 +109,4 @@ ccache g++ -Wall -lm -ldl -lpthread -lX11 -D_REENTRANT -g sfw/core/aabb.o sfw/c
|
||||
game_scene.o main.o \
|
||||
-o game
|
||||
|
||||
|
||||
#export args="-lm -ldl -lpthread -lX11 -w -Iengine/ $args"
|
16
sfw/core/thread_safe.h
Normal file
16
sfw/core/thread_safe.h
Normal file
@ -0,0 +1,16 @@
|
||||
#ifndef THREAD_SAFE_H
|
||||
#define THREAD_SAFE_H
|
||||
|
||||
/*************************************************************************/
|
||||
/* thread_safe.h */
|
||||
/* From https://github.com/Relintai/pandemonium_engine (MIT) */
|
||||
/*************************************************************************/
|
||||
|
||||
#include "core/mutex.h"
|
||||
|
||||
#define _THREAD_SAFE_CLASS_ mutable Mutex _thread_safe_;
|
||||
#define _THREAD_SAFE_METHOD_ MutexLock _thread_safe_method_(_thread_safe_);
|
||||
#define _THREAD_SAFE_LOCK_ _thread_safe_.lock();
|
||||
#define _THREAD_SAFE_UNLOCK_ _thread_safe_.unlock();
|
||||
|
||||
#endif
|
@ -4,8 +4,8 @@
|
||||
|
||||
#include "render_core/window.h"
|
||||
|
||||
void Application::event() {
|
||||
scene->event();
|
||||
void Application::input_event(const Ref<InputEvent> &event) {
|
||||
scene->input_event(event);
|
||||
}
|
||||
|
||||
void Application::update(float delta) {
|
||||
|
@ -1,36 +1,59 @@
|
||||
#ifndef APPLICATION_H
|
||||
#define APPLICATION_H
|
||||
|
||||
#include "core/int_types.h"
|
||||
#include <stdio.h>
|
||||
|
||||
#include "object/object.h"
|
||||
#include "object/reference.h"
|
||||
|
||||
#include "render_core/scene.h"
|
||||
|
||||
class AppWindow;
|
||||
class InputEvent;
|
||||
|
||||
class Application : Object {
|
||||
SFW_OBJECT(Application, Object);
|
||||
|
||||
class Application {
|
||||
public:
|
||||
bool running;
|
||||
int target_fps;
|
||||
bool running;
|
||||
int target_fps;
|
||||
|
||||
virtual void event();
|
||||
virtual void update(float delta);
|
||||
virtual void render();
|
||||
virtual void input_event(const Ref<InputEvent> &event);
|
||||
virtual void update(float delta);
|
||||
virtual void render();
|
||||
|
||||
void main_loop();
|
||||
uint64_t get_idle_frames() const {
|
||||
return _idle_frames;
|
||||
}
|
||||
|
||||
Application();
|
||||
virtual ~Application();
|
||||
uint64_t get_physics_frames() const {
|
||||
return _physics_frames;
|
||||
}
|
||||
|
||||
Scene *scene;
|
||||
bool is_in_physics_frame() const {
|
||||
return _is_in_physics_frame;
|
||||
}
|
||||
|
||||
AppWindow *window;
|
||||
void main_loop();
|
||||
|
||||
static Application *get_singleton();
|
||||
Application();
|
||||
virtual ~Application();
|
||||
|
||||
double frame_delta;
|
||||
Scene *scene;
|
||||
|
||||
AppWindow *window;
|
||||
|
||||
static Application *get_singleton();
|
||||
|
||||
double frame_delta;
|
||||
|
||||
protected:
|
||||
static Application * _instance;
|
||||
static Application *_instance;
|
||||
|
||||
uint64_t _idle_frames;
|
||||
uint64_t _physics_frames;
|
||||
bool _is_in_physics_frame;
|
||||
};
|
||||
|
||||
#endif // APPLICATION_H
|
||||
|
@ -1,6 +1,6 @@
|
||||
/* THIS FILE IS GENERATED DO NOT EDIT */
|
||||
#include "core/typedefs.h"
|
||||
#include "core/input/default_controller_mappings.h"
|
||||
#include "render_core/input/default_controller_mappings.h"
|
||||
const char* DefaultControllerMappings::mappings[] = {
|
||||
#ifdef WINDOWS_ENABLED
|
||||
"03000000300f00000a01000000000000,3 In 1 Conversion Box,a:b2,b:b1,back:b9,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b10,lefttrigger:b4,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b11,righttrigger:b5,rightx:a3,righty:a2,start:b8,x:b3,y:b0,platform:Windows,",
|
||||
|
@ -5,37 +5,39 @@
|
||||
|
||||
#include "input.h"
|
||||
|
||||
#include "core/config/project_settings.h"
|
||||
#include "core/input/default_controller_mappings.h"
|
||||
#include "core/input/input_map.h"
|
||||
#include "core/os/os.h"
|
||||
#include "scene/resources/texture.h"
|
||||
#include "servers/rendering_server.h"
|
||||
#include "render_core/input/default_controller_mappings.h"
|
||||
#include "render_core/input/input_map.h"
|
||||
#include "render_core/texture.h"
|
||||
#include "render_core/application.h"
|
||||
#include "render_core/window.h"
|
||||
#include "core/stime.h"
|
||||
#include "core/logger.h"
|
||||
|
||||
Input *Input::get_singleton() {
|
||||
return singleton;
|
||||
}
|
||||
|
||||
void Input::set_mouse_mode(MouseMode p_mode) {
|
||||
ERR_FAIL_INDEX((int)p_mode, 4);
|
||||
OS::get_singleton()->set_mouse_mode((OS::MouseMode)p_mode);
|
||||
//ERR_FAIL_INDEX((int)p_mode, 4);
|
||||
//OS::get_singleton()->set_mouse_mode((OS::MouseMode)p_mode);
|
||||
}
|
||||
|
||||
Input::MouseMode Input::get_mouse_mode() const {
|
||||
return (MouseMode)OS::get_singleton()->get_mouse_mode();
|
||||
//return (MouseMode)OS::get_singleton()->get_mouse_mode();
|
||||
return MOUSE_MODE_VISIBLE;
|
||||
}
|
||||
|
||||
bool InputDefault::is_key_pressed(int p_scancode) const {
|
||||
bool Input::is_key_pressed(int p_scancode) const {
|
||||
_THREAD_SAFE_METHOD_
|
||||
return keys_pressed.has(p_scancode);
|
||||
}
|
||||
|
||||
bool InputDefault::is_physical_key_pressed(int p_scancode) const {
|
||||
bool Input::is_physical_key_pressed(int p_scancode) const {
|
||||
_THREAD_SAFE_METHOD_
|
||||
return physical_keys_pressed.has(p_scancode);
|
||||
}
|
||||
|
||||
bool InputDefault::is_mouse_button_pressed(int p_button) const {
|
||||
bool Input::is_mouse_button_pressed(int p_button) const {
|
||||
_THREAD_SAFE_METHOD_
|
||||
return (mouse_button_mask & (1 << (p_button - 1))) != 0;
|
||||
}
|
||||
@ -44,17 +46,17 @@ static int _combine_device(int p_value, int p_device) {
|
||||
return p_value | (p_device << 20);
|
||||
}
|
||||
|
||||
bool InputDefault::is_joy_button_pressed(int p_device, int p_button) const {
|
||||
bool Input::is_joy_button_pressed(int p_device, int p_button) const {
|
||||
_THREAD_SAFE_METHOD_
|
||||
return joy_buttons_pressed.has(_combine_device(p_button, p_device));
|
||||
}
|
||||
|
||||
bool InputDefault::is_action_pressed(const StringName &p_action, bool p_exact) const {
|
||||
bool Input::is_action_pressed(const StringName &p_action, bool p_exact) const {
|
||||
ERR_FAIL_COND_V_MSG(!InputMap::get_singleton()->has_action(p_action), false, InputMap::get_singleton()->suggest_actions(p_action));
|
||||
return action_state.has(p_action) && action_state[p_action].pressed && (p_exact ? action_state[p_action].exact : true);
|
||||
}
|
||||
|
||||
bool InputDefault::is_action_just_pressed(const StringName &p_action, bool p_exact) const {
|
||||
bool Input::is_action_just_pressed(const StringName &p_action, bool p_exact) const {
|
||||
ERR_FAIL_COND_V_MSG(!InputMap::get_singleton()->has_action(p_action), false, InputMap::get_singleton()->suggest_actions(p_action));
|
||||
const RBMap<StringName, Action>::Element *E = action_state.find(p_action);
|
||||
if (!E) {
|
||||
@ -68,14 +70,14 @@ bool InputDefault::is_action_just_pressed(const StringName &p_action, bool p_exa
|
||||
// Backward compatibility for legacy behavior, only return true if currently pressed.
|
||||
bool pressed_requirement = legacy_just_pressed_behavior ? E->get().pressed : true;
|
||||
|
||||
if (Engine::get_singleton()->is_in_physics_frame()) {
|
||||
return pressed_requirement && E->get().pressed_physics_frame == Engine::get_singleton()->get_physics_frames();
|
||||
if (Application::get_singleton()->is_in_physics_frame()) {
|
||||
return pressed_requirement && E->get().pressed_physics_frame == Application::get_singleton()->get_physics_frames();
|
||||
} else {
|
||||
return pressed_requirement && E->get().pressed_idle_frame == Engine::get_singleton()->get_idle_frames();
|
||||
return pressed_requirement && E->get().pressed_idle_frame == Application::get_singleton()->get_idle_frames();
|
||||
}
|
||||
}
|
||||
|
||||
bool InputDefault::is_action_just_released(const StringName &p_action, bool p_exact) const {
|
||||
bool Input::is_action_just_released(const StringName &p_action, bool p_exact) const {
|
||||
ERR_FAIL_COND_V_MSG(!InputMap::get_singleton()->has_action(p_action), false, InputMap::get_singleton()->suggest_actions(p_action));
|
||||
const RBMap<StringName, Action>::Element *E = action_state.find(p_action);
|
||||
if (!E) {
|
||||
@ -89,14 +91,14 @@ bool InputDefault::is_action_just_released(const StringName &p_action, bool p_ex
|
||||
// Backward compatibility for legacy behavior, only return true if currently released.
|
||||
bool released_requirement = legacy_just_pressed_behavior ? !E->get().pressed : true;
|
||||
|
||||
if (Engine::get_singleton()->is_in_physics_frame()) {
|
||||
return released_requirement && E->get().released_physics_frame == Engine::get_singleton()->get_physics_frames();
|
||||
if (Application::get_singleton()->is_in_physics_frame()) {
|
||||
return released_requirement && E->get().released_physics_frame == Application::get_singleton()->get_physics_frames();
|
||||
} else {
|
||||
return released_requirement && E->get().released_idle_frame == Engine::get_singleton()->get_idle_frames();
|
||||
return released_requirement && E->get().released_idle_frame == Application::get_singleton()->get_idle_frames();
|
||||
}
|
||||
}
|
||||
|
||||
float InputDefault::get_action_strength(const StringName &p_action, bool p_exact) const {
|
||||
float Input::get_action_strength(const StringName &p_action, bool p_exact) const {
|
||||
ERR_FAIL_COND_V_MSG(!InputMap::get_singleton()->has_action(p_action), 0.0, InputMap::get_singleton()->suggest_actions(p_action));
|
||||
const RBMap<StringName, Action>::Element *E = action_state.find(p_action);
|
||||
if (!E) {
|
||||
@ -110,7 +112,7 @@ float InputDefault::get_action_strength(const StringName &p_action, bool p_exact
|
||||
return E->get().strength;
|
||||
}
|
||||
|
||||
float InputDefault::get_action_raw_strength(const StringName &p_action, bool p_exact) const {
|
||||
float Input::get_action_raw_strength(const StringName &p_action, bool p_exact) const {
|
||||
ERR_FAIL_COND_V_MSG(!InputMap::get_singleton()->has_action(p_action), 0.0, InputMap::get_singleton()->suggest_actions(p_action));
|
||||
const RBMap<StringName, Action>::Element *E = action_state.find(p_action);
|
||||
if (!E) {
|
||||
@ -155,7 +157,7 @@ Vector2 Input::get_vector(const StringName &p_negative_x, const StringName &p_po
|
||||
return vector;
|
||||
}
|
||||
|
||||
float InputDefault::get_joy_axis(int p_device, int p_axis) const {
|
||||
float Input::get_joy_axis(int p_device, int p_axis) const {
|
||||
_THREAD_SAFE_METHOD_
|
||||
int c = _combine_device(p_axis, p_device);
|
||||
if (_joy_axis.has(c)) {
|
||||
@ -165,12 +167,12 @@ float InputDefault::get_joy_axis(int p_device, int p_axis) const {
|
||||
}
|
||||
}
|
||||
|
||||
String InputDefault::get_joy_name(int p_idx) {
|
||||
String Input::get_joy_name(int p_idx) {
|
||||
_THREAD_SAFE_METHOD_
|
||||
return joy_names[p_idx].name;
|
||||
};
|
||||
|
||||
Array InputDefault::get_connected_joypads() {
|
||||
Array Input::get_connected_joypads() {
|
||||
Array ret;
|
||||
RBMap<int, Joypad>::Element *elem = joy_names.front();
|
||||
while (elem) {
|
||||
@ -182,7 +184,7 @@ Array InputDefault::get_connected_joypads() {
|
||||
return ret;
|
||||
}
|
||||
|
||||
void InputDefault::joy_connection_changed(int p_idx, bool p_connected, String p_name, String p_guid) {
|
||||
void Input::joy_connection_changed(int p_idx, bool p_connected, String p_name, String p_guid) {
|
||||
_THREAD_SAFE_METHOD_
|
||||
Joypad js;
|
||||
js.name = p_connected ? p_name : "";
|
||||
@ -220,10 +222,12 @@ void InputDefault::joy_connection_changed(int p_idx, bool p_connected, String p_
|
||||
joy_names[p_idx] = js;
|
||||
|
||||
// Ensure this signal is emitted on the main thread, as some platforms (e.g. Linux) call this from a different thread.
|
||||
call_deferred("emit_signal", "joy_connection_changed", p_idx, p_connected);
|
||||
//call_deferred("emit_signal", "joy_connection_changed", p_idx, p_connected);
|
||||
//TODO thread
|
||||
joy_connection_changed_signal.emit(this, p_idx, p_connected);
|
||||
}
|
||||
|
||||
Vector2 InputDefault::get_joy_vibration_strength(int p_device) {
|
||||
Vector2 Input::get_joy_vibration_strength(int p_device) {
|
||||
if (joy_vibration.has(p_device)) {
|
||||
return Vector2(joy_vibration[p_device].weak_magnitude, joy_vibration[p_device].strong_magnitude);
|
||||
} else {
|
||||
@ -231,7 +235,7 @@ Vector2 InputDefault::get_joy_vibration_strength(int p_device) {
|
||||
}
|
||||
}
|
||||
|
||||
float InputDefault::get_joy_vibration_duration(int p_device) {
|
||||
float Input::get_joy_vibration_duration(int p_device) {
|
||||
if (joy_vibration.has(p_device)) {
|
||||
return joy_vibration[p_device].duration;
|
||||
} else {
|
||||
@ -239,7 +243,7 @@ float InputDefault::get_joy_vibration_duration(int p_device) {
|
||||
}
|
||||
}
|
||||
|
||||
uint64_t InputDefault::get_joy_vibration_timestamp(int p_device) {
|
||||
uint64_t Input::get_joy_vibration_timestamp(int p_device) {
|
||||
if (joy_vibration.has(p_device)) {
|
||||
return joy_vibration[p_device].timestamp;
|
||||
} else {
|
||||
@ -247,7 +251,7 @@ uint64_t InputDefault::get_joy_vibration_timestamp(int p_device) {
|
||||
}
|
||||
}
|
||||
|
||||
void InputDefault::add_joy_mapping(String p_mapping, bool p_update_existing) {
|
||||
void Input::add_joy_mapping(String p_mapping, bool p_update_existing) {
|
||||
parse_mapping(p_mapping);
|
||||
if (p_update_existing) {
|
||||
Vector<String> entry = p_mapping.split(",");
|
||||
@ -261,7 +265,7 @@ void InputDefault::add_joy_mapping(String p_mapping, bool p_update_existing) {
|
||||
}
|
||||
}
|
||||
|
||||
void InputDefault::remove_joy_mapping(String p_guid) {
|
||||
void Input::remove_joy_mapping(String p_guid) {
|
||||
for (int i = map_db.size() - 1; i >= 0; i--) {
|
||||
if (p_guid == map_db[i].uid) {
|
||||
map_db.remove(i);
|
||||
@ -276,20 +280,22 @@ void InputDefault::remove_joy_mapping(String p_guid) {
|
||||
}
|
||||
|
||||
//Defaults to simple implementation for platforms with a fixed gamepad layout, like consoles.
|
||||
bool InputDefault::is_joy_known(int p_device) {
|
||||
return OS::get_singleton()->is_joy_known(p_device);
|
||||
bool Input::is_joy_known(int p_device) {
|
||||
//return OS::get_singleton()->is_joy_known(p_device);
|
||||
return false;
|
||||
}
|
||||
|
||||
String InputDefault::get_joy_guid(int p_device) const {
|
||||
return OS::get_singleton()->get_joy_guid(p_device);
|
||||
String Input::get_joy_guid(int p_device) const {
|
||||
//return OS::get_singleton()->get_joy_guid(p_device);
|
||||
return String();
|
||||
}
|
||||
|
||||
bool InputDefault::should_ignore_device(int p_vendor_id, int p_product_id) const {
|
||||
bool Input::should_ignore_device(int p_vendor_id, int p_product_id) const {
|
||||
uint32_t full_id = (((uint32_t)p_vendor_id) << 16) | ((uint16_t)p_product_id);
|
||||
return ignored_device_ids.has(full_id);
|
||||
}
|
||||
|
||||
void InputDefault::start_joy_vibration(int p_device, float p_weak_magnitude, float p_strong_magnitude, float p_duration) {
|
||||
void Input::start_joy_vibration(int p_device, float p_weak_magnitude, float p_strong_magnitude, float p_duration) {
|
||||
_THREAD_SAFE_METHOD_
|
||||
if (p_weak_magnitude < 0.f || p_weak_magnitude > 1.f || p_strong_magnitude < 0.f || p_strong_magnitude > 1.f) {
|
||||
return;
|
||||
@ -298,31 +304,31 @@ void InputDefault::start_joy_vibration(int p_device, float p_weak_magnitude, flo
|
||||
vibration.weak_magnitude = p_weak_magnitude;
|
||||
vibration.strong_magnitude = p_strong_magnitude;
|
||||
vibration.duration = p_duration;
|
||||
vibration.timestamp = OS::get_singleton()->get_ticks_usec();
|
||||
vibration.timestamp = STime::time_us();
|
||||
joy_vibration[p_device] = vibration;
|
||||
}
|
||||
|
||||
void InputDefault::stop_joy_vibration(int p_device) {
|
||||
void Input::stop_joy_vibration(int p_device) {
|
||||
_THREAD_SAFE_METHOD_
|
||||
VibrationInfo vibration;
|
||||
vibration.weak_magnitude = 0;
|
||||
vibration.strong_magnitude = 0;
|
||||
vibration.duration = 0;
|
||||
vibration.timestamp = OS::get_singleton()->get_ticks_usec();
|
||||
vibration.timestamp = STime::time_us();
|
||||
joy_vibration[p_device] = vibration;
|
||||
}
|
||||
|
||||
void InputDefault::vibrate_handheld(int p_duration_ms) {
|
||||
OS::get_singleton()->vibrate_handheld(p_duration_ms);
|
||||
void Input::vibrate_handheld(int p_duration_ms) {
|
||||
//OS::get_singleton()->vibrate_handheld(p_duration_ms);
|
||||
}
|
||||
|
||||
void InputDefault::set_joy_axis(int p_device, int p_axis, float p_value) {
|
||||
void Input::set_joy_axis(int p_device, int p_axis, float p_value) {
|
||||
_THREAD_SAFE_METHOD_
|
||||
int c = _combine_device(p_axis, p_device);
|
||||
_joy_axis[c] = p_value;
|
||||
}
|
||||
|
||||
void InputDefault::parse_mapping(String p_mapping) {
|
||||
void Input::parse_mapping(String p_mapping) {
|
||||
_THREAD_SAFE_METHOD_;
|
||||
JoyDeviceMapping mapping;
|
||||
|
||||
@ -382,7 +388,7 @@ void InputDefault::parse_mapping(String p_mapping) {
|
||||
JoystickList output_axis = _get_output_axis(output);
|
||||
|
||||
if (output_button == JOY_INVALID_OPTION && output_axis == JOY_INVALID_OPTION) {
|
||||
print_verbose(vformat("Unrecognized output string \"%s\" in mapping:\n%s", output, p_mapping));
|
||||
LOG_TRACE(vformat("Unrecognized output string \"%s\" in mapping:\n%s", output, p_mapping));
|
||||
}
|
||||
|
||||
ERR_CONTINUE_MSG(output_button != JOY_INVALID_OPTION && output_axis != JOY_INVALID_OPTION,
|
||||
@ -426,7 +432,7 @@ void InputDefault::parse_mapping(String p_mapping) {
|
||||
map_db.push_back(mapping);
|
||||
};
|
||||
|
||||
void InputDefault::joy_button(int p_device, int p_button, bool p_pressed) {
|
||||
void Input::joy_button(int p_device, int p_button, bool p_pressed) {
|
||||
_THREAD_SAFE_METHOD_;
|
||||
Joypad &joy = joy_names[p_device];
|
||||
ERR_FAIL_INDEX(p_button, JOY_BUTTON_MAX);
|
||||
@ -459,7 +465,7 @@ void InputDefault::joy_button(int p_device, int p_button, bool p_pressed) {
|
||||
// no event?
|
||||
}
|
||||
|
||||
void InputDefault::joy_axis(int p_device, int p_axis, float p_value) {
|
||||
void Input::joy_axis(int p_device, int p_axis, float p_value) {
|
||||
_THREAD_SAFE_METHOD_;
|
||||
|
||||
ERR_FAIL_INDEX(p_axis, JOY_AXIS_MAX);
|
||||
@ -527,7 +533,7 @@ void InputDefault::joy_axis(int p_device, int p_axis, float p_value) {
|
||||
}
|
||||
}
|
||||
|
||||
void InputDefault::joy_hat(int p_device, int p_val) {
|
||||
void Input::joy_hat(int p_device, int p_val) {
|
||||
_THREAD_SAFE_METHOD_;
|
||||
const Joypad &joy = joy_names[p_device];
|
||||
|
||||
@ -569,27 +575,27 @@ void InputDefault::joy_hat(int p_device, int p_val) {
|
||||
joy_names[p_device].hat_current = p_val;
|
||||
}
|
||||
|
||||
Point2 InputDefault::get_mouse_position() const {
|
||||
Point2 Input::get_mouse_position() const {
|
||||
return mouse_pos;
|
||||
}
|
||||
Point2 InputDefault::get_last_mouse_speed() {
|
||||
Point2 Input::get_last_mouse_speed() {
|
||||
mouse_speed_track.update(Vector2());
|
||||
return mouse_speed_track.speed;
|
||||
}
|
||||
|
||||
int InputDefault::get_mouse_button_mask() const {
|
||||
int Input::get_mouse_button_mask() const {
|
||||
return mouse_button_mask; // do not trust OS implementation, should remove it - OS::get_singleton()->get_mouse_button_state();
|
||||
}
|
||||
|
||||
void InputDefault::set_mouse_position(const Point2 &p_posf) {
|
||||
void Input::set_mouse_position(const Point2 &p_posf) {
|
||||
mouse_pos = p_posf;
|
||||
}
|
||||
|
||||
void InputDefault::warp_mouse_position(const Vector2 &p_to) {
|
||||
OS::get_singleton()->warp_mouse_position(p_to);
|
||||
void Input::warp_mouse_position(const Vector2 &p_to) {
|
||||
//OS::get_singleton()->warp_mouse_position(p_to);
|
||||
}
|
||||
|
||||
Point2i InputDefault::warp_mouse_motion(const Ref<InputEventMouseMotion> &p_motion, const Rect2 &p_rect) {
|
||||
Point2i Input::warp_mouse_motion(const Ref<InputEventMouseMotion> &p_motion, const Rect2 &p_rect) {
|
||||
// The relative distance reported for the next event after a warp is in the boundaries of the
|
||||
// size of the rect on that axis, but it may be greater, in which case there's not problem as fmod()
|
||||
// will warp it, but if the pointer has moved in the opposite direction between the pointer relocation
|
||||
@ -607,92 +613,92 @@ Point2i InputDefault::warp_mouse_motion(const Ref<InputEventMouseMotion> &p_moti
|
||||
|
||||
const Point2i pos_local = p_motion->get_global_position() - p_rect.position;
|
||||
const Point2i pos_warped(Math::fposmod(pos_local.x, p_rect.size.x), Math::fposmod(pos_local.y, p_rect.size.y));
|
||||
if (pos_warped != pos_local) {
|
||||
OS::get_singleton()->warp_mouse_position(pos_warped + p_rect.position);
|
||||
}
|
||||
//if (pos_warped != pos_local) {
|
||||
//OS::get_singleton()->warp_mouse_position(pos_warped + p_rect.position);
|
||||
//}
|
||||
|
||||
return rel_warped;
|
||||
}
|
||||
|
||||
Vector3 InputDefault::get_gravity() const {
|
||||
Vector3 Input::get_gravity() const {
|
||||
_THREAD_SAFE_METHOD_
|
||||
return gravity;
|
||||
}
|
||||
|
||||
Vector3 InputDefault::get_accelerometer() const {
|
||||
Vector3 Input::get_accelerometer() const {
|
||||
_THREAD_SAFE_METHOD_
|
||||
return accelerometer;
|
||||
}
|
||||
|
||||
Vector3 InputDefault::get_magnetometer() const {
|
||||
Vector3 Input::get_magnetometer() const {
|
||||
_THREAD_SAFE_METHOD_
|
||||
return magnetometer;
|
||||
}
|
||||
|
||||
Vector3 InputDefault::get_gyroscope() const {
|
||||
Vector3 Input::get_gyroscope() const {
|
||||
_THREAD_SAFE_METHOD_
|
||||
return gyroscope;
|
||||
}
|
||||
|
||||
void InputDefault::set_gravity(const Vector3 &p_gravity) {
|
||||
void Input::set_gravity(const Vector3 &p_gravity) {
|
||||
_THREAD_SAFE_METHOD_
|
||||
|
||||
gravity = p_gravity;
|
||||
}
|
||||
|
||||
void InputDefault::set_accelerometer(const Vector3 &p_accel) {
|
||||
void Input::set_accelerometer(const Vector3 &p_accel) {
|
||||
_THREAD_SAFE_METHOD_
|
||||
|
||||
accelerometer = p_accel;
|
||||
}
|
||||
|
||||
void InputDefault::set_magnetometer(const Vector3 &p_magnetometer) {
|
||||
void Input::set_magnetometer(const Vector3 &p_magnetometer) {
|
||||
_THREAD_SAFE_METHOD_
|
||||
|
||||
magnetometer = p_magnetometer;
|
||||
}
|
||||
|
||||
void InputDefault::set_gyroscope(const Vector3 &p_gyroscope) {
|
||||
void Input::set_gyroscope(const Vector3 &p_gyroscope) {
|
||||
_THREAD_SAFE_METHOD_
|
||||
|
||||
gyroscope = p_gyroscope;
|
||||
}
|
||||
|
||||
void InputDefault::action_press(const StringName &p_action, float p_strength) {
|
||||
void Input::action_press(const StringName &p_action, float p_strength) {
|
||||
// Create or retrieve existing action.
|
||||
Action &action = action_state[p_action];
|
||||
|
||||
action.pressed_physics_frame = Engine::get_singleton()->get_physics_frames();
|
||||
action.pressed_idle_frame = Engine::get_singleton()->get_idle_frames();
|
||||
action.pressed_physics_frame = Application::get_singleton()->get_physics_frames();
|
||||
action.pressed_idle_frame = Application::get_singleton()->get_idle_frames();
|
||||
action.pressed = true;
|
||||
action.exact = true;
|
||||
action.strength = p_strength;
|
||||
action.raw_strength = p_strength;
|
||||
}
|
||||
|
||||
void InputDefault::action_release(const StringName &p_action) {
|
||||
void Input::action_release(const StringName &p_action) {
|
||||
// Create or retrieve existing action.
|
||||
Action &action = action_state[p_action];
|
||||
|
||||
action.released_physics_frame = Engine::get_singleton()->get_physics_frames();
|
||||
action.released_idle_frame = Engine::get_singleton()->get_idle_frames();
|
||||
action.released_physics_frame = Application::get_singleton()->get_physics_frames();
|
||||
action.released_idle_frame = Application::get_singleton()->get_idle_frames();
|
||||
action.pressed = false;
|
||||
action.exact = true;
|
||||
action.strength = 0.0f;
|
||||
action.raw_strength = 0.0f;
|
||||
}
|
||||
|
||||
void InputDefault::set_emulate_touch_from_mouse(bool p_emulate) {
|
||||
void Input::set_emulate_touch_from_mouse(bool p_emulate) {
|
||||
emulate_touch_from_mouse = p_emulate;
|
||||
}
|
||||
|
||||
bool InputDefault::is_emulating_touch_from_mouse() const {
|
||||
bool Input::is_emulating_touch_from_mouse() const {
|
||||
return emulate_touch_from_mouse;
|
||||
}
|
||||
|
||||
// Calling this whenever the game window is focused helps unstucking the "touch mouse"
|
||||
// if the OS or its abstraction class hasn't properly reported that touch pointers raised
|
||||
void InputDefault::ensure_touch_mouse_raised() {
|
||||
void Input::ensure_touch_mouse_raised() {
|
||||
_THREAD_SAFE_METHOD_
|
||||
if (mouse_from_touch_index != -1) {
|
||||
mouse_from_touch_index = -1;
|
||||
@ -711,19 +717,19 @@ void InputDefault::ensure_touch_mouse_raised() {
|
||||
}
|
||||
}
|
||||
|
||||
void InputDefault::set_emulate_mouse_from_touch(bool p_emulate) {
|
||||
void Input::set_emulate_mouse_from_touch(bool p_emulate) {
|
||||
emulate_mouse_from_touch = p_emulate;
|
||||
}
|
||||
|
||||
bool InputDefault::is_emulating_mouse_from_touch() const {
|
||||
bool Input::is_emulating_mouse_from_touch() const {
|
||||
return emulate_mouse_from_touch;
|
||||
}
|
||||
|
||||
Input::CursorShape InputDefault::get_default_cursor_shape() const {
|
||||
Input::CursorShape Input::get_default_cursor_shape() const {
|
||||
return default_shape;
|
||||
}
|
||||
|
||||
void InputDefault::set_default_cursor_shape(CursorShape p_shape) {
|
||||
void Input::set_default_cursor_shape(CursorShape p_shape) {
|
||||
if (default_shape == p_shape) {
|
||||
return;
|
||||
}
|
||||
@ -738,18 +744,15 @@ void InputDefault::set_default_cursor_shape(CursorShape p_shape) {
|
||||
parse_input_event(mm);
|
||||
}
|
||||
|
||||
Input::CursorShape InputDefault::get_current_cursor_shape() const {
|
||||
return (Input::CursorShape)OS::get_singleton()->get_cursor_shape();
|
||||
Input::CursorShape Input::get_current_cursor_shape() const {
|
||||
//return (Input::CursorShape)OS::get_singleton()->get_cursor_shape();
|
||||
return CURSOR_ARROW;
|
||||
}
|
||||
|
||||
void InputDefault::set_custom_mouse_cursor(const RES &p_cursor, CursorShape p_shape, const Vector2 &p_hotspot) {
|
||||
if (Engine::get_singleton()->is_editor_hint()) {
|
||||
return;
|
||||
}
|
||||
|
||||
void Input::set_custom_mouse_cursor(const Ref<Reference> &p_cursor, CursorShape p_shape, const Vector2 &p_hotspot) {
|
||||
ERR_FAIL_INDEX(p_shape, Input::CURSOR_MAX);
|
||||
|
||||
OS::get_singleton()->set_custom_mouse_cursor(p_cursor, (OS::CursorShape)p_shape, p_hotspot);
|
||||
//OS::get_singleton()->set_custom_mouse_cursor(p_cursor, (OS::CursorShape)p_shape, p_hotspot);
|
||||
}
|
||||
|
||||
static const char *_buttons[JOY_BUTTON_MAX] = {
|
||||
@ -791,12 +794,12 @@ static const char *_axes[JOY_AXIS_MAX] = {
|
||||
""
|
||||
};
|
||||
|
||||
String InputDefault::get_joy_button_string(int p_button) {
|
||||
String Input::get_joy_button_string(int p_button) {
|
||||
ERR_FAIL_INDEX_V(p_button, JOY_BUTTON_MAX, "");
|
||||
return _buttons[p_button];
|
||||
}
|
||||
|
||||
int InputDefault::get_joy_button_index_from_string(String p_button) {
|
||||
int Input::get_joy_button_index_from_string(String p_button) {
|
||||
for (int i = 0; i < JOY_BUTTON_MAX; i++) {
|
||||
if (_buttons[i] == nullptr) {
|
||||
break;
|
||||
@ -809,12 +812,12 @@ int InputDefault::get_joy_button_index_from_string(String p_button) {
|
||||
ERR_FAIL_V_MSG(-1, vformat("Could not find a button index matching the string \"%s\".", p_button));
|
||||
}
|
||||
|
||||
String InputDefault::get_joy_axis_string(int p_axis) {
|
||||
String Input::get_joy_axis_string(int p_axis) {
|
||||
ERR_FAIL_INDEX_V(p_axis, JOY_AXIS_MAX, "");
|
||||
return _axes[p_axis];
|
||||
}
|
||||
|
||||
int InputDefault::get_joy_axis_index_from_string(String p_axis) {
|
||||
int Input::get_joy_axis_index_from_string(String p_axis) {
|
||||
for (int i = 0; i < JOY_AXIS_MAX; i++) {
|
||||
if (_axes[i] == nullptr) {
|
||||
break;
|
||||
@ -827,7 +830,7 @@ int InputDefault::get_joy_axis_index_from_string(String p_axis) {
|
||||
ERR_FAIL_V_MSG(-1, vformat("Could not find an axis index matching the string \"%s\".", p_axis));
|
||||
}
|
||||
|
||||
int InputDefault::get_unused_joy_id() {
|
||||
int Input::get_unused_joy_id() {
|
||||
for (int i = 0; i < JOYPADS_MAX; i++) {
|
||||
if (!joy_names.has(i) || !joy_names[i].connected) {
|
||||
return i;
|
||||
@ -837,7 +840,7 @@ int InputDefault::get_unused_joy_id() {
|
||||
}
|
||||
|
||||
//platforms that use the remapping system can override and call to these ones
|
||||
bool InputDefault::is_joy_mapped(int p_device) {
|
||||
bool Input::is_joy_mapped(int p_device) {
|
||||
if (joy_names.has(p_device)) {
|
||||
int mapping = joy_names[p_device].mapping;
|
||||
if (mapping != -1 && mapping != fallback_mapping) {
|
||||
@ -847,12 +850,12 @@ bool InputDefault::is_joy_mapped(int p_device) {
|
||||
return false;
|
||||
}
|
||||
|
||||
String InputDefault::get_joy_guid_remapped(int p_device) const {
|
||||
String Input::get_joy_guid_remapped(int p_device) const {
|
||||
ERR_FAIL_COND_V(!joy_names.has(p_device), "");
|
||||
return joy_names[p_device].uid;
|
||||
}
|
||||
|
||||
void InputDefault::set_fallback_mapping(String p_guid) {
|
||||
void Input::set_fallback_mapping(String p_guid) {
|
||||
for (int i = 0; i < map_db.size(); i++) {
|
||||
if (map_db[i].uid == p_guid) {
|
||||
fallback_mapping = i;
|
||||
@ -861,7 +864,7 @@ void InputDefault::set_fallback_mapping(String p_guid) {
|
||||
}
|
||||
}
|
||||
|
||||
void InputDefault::parse_input_event(const Ref<InputEvent> &p_event) {
|
||||
void Input::parse_input_event(const Ref<InputEvent> &p_event) {
|
||||
_THREAD_SAFE_METHOD_
|
||||
|
||||
ERR_FAIL_COND(p_event.is_null());
|
||||
@ -877,7 +880,7 @@ void InputDefault::parse_input_event(const Ref<InputEvent> &p_event) {
|
||||
}
|
||||
}
|
||||
|
||||
void InputDefault::flush_buffered_events() {
|
||||
void Input::flush_buffered_events() {
|
||||
_THREAD_SAFE_METHOD_
|
||||
|
||||
while (buffered_events.front()) {
|
||||
@ -893,23 +896,23 @@ void InputDefault::flush_buffered_events() {
|
||||
}
|
||||
}
|
||||
|
||||
bool InputDefault::is_using_input_buffering() {
|
||||
bool Input::is_using_input_buffering() {
|
||||
return use_input_buffering;
|
||||
}
|
||||
|
||||
void InputDefault::set_use_input_buffering(bool p_enable) {
|
||||
void Input::set_use_input_buffering(bool p_enable) {
|
||||
use_input_buffering = p_enable;
|
||||
}
|
||||
|
||||
bool InputDefault::is_using_accumulated_input() {
|
||||
bool Input::is_using_accumulated_input() {
|
||||
return use_accumulated_input;
|
||||
}
|
||||
|
||||
void InputDefault::set_use_accumulated_input(bool p_enable) {
|
||||
void Input::set_use_accumulated_input(bool p_enable) {
|
||||
use_accumulated_input = p_enable;
|
||||
}
|
||||
|
||||
void InputDefault::release_pressed_events() {
|
||||
void Input::release_pressed_events() {
|
||||
flush_buffered_events(); // this is needed to release actions strengths
|
||||
|
||||
keys_pressed.clear();
|
||||
@ -917,7 +920,7 @@ void InputDefault::release_pressed_events() {
|
||||
joy_buttons_pressed.clear();
|
||||
_joy_axis.clear();
|
||||
|
||||
for (RBMap<StringName, InputDefault::Action>::Element *E = action_state.front(); E; E = E->next()) {
|
||||
for (RBMap<StringName, Input::Action>::Element *E = action_state.front(); E; E = E->next()) {
|
||||
if (E->get().pressed) {
|
||||
action_release(E->key());
|
||||
}
|
||||
@ -949,11 +952,11 @@ void Input::get_argument_options(const StringName &p_function, int p_idx, List<S
|
||||
#endif
|
||||
}
|
||||
|
||||
void InputDefault::set_main_loop(MainLoop *p_main_loop) {
|
||||
void Input::set_main_loop(Application *p_main_loop) {
|
||||
main_loop = p_main_loop;
|
||||
}
|
||||
|
||||
void InputDefault::iteration(float p_step) {
|
||||
void Input::iteration(float p_step) {
|
||||
}
|
||||
|
||||
Input::Input() {
|
||||
@ -965,18 +968,10 @@ Input::Input() {
|
||||
emulate_touch_from_mouse = false;
|
||||
emulate_mouse_from_touch = false;
|
||||
mouse_from_touch_index = -1;
|
||||
main_loop = nullptr;
|
||||
//main_loop = nullptr;
|
||||
default_shape = CURSOR_ARROW;
|
||||
legacy_just_pressed_behavior = false;
|
||||
|
||||
fallback_mapping = -1;
|
||||
|
||||
legacy_just_pressed_behavior = GLOBAL_DEF("input_devices/compatibility/legacy_just_pressed_behavior", false);
|
||||
if (Engine::get_singleton()->is_editor_hint()) {
|
||||
// Always use standard behaviour in the editor.
|
||||
legacy_just_pressed_behavior = false;
|
||||
}
|
||||
|
||||
// Parse default mappings.
|
||||
{
|
||||
int i = 0;
|
||||
@ -986,7 +981,7 @@ Input::Input() {
|
||||
}
|
||||
|
||||
// If defined, parse SDL_GAMECONTROLLERCONFIG for possible new mappings/overrides.
|
||||
String env_mapping = OS::get_singleton()->get_environment("SDL_GAMECONTROLLERCONFIG");
|
||||
String env_mapping = "";//OS::get_singleton()->get_environment("SDL_GAMECONTROLLERCONFIG");
|
||||
if (env_mapping != "") {
|
||||
Vector<String> entries = env_mapping.split("\n");
|
||||
for (int i = 0; i < entries.size(); i++) {
|
||||
@ -997,7 +992,7 @@ Input::Input() {
|
||||
}
|
||||
}
|
||||
|
||||
String env_ignore_devices = OS::get_singleton()->get_environment("SDL_GAMECONTROLLER_IGNORE_DEVICES");
|
||||
String env_ignore_devices = "";//OS::get_singleton()->get_environment("SDL_GAMECONTROLLER_IGNORE_DEVICES");
|
||||
if (!env_ignore_devices.empty()) {
|
||||
Vector<String> entries = env_ignore_devices.split(",");
|
||||
for (int i = 0; i < entries.size(); i++) {
|
||||
@ -1007,7 +1002,7 @@ Input::Input() {
|
||||
continue;
|
||||
}
|
||||
|
||||
print_verbose(vformat("Device Ignored -- Vendor: %s Product: %s", vid_pid[0], vid_pid[1]));
|
||||
LOG_TRACE(vformat("Device Ignored -- Vendor: %s Product: %s", vid_pid[0], vid_pid[1]));
|
||||
const uint16_t vid_unswapped = vid_pid[0].hex_to_int();
|
||||
const uint16_t pid_unswapped = vid_pid[1].hex_to_int();
|
||||
const uint16_t vid = BSWAP16(vid_unswapped);
|
||||
@ -1019,7 +1014,7 @@ Input::Input() {
|
||||
}
|
||||
}
|
||||
|
||||
InputDefault::JoyEvent InputDefault::_get_mapped_button_event(const JoyDeviceMapping &mapping, int p_button) {
|
||||
Input::JoyEvent Input::_get_mapped_button_event(const JoyDeviceMapping &mapping, int p_button) {
|
||||
JoyEvent event;
|
||||
event.type = TYPE_MAX;
|
||||
|
||||
@ -1048,14 +1043,14 @@ InputDefault::JoyEvent InputDefault::_get_mapped_button_event(const JoyDeviceMap
|
||||
}
|
||||
return event;
|
||||
default:
|
||||
ERR_PRINT_ONCE("Joypad button mapping error.");
|
||||
ERR_PRINT("Joypad button mapping error.");
|
||||
}
|
||||
}
|
||||
}
|
||||
return event;
|
||||
}
|
||||
|
||||
InputDefault::JoyEvent InputDefault::_get_mapped_axis_event(const JoyDeviceMapping &mapping, int p_axis, float p_value) {
|
||||
Input::JoyEvent Input::_get_mapped_axis_event(const JoyDeviceMapping &mapping, int p_axis, float p_value) {
|
||||
JoyEvent event;
|
||||
event.type = TYPE_MAX;
|
||||
|
||||
@ -1117,7 +1112,7 @@ InputDefault::JoyEvent InputDefault::_get_mapped_axis_event(const JoyDeviceMappi
|
||||
}
|
||||
return event;
|
||||
default:
|
||||
ERR_PRINT_ONCE("Joypad axis mapping error.");
|
||||
ERR_PRINT("Joypad axis mapping error.");
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1125,7 +1120,7 @@ InputDefault::JoyEvent InputDefault::_get_mapped_axis_event(const JoyDeviceMappi
|
||||
return event;
|
||||
}
|
||||
|
||||
void InputDefault::_get_mapped_hat_events(const JoyDeviceMapping &mapping, int p_hat, JoyEvent r_events[HAT_MAX]) {
|
||||
void Input::_get_mapped_hat_events(const JoyDeviceMapping &mapping, int p_hat, JoyEvent r_events[HAT_MAX]) {
|
||||
for (int i = 0; i < mapping.bindings.size(); i++) {
|
||||
const JoyBinding binding = mapping.bindings[i];
|
||||
if (binding.inputType == TYPE_HAT && binding.input.hat.hat == p_hat) {
|
||||
@ -1144,7 +1139,7 @@ void InputDefault::_get_mapped_hat_events(const JoyDeviceMapping &mapping, int p
|
||||
hat_direction = HAT_LEFT;
|
||||
break;
|
||||
default:
|
||||
ERR_PRINT_ONCE("Joypad button mapping error.");
|
||||
ERR_PRINT("Joypad button mapping error.");
|
||||
continue;
|
||||
}
|
||||
|
||||
@ -1170,7 +1165,7 @@ void InputDefault::_get_mapped_hat_events(const JoyDeviceMapping &mapping, int p
|
||||
}
|
||||
break;
|
||||
default:
|
||||
ERR_PRINT_ONCE("Joypad button mapping error.");
|
||||
ERR_PRINT("Joypad button mapping error.");
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1180,7 +1175,7 @@ void InputDefault::_get_mapped_hat_events(const JoyDeviceMapping &mapping, int p
|
||||
static const char *_joy_buttons[] = { "a", "b", "x", "y", "leftshoulder", "rightshoulder", "lefttrigger", "righttrigger", "leftstick", "rightstick", "back", "start", "dpup", "dpdown", "dpleft", "dpright", "guide", "misc1", "paddle1", "paddle2", "paddle3", "paddle4", "touchpad", nullptr };
|
||||
static const char *_joy_axes[] = { "leftx", "lefty", "rightx", "righty", nullptr };
|
||||
|
||||
JoystickList InputDefault::_get_output_button(String output) {
|
||||
JoystickList Input::_get_output_button(String output) {
|
||||
for (int i = 0; _joy_buttons[i]; i++) {
|
||||
if (output == _joy_buttons[i]) {
|
||||
return JoystickList(i);
|
||||
@ -1189,7 +1184,7 @@ JoystickList InputDefault::_get_output_button(String output) {
|
||||
return JoystickList::JOY_INVALID_OPTION;
|
||||
}
|
||||
|
||||
JoystickList InputDefault::_get_output_axis(String output) {
|
||||
JoystickList Input::_get_output_axis(String output) {
|
||||
for (int i = 0; _joy_axes[i]; i++) {
|
||||
if (output == _joy_axes[i]) {
|
||||
return JoystickList(i);
|
||||
@ -1198,7 +1193,7 @@ JoystickList InputDefault::_get_output_axis(String output) {
|
||||
return JoystickList::JOY_INVALID_OPTION;
|
||||
}
|
||||
|
||||
void InputDefault::_button_event(int p_device, int p_index, bool p_pressed) {
|
||||
void Input::_button_event(int p_device, int p_index, bool p_pressed) {
|
||||
Ref<InputEventJoypadButton> ievent;
|
||||
ievent.instance();
|
||||
ievent->set_device(p_device);
|
||||
@ -1208,7 +1203,7 @@ void InputDefault::_button_event(int p_device, int p_index, bool p_pressed) {
|
||||
parse_input_event(ievent);
|
||||
}
|
||||
|
||||
void InputDefault::_axis_event(int p_device, int p_axis, float p_value) {
|
||||
void Input::_axis_event(int p_device, int p_axis, float p_value) {
|
||||
Ref<InputEventJoypadMotion> ievent;
|
||||
ievent.instance();
|
||||
ievent->set_device(p_device);
|
||||
@ -1218,7 +1213,7 @@ void InputDefault::_axis_event(int p_device, int p_axis, float p_value) {
|
||||
parse_input_event(ievent);
|
||||
};
|
||||
|
||||
void InputDefault::_parse_input_event_impl(const Ref<InputEvent> &p_event, bool p_is_emulated) {
|
||||
void Input::_parse_input_event_impl(const Ref<InputEvent> &p_event, bool p_is_emulated) {
|
||||
// This function does the final delivery of the input event to user land.
|
||||
// Regardless where the event came from originally, this has to happen on the main thread.
|
||||
DEV_ASSERT(Thread::get_caller_id() == Thread::get_main_id());
|
||||
@ -1405,12 +1400,12 @@ void InputDefault::_parse_input_event_impl(const Ref<InputEvent> &p_event, bool
|
||||
if (!p_event->is_echo() && is_action_pressed(E->key(), false) != p_event->is_action_pressed(E->key())) {
|
||||
if (p_event->is_action_pressed(E->key())) {
|
||||
action.pressed = true;
|
||||
action.pressed_physics_frame = Engine::get_singleton()->get_physics_frames();
|
||||
action.pressed_idle_frame = Engine::get_singleton()->get_idle_frames();
|
||||
action.pressed_physics_frame = Application::get_singleton()->get_physics_frames();
|
||||
action.pressed_idle_frame = Application::get_singleton()->get_idle_frames();
|
||||
} else {
|
||||
action.pressed = false;
|
||||
action.released_physics_frame = Engine::get_singleton()->get_physics_frames();
|
||||
action.released_idle_frame = Engine::get_singleton()->get_idle_frames();
|
||||
action.released_physics_frame = Application::get_singleton()->get_physics_frames();
|
||||
action.released_idle_frame = Application::get_singleton()->get_idle_frames();
|
||||
}
|
||||
|
||||
action.strength = 0.0f;
|
||||
@ -1430,7 +1425,7 @@ void InputDefault::_parse_input_event_impl(const Ref<InputEvent> &p_event, bool
|
||||
}
|
||||
}
|
||||
|
||||
static String Input::_hex_str(uint8_t p_byte) {
|
||||
String Input::_hex_str(uint8_t p_byte) {
|
||||
static const char *dict = "0123456789abcdef";
|
||||
char ret[3];
|
||||
ret[2] = 0;
|
||||
@ -1443,8 +1438,8 @@ static String Input::_hex_str(uint8_t p_byte) {
|
||||
|
||||
Input *Input::singleton = nullptr;
|
||||
|
||||
void InputDefault::SpeedTrack::update(const Vector2 &p_delta_p) {
|
||||
uint64_t tick = OS::get_singleton()->get_ticks_usec();
|
||||
void Input::SpeedTrack::update(const Vector2 &p_delta_p) {
|
||||
uint64_t tick = STime::time_us();
|
||||
uint32_t tdiff = tick - last_tick;
|
||||
float delta_t = tdiff / 1000000.0;
|
||||
last_tick = tick;
|
||||
@ -1470,14 +1465,14 @@ void InputDefault::SpeedTrack::update(const Vector2 &p_delta_p) {
|
||||
accum_t = 0;
|
||||
}
|
||||
|
||||
void InputDefault::SpeedTrack::reset() {
|
||||
last_tick = OS::get_singleton()->get_ticks_usec();
|
||||
void Input::SpeedTrack::reset() {
|
||||
last_tick = STime::time_us();
|
||||
speed = Vector2();
|
||||
accum = Vector2();
|
||||
accum_t = 0;
|
||||
}
|
||||
|
||||
InputDefault::SpeedTrack::SpeedTrack() {
|
||||
Input::SpeedTrack::SpeedTrack() {
|
||||
min_ref_frame = 0.1;
|
||||
max_ref_frame = 3.0;
|
||||
reset();
|
||||
|
@ -6,17 +6,26 @@
|
||||
/* From https://github.com/Relintai/pandemonium_engine (MIT) */
|
||||
/*************************************************************************/
|
||||
|
||||
#include "core/math/vector2i.h"
|
||||
#include "core/object/object.h"
|
||||
#include "core/os/main_loop.h"
|
||||
#include "core/os/thread_safe.h"
|
||||
#include "core/vector2i.h"
|
||||
#include "object/object.h"
|
||||
//#include "core/os/main_loop.h"
|
||||
#include "core/rb_set.h"
|
||||
#include "core/rb_map.h"
|
||||
#include "core/thread_safe.h"
|
||||
#include "object/reference.h"
|
||||
#include "object/psignal.h"
|
||||
#include "render_core/input/input_event.h"
|
||||
|
||||
class Application;
|
||||
|
||||
class Input : public Object {
|
||||
GDCLASS(Input, Object);
|
||||
SFW_OBJECT(Input, Object);
|
||||
|
||||
_THREAD_SAFE_CLASS_
|
||||
|
||||
public:
|
||||
Signal joy_connection_changed_signal;
|
||||
|
||||
enum MouseMode {
|
||||
MOUSE_MODE_VISIBLE,
|
||||
MOUSE_MODE_HIDDEN,
|
||||
@ -143,7 +152,7 @@ public:
|
||||
virtual CursorShape get_default_cursor_shape() const;
|
||||
virtual void set_default_cursor_shape(CursorShape p_shape);
|
||||
virtual CursorShape get_current_cursor_shape() const;
|
||||
virtual void set_custom_mouse_cursor(const RES &p_cursor, CursorShape p_shape = CURSOR_ARROW, const Vector2 &p_hotspot = Vector2());
|
||||
virtual void set_custom_mouse_cursor(const Ref<Reference> &p_cursor, CursorShape p_shape = CURSOR_ARROW, const Vector2 &p_hotspot = Vector2());
|
||||
|
||||
virtual String get_joy_button_string(int p_button);
|
||||
virtual String get_joy_axis_string(int p_axis);
|
||||
@ -168,116 +177,12 @@ public:
|
||||
|
||||
void get_argument_options(const StringName &p_function, int p_idx, List<String> *r_options, const String "e_style) const;
|
||||
|
||||
void set_main_loop(MainLoop *p_main_loop);
|
||||
void set_main_loop(Application *p_main_loop);
|
||||
void iteration(float p_step);
|
||||
|
||||
Input();
|
||||
|
||||
protected:
|
||||
JoyEvent _get_mapped_button_event(const JoyDeviceMapping &mapping, int p_button);
|
||||
JoyEvent _get_mapped_axis_event(const JoyDeviceMapping &mapping, int p_axis, float p_value);
|
||||
void _get_mapped_hat_events(const JoyDeviceMapping &mapping, int p_hat, JoyEvent r_events[HAT_MAX]);
|
||||
JoystickList _get_output_button(String output);
|
||||
JoystickList _get_output_axis(String output);
|
||||
void _button_event(int p_device, int p_index, bool p_pressed);
|
||||
void _axis_event(int p_device, int p_axis, float p_value);
|
||||
|
||||
void _parse_input_event_impl(const Ref<InputEvent> &p_event, bool p_is_emulated);
|
||||
|
||||
static String _hex_str(uint8_t p_byte);
|
||||
|
||||
List<Ref<InputEvent>> buffered_events;
|
||||
bool use_input_buffering;
|
||||
bool use_accumulated_input;
|
||||
|
||||
int mouse_button_mask;
|
||||
|
||||
RBSet<int> physical_keys_pressed;
|
||||
RBSet<int> keys_pressed;
|
||||
RBSet<int> joy_buttons_pressed;
|
||||
RBMap<int, float> _joy_axis;
|
||||
//Map<StringName,int> custom_action_press;
|
||||
Vector3 gravity;
|
||||
Vector3 accelerometer;
|
||||
Vector3 magnetometer;
|
||||
Vector3 gyroscope;
|
||||
Vector2 mouse_pos;
|
||||
MainLoop *main_loop;
|
||||
bool legacy_just_pressed_behavior;
|
||||
|
||||
struct Action {
|
||||
uint64_t pressed_physics_frame;
|
||||
uint64_t pressed_idle_frame;
|
||||
uint64_t released_physics_frame;
|
||||
uint64_t released_idle_frame;
|
||||
bool pressed;
|
||||
bool exact;
|
||||
float strength;
|
||||
float raw_strength;
|
||||
|
||||
Action() {
|
||||
pressed_physics_frame = UINT64_MAX;
|
||||
pressed_idle_frame = UINT64_MAX;
|
||||
released_physics_frame = UINT64_MAX;
|
||||
released_idle_frame = UINT64_MAX;
|
||||
pressed = false;
|
||||
exact = true;
|
||||
strength = 0.0f;
|
||||
raw_strength = 0.0f;
|
||||
}
|
||||
};
|
||||
|
||||
RBMap<StringName, Action> action_state;
|
||||
|
||||
bool emulate_touch_from_mouse;
|
||||
bool emulate_mouse_from_touch;
|
||||
|
||||
int mouse_from_touch_index;
|
||||
|
||||
struct SpeedTrack {
|
||||
uint64_t last_tick;
|
||||
Vector2 speed;
|
||||
Vector2 accum;
|
||||
float accum_t;
|
||||
float min_ref_frame;
|
||||
float max_ref_frame;
|
||||
|
||||
void update(const Vector2 &p_delta_p);
|
||||
void reset();
|
||||
SpeedTrack();
|
||||
};
|
||||
|
||||
struct Joypad {
|
||||
StringName name;
|
||||
StringName uid;
|
||||
bool connected;
|
||||
bool last_buttons[JOY_BUTTON_MAX + 12]; //apparently SDL specifies 35 possible buttons on android
|
||||
float last_axis[JOY_AXIS_MAX];
|
||||
int last_hat;
|
||||
int mapping;
|
||||
int hat_current;
|
||||
|
||||
Joypad() {
|
||||
for (int i = 0; i < JOY_AXIS_MAX; i++) {
|
||||
last_axis[i] = 0.0f;
|
||||
}
|
||||
for (int i = 0; i < JOY_BUTTON_MAX + 12; i++) {
|
||||
last_buttons[i] = false;
|
||||
}
|
||||
connected = false;
|
||||
last_hat = HAT_MASK_CENTER;
|
||||
mapping = -1;
|
||||
hat_current = 0;
|
||||
}
|
||||
};
|
||||
|
||||
SpeedTrack mouse_speed_track;
|
||||
RBMap<int, SpeedTrack> touch_speed_track;
|
||||
RBMap<int, Joypad> joy_names;
|
||||
int fallback_mapping;
|
||||
|
||||
CursorShape default_shape;
|
||||
|
||||
enum JoyType {
|
||||
TYPE_BUTTON,
|
||||
TYPE_AXIS,
|
||||
@ -333,9 +238,42 @@ protected:
|
||||
Vector<JoyBinding> bindings;
|
||||
};
|
||||
|
||||
Vector<JoyDeviceMapping> map_db;
|
||||
struct SpeedTrack {
|
||||
uint64_t last_tick;
|
||||
Vector2 speed;
|
||||
Vector2 accum;
|
||||
float accum_t;
|
||||
float min_ref_frame;
|
||||
float max_ref_frame;
|
||||
|
||||
RBSet<uint32_t> ignored_device_ids;
|
||||
void update(const Vector2 &p_delta_p);
|
||||
void reset();
|
||||
SpeedTrack();
|
||||
};
|
||||
|
||||
struct Joypad {
|
||||
StringName name;
|
||||
StringName uid;
|
||||
bool connected;
|
||||
bool last_buttons[JOY_BUTTON_MAX + 12]; //apparently SDL specifies 35 possible buttons on android
|
||||
float last_axis[JOY_AXIS_MAX];
|
||||
int last_hat;
|
||||
int mapping;
|
||||
int hat_current;
|
||||
|
||||
Joypad() {
|
||||
for (int i = 0; i < JOY_AXIS_MAX; i++) {
|
||||
last_axis[i] = 0.0f;
|
||||
}
|
||||
for (int i = 0; i < JOY_BUTTON_MAX + 12; i++) {
|
||||
last_buttons[i] = false;
|
||||
}
|
||||
connected = false;
|
||||
last_hat = HAT_MASK_CENTER;
|
||||
mapping = -1;
|
||||
hat_current = 0;
|
||||
}
|
||||
};
|
||||
|
||||
struct VibrationInfo {
|
||||
float weak_magnitude;
|
||||
@ -344,12 +282,80 @@ protected:
|
||||
uint64_t timestamp;
|
||||
};
|
||||
|
||||
struct Action {
|
||||
uint64_t pressed_physics_frame;
|
||||
uint64_t pressed_idle_frame;
|
||||
uint64_t released_physics_frame;
|
||||
uint64_t released_idle_frame;
|
||||
bool pressed;
|
||||
bool exact;
|
||||
float strength;
|
||||
float raw_strength;
|
||||
|
||||
Action() {
|
||||
pressed_physics_frame = UINT64_MAX;
|
||||
pressed_idle_frame = UINT64_MAX;
|
||||
released_physics_frame = UINT64_MAX;
|
||||
released_idle_frame = UINT64_MAX;
|
||||
pressed = false;
|
||||
exact = true;
|
||||
strength = 0.0f;
|
||||
raw_strength = 0.0f;
|
||||
}
|
||||
};
|
||||
|
||||
JoyEvent _get_mapped_button_event(const JoyDeviceMapping &mapping, int p_button);
|
||||
JoyEvent _get_mapped_axis_event(const JoyDeviceMapping &mapping, int p_axis, float p_value);
|
||||
void _get_mapped_hat_events(const JoyDeviceMapping &mapping, int p_hat, JoyEvent r_events[HAT_MAX]);
|
||||
JoystickList _get_output_button(String output);
|
||||
JoystickList _get_output_axis(String output);
|
||||
void _button_event(int p_device, int p_index, bool p_pressed);
|
||||
void _axis_event(int p_device, int p_axis, float p_value);
|
||||
|
||||
void _parse_input_event_impl(const Ref<InputEvent> &p_event, bool p_is_emulated);
|
||||
|
||||
static String _hex_str(uint8_t p_byte);
|
||||
|
||||
List<Ref<InputEvent>> buffered_events;
|
||||
bool use_input_buffering;
|
||||
bool use_accumulated_input;
|
||||
|
||||
int mouse_button_mask;
|
||||
|
||||
RBSet<int> physical_keys_pressed;
|
||||
RBSet<int> keys_pressed;
|
||||
RBSet<int> joy_buttons_pressed;
|
||||
RBMap<int, float> _joy_axis;
|
||||
//Map<StringName,int> custom_action_press;
|
||||
Vector3 gravity;
|
||||
Vector3 accelerometer;
|
||||
Vector3 magnetometer;
|
||||
Vector3 gyroscope;
|
||||
Vector2 mouse_pos;
|
||||
Application *main_loop;
|
||||
bool legacy_just_pressed_behavior;
|
||||
|
||||
RBMap<StringName, Action> action_state;
|
||||
|
||||
bool emulate_touch_from_mouse;
|
||||
bool emulate_mouse_from_touch;
|
||||
|
||||
int mouse_from_touch_index;
|
||||
|
||||
SpeedTrack mouse_speed_track;
|
||||
RBMap<int, SpeedTrack> touch_speed_track;
|
||||
RBMap<int, Joypad> joy_names;
|
||||
int fallback_mapping;
|
||||
|
||||
CursorShape default_shape;
|
||||
|
||||
Vector<JoyDeviceMapping> map_db;
|
||||
|
||||
RBSet<uint32_t> ignored_device_ids;
|
||||
|
||||
RBMap<int, VibrationInfo> joy_vibration;
|
||||
|
||||
static Input *singleton;
|
||||
};
|
||||
|
||||
VARIANT_ENUM_CAST(Input::MouseMode);
|
||||
VARIANT_ENUM_CAST(Input::CursorShape);
|
||||
|
||||
#endif // INPUT_H
|
||||
|
@ -5,9 +5,9 @@
|
||||
|
||||
#include "input_event.h"
|
||||
|
||||
#include "core/input/input_map.h"
|
||||
#include "core/input/shortcut.h"
|
||||
#include "core/os/keyboard.h"
|
||||
#include "render_core/input/input_map.h"
|
||||
#include "render_core/input/keyboard.h"
|
||||
#include "render_core/input/shortcut.h"
|
||||
|
||||
const int InputEvent::DEVICE_ID_TOUCH_MOUSE = -1;
|
||||
const int InputEvent::DEVICE_ID_INTERNAL = -2;
|
||||
@ -84,33 +84,6 @@ bool InputEvent::is_action_type() const {
|
||||
return false;
|
||||
}
|
||||
|
||||
void InputEvent::_bind_methods() {
|
||||
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_action", "action", "exact_match"), &InputEvent::is_action, DEFVAL(false));
|
||||
ClassDB::bind_method(D_METHOD("is_action_pressed", "action", "allow_echo", "exact_match"), &InputEvent::is_action_pressed, DEFVAL(false), DEFVAL(false));
|
||||
ClassDB::bind_method(D_METHOD("is_action_released", "action", "exact_match"), &InputEvent::is_action_released, DEFVAL(false));
|
||||
ClassDB::bind_method(D_METHOD("get_action_strength", "action", "exact_match"), &InputEvent::get_action_strength, DEFVAL(false));
|
||||
|
||||
ClassDB::bind_method(D_METHOD("is_canceled"), &InputEvent::is_canceled);
|
||||
ClassDB::bind_method(D_METHOD("is_pressed"), &InputEvent::is_pressed);
|
||||
ClassDB::bind_method(D_METHOD("is_released"), &InputEvent::is_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("shortcut_match", "event", "exact_match"), &InputEvent::shortcut_match, DEFVAL(true));
|
||||
|
||||
ClassDB::bind_method(D_METHOD("is_action_type"), &InputEvent::is_action_type);
|
||||
|
||||
ClassDB::bind_method(D_METHOD("accumulate", "with_event"), &InputEvent::accumulate);
|
||||
|
||||
ClassDB::bind_method(D_METHOD("xformed_by", "xform", "local_ofs"), &InputEvent::xformed_by, DEFVAL(Vector2()));
|
||||
|
||||
ADD_PROPERTY(PropertyInfo(Variant::INT, "device"), "set_device", "get_device");
|
||||
}
|
||||
|
||||
InputEvent::InputEvent() {
|
||||
device = 0;
|
||||
canceled = false;
|
||||
@ -179,29 +152,6 @@ uint32_t InputEventWithModifiers::get_modifiers_mask() const {
|
||||
return mask;
|
||||
}
|
||||
|
||||
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;
|
||||
@ -353,34 +303,6 @@ bool InputEventKey::shortcut_match(const Ref<InputEvent> &p_event, bool p_exact_
|
||||
}
|
||||
}
|
||||
|
||||
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_physical_scancode", "scancode"), &InputEventKey::set_physical_scancode);
|
||||
ClassDB::bind_method(D_METHOD("get_physical_scancode"), &InputEventKey::get_physical_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("set_action_match_force_exact", "unicode"), &InputEventKey::set_action_match_force_exact);
|
||||
ClassDB::bind_method(D_METHOD("is_action_match_force_exact"), &InputEventKey::is_action_match_force_exact);
|
||||
|
||||
ClassDB::bind_method(D_METHOD("get_scancode_with_modifiers"), &InputEventKey::get_scancode_with_modifiers);
|
||||
ClassDB::bind_method(D_METHOD("get_physical_scancode_with_modifiers"), &InputEventKey::get_physical_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, "physical_scancode"), "set_physical_scancode", "get_physical_scancode");
|
||||
ADD_PROPERTY(PropertyInfo(Variant::INT, "unicode"), "set_unicode", "get_unicode");
|
||||
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "echo"), "set_echo", "is_echo");
|
||||
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "action_match_force_exact"), "set_action_match_force_exact", "is_action_match_force_exact");
|
||||
}
|
||||
|
||||
InputEventKey::InputEventKey() {
|
||||
scancode = 0;
|
||||
physical_scancode = 0;
|
||||
@ -412,21 +334,6 @@ 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;
|
||||
}
|
||||
@ -565,26 +472,6 @@ String InputEventMouseButton::as_text() const {
|
||||
return "InputEventMouseButton : button_index=" + button_index_string + ", pressed=" + (pressed ? "true" : "false") + ", canceled=" + (canceled ? "true" : "false") + ", position=(" + String(get_position()) + "), button_mask=" + itos(get_button_mask()) + ", doubleclick=" + (doubleclick ? "true" : "false");
|
||||
}
|
||||
|
||||
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("set_canceled", "canceled"), &InputEventMouseButton::set_canceled);
|
||||
|
||||
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, "canceled"), "set_canceled", "is_canceled");
|
||||
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "doubleclick"), "set_doubleclick", "is_doubleclick");
|
||||
}
|
||||
|
||||
InputEventMouseButton::InputEventMouseButton() {
|
||||
factor = 1;
|
||||
button_index = 0;
|
||||
@ -726,29 +613,6 @@ bool InputEventMouseMotion::accumulate(const Ref<InputEvent> &p_event) {
|
||||
return true;
|
||||
}
|
||||
|
||||
void InputEventMouseMotion::_bind_methods() {
|
||||
ClassDB::bind_method(D_METHOD("set_tilt", "tilt"), &InputEventMouseMotion::set_tilt);
|
||||
ClassDB::bind_method(D_METHOD("get_tilt"), &InputEventMouseMotion::get_tilt);
|
||||
|
||||
ClassDB::bind_method(D_METHOD("set_pressure", "pressure"), &InputEventMouseMotion::set_pressure);
|
||||
ClassDB::bind_method(D_METHOD("get_pressure"), &InputEventMouseMotion::get_pressure);
|
||||
|
||||
ClassDB::bind_method(D_METHOD("set_pen_inverted", "pen_inverted"), &InputEventMouseMotion::set_pen_inverted);
|
||||
ClassDB::bind_method(D_METHOD("get_pen_inverted"), &InputEventMouseMotion::get_pen_inverted);
|
||||
|
||||
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, "tilt"), "set_tilt", "get_tilt");
|
||||
ADD_PROPERTY(PropertyInfo(Variant::REAL, "pressure"), "set_pressure", "get_pressure");
|
||||
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "pen_inverted"), "set_pen_inverted", "get_pen_inverted");
|
||||
ADD_PROPERTY(PropertyInfo(Variant::VECTOR2, "relative"), "set_relative", "get_relative");
|
||||
ADD_PROPERTY(PropertyInfo(Variant::VECTOR2, "speed"), "set_speed", "get_speed");
|
||||
}
|
||||
|
||||
InputEventMouseMotion::InputEventMouseMotion() {
|
||||
pressure = 0;
|
||||
pen_inverted = false;
|
||||
@ -827,17 +691,6 @@ String InputEventJoypadMotion::as_text() const {
|
||||
return "InputEventJoypadMotion : axis=" + itos(axis) + ", axis_value=" + String(Variant(axis_value));
|
||||
}
|
||||
|
||||
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;
|
||||
@ -900,20 +753,6 @@ String InputEventJoypadButton::as_text() const {
|
||||
return "InputEventJoypadButton : button_index=" + itos(button_index) + ", pressed=" + (is_pressed() ? "true" : "false") + ", pressure=" + String(Variant(pressure));
|
||||
}
|
||||
|
||||
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);
|
||||
|
||||
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;
|
||||
@ -966,26 +805,6 @@ String InputEventScreenTouch::as_text() const {
|
||||
return "InputEventScreenTouch : index=" + itos(index) + ", pressed=" + (pressed ? "true" : "false") + ", canceled=" + (canceled ? "true" : "false") + ", position=(" + String(get_position()) + "), double_tap=" + (double_tap ? "true" : "false");
|
||||
}
|
||||
|
||||
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", "position"), &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("set_canceled", "canceled"), &InputEventScreenTouch::set_canceled);
|
||||
|
||||
ClassDB::bind_method(D_METHOD("set_double_tap", "double_tap"), &InputEventScreenTouch::set_double_tap);
|
||||
ClassDB::bind_method(D_METHOD("is_double_tap"), &InputEventScreenTouch::is_double_tap);
|
||||
|
||||
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, "canceled"), "set_canceled", "is_canceled");
|
||||
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "pressed"), "set_pressed", "is_pressed");
|
||||
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "double_tap"), "set_double_tap", "is_double_tap");
|
||||
}
|
||||
|
||||
InputEventScreenTouch::InputEventScreenTouch() {
|
||||
index = 0;
|
||||
double_tap = false;
|
||||
@ -1058,25 +877,6 @@ bool InputEventScreenDrag::accumulate(const Ref<InputEvent> &p_event) {
|
||||
return true;
|
||||
}
|
||||
|
||||
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;
|
||||
}
|
||||
@ -1140,20 +940,6 @@ String InputEventAction::as_text() const {
|
||||
return "InputEventAction : action=" + action + ", pressed=(" + (is_pressed() ? "true" : "false");
|
||||
}
|
||||
|
||||
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("set_strength", "strength"), &InputEventAction::set_strength);
|
||||
ClassDB::bind_method(D_METHOD("get_strength"), &InputEventAction::get_strength);
|
||||
|
||||
ADD_PROPERTY(PropertyInfo(Variant::STRING_NAME, "action"), "set_action", "get_action");
|
||||
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "pressed"), "set_pressed", "is_pressed");
|
||||
ADD_PROPERTY(PropertyInfo(Variant::REAL, "strength", PROPERTY_HINT_RANGE, "0,1,0.01"), "set_strength", "get_strength");
|
||||
}
|
||||
|
||||
InputEventAction::InputEventAction() {
|
||||
strength = 1.0f;
|
||||
}
|
||||
@ -1163,13 +949,6 @@ void InputEventGesture::set_position(const Vector2 &p_pos) {
|
||||
pos = p_pos;
|
||||
}
|
||||
|
||||
void InputEventGesture::_bind_methods() {
|
||||
ClassDB::bind_method(D_METHOD("set_position", "position"), &InputEventGesture::set_position);
|
||||
ClassDB::bind_method(D_METHOD("get_position"), &InputEventGesture::get_position);
|
||||
|
||||
ADD_PROPERTY(PropertyInfo(Variant::VECTOR2, "position"), "set_position", "get_position");
|
||||
}
|
||||
|
||||
Vector2 InputEventGesture::get_position() const {
|
||||
return pos;
|
||||
}
|
||||
@ -1200,13 +979,6 @@ String InputEventMagnifyGesture::as_text() const {
|
||||
return "InputEventMagnifyGesture : factor=" + rtos(get_factor()) + ", position=(" + String(get_position()) + ")";
|
||||
}
|
||||
|
||||
void InputEventMagnifyGesture::_bind_methods() {
|
||||
ClassDB::bind_method(D_METHOD("set_factor", "factor"), &InputEventMagnifyGesture::set_factor);
|
||||
ClassDB::bind_method(D_METHOD("get_factor"), &InputEventMagnifyGesture::get_factor);
|
||||
|
||||
ADD_PROPERTY(PropertyInfo(Variant::REAL, "factor"), "set_factor", "get_factor");
|
||||
}
|
||||
|
||||
InputEventMagnifyGesture::InputEventMagnifyGesture() {
|
||||
factor = 1.0;
|
||||
}
|
||||
@ -1237,13 +1009,6 @@ String InputEventPanGesture::as_text() const {
|
||||
return "InputEventPanGesture : delta=(" + String(get_delta()) + "), position=(" + String(get_position()) + ")";
|
||||
}
|
||||
|
||||
void InputEventPanGesture::_bind_methods() {
|
||||
ClassDB::bind_method(D_METHOD("set_delta", "delta"), &InputEventPanGesture::set_delta);
|
||||
ClassDB::bind_method(D_METHOD("get_delta"), &InputEventPanGesture::get_delta);
|
||||
|
||||
ADD_PROPERTY(PropertyInfo(Variant::VECTOR2, "delta"), "set_delta", "get_delta");
|
||||
}
|
||||
|
||||
InputEventPanGesture::InputEventPanGesture() {
|
||||
delta = Vector2(0, 0);
|
||||
}
|
||||
@ -1317,34 +1082,6 @@ String InputEventMIDI::as_text() const {
|
||||
return "InputEventMIDI : channel=(" + itos(get_channel()) + "), message=(" + itos(get_message()) + ")";
|
||||
}
|
||||
|
||||
void InputEventMIDI::_bind_methods() {
|
||||
ClassDB::bind_method(D_METHOD("set_channel", "channel"), &InputEventMIDI::set_channel);
|
||||
ClassDB::bind_method(D_METHOD("get_channel"), &InputEventMIDI::get_channel);
|
||||
ClassDB::bind_method(D_METHOD("set_message", "message"), &InputEventMIDI::set_message);
|
||||
ClassDB::bind_method(D_METHOD("get_message"), &InputEventMIDI::get_message);
|
||||
ClassDB::bind_method(D_METHOD("set_pitch", "pitch"), &InputEventMIDI::set_pitch);
|
||||
ClassDB::bind_method(D_METHOD("get_pitch"), &InputEventMIDI::get_pitch);
|
||||
ClassDB::bind_method(D_METHOD("set_velocity", "velocity"), &InputEventMIDI::set_velocity);
|
||||
ClassDB::bind_method(D_METHOD("get_velocity"), &InputEventMIDI::get_velocity);
|
||||
ClassDB::bind_method(D_METHOD("set_instrument", "instrument"), &InputEventMIDI::set_instrument);
|
||||
ClassDB::bind_method(D_METHOD("get_instrument"), &InputEventMIDI::get_instrument);
|
||||
ClassDB::bind_method(D_METHOD("set_pressure", "pressure"), &InputEventMIDI::set_pressure);
|
||||
ClassDB::bind_method(D_METHOD("get_pressure"), &InputEventMIDI::get_pressure);
|
||||
ClassDB::bind_method(D_METHOD("set_controller_number", "controller_number"), &InputEventMIDI::set_controller_number);
|
||||
ClassDB::bind_method(D_METHOD("get_controller_number"), &InputEventMIDI::get_controller_number);
|
||||
ClassDB::bind_method(D_METHOD("set_controller_value", "controller_value"), &InputEventMIDI::set_controller_value);
|
||||
ClassDB::bind_method(D_METHOD("get_controller_value"), &InputEventMIDI::get_controller_value);
|
||||
|
||||
ADD_PROPERTY(PropertyInfo(Variant::INT, "channel"), "set_channel", "get_channel");
|
||||
ADD_PROPERTY(PropertyInfo(Variant::INT, "message"), "set_message", "get_message");
|
||||
ADD_PROPERTY(PropertyInfo(Variant::INT, "pitch"), "set_pitch", "get_pitch");
|
||||
ADD_PROPERTY(PropertyInfo(Variant::INT, "velocity"), "set_velocity", "get_velocity");
|
||||
ADD_PROPERTY(PropertyInfo(Variant::INT, "instrument"), "set_instrument", "get_instrument");
|
||||
ADD_PROPERTY(PropertyInfo(Variant::INT, "pressure"), "set_pressure", "get_pressure");
|
||||
ADD_PROPERTY(PropertyInfo(Variant::INT, "controller_number"), "set_controller_number", "get_controller_number");
|
||||
ADD_PROPERTY(PropertyInfo(Variant::INT, "controller_value"), "set_controller_value", "get_controller_value");
|
||||
}
|
||||
|
||||
InputEventMIDI::InputEventMIDI() {
|
||||
channel = 0;
|
||||
message = 0;
|
||||
@ -1367,13 +1104,6 @@ Ref<ShortCut> InputEventShortCut::get_shortcut() {
|
||||
return shortcut;
|
||||
}
|
||||
|
||||
void InputEventShortCut::_bind_methods() {
|
||||
ClassDB::bind_method(D_METHOD("set_shortcut", "shortcut"), &InputEventShortCut::set_shortcut);
|
||||
ClassDB::bind_method(D_METHOD("get_shortcut"), &InputEventShortCut::get_shortcut);
|
||||
|
||||
ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "shortcut", PROPERTY_HINT_RESOURCE_TYPE, "ShortCut"), "set_shortcut", "get_shortcut");
|
||||
}
|
||||
|
||||
String InputEventShortCut::as_text() const {
|
||||
ERR_FAIL_COND_V(shortcut.is_null(), "None");
|
||||
|
||||
|
@ -6,9 +6,9 @@
|
||||
/* From https://github.com/Relintai/pandemonium_engine (MIT) */
|
||||
/*************************************************************************/
|
||||
|
||||
#include "core/math/transform_2d.h"
|
||||
#include "core/object/resource.h"
|
||||
#include "core/string/ustring.h"
|
||||
#include "core/transform_2d.h"
|
||||
#include "object/resource.h"
|
||||
#include "core/ustring.h"
|
||||
#include "core/typedefs.h"
|
||||
|
||||
/**
|
||||
@ -172,7 +172,7 @@ enum MidiMessageList {
|
||||
*/
|
||||
|
||||
class InputEvent : public Resource {
|
||||
GDCLASS(InputEvent, Resource);
|
||||
SFW_OBJECT(InputEvent, Resource);
|
||||
|
||||
int device;
|
||||
|
||||
@ -180,8 +180,6 @@ protected:
|
||||
bool canceled;
|
||||
bool pressed;
|
||||
|
||||
static void _bind_methods();
|
||||
|
||||
public:
|
||||
static const int DEVICE_ID_TOUCH_MOUSE;
|
||||
static const int DEVICE_ID_INTERNAL;
|
||||
@ -214,7 +212,7 @@ public:
|
||||
};
|
||||
|
||||
class InputEventWithModifiers : public InputEvent {
|
||||
GDCLASS(InputEventWithModifiers, InputEvent);
|
||||
SFW_OBJECT(InputEventWithModifiers, InputEvent);
|
||||
|
||||
bool shift;
|
||||
bool alt;
|
||||
@ -234,9 +232,6 @@ class InputEventWithModifiers : public InputEvent {
|
||||
|
||||
#endif
|
||||
|
||||
protected:
|
||||
static void _bind_methods();
|
||||
|
||||
public:
|
||||
void set_shift(bool p_enabled);
|
||||
bool get_shift() const;
|
||||
@ -261,7 +256,7 @@ public:
|
||||
};
|
||||
|
||||
class InputEventKey : public InputEventWithModifiers {
|
||||
GDCLASS(InputEventKey, InputEventWithModifiers);
|
||||
SFW_OBJECT(InputEventKey, InputEventWithModifiers);
|
||||
|
||||
uint32_t scancode; ///< check keyboard.h , KeyCode enum, without modifier masks
|
||||
uint32_t physical_scancode;
|
||||
@ -271,9 +266,6 @@ class InputEventKey : public InputEventWithModifiers {
|
||||
|
||||
bool action_match_force_exact;
|
||||
|
||||
protected:
|
||||
static void _bind_methods();
|
||||
|
||||
public:
|
||||
void set_pressed(bool p_pressed);
|
||||
|
||||
@ -306,16 +298,13 @@ public:
|
||||
};
|
||||
|
||||
class InputEventMouse : public InputEventWithModifiers {
|
||||
GDCLASS(InputEventMouse, InputEventWithModifiers);
|
||||
SFW_OBJECT(InputEventMouse, InputEventWithModifiers);
|
||||
|
||||
int button_mask;
|
||||
|
||||
Vector2 pos;
|
||||
Vector2 global_pos;
|
||||
|
||||
protected:
|
||||
static void _bind_methods();
|
||||
|
||||
public:
|
||||
void set_button_mask(int p_mask);
|
||||
int get_button_mask() const;
|
||||
@ -330,15 +319,12 @@ public:
|
||||
};
|
||||
|
||||
class InputEventMouseButton : public InputEventMouse {
|
||||
GDCLASS(InputEventMouseButton, InputEventMouse);
|
||||
SFW_OBJECT(InputEventMouseButton, InputEventMouse);
|
||||
|
||||
float factor;
|
||||
int button_index;
|
||||
bool doubleclick; //last even less than doubleclick time
|
||||
|
||||
protected:
|
||||
static void _bind_methods();
|
||||
|
||||
public:
|
||||
void set_factor(float p_factor);
|
||||
float get_factor() const;
|
||||
@ -363,7 +349,7 @@ public:
|
||||
};
|
||||
|
||||
class InputEventMouseMotion : public InputEventMouse {
|
||||
GDCLASS(InputEventMouseMotion, InputEventMouse);
|
||||
SFW_OBJECT(InputEventMouseMotion, InputEventMouse);
|
||||
|
||||
Vector2 tilt;
|
||||
float pressure;
|
||||
@ -371,9 +357,6 @@ class InputEventMouseMotion : public InputEventMouse {
|
||||
Vector2 speed;
|
||||
bool pen_inverted;
|
||||
|
||||
protected:
|
||||
static void _bind_methods();
|
||||
|
||||
public:
|
||||
void set_tilt(const Vector2 &p_tilt);
|
||||
Vector2 get_tilt() const;
|
||||
@ -399,14 +382,11 @@ public:
|
||||
};
|
||||
|
||||
class InputEventJoypadMotion : public InputEvent {
|
||||
GDCLASS(InputEventJoypadMotion, InputEvent);
|
||||
SFW_OBJECT(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;
|
||||
@ -424,12 +404,10 @@ public:
|
||||
};
|
||||
|
||||
class InputEventJoypadButton : public InputEvent {
|
||||
GDCLASS(InputEventJoypadButton, InputEvent);
|
||||
SFW_OBJECT(InputEventJoypadButton, InputEvent);
|
||||
|
||||
int button_index;
|
||||
float pressure; //0 to 1
|
||||
protected:
|
||||
static void _bind_methods();
|
||||
|
||||
public:
|
||||
void set_button_index(int p_index);
|
||||
@ -450,14 +428,11 @@ public:
|
||||
};
|
||||
|
||||
class InputEventScreenTouch : public InputEvent {
|
||||
GDCLASS(InputEventScreenTouch, InputEvent);
|
||||
SFW_OBJECT(InputEventScreenTouch, InputEvent);
|
||||
int index;
|
||||
Vector2 pos;
|
||||
bool double_tap;
|
||||
|
||||
protected:
|
||||
static void _bind_methods();
|
||||
|
||||
public:
|
||||
void set_index(int p_index);
|
||||
int get_index() const;
|
||||
@ -478,15 +453,12 @@ public:
|
||||
};
|
||||
|
||||
class InputEventScreenDrag : public InputEvent {
|
||||
GDCLASS(InputEventScreenDrag, InputEvent);
|
||||
SFW_OBJECT(InputEventScreenDrag, InputEvent);
|
||||
int index;
|
||||
Vector2 pos;
|
||||
Vector2 relative;
|
||||
Vector2 speed;
|
||||
|
||||
protected:
|
||||
static void _bind_methods();
|
||||
|
||||
public:
|
||||
void set_index(int p_index);
|
||||
int get_index() const;
|
||||
@ -509,14 +481,11 @@ public:
|
||||
};
|
||||
|
||||
class InputEventAction : public InputEvent {
|
||||
GDCLASS(InputEventAction, InputEvent);
|
||||
SFW_OBJECT(InputEventAction, InputEvent);
|
||||
|
||||
StringName action;
|
||||
float strength;
|
||||
|
||||
protected:
|
||||
static void _bind_methods();
|
||||
|
||||
public:
|
||||
void set_action(const StringName &p_action);
|
||||
StringName get_action() const;
|
||||
@ -538,25 +507,19 @@ public:
|
||||
};
|
||||
|
||||
class InputEventGesture : public InputEventWithModifiers {
|
||||
GDCLASS(InputEventGesture, InputEventWithModifiers);
|
||||
SFW_OBJECT(InputEventGesture, InputEventWithModifiers);
|
||||
|
||||
Vector2 pos;
|
||||
|
||||
protected:
|
||||
static void _bind_methods();
|
||||
|
||||
public:
|
||||
void set_position(const Vector2 &p_pos);
|
||||
Vector2 get_position() const;
|
||||
};
|
||||
|
||||
class InputEventMagnifyGesture : public InputEventGesture {
|
||||
GDCLASS(InputEventMagnifyGesture, InputEventGesture);
|
||||
SFW_OBJECT(InputEventMagnifyGesture, InputEventGesture);
|
||||
real_t factor;
|
||||
|
||||
protected:
|
||||
static void _bind_methods();
|
||||
|
||||
public:
|
||||
void set_factor(real_t p_factor);
|
||||
real_t get_factor() const;
|
||||
@ -568,12 +531,9 @@ public:
|
||||
};
|
||||
|
||||
class InputEventPanGesture : public InputEventGesture {
|
||||
GDCLASS(InputEventPanGesture, InputEventGesture);
|
||||
SFW_OBJECT(InputEventPanGesture, InputEventGesture);
|
||||
Vector2 delta;
|
||||
|
||||
protected:
|
||||
static void _bind_methods();
|
||||
|
||||
public:
|
||||
void set_delta(const Vector2 &p_delta);
|
||||
Vector2 get_delta() const;
|
||||
@ -585,7 +545,7 @@ public:
|
||||
};
|
||||
|
||||
class InputEventMIDI : public InputEvent {
|
||||
GDCLASS(InputEventMIDI, InputEvent);
|
||||
SFW_OBJECT(InputEventMIDI, InputEvent);
|
||||
|
||||
int channel;
|
||||
int message;
|
||||
@ -596,9 +556,6 @@ class InputEventMIDI : public InputEvent {
|
||||
int controller_number;
|
||||
int controller_value;
|
||||
|
||||
protected:
|
||||
static void _bind_methods();
|
||||
|
||||
public:
|
||||
void set_channel(const int p_channel);
|
||||
int get_channel() const;
|
||||
@ -630,13 +587,10 @@ public:
|
||||
};
|
||||
|
||||
class InputEventShortCut : public InputEvent {
|
||||
GDCLASS(InputEventShortCut, InputEvent);
|
||||
SFW_OBJECT(InputEventShortCut, InputEvent);
|
||||
|
||||
Ref<ShortCut> shortcut;
|
||||
|
||||
protected:
|
||||
static void _bind_methods();
|
||||
|
||||
public:
|
||||
void set_shortcut(Ref<ShortCut> p_shortcut);
|
||||
Ref<ShortCut> get_shortcut();
|
||||
|
@ -5,31 +5,13 @@
|
||||
|
||||
#include "input_map.h"
|
||||
|
||||
#include "core/config/project_settings.h"
|
||||
#include "core/input/input.h"
|
||||
#include "core/os/keyboard.h"
|
||||
#include "render_core/input/input.h"
|
||||
#include "render_core/input/keyboard.h"
|
||||
|
||||
InputMap *InputMap::singleton = nullptr;
|
||||
|
||||
int InputMap::ALL_DEVICES = -1;
|
||||
|
||||
void InputMap::_bind_methods() {
|
||||
ClassDB::bind_method(D_METHOD("has_action", "action"), &InputMap::has_action);
|
||||
ClassDB::bind_method(D_METHOD("get_actions"), &InputMap::_get_actions);
|
||||
ClassDB::bind_method(D_METHOD("add_action", "action", "deadzone"), &InputMap::add_action, DEFVAL(0.5f));
|
||||
ClassDB::bind_method(D_METHOD("erase_action", "action"), &InputMap::erase_action);
|
||||
|
||||
ClassDB::bind_method(D_METHOD("action_set_deadzone", "action", "deadzone"), &InputMap::action_set_deadzone);
|
||||
ClassDB::bind_method(D_METHOD("action_get_deadzone", "action"), &InputMap::action_get_deadzone);
|
||||
ClassDB::bind_method(D_METHOD("action_add_event", "action", "event"), &InputMap::action_add_event);
|
||||
ClassDB::bind_method(D_METHOD("action_has_event", "action", "event"), &InputMap::action_has_event);
|
||||
ClassDB::bind_method(D_METHOD("action_erase_event", "action", "event"), &InputMap::action_erase_event);
|
||||
ClassDB::bind_method(D_METHOD("action_erase_events", "action"), &InputMap::action_erase_events);
|
||||
ClassDB::bind_method(D_METHOD("get_action_list", "action"), &InputMap::_get_action_list);
|
||||
ClassDB::bind_method(D_METHOD("event_is_action", "event", "action", "exact_match"), &InputMap::event_is_action, DEFVAL(false));
|
||||
ClassDB::bind_method(D_METHOD("load_from_globals"), &InputMap::load_from_globals);
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns an nonexistent action error message with a suggestion of the closest
|
||||
* matching action name (if possible).
|
||||
@ -236,36 +218,6 @@ const RBMap<StringName, InputMap::Action> &InputMap::get_action_map() const {
|
||||
return input_map;
|
||||
}
|
||||
|
||||
void InputMap::load_from_globals() {
|
||||
input_map.clear();
|
||||
|
||||
List<PropertyInfo> pinfo;
|
||||
ProjectSettings::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());
|
||||
|
||||
Dictionary action = ProjectSettings::get_singleton()->get(pi.name);
|
||||
float deadzone = action.has("deadzone") ? (float)action["deadzone"] : 0.5f;
|
||||
Array events = action["events"];
|
||||
|
||||
add_action(name, deadzone);
|
||||
for (int i = 0; i < events.size(); i++) {
|
||||
Ref<InputEvent> event = events[i];
|
||||
if (event.is_null()) {
|
||||
continue;
|
||||
}
|
||||
action_add_event(name, event);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void InputMap::load_default() {
|
||||
Ref<InputEventKey> key;
|
||||
|
||||
|
@ -6,11 +6,12 @@
|
||||
/* From https://github.com/Relintai/pandemonium_engine (MIT) */
|
||||
/*************************************************************************/
|
||||
|
||||
#include "core/input/input_event.h"
|
||||
#include "core/object/object.h"
|
||||
#include "render_core/input/input_event.h"
|
||||
#include "object/object.h"
|
||||
#include "core/rb_map.h"
|
||||
|
||||
class InputMap : public Object {
|
||||
GDCLASS(InputMap, Object);
|
||||
SFW_OBJECT(InputMap, Object);
|
||||
|
||||
public:
|
||||
/**
|
||||
@ -34,9 +35,6 @@ private:
|
||||
Array _get_action_list(const StringName &p_action);
|
||||
Array _get_actions();
|
||||
|
||||
protected:
|
||||
static void _bind_methods();
|
||||
|
||||
public:
|
||||
static _FORCE_INLINE_ InputMap *get_singleton() { return singleton; }
|
||||
|
||||
@ -57,7 +55,6 @@ public:
|
||||
bool event_get_action_status(const Ref<InputEvent> &p_event, const StringName &p_action, bool p_exact_match = false, bool *p_pressed = nullptr, float *p_strength = nullptr, float *p_raw_strength = nullptr) const;
|
||||
|
||||
const RBMap<StringName, Action> &get_action_map() const;
|
||||
void load_from_globals();
|
||||
void load_default();
|
||||
|
||||
String suggest_actions(const StringName &p_action) const;
|
||||
|
@ -5,7 +5,7 @@
|
||||
|
||||
#include "shortcut.h"
|
||||
|
||||
#include "core/render_core/input_event.h"
|
||||
#include "render_core/input/input_event.h"
|
||||
|
||||
void ShortCut::set_shortcut(const Ref<InputEvent> &p_shortcut) {
|
||||
shortcut = p_shortcut;
|
||||
|
@ -6,12 +6,12 @@
|
||||
/* From https://github.com/Relintai/pandemonium_engine (MIT) */
|
||||
/*************************************************************************/
|
||||
|
||||
#include "resource.h"
|
||||
#include "object/resource.h"
|
||||
|
||||
class InputEvent;
|
||||
|
||||
class ShortCut : public Resource {
|
||||
GDCLASS(ShortCut, Resource);
|
||||
SFW_OBJECT(ShortCut, Resource);
|
||||
|
||||
public:
|
||||
void set_shortcut(const Ref<InputEvent> &p_shortcut);
|
||||
|
@ -18,7 +18,7 @@
|
||||
This class is set apart that it assumes a single surface is always generated for our mesh.
|
||||
*/
|
||||
class PrimitiveMesh : public Mesh {
|
||||
GDCLASS(PrimitiveMesh, Mesh);
|
||||
SFW_OBJECT(PrimitiveMesh, Mesh);
|
||||
|
||||
private:
|
||||
RID mesh;
|
||||
@ -74,7 +74,7 @@ public:
|
||||
Mesh for a simple capsule
|
||||
*/
|
||||
class CapsuleMesh : public PrimitiveMesh {
|
||||
GDCLASS(CapsuleMesh, PrimitiveMesh);
|
||||
SFW_OBJECT(CapsuleMesh, PrimitiveMesh);
|
||||
|
||||
private:
|
||||
float radius;
|
||||
@ -108,7 +108,7 @@ public:
|
||||
Similar to test cube but with subdivision support and different texture coordinates
|
||||
*/
|
||||
class CubeMesh : public PrimitiveMesh {
|
||||
GDCLASS(CubeMesh, PrimitiveMesh);
|
||||
SFW_OBJECT(CubeMesh, PrimitiveMesh);
|
||||
|
||||
private:
|
||||
Vector3 size;
|
||||
@ -143,7 +143,7 @@ public:
|
||||
*/
|
||||
|
||||
class CylinderMesh : public PrimitiveMesh {
|
||||
GDCLASS(CylinderMesh, PrimitiveMesh);
|
||||
SFW_OBJECT(CylinderMesh, PrimitiveMesh);
|
||||
|
||||
private:
|
||||
float top_radius;
|
||||
@ -181,7 +181,7 @@ public:
|
||||
Similar to quadmesh but with tessellation support
|
||||
*/
|
||||
class PlaneMesh : public PrimitiveMesh {
|
||||
GDCLASS(PlaneMesh, PrimitiveMesh);
|
||||
SFW_OBJECT(PlaneMesh, PrimitiveMesh);
|
||||
|
||||
private:
|
||||
Size2 size;
|
||||
@ -213,7 +213,7 @@ public:
|
||||
A prism shapen, handy for ramps, triangles, etc.
|
||||
*/
|
||||
class PrismMesh : public PrimitiveMesh {
|
||||
GDCLASS(PrismMesh, PrimitiveMesh);
|
||||
SFW_OBJECT(PrismMesh, PrimitiveMesh);
|
||||
|
||||
private:
|
||||
float left_to_right;
|
||||
@ -250,7 +250,7 @@ public:
|
||||
*/
|
||||
|
||||
class QuadMesh : public PrimitiveMesh {
|
||||
GDCLASS(QuadMesh, PrimitiveMesh);
|
||||
SFW_OBJECT(QuadMesh, PrimitiveMesh);
|
||||
|
||||
private:
|
||||
Size2 size;
|
||||
@ -274,7 +274,7 @@ public:
|
||||
A sphere..
|
||||
*/
|
||||
class SphereMesh : public PrimitiveMesh {
|
||||
GDCLASS(SphereMesh, PrimitiveMesh);
|
||||
SFW_OBJECT(SphereMesh, PrimitiveMesh);
|
||||
|
||||
private:
|
||||
float radius;
|
||||
@ -313,7 +313,7 @@ public:
|
||||
*/
|
||||
|
||||
class PointMesh : public PrimitiveMesh {
|
||||
GDCLASS(PointMesh, PrimitiveMesh)
|
||||
SFW_OBJECT(PointMesh, PrimitiveMesh)
|
||||
|
||||
protected:
|
||||
virtual void _create_mesh_array(Array &p_arr) const;
|
||||
@ -327,7 +327,7 @@ public:
|
||||
*/
|
||||
|
||||
class TextMesh : public PrimitiveMesh {
|
||||
GDCLASS(TextMesh, PrimitiveMesh);
|
||||
SFW_OBJECT(TextMesh, PrimitiveMesh);
|
||||
|
||||
public:
|
||||
enum Align {
|
||||
|
@ -1,5 +1,14 @@
|
||||
#include "render_core/scene.h"
|
||||
|
||||
#include "render_core/input/input_event.h"
|
||||
|
||||
void Scene::input_event(const Ref<InputEvent> &event) {
|
||||
}
|
||||
void Scene::update(float delta) {
|
||||
}
|
||||
void Scene::render() {
|
||||
}
|
||||
|
||||
Scene::Scene() {
|
||||
}
|
||||
|
||||
|
@ -1,14 +1,20 @@
|
||||
#ifndef SCENE_H
|
||||
#define SCENE_H
|
||||
|
||||
class Scene {
|
||||
public:
|
||||
virtual void event() = 0;
|
||||
virtual void update(float delta) = 0;
|
||||
virtual void render() = 0;
|
||||
#include "object/reference.h"
|
||||
|
||||
Scene();
|
||||
virtual ~Scene();
|
||||
class InputEvent;
|
||||
|
||||
class Scene : Reference {
|
||||
SFW_OBJECT(Scene, Reference);
|
||||
|
||||
public:
|
||||
virtual void input_event(const Ref<InputEvent> &event);
|
||||
virtual void update(float delta);
|
||||
virtual void render();
|
||||
|
||||
Scene();
|
||||
virtual ~Scene();
|
||||
};
|
||||
|
||||
#endif // APPLICATION_H
|
||||
|
@ -65,18 +65,25 @@ public:
|
||||
|
||||
void set_focus(); // window attribute using haz catz language for now
|
||||
int has_focus();
|
||||
|
||||
void set_fullscreen(int enabled);
|
||||
int has_fullscreen();
|
||||
|
||||
void set_cursor(int visible);
|
||||
int has_cursor();
|
||||
|
||||
void set_pause(int paused);
|
||||
int has_pause();
|
||||
|
||||
void set_visible(int visible);
|
||||
int has_visible();
|
||||
|
||||
void set_maximize(int enabled);
|
||||
int has_maximize();
|
||||
|
||||
void set_transparent(int enabled);
|
||||
int has_transparent();
|
||||
|
||||
void set_icon(const char *file_icon);
|
||||
int has_icon();
|
||||
|
||||
|
Loading…
Reference in New Issue
Block a user