Display Server support
This commit is contained in:
PouleyKetchoupp
parent
af424b1c7c
commit
e167af3737
|
|
@ -7,7 +7,12 @@ env.add_source_files(env.drivers_sources, "*.cpp")
|
|||
if env["platform"] == "android":
|
||||
# Use NDK Vulkan headers
|
||||
thirdparty_dir = env["ANDROID_NDK_ROOT"] + "/sources/third_party/vulkan/src"
|
||||
thirdparty_includes = [thirdparty_dir, thirdparty_dir + "/include", thirdparty_dir + "/layers", thirdparty_dir + "/layers/generated"]
|
||||
thirdparty_includes = [
|
||||
thirdparty_dir,
|
||||
thirdparty_dir + "/include",
|
||||
thirdparty_dir + "/layers",
|
||||
thirdparty_dir + "/layers/generated",
|
||||
]
|
||||
env.Prepend(CPPPATH=thirdparty_includes)
|
||||
elif env["builtin_vulkan"]:
|
||||
# Use bundled Vulkan headers
|
||||
|
|
|
|||
|
|
@ -1564,7 +1564,10 @@ RID RenderingDeviceVulkan::texture_create(const TextureFormat &p_format, const T
|
|||
image_create_info.pNext = nullptr;
|
||||
image_create_info.flags = 0;
|
||||
|
||||
// TODO: vkCreateImage fails with format list on Android (VK_ERROR_OUT_OF_HOST_MEMORY)
|
||||
#ifndef _MSC_VER
|
||||
#warning TODO check for support via RenderingDevice to enable on mobile when possible
|
||||
#endif
|
||||
// vkCreateImage fails with format list on Android (VK_ERROR_OUT_OF_HOST_MEMORY)
|
||||
#ifndef ANDROID_ENABLED
|
||||
if (p_format.shareable_formats.size()) {
|
||||
image_create_info.flags |= VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT;
|
||||
|
|
|
|||
|
|
@ -37,8 +37,10 @@
|
|||
#include "servers/rendering/rendering_device.h"
|
||||
|
||||
#ifdef DEBUG_ENABLED
|
||||
#ifndef _DEBUG
|
||||
#define _DEBUG
|
||||
#endif
|
||||
#endif
|
||||
#include "vk_mem_alloc.h"
|
||||
#include <vulkan/vulkan.h>
|
||||
//todo:
|
||||
|
|
|
|||
|
|
@ -17,8 +17,8 @@ android_files = [
|
|||
"java_godot_io_wrapper.cpp",
|
||||
"jni_utils.cpp",
|
||||
"android_keys_utils.cpp",
|
||||
"plugin/godot_plugin_jni.cpp",
|
||||
"vulkan/vulkan_context_android.cpp"
|
||||
"display_server_android.cpp",
|
||||
"vulkan/vulkan_context_android.cpp",
|
||||
]
|
||||
|
||||
env_android = env.Clone()
|
||||
|
|
|
|||
|
|
@ -0,0 +1,655 @@
|
|||
/*************************************************************************/
|
||||
/* display_server_android.cpp */
|
||||
/*************************************************************************/
|
||||
/* This file is part of: */
|
||||
/* GODOT ENGINE */
|
||||
/* https://godotengine.org */
|
||||
/*************************************************************************/
|
||||
/* Copyright (c) 2007-2020 Juan Linietsky, Ariel Manzur. */
|
||||
/* Copyright (c) 2014-2020 Godot Engine contributors (cf. AUTHORS.md). */
|
||||
/* */
|
||||
/* Permission is hereby granted, free of charge, to any person obtaining */
|
||||
/* a copy of this software and associated documentation files (the */
|
||||
/* "Software"), to deal in the Software without restriction, including */
|
||||
/* without limitation the rights to use, copy, modify, merge, publish, */
|
||||
/* distribute, sublicense, and/or sell copies of the Software, and to */
|
||||
/* permit persons to whom the Software is furnished to do so, subject to */
|
||||
/* the following conditions: */
|
||||
/* */
|
||||
/* The above copyright notice and this permission notice shall be */
|
||||
/* included in all copies or substantial portions of the Software. */
|
||||
/* */
|
||||
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
|
||||
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
|
||||
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
|
||||
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
|
||||
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
|
||||
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
|
||||
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
|
||||
/*************************************************************************/
|
||||
|
||||
#include "display_server_android.h"
|
||||
|
||||
#include "android_keys_utils.h"
|
||||
#include "core/project_settings.h"
|
||||
#include "java_godot_io_wrapper.h"
|
||||
#include "java_godot_wrapper.h"
|
||||
#include "os_android.h"
|
||||
|
||||
#if defined(OPENGL_ENABLED)
|
||||
#include "drivers/gles2/rasterizer_gles2.h"
|
||||
#endif
|
||||
#if defined(VULKAN_ENABLED)
|
||||
#include "drivers/vulkan/rendering_device_vulkan.h"
|
||||
#include "platform/android/vulkan/vulkan_context_android.h"
|
||||
#include "servers/rendering/rasterizer_rd/rasterizer_rd.h"
|
||||
#endif
|
||||
|
||||
DisplayServerAndroid *DisplayServerAndroid::get_singleton() {
|
||||
return (DisplayServerAndroid *)DisplayServer::get_singleton();
|
||||
}
|
||||
|
||||
bool DisplayServerAndroid::has_feature(Feature p_feature) const {
|
||||
switch (p_feature) {
|
||||
//case FEATURE_CONSOLE_WINDOW:
|
||||
//case FEATURE_CURSOR_SHAPE:
|
||||
//case FEATURE_CUSTOM_CURSOR_SHAPE:
|
||||
//case FEATURE_GLOBAL_MENU:
|
||||
//case FEATURE_HIDPI:
|
||||
//case FEATURE_ICON:
|
||||
//case FEATURE_IME:
|
||||
//case FEATURE_MOUSE:
|
||||
//case FEATURE_MOUSE_WARP:
|
||||
//case FEATURE_NATIVE_DIALOG:
|
||||
//case FEATURE_NATIVE_ICON:
|
||||
//case FEATURE_NATIVE_VIDEO:
|
||||
//case FEATURE_WINDOW_TRANSPARENCY:
|
||||
case FEATURE_CLIPBOARD:
|
||||
case FEATURE_KEEP_SCREEN_ON:
|
||||
case FEATURE_ORIENTATION:
|
||||
case FEATURE_TOUCHSCREEN:
|
||||
case FEATURE_VIRTUAL_KEYBOARD:
|
||||
return true;
|
||||
default:
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
String DisplayServerAndroid::get_name() const {
|
||||
return "Android";
|
||||
}
|
||||
|
||||
void DisplayServerAndroid::clipboard_set(const String &p_text) {
|
||||
GodotJavaWrapper *godot_java = OS_Android::get_singleton()->get_godot_java();
|
||||
ERR_FAIL_COND(!godot_java);
|
||||
|
||||
if (godot_java->has_set_clipboard()) {
|
||||
godot_java->set_clipboard(p_text);
|
||||
} else {
|
||||
DisplayServer::clipboard_set(p_text);
|
||||
}
|
||||
}
|
||||
|
||||
String DisplayServerAndroid::clipboard_get() const {
|
||||
GodotJavaWrapper *godot_java = OS_Android::get_singleton()->get_godot_java();
|
||||
ERR_FAIL_COND_V(!godot_java, String());
|
||||
|
||||
if (godot_java->has_get_clipboard()) {
|
||||
return godot_java->get_clipboard();
|
||||
} else {
|
||||
return DisplayServer::clipboard_get();
|
||||
}
|
||||
}
|
||||
|
||||
void DisplayServerAndroid::screen_set_keep_on(bool p_enable) {
|
||||
GodotJavaWrapper *godot_java = OS_Android::get_singleton()->get_godot_java();
|
||||
ERR_FAIL_COND(!godot_java);
|
||||
|
||||
godot_java->set_keep_screen_on(p_enable);
|
||||
keep_screen_on = p_enable;
|
||||
}
|
||||
|
||||
bool DisplayServerAndroid::screen_is_kept_on() const {
|
||||
return keep_screen_on;
|
||||
}
|
||||
|
||||
void DisplayServerAndroid::screen_set_orientation(DisplayServer::ScreenOrientation p_orientation, int p_screen) {
|
||||
GodotIOJavaWrapper *godot_io_java = OS_Android::get_singleton()->get_godot_io_java();
|
||||
ERR_FAIL_COND(!godot_io_java);
|
||||
|
||||
godot_io_java->set_screen_orientation(p_orientation);
|
||||
}
|
||||
|
||||
DisplayServer::ScreenOrientation DisplayServerAndroid::screen_get_orientation(int p_screen) const {
|
||||
GodotIOJavaWrapper *godot_io_java = OS_Android::get_singleton()->get_godot_io_java();
|
||||
ERR_FAIL_COND_V(!godot_io_java, SCREEN_LANDSCAPE);
|
||||
|
||||
return (ScreenOrientation)godot_io_java->get_screen_orientation();
|
||||
}
|
||||
|
||||
int DisplayServerAndroid::get_screen_count() const {
|
||||
return 1;
|
||||
}
|
||||
|
||||
Point2i DisplayServerAndroid::screen_get_position(int p_screen) const {
|
||||
return Point2i(0, 0);
|
||||
}
|
||||
|
||||
Size2i DisplayServerAndroid::screen_get_size(int p_screen) const {
|
||||
return OS_Android::get_singleton()->get_display_size();
|
||||
}
|
||||
|
||||
Rect2i DisplayServerAndroid::screen_get_usable_rect(int p_screen) const {
|
||||
Size2i display_size = OS_Android::get_singleton()->get_display_size();
|
||||
return Rect2i(0, 0, display_size.width, display_size.height);
|
||||
}
|
||||
|
||||
int DisplayServerAndroid::screen_get_dpi(int p_screen) const {
|
||||
GodotIOJavaWrapper *godot_io_java = OS_Android::get_singleton()->get_godot_io_java();
|
||||
ERR_FAIL_COND_V(!godot_io_java, 0);
|
||||
|
||||
return godot_io_java->get_screen_dpi();
|
||||
}
|
||||
|
||||
bool DisplayServerAndroid::screen_is_touchscreen(int p_screen) const {
|
||||
return true;
|
||||
}
|
||||
|
||||
void DisplayServerAndroid::virtual_keyboard_show(const String &p_existing_text, const Rect2 &p_screen_rect, int p_max_length) {
|
||||
GodotIOJavaWrapper *godot_io_java = OS_Android::get_singleton()->get_godot_io_java();
|
||||
ERR_FAIL_COND(!godot_io_java);
|
||||
|
||||
if (godot_io_java->has_vk()) {
|
||||
godot_io_java->show_vk(p_existing_text, p_max_length);
|
||||
} else {
|
||||
ERR_PRINT("Virtual keyboard not available");
|
||||
}
|
||||
}
|
||||
|
||||
void DisplayServerAndroid::virtual_keyboard_hide() {
|
||||
GodotIOJavaWrapper *godot_io_java = OS_Android::get_singleton()->get_godot_io_java();
|
||||
ERR_FAIL_COND(!godot_io_java);
|
||||
|
||||
if (godot_io_java->has_vk()) {
|
||||
godot_io_java->hide_vk();
|
||||
} else {
|
||||
ERR_PRINT("Virtual keyboard not available");
|
||||
}
|
||||
}
|
||||
|
||||
int DisplayServerAndroid::virtual_keyboard_get_height() const {
|
||||
GodotIOJavaWrapper *godot_io_java = OS_Android::get_singleton()->get_godot_io_java();
|
||||
ERR_FAIL_COND_V(!godot_io_java, 0);
|
||||
|
||||
return godot_io_java->get_vk_height();
|
||||
}
|
||||
|
||||
void DisplayServerAndroid::window_set_window_event_callback(const Callable &p_callable, DisplayServer::WindowID p_window) {
|
||||
window_event_callback = p_callable;
|
||||
}
|
||||
|
||||
void DisplayServerAndroid::window_set_input_event_callback(const Callable &p_callable, DisplayServer::WindowID p_window) {
|
||||
input_event_callback = p_callable;
|
||||
}
|
||||
|
||||
void DisplayServerAndroid::window_set_input_text_callback(const Callable &p_callable, DisplayServer::WindowID p_window) {
|
||||
input_text_callback = p_callable;
|
||||
}
|
||||
|
||||
void DisplayServerAndroid::window_set_rect_changed_callback(const Callable &p_callable, DisplayServer::WindowID p_window) {
|
||||
// Not supported on Android.
|
||||
}
|
||||
|
||||
void DisplayServerAndroid::window_set_drop_files_callback(const Callable &p_callable, DisplayServer::WindowID p_window) {
|
||||
// Not supported on Android.
|
||||
}
|
||||
|
||||
void DisplayServerAndroid::_window_callback(const Callable &p_callable, const Variant &p_arg) const {
|
||||
if (!p_callable.is_null()) {
|
||||
const Variant *argp = &p_arg;
|
||||
Variant ret;
|
||||
Callable::CallError ce;
|
||||
p_callable.call((const Variant **)&argp, 1, ret, ce);
|
||||
}
|
||||
}
|
||||
|
||||
void DisplayServerAndroid::send_window_event(DisplayServer::WindowEvent p_event) const {
|
||||
_window_callback(window_event_callback, int(p_event));
|
||||
}
|
||||
|
||||
void DisplayServerAndroid::send_input_event(const Ref<InputEvent> &p_event) const {
|
||||
_window_callback(input_event_callback, p_event);
|
||||
}
|
||||
|
||||
void DisplayServerAndroid::send_input_text(const String &p_text) const {
|
||||
_window_callback(input_text_callback, p_text);
|
||||
}
|
||||
|
||||
void DisplayServerAndroid::_dispatch_input_events(const Ref<InputEvent> &p_event) {
|
||||
DisplayServerAndroid::get_singleton()->send_input_event(p_event);
|
||||
}
|
||||
|
||||
Vector<DisplayServer::WindowID> DisplayServerAndroid::get_window_list() const {
|
||||
Vector<WindowID> ret;
|
||||
ret.push_back(MAIN_WINDOW_ID);
|
||||
return ret;
|
||||
}
|
||||
|
||||
DisplayServer::WindowID DisplayServerAndroid::get_window_at_screen_position(const Point2i &p_position) const {
|
||||
return MAIN_WINDOW_ID;
|
||||
}
|
||||
|
||||
void DisplayServerAndroid::window_attach_instance_id(ObjectID p_instance, DisplayServer::WindowID p_window) {
|
||||
window_attached_instance_id = p_instance;
|
||||
}
|
||||
|
||||
ObjectID DisplayServerAndroid::window_get_attached_instance_id(DisplayServer::WindowID p_window) const {
|
||||
return window_attached_instance_id;
|
||||
}
|
||||
|
||||
void DisplayServerAndroid::window_set_title(const String &p_title, DisplayServer::WindowID p_window) {
|
||||
// Not supported on Android.
|
||||
}
|
||||
|
||||
int DisplayServerAndroid::window_get_current_screen(DisplayServer::WindowID p_window) const {
|
||||
return SCREEN_OF_MAIN_WINDOW;
|
||||
}
|
||||
|
||||
void DisplayServerAndroid::window_set_current_screen(int p_screen, DisplayServer::WindowID p_window) {
|
||||
// Not supported on Android.
|
||||
}
|
||||
|
||||
Point2i DisplayServerAndroid::window_get_position(DisplayServer::WindowID p_window) const {
|
||||
return Point2i();
|
||||
}
|
||||
|
||||
void DisplayServerAndroid::window_set_position(const Point2i &p_position, DisplayServer::WindowID p_window) {
|
||||
// Not supported on Android.
|
||||
}
|
||||
|
||||
void DisplayServerAndroid::window_set_transient(DisplayServer::WindowID p_window, DisplayServer::WindowID p_parent) {
|
||||
// Not supported on Android.
|
||||
}
|
||||
|
||||
void DisplayServerAndroid::window_set_max_size(const Size2i p_size, DisplayServer::WindowID p_window) {
|
||||
// Not supported on Android.
|
||||
}
|
||||
|
||||
Size2i DisplayServerAndroid::window_get_max_size(DisplayServer::WindowID p_window) const {
|
||||
return Size2i();
|
||||
}
|
||||
|
||||
void DisplayServerAndroid::window_set_min_size(const Size2i p_size, DisplayServer::WindowID p_window) {
|
||||
// Not supported on Android.
|
||||
}
|
||||
|
||||
Size2i DisplayServerAndroid::window_get_min_size(DisplayServer::WindowID p_window) const {
|
||||
return Size2i();
|
||||
}
|
||||
|
||||
void DisplayServerAndroid::window_set_size(const Size2i p_size, DisplayServer::WindowID p_window) {
|
||||
// Not supported on Android.
|
||||
}
|
||||
|
||||
Size2i DisplayServerAndroid::window_get_size(DisplayServer::WindowID p_window) const {
|
||||
return OS_Android::get_singleton()->get_display_size();
|
||||
}
|
||||
|
||||
Size2i DisplayServerAndroid::window_get_real_size(DisplayServer::WindowID p_window) const {
|
||||
return OS_Android::get_singleton()->get_display_size();
|
||||
}
|
||||
|
||||
void DisplayServerAndroid::window_set_mode(DisplayServer::WindowMode p_mode, DisplayServer::WindowID p_window) {
|
||||
// Not supported on Android.
|
||||
}
|
||||
|
||||
DisplayServer::WindowMode DisplayServerAndroid::window_get_mode(DisplayServer::WindowID p_window) const {
|
||||
return WINDOW_MODE_FULLSCREEN;
|
||||
}
|
||||
|
||||
bool DisplayServerAndroid::window_is_maximize_allowed(DisplayServer::WindowID p_window) const {
|
||||
return false;
|
||||
}
|
||||
|
||||
void DisplayServerAndroid::window_set_flag(DisplayServer::WindowFlags p_flag, bool p_enabled, DisplayServer::WindowID p_window) {
|
||||
// Not supported on Android.
|
||||
}
|
||||
|
||||
bool DisplayServerAndroid::window_get_flag(DisplayServer::WindowFlags p_flag, DisplayServer::WindowID p_window) const {
|
||||
return false;
|
||||
}
|
||||
|
||||
void DisplayServerAndroid::window_request_attention(DisplayServer::WindowID p_window) {
|
||||
// Not supported on Android.
|
||||
}
|
||||
|
||||
void DisplayServerAndroid::window_move_to_foreground(DisplayServer::WindowID p_window) {
|
||||
// Not supported on Android.
|
||||
}
|
||||
|
||||
bool DisplayServerAndroid::window_can_draw(DisplayServer::WindowID p_window) const {
|
||||
return true;
|
||||
}
|
||||
|
||||
bool DisplayServerAndroid::can_any_window_draw() const {
|
||||
return true;
|
||||
}
|
||||
|
||||
void DisplayServerAndroid::alert(const String &p_alert, const String &p_title) {
|
||||
GodotJavaWrapper *godot_java = OS_Android::get_singleton()->get_godot_java();
|
||||
ERR_FAIL_COND(!godot_java);
|
||||
|
||||
godot_java->alert(p_alert, p_title);
|
||||
}
|
||||
|
||||
void DisplayServerAndroid::process_events() {
|
||||
// Nothing to do
|
||||
}
|
||||
|
||||
Vector<String> DisplayServerAndroid::get_rendering_drivers_func() {
|
||||
Vector<String> drivers;
|
||||
|
||||
#ifdef OPENGL_ENABLED
|
||||
drivers.push_back("opengl");
|
||||
#endif
|
||||
#ifdef VULKAN_ENABLED
|
||||
drivers.push_back("vulkan");
|
||||
#endif
|
||||
|
||||
return drivers;
|
||||
}
|
||||
|
||||
DisplayServer *DisplayServerAndroid::create_func(const String &p_rendering_driver, DisplayServer::WindowMode p_mode, uint32_t p_flags, const Vector2i &p_resolution, Error &r_error) {
|
||||
return memnew(DisplayServerAndroid(p_rendering_driver, p_mode, p_flags, p_resolution, r_error));
|
||||
}
|
||||
|
||||
void DisplayServerAndroid::register_android_driver() {
|
||||
register_create_function("android", create_func, get_rendering_drivers_func);
|
||||
}
|
||||
|
||||
DisplayServerAndroid::DisplayServerAndroid(const String &p_rendering_driver, DisplayServer::WindowMode p_mode, uint32_t p_flags, const Vector2i &p_resolution, Error &r_error) {
|
||||
rendering_driver = p_rendering_driver;
|
||||
|
||||
// TODO: rendering_driver is broken, change when different drivers are supported again
|
||||
rendering_driver = "vulkan";
|
||||
|
||||
keep_screen_on = GLOBAL_GET("display/window/energy_saving/keep_screen_on");
|
||||
|
||||
#if defined(OPENGL_ENABLED)
|
||||
if (rendering_driver == "opengl") {
|
||||
bool gl_initialization_error = false;
|
||||
|
||||
if (RasterizerGLES2::is_viable() == OK) {
|
||||
RasterizerGLES2::register_config();
|
||||
RasterizerGLES2::make_current();
|
||||
} else {
|
||||
gl_initialization_error = true;
|
||||
}
|
||||
|
||||
if (gl_initialization_error) {
|
||||
OS::get_singleton()->alert("Your device does not support any of the supported OpenGL versions.\n"
|
||||
"Please try updating your Android version.",
|
||||
"Unable to initialize video driver");
|
||||
return;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
#if defined(VULKAN_ENABLED)
|
||||
context_vulkan = nullptr;
|
||||
rendering_device_vulkan = nullptr;
|
||||
|
||||
if (rendering_driver == "vulkan") {
|
||||
ANativeWindow *native_window = OS_Android::get_singleton()->get_native_window();
|
||||
ERR_FAIL_COND(!native_window);
|
||||
|
||||
context_vulkan = memnew(VulkanContextAndroid);
|
||||
if (context_vulkan->initialize() != OK) {
|
||||
memdelete(context_vulkan);
|
||||
context_vulkan = nullptr;
|
||||
ERR_FAIL_MSG("Failed to initialize Vulkan context");
|
||||
}
|
||||
|
||||
Size2i display_size = OS_Android::get_singleton()->get_display_size();
|
||||
if (context_vulkan->window_create(native_window, display_size.width, display_size.height) == -1) {
|
||||
memdelete(context_vulkan);
|
||||
context_vulkan = nullptr;
|
||||
ERR_FAIL_MSG("Failed to create Vulkan window.");
|
||||
}
|
||||
|
||||
rendering_device_vulkan = memnew(RenderingDeviceVulkan);
|
||||
rendering_device_vulkan->initialize(context_vulkan);
|
||||
|
||||
RasterizerRD::make_current();
|
||||
}
|
||||
#endif
|
||||
|
||||
InputFilter::get_singleton()->set_event_dispatch_function(_dispatch_input_events);
|
||||
}
|
||||
|
||||
DisplayServerAndroid::~DisplayServerAndroid() {
|
||||
#if defined(VULKAN_ENABLED)
|
||||
if (rendering_driver == "vulkan") {
|
||||
if (rendering_device_vulkan) {
|
||||
rendering_device_vulkan->finalize();
|
||||
memdelete(rendering_device_vulkan);
|
||||
}
|
||||
|
||||
if (context_vulkan) {
|
||||
memdelete(context_vulkan);
|
||||
}
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
void DisplayServerAndroid::process_joy_event(DisplayServerAndroid::JoypadEvent p_event) {
|
||||
switch (p_event.type) {
|
||||
case JOY_EVENT_BUTTON:
|
||||
InputFilter::get_singleton()->joy_button(p_event.device, p_event.index, p_event.pressed);
|
||||
break;
|
||||
case JOY_EVENT_AXIS:
|
||||
InputFilter::JoyAxis value;
|
||||
value.min = -1;
|
||||
value.value = p_event.value;
|
||||
InputFilter::get_singleton()->joy_axis(p_event.device, p_event.index, value);
|
||||
break;
|
||||
case JOY_EVENT_HAT:
|
||||
InputFilter::get_singleton()->joy_hat(p_event.device, p_event.hat);
|
||||
break;
|
||||
default:
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
void DisplayServerAndroid::process_key_event(int p_keycode, int p_scancode, int p_unicode_char, bool p_pressed) {
|
||||
Ref<InputEventKey> ev;
|
||||
ev.instance();
|
||||
int val = p_unicode_char;
|
||||
int keycode = android_get_keysym(p_keycode);
|
||||
int phy_keycode = android_get_keysym(p_scancode);
|
||||
ev->set_keycode(keycode);
|
||||
ev->set_physical_keycode(phy_keycode);
|
||||
ev->set_unicode(val);
|
||||
ev->set_pressed(p_pressed);
|
||||
|
||||
if (val == '\n') {
|
||||
ev->set_keycode(KEY_ENTER);
|
||||
} else if (val == 61448) {
|
||||
ev->set_keycode(KEY_BACKSPACE);
|
||||
ev->set_unicode(KEY_BACKSPACE);
|
||||
} else if (val == 61453) {
|
||||
ev->set_keycode(KEY_ENTER);
|
||||
ev->set_unicode(KEY_ENTER);
|
||||
} else if (p_keycode == 4) {
|
||||
OS_Android::get_singleton()->main_loop_request_go_back();
|
||||
}
|
||||
|
||||
InputFilter::get_singleton()->parse_input_event(ev);
|
||||
}
|
||||
|
||||
void DisplayServerAndroid::process_touch(int p_what, int p_pointer, const Vector<DisplayServerAndroid::TouchPos> &p_points) {
|
||||
switch (p_what) {
|
||||
case 0: { //gesture begin
|
||||
if (touch.size()) {
|
||||
//end all if exist
|
||||
for (int i = 0; i < touch.size(); i++) {
|
||||
|
||||
Ref<InputEventScreenTouch> ev;
|
||||
ev.instance();
|
||||
ev->set_index(touch[i].id);
|
||||
ev->set_pressed(false);
|
||||
ev->set_position(touch[i].pos);
|
||||
InputFilter::get_singleton()->parse_input_event(ev);
|
||||
}
|
||||
}
|
||||
|
||||
touch.resize(p_points.size());
|
||||
for (int i = 0; i < p_points.size(); i++) {
|
||||
touch.write[i].id = p_points[i].id;
|
||||
touch.write[i].pos = p_points[i].pos;
|
||||
}
|
||||
|
||||
//send touch
|
||||
for (int i = 0; i < touch.size(); i++) {
|
||||
|
||||
Ref<InputEventScreenTouch> ev;
|
||||
ev.instance();
|
||||
ev->set_index(touch[i].id);
|
||||
ev->set_pressed(true);
|
||||
ev->set_position(touch[i].pos);
|
||||
InputFilter::get_singleton()->parse_input_event(ev);
|
||||
}
|
||||
|
||||
} break;
|
||||
case 1: { //motion
|
||||
ERR_FAIL_COND(touch.size() != p_points.size());
|
||||
|
||||
for (int i = 0; i < touch.size(); i++) {
|
||||
|
||||
int idx = -1;
|
||||
for (int j = 0; j < p_points.size(); j++) {
|
||||
|
||||
if (touch[i].id == p_points[j].id) {
|
||||
idx = j;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
ERR_CONTINUE(idx == -1);
|
||||
|
||||
if (touch[i].pos == p_points[idx].pos)
|
||||
continue; //no move unncesearily
|
||||
|
||||
Ref<InputEventScreenDrag> ev;
|
||||
ev.instance();
|
||||
ev->set_index(touch[i].id);
|
||||
ev->set_position(p_points[idx].pos);
|
||||
ev->set_relative(p_points[idx].pos - touch[i].pos);
|
||||
InputFilter::get_singleton()->parse_input_event(ev);
|
||||
touch.write[i].pos = p_points[idx].pos;
|
||||
}
|
||||
|
||||
} break;
|
||||
case 2: { //release
|
||||
if (touch.size()) {
|
||||
//end all if exist
|
||||
for (int i = 0; i < touch.size(); i++) {
|
||||
|
||||
Ref<InputEventScreenTouch> ev;
|
||||
ev.instance();
|
||||
ev->set_index(touch[i].id);
|
||||
ev->set_pressed(false);
|
||||
ev->set_position(touch[i].pos);
|
||||
InputFilter::get_singleton()->parse_input_event(ev);
|
||||
}
|
||||
touch.clear();
|
||||
}
|
||||
} break;
|
||||
case 3: { // add touch
|
||||
for (int i = 0; i < p_points.size(); i++) {
|
||||
if (p_points[i].id == p_pointer) {
|
||||
TouchPos tp = p_points[i];
|
||||
touch.push_back(tp);
|
||||
|
||||
Ref<InputEventScreenTouch> ev;
|
||||
ev.instance();
|
||||
|
||||
ev->set_index(tp.id);
|
||||
ev->set_pressed(true);
|
||||
ev->set_position(tp.pos);
|
||||
InputFilter::get_singleton()->parse_input_event(ev);
|
||||
|
||||
break;
|
||||
}
|
||||
}
|
||||
} break;
|
||||
case 4: { // remove touch
|
||||
for (int i = 0; i < touch.size(); i++) {
|
||||
if (touch[i].id == p_pointer) {
|
||||
|
||||
Ref<InputEventScreenTouch> ev;
|
||||
ev.instance();
|
||||
ev->set_index(touch[i].id);
|
||||
ev->set_pressed(false);
|
||||
ev->set_position(touch[i].pos);
|
||||
InputFilter::get_singleton()->parse_input_event(ev);
|
||||
touch.remove(i);
|
||||
|
||||
break;
|
||||
}
|
||||
}
|
||||
} break;
|
||||
}
|
||||
}
|
||||
|
||||
void DisplayServerAndroid::process_hover(int p_type, Point2 p_pos) {
|
||||
// https://developer.android.com/reference/android/view/MotionEvent.html#ACTION_HOVER_ENTER
|
||||
switch (p_type) {
|
||||
case 7: // hover move
|
||||
case 9: // hover enter
|
||||
case 10: { // hover exit
|
||||
Ref<InputEventMouseMotion> ev;
|
||||
ev.instance();
|
||||
ev->set_position(p_pos);
|
||||
ev->set_global_position(p_pos);
|
||||
ev->set_relative(p_pos - hover_prev_pos);
|
||||
InputFilter::get_singleton()->parse_input_event(ev);
|
||||
hover_prev_pos = p_pos;
|
||||
} break;
|
||||
}
|
||||
}
|
||||
|
||||
void DisplayServerAndroid::process_double_tap(Point2 p_pos) {
|
||||
Ref<InputEventMouseButton> ev;
|
||||
ev.instance();
|
||||
ev->set_position(p_pos);
|
||||
ev->set_global_position(p_pos);
|
||||
ev->set_pressed(false);
|
||||
ev->set_doubleclick(true);
|
||||
InputFilter::get_singleton()->parse_input_event(ev);
|
||||
}
|
||||
|
||||
void DisplayServerAndroid::process_scroll(Point2 p_pos) {
|
||||
Ref<InputEventPanGesture> ev;
|
||||
ev.instance();
|
||||
ev->set_position(p_pos);
|
||||
ev->set_delta(p_pos - scroll_prev_pos);
|
||||
InputFilter::get_singleton()->parse_input_event(ev);
|
||||
scroll_prev_pos = p_pos;
|
||||
}
|
||||
|
||||
void DisplayServerAndroid::process_accelerometer(const Vector3 &p_accelerometer) {
|
||||
InputFilter::get_singleton()->set_accelerometer(p_accelerometer);
|
||||
}
|
||||
|
||||
void DisplayServerAndroid::process_gravity(const Vector3 &p_gravity) {
|
||||
InputFilter::get_singleton()->set_gravity(p_gravity);
|
||||
}
|
||||
|
||||
void DisplayServerAndroid::process_magnetometer(const Vector3 &p_magnetometer) {
|
||||
InputFilter::get_singleton()->set_magnetometer(p_magnetometer);
|
||||
}
|
||||
|
||||
void DisplayServerAndroid::process_gyroscope(const Vector3 &p_gyroscope) {
|
||||
InputFilter::get_singleton()->set_gyroscope(p_gyroscope);
|
||||
}
|
||||
|
|
@ -0,0 +1,174 @@
|
|||
/*************************************************************************/
|
||||
/* display_server_android.h */
|
||||
/*************************************************************************/
|
||||
/* This file is part of: */
|
||||
/* GODOT ENGINE */
|
||||
/* https://godotengine.org */
|
||||
/*************************************************************************/
|
||||
/* Copyright (c) 2007-2020 Juan Linietsky, Ariel Manzur. */
|
||||
/* Copyright (c) 2014-2020 Godot Engine contributors (cf. AUTHORS.md). */
|
||||
/* */
|
||||
/* Permission is hereby granted, free of charge, to any person obtaining */
|
||||
/* a copy of this software and associated documentation files (the */
|
||||
/* "Software"), to deal in the Software without restriction, including */
|
||||
/* without limitation the rights to use, copy, modify, merge, publish, */
|
||||
/* distribute, sublicense, and/or sell copies of the Software, and to */
|
||||
/* permit persons to whom the Software is furnished to do so, subject to */
|
||||
/* the following conditions: */
|
||||
/* */
|
||||
/* The above copyright notice and this permission notice shall be */
|
||||
/* included in all copies or substantial portions of the Software. */
|
||||
/* */
|
||||
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
|
||||
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
|
||||
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
|
||||
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
|
||||
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
|
||||
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
|
||||
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
|
||||
/*************************************************************************/
|
||||
|
||||
#ifndef DISPLAY_SERVER_ANDROID_H
|
||||
#define DISPLAY_SERVER_ANDROID_H
|
||||
|
||||
#include "servers/display_server.h"
|
||||
|
||||
#if defined(VULKAN_ENABLED)
|
||||
class VulkanContextAndroid;
|
||||
class RenderingDeviceVulkan;
|
||||
#endif
|
||||
|
||||
class DisplayServerAndroid : public DisplayServer {
|
||||
public:
|
||||
struct TouchPos {
|
||||
int id;
|
||||
Point2 pos;
|
||||
};
|
||||
|
||||
enum {
|
||||
JOY_EVENT_BUTTON = 0,
|
||||
JOY_EVENT_AXIS = 1,
|
||||
JOY_EVENT_HAT = 2
|
||||
};
|
||||
|
||||
struct JoypadEvent {
|
||||
|
||||
int device;
|
||||
int type;
|
||||
int index;
|
||||
bool pressed;
|
||||
float value;
|
||||
int hat;
|
||||
};
|
||||
|
||||
private:
|
||||
String rendering_driver;
|
||||
|
||||
bool keep_screen_on;
|
||||
|
||||
Vector<TouchPos> touch;
|
||||
Point2 hover_prev_pos; // needed to calculate the relative position on hover events
|
||||
Point2 scroll_prev_pos; // needed to calculate the relative position on scroll events
|
||||
|
||||
#if defined(VULKAN_ENABLED)
|
||||
VulkanContextAndroid *context_vulkan;
|
||||
RenderingDeviceVulkan *rendering_device_vulkan;
|
||||
#endif
|
||||
|
||||
ObjectID window_attached_instance_id;
|
||||
|
||||
Callable window_event_callback;
|
||||
Callable input_event_callback;
|
||||
Callable input_text_callback;
|
||||
|
||||
void _window_callback(const Callable &p_callable, const Variant &p_arg) const;
|
||||
|
||||
static void _dispatch_input_events(const Ref<InputEvent> &p_event);
|
||||
|
||||
public:
|
||||
static DisplayServerAndroid *get_singleton();
|
||||
|
||||
virtual bool has_feature(Feature p_feature) const;
|
||||
virtual String get_name() const;
|
||||
|
||||
virtual void clipboard_set(const String &p_text);
|
||||
virtual String clipboard_get() const;
|
||||
|
||||
virtual void screen_set_keep_on(bool p_enable);
|
||||
virtual bool screen_is_kept_on() const;
|
||||
|
||||
virtual void screen_set_orientation(ScreenOrientation p_orientation, int p_screen = SCREEN_OF_MAIN_WINDOW);
|
||||
virtual ScreenOrientation screen_get_orientation(int p_screen = SCREEN_OF_MAIN_WINDOW) const;
|
||||
|
||||
virtual int get_screen_count() const;
|
||||
virtual Point2i screen_get_position(int p_screen = SCREEN_OF_MAIN_WINDOW) const;
|
||||
virtual Size2i screen_get_size(int p_screen = SCREEN_OF_MAIN_WINDOW) const;
|
||||
virtual Rect2i screen_get_usable_rect(int p_screen = SCREEN_OF_MAIN_WINDOW) const;
|
||||
virtual int screen_get_dpi(int p_screen = SCREEN_OF_MAIN_WINDOW) const;
|
||||
virtual bool screen_is_touchscreen(int p_screen = SCREEN_OF_MAIN_WINDOW) const;
|
||||
|
||||
virtual void virtual_keyboard_show(const String &p_existing_text, const Rect2 &p_screen_rect = Rect2(), int p_max_length = -1);
|
||||
virtual void virtual_keyboard_hide();
|
||||
virtual int virtual_keyboard_get_height() const;
|
||||
|
||||
virtual void window_set_window_event_callback(const Callable &p_callable, WindowID p_window = MAIN_WINDOW_ID);
|
||||
virtual void window_set_input_event_callback(const Callable &p_callable, WindowID p_window = MAIN_WINDOW_ID);
|
||||
virtual void window_set_input_text_callback(const Callable &p_callable, WindowID p_window = MAIN_WINDOW_ID);
|
||||
virtual void window_set_rect_changed_callback(const Callable &p_callable, WindowID p_window = MAIN_WINDOW_ID);
|
||||
virtual void window_set_drop_files_callback(const Callable &p_callable, WindowID p_window = MAIN_WINDOW_ID);
|
||||
|
||||
void send_window_event(WindowEvent p_event) const;
|
||||
void send_input_event(const Ref<InputEvent> &p_event) const;
|
||||
void send_input_text(const String &p_text) const;
|
||||
|
||||
virtual Vector<WindowID> get_window_list() const;
|
||||
virtual WindowID get_window_at_screen_position(const Point2i &p_position) const;
|
||||
virtual void window_attach_instance_id(ObjectID p_instance, WindowID p_window = MAIN_WINDOW_ID);
|
||||
virtual ObjectID window_get_attached_instance_id(WindowID p_window = MAIN_WINDOW_ID) const;
|
||||
virtual void window_set_title(const String &p_title, WindowID p_window = MAIN_WINDOW_ID);
|
||||
virtual int window_get_current_screen(WindowID p_window = MAIN_WINDOW_ID) const;
|
||||
virtual void window_set_current_screen(int p_screen, WindowID p_window = MAIN_WINDOW_ID);
|
||||
virtual Point2i window_get_position(WindowID p_window = MAIN_WINDOW_ID) const;
|
||||
virtual void window_set_position(const Point2i &p_position, WindowID p_window = MAIN_WINDOW_ID);
|
||||
virtual void window_set_transient(WindowID p_window, WindowID p_parent);
|
||||
virtual void window_set_max_size(const Size2i p_size, WindowID p_window = MAIN_WINDOW_ID);
|
||||
virtual Size2i window_get_max_size(WindowID p_window = MAIN_WINDOW_ID) const;
|
||||
virtual void window_set_min_size(const Size2i p_size, WindowID p_window = MAIN_WINDOW_ID);
|
||||
virtual Size2i window_get_min_size(WindowID p_window = MAIN_WINDOW_ID) const;
|
||||
virtual void window_set_size(const Size2i p_size, WindowID p_window = MAIN_WINDOW_ID);
|
||||
virtual Size2i window_get_size(WindowID p_window = MAIN_WINDOW_ID) const;
|
||||
virtual Size2i window_get_real_size(WindowID p_window = MAIN_WINDOW_ID) const;
|
||||
virtual void window_set_mode(WindowMode p_mode, WindowID p_window = MAIN_WINDOW_ID);
|
||||
virtual WindowMode window_get_mode(WindowID p_window = MAIN_WINDOW_ID) const;
|
||||
virtual bool window_is_maximize_allowed(WindowID p_window = MAIN_WINDOW_ID) const;
|
||||
virtual void window_set_flag(WindowFlags p_flag, bool p_enabled, WindowID p_window = MAIN_WINDOW_ID);
|
||||
virtual bool window_get_flag(WindowFlags p_flag, WindowID p_window = MAIN_WINDOW_ID) const;
|
||||
virtual void window_request_attention(WindowID p_window = MAIN_WINDOW_ID);
|
||||
virtual void window_move_to_foreground(WindowID p_window = MAIN_WINDOW_ID);
|
||||
virtual bool window_can_draw(WindowID p_window = MAIN_WINDOW_ID) const;
|
||||
virtual bool can_any_window_draw() const;
|
||||
|
||||
virtual void alert(const String &p_alert, const String &p_title);
|
||||
|
||||
virtual void process_events();
|
||||
|
||||
void process_accelerometer(const Vector3 &p_accelerometer);
|
||||
void process_gravity(const Vector3 &p_gravity);
|
||||
void process_magnetometer(const Vector3 &p_magnetometer);
|
||||
void process_gyroscope(const Vector3 &p_gyroscope);
|
||||
void process_touch(int p_what, int p_pointer, const Vector<TouchPos> &p_points);
|
||||
void process_hover(int p_type, Point2 p_pos);
|
||||
void process_double_tap(Point2 p_pos);
|
||||
void process_scroll(Point2 p_pos);
|
||||
void process_joy_event(JoypadEvent p_event);
|
||||
void process_key_event(int p_keycode, int p_scancode, int p_unicode_char, bool p_pressed);
|
||||
|
||||
static DisplayServer *create_func(const String &p_rendering_driver, WindowMode p_mode, uint32_t p_flags, const Vector2i &p_resolution, Error &r_error);
|
||||
static Vector<String> get_rendering_drivers_func();
|
||||
static void register_android_driver();
|
||||
|
||||
DisplayServerAndroid(const String &p_rendering_driver, WindowMode p_mode, uint32_t p_flags, const Vector2i &p_resolution, Error &r_error);
|
||||
~DisplayServerAndroid();
|
||||
};
|
||||
|
||||
#endif // DISPLAY_SERVER_ANDROID_H
|
||||
|
|
@ -53,8 +53,6 @@ public class GodotIO {
|
|||
Godot activity;
|
||||
GodotEditText edit;
|
||||
|
||||
MediaPlayer mediaPlayer;
|
||||
|
||||
final int SCREEN_LANDSCAPE = 0;
|
||||
final int SCREEN_PORTRAIT = 1;
|
||||
final int SCREEN_REVERSE_LANDSCAPE = 2;
|
||||
|
|
@ -530,46 +528,16 @@ public class GodotIO {
|
|||
activity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_FULL_SENSOR);
|
||||
} break;
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
public int getScreenOrientation() {
|
||||
return activity.getRequestedOrientation();
|
||||
}
|
||||
|
||||
public void setEdit(GodotEditText _edit) {
|
||||
edit = _edit;
|
||||
}
|
||||
|
||||
public void playVideo(String p_path) {
|
||||
Uri filePath = Uri.parse(p_path);
|
||||
mediaPlayer = new MediaPlayer();
|
||||
|
||||
try {
|
||||
mediaPlayer.setAudioStreamType(AudioManager.STREAM_MUSIC);
|
||||
mediaPlayer.setDataSource(activity.getApplicationContext(), filePath);
|
||||
mediaPlayer.prepare();
|
||||
mediaPlayer.start();
|
||||
} catch (IOException e) {
|
||||
System.out.println("IOError while playing video");
|
||||
}
|
||||
}
|
||||
|
||||
public boolean isVideoPlaying() {
|
||||
if (mediaPlayer != null) {
|
||||
return mediaPlayer.isPlaying();
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
public void pauseVideo() {
|
||||
if (mediaPlayer != null) {
|
||||
mediaPlayer.pause();
|
||||
}
|
||||
}
|
||||
|
||||
public void stopVideo() {
|
||||
if (mediaPlayer != null) {
|
||||
mediaPlayer.release();
|
||||
mediaPlayer = null;
|
||||
}
|
||||
}
|
||||
|
||||
public static final int SYSTEM_DIR_DESKTOP = 0;
|
||||
public static final int SYSTEM_DIR_DCIM = 1;
|
||||
public static final int SYSTEM_DIR_DOCUMENTS = 2;
|
||||
|
|
|
|||
|
|
@ -56,11 +56,8 @@ GodotIOJavaWrapper::GodotIOJavaWrapper(JNIEnv *p_env, jobject p_godot_io_instanc
|
|||
_show_keyboard = p_env->GetMethodID(cls, "showKeyboard", "(Ljava/lang/String;I)V");
|
||||
_hide_keyboard = p_env->GetMethodID(cls, "hideKeyboard", "()V");
|
||||
_set_screen_orientation = p_env->GetMethodID(cls, "setScreenOrientation", "(I)V");
|
||||
_get_screen_orientation = p_env->GetMethodID(cls, "getScreenOrientation", "()I");
|
||||
_get_system_dir = p_env->GetMethodID(cls, "getSystemDir", "(I)Ljava/lang/String;");
|
||||
_play_video = p_env->GetMethodID(cls, "playVideo", "(Ljava/lang/String;)V");
|
||||
_is_video_playing = p_env->GetMethodID(cls, "isVideoPlaying", "()Z");
|
||||
_pause_video = p_env->GetMethodID(cls, "pauseVideo", "()V");
|
||||
_stop_video = p_env->GetMethodID(cls, "stopVideo", "()V");
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -157,6 +154,15 @@ void GodotIOJavaWrapper::set_screen_orientation(int p_orient) {
|
|||
}
|
||||
}
|
||||
|
||||
int GodotIOJavaWrapper::get_screen_orientation() {
|
||||
if (_get_screen_orientation) {
|
||||
JNIEnv *env = ThreadAndroid::get_env();
|
||||
return env->CallIntMethod(godot_io_instance, _get_screen_orientation);
|
||||
} else {
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
String GodotIOJavaWrapper::get_system_dir(int p_dir) {
|
||||
if (_get_system_dir) {
|
||||
JNIEnv *env = ThreadAndroid::get_env();
|
||||
|
|
@ -167,33 +173,6 @@ String GodotIOJavaWrapper::get_system_dir(int p_dir) {
|
|||
}
|
||||
}
|
||||
|
||||
void GodotIOJavaWrapper::play_video(const String &p_path) {
|
||||
// Why is this not here?!?!
|
||||
}
|
||||
|
||||
bool GodotIOJavaWrapper::is_video_playing() {
|
||||
if (_is_video_playing) {
|
||||
JNIEnv *env = ThreadAndroid::get_env();
|
||||
return env->CallBooleanMethod(godot_io_instance, _is_video_playing);
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
void GodotIOJavaWrapper::pause_video() {
|
||||
if (_pause_video) {
|
||||
JNIEnv *env = ThreadAndroid::get_env();
|
||||
env->CallVoidMethod(godot_io_instance, _pause_video);
|
||||
}
|
||||
}
|
||||
|
||||
void GodotIOJavaWrapper::stop_video() {
|
||||
if (_stop_video) {
|
||||
JNIEnv *env = ThreadAndroid::get_env();
|
||||
env->CallVoidMethod(godot_io_instance, _stop_video);
|
||||
}
|
||||
}
|
||||
|
||||
// volatile because it can be changed from non-main thread and we need to
|
||||
// ensure the change is immediately visible to other threads.
|
||||
static volatile int virtual_keyboard_height;
|
||||
|
|
|
|||
|
|
@ -54,11 +54,8 @@ private:
|
|||
jmethodID _show_keyboard = 0;
|
||||
jmethodID _hide_keyboard = 0;
|
||||
jmethodID _set_screen_orientation = 0;
|
||||
jmethodID _get_screen_orientation = 0;
|
||||
jmethodID _get_system_dir = 0;
|
||||
jmethodID _play_video = 0;
|
||||
jmethodID _is_video_playing = 0;
|
||||
jmethodID _pause_video = 0;
|
||||
jmethodID _stop_video = 0;
|
||||
|
||||
public:
|
||||
GodotIOJavaWrapper(JNIEnv *p_env, jobject p_godot_io_instance);
|
||||
|
|
@ -78,11 +75,8 @@ public:
|
|||
int get_vk_height();
|
||||
void set_vk_height(int p_height);
|
||||
void set_screen_orientation(int p_orient);
|
||||
int get_screen_orientation();
|
||||
String get_system_dir(int p_dir);
|
||||
void play_video(const String &p_path);
|
||||
bool is_video_playing();
|
||||
void pause_video();
|
||||
void stop_video();
|
||||
};
|
||||
|
||||
#endif /* !JAVA_GODOT_IO_WRAPPER_H */
|
||||
|
|
|
|||
|
|
@ -34,13 +34,13 @@
|
|||
#include "java_godot_wrapper.h"
|
||||
|
||||
#include "android/asset_manager_jni.h"
|
||||
#include "android_keys_utils.h"
|
||||
#include "api/java_class_wrapper.h"
|
||||
#include "audio_driver_jandroid.h"
|
||||
#include "core/engine.h"
|
||||
#include "core/input/input_filter.h"
|
||||
#include "core/project_settings.h"
|
||||
#include "dir_access_jandroid.h"
|
||||
#include "display_server_android.h"
|
||||
#include "file_access_android.h"
|
||||
#include "file_access_jandroid.h"
|
||||
#include "jni_utils.h"
|
||||
|
|
@ -167,7 +167,7 @@ JNIEXPORT void JNICALL Java_org_godotengine_godot_GodotLib_setup(JNIEnv *env, jc
|
|||
JNIEXPORT void JNICALL Java_org_godotengine_godot_GodotLib_resize(JNIEnv *env, jclass clazz, jint width, jint height) {
|
||||
|
||||
if (os_android)
|
||||
os_android->set_display_size(Size2(width, height));
|
||||
os_android->set_display_size(Size2i(width, height));
|
||||
}
|
||||
|
||||
JNIEXPORT void JNICALL Java_org_godotengine_godot_GodotLib_newcontext(JNIEnv *env, jclass clazz, jobject p_surface, jboolean p_32_bits) {
|
||||
|
|
@ -200,7 +200,6 @@ JNIEXPORT void JNICALL Java_org_godotengine_godot_GodotLib_step(JNIEnv *env, jcl
|
|||
return;
|
||||
|
||||
if (step == 0) {
|
||||
|
||||
// Since Godot is initialized on the UI thread, _main_thread_id was set to that thread's id,
|
||||
// but for Godot purposes, the main thread is the one running the game loop
|
||||
Main::setup2(Thread::get_caller_id());
|
||||
|
|
@ -218,10 +217,10 @@ JNIEXPORT void JNICALL Java_org_godotengine_godot_GodotLib_step(JNIEnv *env, jcl
|
|||
++step;
|
||||
}
|
||||
|
||||
os_android->process_accelerometer(accelerometer);
|
||||
os_android->process_gravity(gravity);
|
||||
os_android->process_magnetometer(magnetometer);
|
||||
os_android->process_gyroscope(gyroscope);
|
||||
DisplayServerAndroid::get_singleton()->process_accelerometer(accelerometer);
|
||||
DisplayServerAndroid::get_singleton()->process_gravity(gravity);
|
||||
DisplayServerAndroid::get_singleton()->process_magnetometer(magnetometer);
|
||||
DisplayServerAndroid::get_singleton()->process_gyroscope(gyroscope);
|
||||
|
||||
if (os_android->main_loop_iterate()) {
|
||||
|
||||
|
|
@ -234,18 +233,18 @@ JNIEXPORT void JNICALL Java_org_godotengine_godot_GodotLib_touch(JNIEnv *env, jc
|
|||
if (step == 0)
|
||||
return;
|
||||
|
||||
Vector<OS_Android::TouchPos> points;
|
||||
Vector<DisplayServerAndroid::TouchPos> points;
|
||||
for (int i = 0; i < count; i++) {
|
||||
|
||||
jint p[3];
|
||||
env->GetIntArrayRegion(positions, i * 3, 3, p);
|
||||
OS_Android::TouchPos tp;
|
||||
DisplayServerAndroid::TouchPos tp;
|
||||
tp.pos = Point2(p[1], p[2]);
|
||||
tp.id = p[0];
|
||||
points.push_back(tp);
|
||||
}
|
||||
|
||||
os_android->process_touch(ev, pointer, points);
|
||||
DisplayServerAndroid::get_singleton()->process_touch(ev, pointer, points);
|
||||
|
||||
/*
|
||||
if (os_android)
|
||||
|
|
@ -257,78 +256,78 @@ JNIEXPORT void JNICALL Java_org_godotengine_godot_GodotLib_hover(JNIEnv *env, jc
|
|||
if (step == 0)
|
||||
return;
|
||||
|
||||
os_android->process_hover(p_type, Point2(p_x, p_y));
|
||||
DisplayServerAndroid::get_singleton()->process_hover(p_type, Point2(p_x, p_y));
|
||||
}
|
||||
|
||||
JNIEXPORT void JNICALL Java_org_godotengine_godot_GodotLib_doubletap(JNIEnv *env, jclass clazz, jint p_x, jint p_y) {
|
||||
if (step == 0)
|
||||
return;
|
||||
|
||||
os_android->process_double_tap(Point2(p_x, p_y));
|
||||
DisplayServerAndroid::get_singleton()->process_double_tap(Point2(p_x, p_y));
|
||||
}
|
||||
|
||||
JNIEXPORT void JNICALL Java_org_godotengine_godot_GodotLib_scroll(JNIEnv *env, jclass clazz, jint p_x, jint p_y) {
|
||||
if (step == 0)
|
||||
return;
|
||||
|
||||
os_android->process_scroll(Point2(p_x, p_y));
|
||||
DisplayServerAndroid::get_singleton()->process_scroll(Point2(p_x, p_y));
|
||||
}
|
||||
|
||||
JNIEXPORT void JNICALL Java_org_godotengine_godot_GodotLib_joybutton(JNIEnv *env, jclass clazz, jint p_device, jint p_button, jboolean p_pressed) {
|
||||
if (step == 0)
|
||||
return;
|
||||
|
||||
OS_Android::JoypadEvent jevent;
|
||||
DisplayServerAndroid::JoypadEvent jevent;
|
||||
jevent.device = p_device;
|
||||
jevent.type = OS_Android::JOY_EVENT_BUTTON;
|
||||
jevent.type = DisplayServerAndroid::JOY_EVENT_BUTTON;
|
||||
jevent.index = p_button;
|
||||
jevent.pressed = p_pressed;
|
||||
|
||||
os_android->process_joy_event(jevent);
|
||||
DisplayServerAndroid::get_singleton()->process_joy_event(jevent);
|
||||
}
|
||||
|
||||
JNIEXPORT void JNICALL Java_org_godotengine_godot_GodotLib_joyaxis(JNIEnv *env, jclass clazz, jint p_device, jint p_axis, jfloat p_value) {
|
||||
if (step == 0)
|
||||
return;
|
||||
|
||||
OS_Android::JoypadEvent jevent;
|
||||
DisplayServerAndroid::JoypadEvent jevent;
|
||||
jevent.device = p_device;
|
||||
jevent.type = OS_Android::JOY_EVENT_AXIS;
|
||||
jevent.type = DisplayServerAndroid::JOY_EVENT_AXIS;
|
||||
jevent.index = p_axis;
|
||||
jevent.value = p_value;
|
||||
|
||||
os_android->process_joy_event(jevent);
|
||||
DisplayServerAndroid::get_singleton()->process_joy_event(jevent);
|
||||
}
|
||||
|
||||
JNIEXPORT void JNICALL Java_org_godotengine_godot_GodotLib_joyhat(JNIEnv *env, jclass clazz, jint p_device, jint p_hat_x, jint p_hat_y) {
|
||||
if (step == 0)
|
||||
return;
|
||||
|
||||
OS_Android::JoypadEvent jevent;
|
||||
DisplayServerAndroid::JoypadEvent jevent;
|
||||
jevent.device = p_device;
|
||||
jevent.type = OS_Android::JOY_EVENT_HAT;
|
||||
jevent.type = DisplayServerAndroid::JOY_EVENT_HAT;
|
||||
int hat = 0;
|
||||
if (p_hat_x != 0) {
|
||||
if (p_hat_x < 0)
|
||||
hat |= InputDefault::HAT_MASK_LEFT;
|
||||
hat |= InputFilter::HAT_MASK_LEFT;
|
||||
else
|
||||
hat |= InputDefault::HAT_MASK_RIGHT;
|
||||
hat |= InputFilter::HAT_MASK_RIGHT;
|
||||
}
|
||||
if (p_hat_y != 0) {
|
||||
if (p_hat_y < 0)
|
||||
hat |= InputDefault::HAT_MASK_UP;
|
||||
hat |= InputFilter::HAT_MASK_UP;
|
||||
else
|
||||
hat |= InputDefault::HAT_MASK_DOWN;
|
||||
hat |= InputFilter::HAT_MASK_DOWN;
|
||||
}
|
||||
jevent.hat = hat;
|
||||
|
||||
os_android->process_joy_event(jevent);
|
||||
DisplayServerAndroid::get_singleton()->process_joy_event(jevent);
|
||||
}
|
||||
|
||||
JNIEXPORT void JNICALL Java_org_godotengine_godot_GodotLib_joyconnectionchanged(JNIEnv *env, jclass clazz, jint p_device, jboolean p_connected, jstring p_name) {
|
||||
if (os_android) {
|
||||
String name = jstring_to_string(p_name, env);
|
||||
os_android->joy_connection_changed(p_device, p_connected, name);
|
||||
InputFilter::get_singleton()->joy_connection_changed(p_device, p_connected, name);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -336,29 +335,7 @@ JNIEXPORT void JNICALL Java_org_godotengine_godot_GodotLib_key(JNIEnv *env, jcla
|
|||
if (step == 0)
|
||||
return;
|
||||
|
||||
Ref<InputEventKey> ievent;
|
||||
ievent.instance();
|
||||
int val = p_unicode_char;
|
||||
int keycode = android_get_keysym(p_keycode);
|
||||
int phy_keycode = android_get_keysym(p_scancode);
|
||||
ievent->set_keycode(keycode);
|
||||
ievent->set_physical_keycode(phy_keycode);
|
||||
ievent->set_unicode(val);
|
||||
ievent->set_pressed(p_pressed);
|
||||
|
||||
if (val == '\n') {
|
||||
ievent->set_keycode(KEY_ENTER);
|
||||
} else if (val == 61448) {
|
||||
ievent->set_keycode(KEY_BACKSPACE);
|
||||
ievent->set_unicode(KEY_BACKSPACE);
|
||||
} else if (val == 61453) {
|
||||
ievent->set_keycode(KEY_ENTER);
|
||||
ievent->set_unicode(KEY_ENTER);
|
||||
} else if (p_keycode == 4) {
|
||||
os_android->main_loop_request_go_back();
|
||||
}
|
||||
|
||||
os_android->process_event(ievent);
|
||||
DisplayServerAndroid::get_singleton()->process_key_event(p_keycode, p_scancode, p_unicode_char, p_pressed);
|
||||
}
|
||||
|
||||
JNIEXPORT void JNICALL Java_org_godotengine_godot_GodotLib_accelerometer(JNIEnv *env, jclass clazz, jfloat x, jfloat y, jfloat z) {
|
||||
|
|
|
|||
|
|
@ -32,20 +32,11 @@
|
|||
|
||||
#include "core/io/file_access_buffered_fa.h"
|
||||
#include "core/project_settings.h"
|
||||
#if defined(OPENGL_ENABLED)
|
||||
#include "drivers/gles2/rasterizer_gles2.h"
|
||||
#endif
|
||||
#if defined(VULKAN_ENABLED)
|
||||
#include "drivers/vulkan/rendering_device_vulkan.h"
|
||||
#include "platform/android/vulkan/vulkan_context_android.h"
|
||||
#include "servers/visual/rasterizer_rd/rasterizer_rd.h"
|
||||
#endif
|
||||
#include "drivers/unix/dir_access_unix.h"
|
||||
#include "drivers/unix/file_access_unix.h"
|
||||
#include "file_access_android.h"
|
||||
#include "main/main.h"
|
||||
#include "servers/rendering/rendering_server_raster.h"
|
||||
#include "servers/rendering/rendering_server_wrap_mt.h"
|
||||
#include "platform/android/display_server_android.h"
|
||||
|
||||
#include "dir_access_jandroid.h"
|
||||
#include "file_access_jandroid.h"
|
||||
|
|
@ -65,16 +56,6 @@ public:
|
|||
virtual ~AndroidLogger() {}
|
||||
};
|
||||
|
||||
int OS_Android::get_audio_driver_count() const {
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
const char *OS_Android::get_audio_driver_name(int p_driver) const {
|
||||
|
||||
return "Android";
|
||||
}
|
||||
|
||||
void OS_Android::initialize_core() {
|
||||
|
||||
OS_Unix::initialize_core();
|
||||
|
|
@ -102,107 +83,33 @@ void OS_Android::initialize_core() {
|
|||
NetSocketAndroid::make_default();
|
||||
}
|
||||
|
||||
void OS_Android::set_opengl_extensions(const char *p_gl_extensions) {
|
||||
|
||||
ERR_FAIL_COND(!p_gl_extensions);
|
||||
gl_extensions = p_gl_extensions;
|
||||
void OS_Android::initialize() {
|
||||
initialize_core();
|
||||
}
|
||||
|
||||
int OS_Android::get_current_video_driver() const {
|
||||
return video_driver_index;
|
||||
}
|
||||
void OS_Android::initialize_joypads() {
|
||||
InputFilter::get_singleton()->set_fallback_mapping(godot_java->get_input_fallback_mapping());
|
||||
|
||||
Error OS_Android::initialize(const VideoMode &p_desired, int p_video_driver, int p_audio_driver) {
|
||||
video_driver_index = p_video_driver;
|
||||
|
||||
#if defined(OPENGL_ENABLED)
|
||||
if (video_driver_index == VIDEO_DRIVER_GLES2) {
|
||||
bool gl_initialization_error = false;
|
||||
|
||||
if (RasterizerGLES2::is_viable() == OK) {
|
||||
RasterizerGLES2::register_config();
|
||||
RasterizerGLES2::make_current();
|
||||
} else {
|
||||
gl_initialization_error = true;
|
||||
}
|
||||
|
||||
if (gl_initialization_error) {
|
||||
OS::get_singleton()->alert("Your device does not support any of the supported OpenGL versions.\n"
|
||||
"Please try updating your Android version.",
|
||||
"Unable to initialize video driver");
|
||||
return ERR_UNAVAILABLE;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
#if defined(VULKAN_ENABLED)
|
||||
if (video_driver_index == VIDEO_DRIVER_VULKAN) {
|
||||
ERR_FAIL_COND_V(!native_window, ERR_UNAVAILABLE);
|
||||
|
||||
context_vulkan = memnew(VulkanContextAndroid);
|
||||
if (context_vulkan->initialize() != OK) {
|
||||
memdelete(context_vulkan);
|
||||
context_vulkan = NULL;
|
||||
ERR_FAIL_V(ERR_UNAVAILABLE);
|
||||
}
|
||||
|
||||
Size2 window_size = get_window_size();
|
||||
if (context_vulkan->window_create(native_window, window_size.width, window_size.height) == -1) {
|
||||
memdelete(context_vulkan);
|
||||
context_vulkan = NULL;
|
||||
ERR_FAIL_V_MSG(ERR_UNAVAILABLE, "Failed to create Vulkan window.");
|
||||
}
|
||||
|
||||
//temporary
|
||||
rendering_device_vulkan = memnew(RenderingDeviceVulkan);
|
||||
rendering_device_vulkan->initialize(context_vulkan);
|
||||
|
||||
RasterizerRD::make_current();
|
||||
}
|
||||
#endif
|
||||
|
||||
rendering_server = memnew(RenderingServerRaster);
|
||||
if (get_render_thread_mode() != RENDER_THREAD_UNSAFE) {
|
||||
rendering_server = memnew(RenderingServerWrapMT(rendering_server, false));
|
||||
}
|
||||
|
||||
rendering_server->init();
|
||||
|
||||
AudioDriverManager::initialize(p_audio_driver);
|
||||
|
||||
input = memnew(InputDefault);
|
||||
input->set_fallback_mapping(godot_java->get_input_fallback_mapping());
|
||||
|
||||
return OK;
|
||||
// This queries/updates the currently connected devices/joypads.
|
||||
godot_java->init_input_devices();
|
||||
}
|
||||
|
||||
void OS_Android::set_main_loop(MainLoop *p_main_loop) {
|
||||
|
||||
main_loop = p_main_loop;
|
||||
input->set_main_loop(p_main_loop);
|
||||
}
|
||||
|
||||
void OS_Android::delete_main_loop() {
|
||||
|
||||
memdelete(main_loop);
|
||||
if (main_loop) {
|
||||
memdelete(main_loop);
|
||||
main_loop = nullptr;
|
||||
}
|
||||
}
|
||||
|
||||
void OS_Android::finalize() {
|
||||
}
|
||||
|
||||
memdelete(input);
|
||||
|
||||
#if defined(VULKAN_ENABLED)
|
||||
if (video_driver_index == VIDEO_DRIVER_VULKAN) {
|
||||
if (rendering_device_vulkan) {
|
||||
rendering_device_vulkan->finalize();
|
||||
memdelete(rendering_device_vulkan);
|
||||
}
|
||||
|
||||
if (context_vulkan) {
|
||||
memdelete(context_vulkan);
|
||||
}
|
||||
}
|
||||
#endif
|
||||
OS_Android *OS_Android::get_singleton() {
|
||||
return (OS_Android *)OS::get_singleton();
|
||||
}
|
||||
|
||||
GodotJavaWrapper *OS_Android::get_godot_java() {
|
||||
|
|
@ -213,12 +120,6 @@ GodotIOJavaWrapper *OS_Android::get_godot_io_java() {
|
|||
return godot_io_java;
|
||||
}
|
||||
|
||||
void OS_Android::alert(const String &p_alert, const String &p_title) {
|
||||
|
||||
//print("ALERT: %s\n", p_alert.utf8().get_data());
|
||||
godot_java->alert(p_alert, p_title);
|
||||
}
|
||||
|
||||
bool OS_Android::request_permission(const String &p_name) {
|
||||
|
||||
return godot_java->request_permission(p_name);
|
||||
|
|
@ -240,63 +141,6 @@ Error OS_Android::open_dynamic_library(const String p_path, void *&p_library_han
|
|||
return OK;
|
||||
}
|
||||
|
||||
void OS_Android::set_mouse_show(bool p_show) {
|
||||
|
||||
//android has no mouse...
|
||||
}
|
||||
|
||||
void OS_Android::set_mouse_grab(bool p_grab) {
|
||||
|
||||
//it really has no mouse...!
|
||||
}
|
||||
|
||||
bool OS_Android::is_mouse_grab_enabled() const {
|
||||
|
||||
//*sigh* technology has evolved so much since i was a kid..
|
||||
return false;
|
||||
}
|
||||
|
||||
Point2 OS_Android::get_mouse_position() const {
|
||||
|
||||
return Point2();
|
||||
}
|
||||
|
||||
int OS_Android::get_mouse_button_state() const {
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
void OS_Android::set_window_title(const String &p_title) {
|
||||
//This queries/updates the currently connected devices/joypads
|
||||
//Set_window_title is called when initializing the main loop (main.cpp)
|
||||
//therefore this place is found to be suitable (I found no better).
|
||||
godot_java->init_input_devices();
|
||||
}
|
||||
|
||||
void OS_Android::set_video_mode(const VideoMode &p_video_mode, int p_screen) {
|
||||
}
|
||||
|
||||
OS::VideoMode OS_Android::get_video_mode(int p_screen) const {
|
||||
|
||||
return default_videomode;
|
||||
}
|
||||
|
||||
void OS_Android::get_fullscreen_mode_list(List<VideoMode> *p_list, int p_screen) const {
|
||||
|
||||
p_list->push_back(default_videomode);
|
||||
}
|
||||
|
||||
void OS_Android::set_keep_screen_on(bool p_enabled) {
|
||||
OS::set_keep_screen_on(p_enabled);
|
||||
|
||||
godot_java->set_keep_screen_on(p_enabled);
|
||||
}
|
||||
|
||||
Size2 OS_Android::get_window_size() const {
|
||||
|
||||
return Vector2(default_videomode.width, default_videomode.height);
|
||||
}
|
||||
|
||||
String OS_Android::get_name() const {
|
||||
|
||||
return "Android";
|
||||
|
|
@ -307,11 +151,6 @@ MainLoop *OS_Android::get_main_loop() const {
|
|||
return main_loop;
|
||||
}
|
||||
|
||||
bool OS_Android::can_draw() const {
|
||||
|
||||
return true; //always?
|
||||
}
|
||||
|
||||
void OS_Android::main_loop_begin() {
|
||||
|
||||
if (main_loop)
|
||||
|
|
@ -332,276 +171,17 @@ void OS_Android::main_loop_end() {
|
|||
}
|
||||
|
||||
void OS_Android::main_loop_focusout() {
|
||||
|
||||
if (main_loop)
|
||||
main_loop->notification(NOTIFICATION_WM_FOCUS_OUT);
|
||||
DisplayServerAndroid::get_singleton()->send_window_event(DisplayServer::WINDOW_EVENT_FOCUS_OUT);
|
||||
audio_driver_android.set_pause(true);
|
||||
}
|
||||
|
||||
void OS_Android::main_loop_focusin() {
|
||||
|
||||
if (main_loop)
|
||||
main_loop->notification(NOTIFICATION_WM_FOCUS_IN);
|
||||
DisplayServerAndroid::get_singleton()->send_window_event(DisplayServer::WINDOW_EVENT_FOCUS_IN);
|
||||
audio_driver_android.set_pause(false);
|
||||
}
|
||||
|
||||
void OS_Android::process_joy_event(OS_Android::JoypadEvent p_event) {
|
||||
|
||||
switch (p_event.type) {
|
||||
case JOY_EVENT_BUTTON:
|
||||
input->joy_button(p_event.device, p_event.index, p_event.pressed);
|
||||
break;
|
||||
case JOY_EVENT_AXIS:
|
||||
InputDefault::JoyAxis value;
|
||||
value.min = -1;
|
||||
value.value = p_event.value;
|
||||
input->joy_axis(p_event.device, p_event.index, value);
|
||||
break;
|
||||
case JOY_EVENT_HAT:
|
||||
input->joy_hat(p_event.device, p_event.hat);
|
||||
break;
|
||||
default:
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
void OS_Android::process_event(Ref<InputEvent> p_event) {
|
||||
|
||||
input->parse_input_event(p_event);
|
||||
}
|
||||
|
||||
void OS_Android::process_touch(int p_what, int p_pointer, const Vector<TouchPos> &p_points) {
|
||||
|
||||
switch (p_what) {
|
||||
case 0: { //gesture begin
|
||||
|
||||
if (touch.size()) {
|
||||
//end all if exist
|
||||
for (int i = 0; i < touch.size(); i++) {
|
||||
|
||||
Ref<InputEventScreenTouch> ev;
|
||||
ev.instance();
|
||||
ev->set_index(touch[i].id);
|
||||
ev->set_pressed(false);
|
||||
ev->set_position(touch[i].pos);
|
||||
input->parse_input_event(ev);
|
||||
}
|
||||
}
|
||||
|
||||
touch.resize(p_points.size());
|
||||
for (int i = 0; i < p_points.size(); i++) {
|
||||
touch.write[i].id = p_points[i].id;
|
||||
touch.write[i].pos = p_points[i].pos;
|
||||
}
|
||||
|
||||
//send touch
|
||||
for (int i = 0; i < touch.size(); i++) {
|
||||
|
||||
Ref<InputEventScreenTouch> ev;
|
||||
ev.instance();
|
||||
ev->set_index(touch[i].id);
|
||||
ev->set_pressed(true);
|
||||
ev->set_position(touch[i].pos);
|
||||
input->parse_input_event(ev);
|
||||
}
|
||||
|
||||
} break;
|
||||
case 1: { //motion
|
||||
|
||||
ERR_FAIL_COND(touch.size() != p_points.size());
|
||||
|
||||
for (int i = 0; i < touch.size(); i++) {
|
||||
|
||||
int idx = -1;
|
||||
for (int j = 0; j < p_points.size(); j++) {
|
||||
|
||||
if (touch[i].id == p_points[j].id) {
|
||||
idx = j;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
ERR_CONTINUE(idx == -1);
|
||||
|
||||
if (touch[i].pos == p_points[idx].pos)
|
||||
continue; //no move unncesearily
|
||||
|
||||
Ref<InputEventScreenDrag> ev;
|
||||
ev.instance();
|
||||
ev->set_index(touch[i].id);
|
||||
ev->set_position(p_points[idx].pos);
|
||||
ev->set_relative(p_points[idx].pos - touch[i].pos);
|
||||
input->parse_input_event(ev);
|
||||
touch.write[i].pos = p_points[idx].pos;
|
||||
}
|
||||
|
||||
} break;
|
||||
case 2: { //release
|
||||
|
||||
if (touch.size()) {
|
||||
//end all if exist
|
||||
for (int i = 0; i < touch.size(); i++) {
|
||||
|
||||
Ref<InputEventScreenTouch> ev;
|
||||
ev.instance();
|
||||
ev->set_index(touch[i].id);
|
||||
ev->set_pressed(false);
|
||||
ev->set_position(touch[i].pos);
|
||||
input->parse_input_event(ev);
|
||||
}
|
||||
touch.clear();
|
||||
}
|
||||
} break;
|
||||
case 3: { // add touch
|
||||
|
||||
for (int i = 0; i < p_points.size(); i++) {
|
||||
if (p_points[i].id == p_pointer) {
|
||||
TouchPos tp = p_points[i];
|
||||
touch.push_back(tp);
|
||||
|
||||
Ref<InputEventScreenTouch> ev;
|
||||
ev.instance();
|
||||
|
||||
ev->set_index(tp.id);
|
||||
ev->set_pressed(true);
|
||||
ev->set_position(tp.pos);
|
||||
input->parse_input_event(ev);
|
||||
|
||||
break;
|
||||
}
|
||||
}
|
||||
} break;
|
||||
case 4: { // remove touch
|
||||
|
||||
for (int i = 0; i < touch.size(); i++) {
|
||||
if (touch[i].id == p_pointer) {
|
||||
|
||||
Ref<InputEventScreenTouch> ev;
|
||||
ev.instance();
|
||||
ev->set_index(touch[i].id);
|
||||
ev->set_pressed(false);
|
||||
ev->set_position(touch[i].pos);
|
||||
input->parse_input_event(ev);
|
||||
touch.remove(i);
|
||||
|
||||
break;
|
||||
}
|
||||
}
|
||||
} break;
|
||||
}
|
||||
}
|
||||
|
||||
void OS_Android::process_hover(int p_type, Point2 p_pos) {
|
||||
// https://developer.android.com/reference/android/view/MotionEvent.html#ACTION_HOVER_ENTER
|
||||
switch (p_type) {
|
||||
case 7: // hover move
|
||||
case 9: // hover enter
|
||||
case 10: { // hover exit
|
||||
Ref<InputEventMouseMotion> ev;
|
||||
ev.instance();
|
||||
ev->set_position(p_pos);
|
||||
ev->set_global_position(p_pos);
|
||||
ev->set_relative(p_pos - hover_prev_pos);
|
||||
input->parse_input_event(ev);
|
||||
hover_prev_pos = p_pos;
|
||||
} break;
|
||||
}
|
||||
}
|
||||
|
||||
void OS_Android::process_double_tap(Point2 p_pos) {
|
||||
Ref<InputEventMouseButton> ev;
|
||||
ev.instance();
|
||||
ev->set_position(p_pos);
|
||||
ev->set_global_position(p_pos);
|
||||
ev->set_pressed(false);
|
||||
ev->set_doubleclick(true);
|
||||
input->parse_input_event(ev);
|
||||
}
|
||||
|
||||
void OS_Android::process_scroll(Point2 p_pos) {
|
||||
Ref<InputEventPanGesture> ev;
|
||||
ev.instance();
|
||||
ev->set_position(p_pos);
|
||||
ev->set_delta(p_pos - scroll_prev_pos);
|
||||
input->parse_input_event(ev);
|
||||
scroll_prev_pos = p_pos;
|
||||
}
|
||||
|
||||
void OS_Android::process_accelerometer(const Vector3 &p_accelerometer) {
|
||||
|
||||
input->set_accelerometer(p_accelerometer);
|
||||
}
|
||||
|
||||
void OS_Android::process_gravity(const Vector3 &p_gravity) {
|
||||
|
||||
input->set_gravity(p_gravity);
|
||||
}
|
||||
|
||||
void OS_Android::process_magnetometer(const Vector3 &p_magnetometer) {
|
||||
|
||||
input->set_magnetometer(p_magnetometer);
|
||||
}
|
||||
|
||||
void OS_Android::process_gyroscope(const Vector3 &p_gyroscope) {
|
||||
|
||||
input->set_gyroscope(p_gyroscope);
|
||||
}
|
||||
|
||||
bool OS_Android::has_touchscreen_ui_hint() const {
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
bool OS_Android::has_virtual_keyboard() const {
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
int OS_Android::get_virtual_keyboard_height() const {
|
||||
return godot_io_java->get_vk_height();
|
||||
|
||||
// ERR_PRINT("Cannot obtain virtual keyboard height.");
|
||||
// return 0;
|
||||
}
|
||||
|
||||
void OS_Android::show_virtual_keyboard(const String &p_existing_text, const Rect2 &p_screen_rect, int p_max_input_length) {
|
||||
|
||||
if (godot_io_java->has_vk()) {
|
||||
godot_io_java->show_vk(p_existing_text, p_max_input_length);
|
||||
} else {
|
||||
|
||||
ERR_PRINT("Virtual keyboard not available");
|
||||
};
|
||||
}
|
||||
|
||||
void OS_Android::hide_virtual_keyboard() {
|
||||
|
||||
if (godot_io_java->has_vk()) {
|
||||
|
||||
godot_io_java->hide_vk();
|
||||
} else {
|
||||
|
||||
ERR_PRINT("Virtual keyboard not available");
|
||||
};
|
||||
}
|
||||
|
||||
void OS_Android::init_video_mode(int p_video_width, int p_video_height) {
|
||||
|
||||
default_videomode.width = p_video_width;
|
||||
default_videomode.height = p_video_height;
|
||||
default_videomode.fullscreen = true;
|
||||
default_videomode.resizable = false;
|
||||
}
|
||||
|
||||
void OS_Android::main_loop_request_go_back() {
|
||||
|
||||
if (main_loop)
|
||||
main_loop->notification(NOTIFICATION_WM_GO_BACK_REQUEST);
|
||||
}
|
||||
|
||||
void OS_Android::set_display_size(Size2 p_size) {
|
||||
default_videomode.width = p_size.width;
|
||||
default_videomode.height = p_size.height;
|
||||
DisplayServerAndroid::get_singleton()->send_window_event(DisplayServer::WINDOW_EVENT_GO_BACK_REQUEST);
|
||||
}
|
||||
|
||||
Error OS_Android::shell_open(String p_uri) {
|
||||
|
|
@ -624,26 +204,6 @@ String OS_Android::get_locale() const {
|
|||
return OS_Unix::get_locale();
|
||||
}
|
||||
|
||||
void OS_Android::set_clipboard(const String &p_text) {
|
||||
|
||||
// DO we really need the fallback to OS_Unix here?!
|
||||
if (godot_java->has_set_clipboard()) {
|
||||
godot_java->set_clipboard(p_text);
|
||||
} else {
|
||||
OS_Unix::set_clipboard(p_text);
|
||||
}
|
||||
}
|
||||
|
||||
String OS_Android::get_clipboard() const {
|
||||
|
||||
// DO we really need the fallback to OS_Unix here?!
|
||||
if (godot_java->has_get_clipboard()) {
|
||||
return godot_java->get_clipboard();
|
||||
}
|
||||
|
||||
return OS_Unix::get_clipboard();
|
||||
}
|
||||
|
||||
String OS_Android::get_model_name() const {
|
||||
|
||||
String model = godot_io_java->get_model();
|
||||
|
|
@ -653,11 +213,6 @@ String OS_Android::get_model_name() const {
|
|||
return OS_Unix::get_model_name();
|
||||
}
|
||||
|
||||
int OS_Android::get_screen_dpi(int p_screen) const {
|
||||
|
||||
return godot_io_java->get_screen_dpi();
|
||||
}
|
||||
|
||||
String OS_Android::get_user_data_dir() const {
|
||||
|
||||
if (data_dir_cache != String())
|
||||
|
|
@ -689,11 +244,6 @@ String OS_Android::get_user_data_dir() const {
|
|||
return ".";
|
||||
}
|
||||
|
||||
void OS_Android::set_screen_orientation(ScreenOrientation p_orientation) {
|
||||
|
||||
godot_io_java->set_screen_orientation(p_orientation);
|
||||
}
|
||||
|
||||
String OS_Android::get_unique_id() const {
|
||||
|
||||
String unique_id = godot_io_java->get_unique_id();
|
||||
|
|
@ -703,38 +253,32 @@ String OS_Android::get_unique_id() const {
|
|||
return OS::get_unique_id();
|
||||
}
|
||||
|
||||
Error OS_Android::native_video_play(String p_path, float p_volume, String p_audio_track, String p_subtitle_track) {
|
||||
// FIXME: Add support for volume, audio and subtitle tracks
|
||||
|
||||
godot_io_java->play_video(p_path);
|
||||
return OK;
|
||||
}
|
||||
|
||||
bool OS_Android::native_video_is_playing() const {
|
||||
|
||||
return godot_io_java->is_video_playing();
|
||||
}
|
||||
|
||||
void OS_Android::native_video_pause() {
|
||||
|
||||
godot_io_java->pause_video();
|
||||
}
|
||||
|
||||
String OS_Android::get_system_dir(SystemDir p_dir) const {
|
||||
|
||||
return godot_io_java->get_system_dir(p_dir);
|
||||
}
|
||||
|
||||
void OS_Android::native_video_stop() {
|
||||
void OS_Android::set_display_size(const Size2i &p_size) {
|
||||
display_size = p_size;
|
||||
}
|
||||
|
||||
godot_io_java->stop_video();
|
||||
Size2i OS_Android::get_display_size() const {
|
||||
return display_size;
|
||||
}
|
||||
|
||||
void OS_Android::set_context_is_16_bits(bool p_is_16) {
|
||||
|
||||
#if defined(OPENGL_ENABLED)
|
||||
//use_16bits_fbo = p_is_16;
|
||||
//if (rasterizer)
|
||||
// rasterizer->set_force_16_bits_fbo(p_is_16);
|
||||
#endif
|
||||
}
|
||||
|
||||
void OS_Android::set_opengl_extensions(const char *p_gl_extensions) {
|
||||
#if defined(OPENGL_ENABLED)
|
||||
ERR_FAIL_COND(!p_gl_extensions);
|
||||
gl_extensions = p_gl_extensions;
|
||||
#endif
|
||||
}
|
||||
|
||||
void OS_Android::set_native_window(ANativeWindow *p_native_window) {
|
||||
|
|
@ -743,16 +287,12 @@ void OS_Android::set_native_window(ANativeWindow *p_native_window) {
|
|||
#endif
|
||||
}
|
||||
|
||||
void OS_Android::joy_connection_changed(int p_device, bool p_connected, String p_name) {
|
||||
return input->joy_connection_changed(p_device, p_connected, p_name, "");
|
||||
}
|
||||
|
||||
bool OS_Android::is_joy_known(int p_device) {
|
||||
return input->is_joy_mapped(p_device);
|
||||
}
|
||||
|
||||
String OS_Android::get_joy_guid(int p_device) const {
|
||||
return input->get_joy_guid_remapped(p_device);
|
||||
ANativeWindow *OS_Android::get_native_window() const {
|
||||
#if defined(VULKAN_ENABLED)
|
||||
return native_window;
|
||||
#else
|
||||
return nullptr;
|
||||
#endif
|
||||
}
|
||||
|
||||
void OS_Android::vibrate_handheld(int p_duration_ms) {
|
||||
|
|
@ -780,25 +320,21 @@ bool OS_Android::_check_internal_feature_support(const String &p_feature) {
|
|||
}
|
||||
|
||||
OS_Android::OS_Android(GodotJavaWrapper *p_godot_java, GodotIOJavaWrapper *p_godot_io_java, bool p_use_apk_expansion) {
|
||||
display_size.width = 800;
|
||||
display_size.height = 600;
|
||||
|
||||
use_apk_expansion = p_use_apk_expansion;
|
||||
default_videomode.width = 800;
|
||||
default_videomode.height = 600;
|
||||
default_videomode.fullscreen = true;
|
||||
default_videomode.resizable = false;
|
||||
|
||||
main_loop = nullptr;
|
||||
gl_extensions = nullptr;
|
||||
//rasterizer = nullptr;
|
||||
use_gl2 = false;
|
||||
|
||||
#if defined(VULKAN_ENABLED)
|
||||
context_vulkan = NULL;
|
||||
rendering_device_vulkan = NULL;
|
||||
native_window = NULL;
|
||||
#if defined(OPENGL_ENABLED)
|
||||
gl_extensions = nullptr;
|
||||
use_gl2 = false;
|
||||
#endif
|
||||
|
||||
rendering_server = nullptr;
|
||||
#if defined(VULKAN_ENABLED)
|
||||
native_window = nullptr;
|
||||
#endif
|
||||
|
||||
godot_java = p_godot_java;
|
||||
godot_io_java = p_godot_io_java;
|
||||
|
|
@ -808,6 +344,8 @@ OS_Android::OS_Android(GodotJavaWrapper *p_godot_java, GodotIOJavaWrapper *p_god
|
|||
_set_logger(memnew(CompositeLogger(loggers)));
|
||||
|
||||
AudioDriverManager::add_driver(&audio_driver_android);
|
||||
|
||||
DisplayServerAndroid::register_android_driver();
|
||||
}
|
||||
|
||||
OS_Android::~OS_Android() {
|
||||
|
|
|
|||
|
|
@ -33,87 +33,45 @@
|
|||
|
||||
#include "audio_driver_jandroid.h"
|
||||
#include "audio_driver_opensl.h"
|
||||
#include "core/input/input_filter.h"
|
||||
#include "core/os/main_loop.h"
|
||||
#include "drivers/unix/os_unix.h"
|
||||
#include "servers/audio_server.h"
|
||||
#include "servers/rendering/rasterizer.h"
|
||||
|
||||
class GodotJavaWrapper;
|
||||
class GodotIOJavaWrapper;
|
||||
|
||||
#if defined(VULKAN_ENABLED)
|
||||
class VulkanContextAndroid;
|
||||
class RenderingDeviceVulkan;
|
||||
#endif
|
||||
|
||||
struct ANativeWindow;
|
||||
|
||||
class OS_Android : public OS_Unix {
|
||||
public:
|
||||
struct TouchPos {
|
||||
int id;
|
||||
Point2 pos;
|
||||
};
|
||||
|
||||
enum {
|
||||
JOY_EVENT_BUTTON = 0,
|
||||
JOY_EVENT_AXIS = 1,
|
||||
JOY_EVENT_HAT = 2
|
||||
};
|
||||
|
||||
struct JoypadEvent {
|
||||
|
||||
int device;
|
||||
int type;
|
||||
int index;
|
||||
bool pressed;
|
||||
float value;
|
||||
int hat;
|
||||
};
|
||||
|
||||
private:
|
||||
Vector<TouchPos> touch;
|
||||
Point2 hover_prev_pos; // needed to calculate the relative position on hover events
|
||||
Point2 scroll_prev_pos; // needed to calculate the relative position on scroll events
|
||||
Size2i display_size;
|
||||
|
||||
bool use_gl2;
|
||||
bool use_apk_expansion;
|
||||
|
||||
#if defined(OPENGL_ENABLED)
|
||||
bool use_16bits_fbo;
|
||||
|
||||
#if defined(VULKAN_ENABLED)
|
||||
VulkanContextAndroid *context_vulkan;
|
||||
RenderingDeviceVulkan *rendering_device_vulkan;
|
||||
ANativeWindow *native_window;
|
||||
const char *gl_extensions;
|
||||
#endif
|
||||
|
||||
RenderingServer *rendering_server;
|
||||
#if defined(VULKAN_ENABLED)
|
||||
ANativeWindow *native_window;
|
||||
#endif
|
||||
|
||||
mutable String data_dir_cache;
|
||||
|
||||
//AudioDriverAndroid audio_driver_android;
|
||||
AudioDriverOpenSL audio_driver_android;
|
||||
|
||||
const char *gl_extensions;
|
||||
|
||||
InputDefault *input;
|
||||
VideoMode default_videomode;
|
||||
MainLoop *main_loop;
|
||||
|
||||
GodotJavaWrapper *godot_java;
|
||||
GodotIOJavaWrapper *godot_io_java;
|
||||
|
||||
int video_driver_index;
|
||||
|
||||
public:
|
||||
virtual int get_audio_driver_count() const;
|
||||
virtual const char *get_audio_driver_name(int p_driver) const;
|
||||
|
||||
virtual int get_current_video_driver() const;
|
||||
|
||||
virtual void initialize_core();
|
||||
virtual Error initialize(const VideoMode &p_desired, int p_video_driver, int p_audio_driver);
|
||||
virtual void initialize();
|
||||
|
||||
virtual void initialize_joypads();
|
||||
|
||||
virtual void set_main_loop(MainLoop *p_main_loop);
|
||||
virtual void delete_main_loop();
|
||||
|
|
@ -122,37 +80,19 @@ public:
|
|||
|
||||
typedef int64_t ProcessID;
|
||||
|
||||
static OS *get_singleton();
|
||||
static OS_Android *get_singleton();
|
||||
GodotJavaWrapper *get_godot_java();
|
||||
GodotIOJavaWrapper *get_godot_io_java();
|
||||
|
||||
virtual void alert(const String &p_alert, const String &p_title = "ALERT!");
|
||||
virtual bool request_permission(const String &p_name);
|
||||
virtual bool request_permissions();
|
||||
virtual Vector<String> get_granted_permissions() const;
|
||||
|
||||
virtual Error open_dynamic_library(const String p_path, void *&p_library_handle, bool p_also_set_library_path = false);
|
||||
|
||||
virtual void set_mouse_show(bool p_show);
|
||||
virtual void set_mouse_grab(bool p_grab);
|
||||
virtual bool is_mouse_grab_enabled() const;
|
||||
virtual Point2 get_mouse_position() const;
|
||||
virtual int get_mouse_button_state() const;
|
||||
virtual void set_window_title(const String &p_title);
|
||||
|
||||
virtual void set_video_mode(const VideoMode &p_video_mode, int p_screen = 0);
|
||||
virtual VideoMode get_video_mode(int p_screen = 0) const;
|
||||
virtual void get_fullscreen_mode_list(List<VideoMode> *p_list, int p_screen = 0) const;
|
||||
|
||||
virtual void set_keep_screen_on(bool p_enabled);
|
||||
|
||||
virtual Size2 get_window_size() const;
|
||||
|
||||
virtual String get_name() const;
|
||||
virtual MainLoop *get_main_loop() const;
|
||||
|
||||
virtual bool can_draw() const;
|
||||
|
||||
void main_loop_begin();
|
||||
bool main_loop_iterate();
|
||||
void main_loop_request_go_back();
|
||||
|
|
@ -160,55 +100,25 @@ public:
|
|||
void main_loop_focusout();
|
||||
void main_loop_focusin();
|
||||
|
||||
virtual bool has_touchscreen_ui_hint() const;
|
||||
|
||||
virtual bool has_virtual_keyboard() const;
|
||||
virtual void show_virtual_keyboard(const String &p_existing_text, const Rect2 &p_screen_rect = Rect2(), int p_max_input_length = -1);
|
||||
virtual void hide_virtual_keyboard();
|
||||
virtual int get_virtual_keyboard_height() const;
|
||||
|
||||
void set_opengl_extensions(const char *p_gl_extensions);
|
||||
void set_display_size(Size2 p_size);
|
||||
void set_display_size(const Size2i &p_size);
|
||||
Size2i get_display_size() const;
|
||||
|
||||
void set_context_is_16_bits(bool p_is_16);
|
||||
void set_opengl_extensions(const char *p_gl_extensions);
|
||||
|
||||
void set_native_window(ANativeWindow *p_native_window);
|
||||
|
||||
virtual void set_screen_orientation(ScreenOrientation p_orientation);
|
||||
ANativeWindow *get_native_window() const;
|
||||
|
||||
virtual Error shell_open(String p_uri);
|
||||
virtual String get_user_data_dir() const;
|
||||
virtual String get_resource_dir() const;
|
||||
virtual String get_locale() const;
|
||||
virtual void set_clipboard(const String &p_text);
|
||||
virtual String get_clipboard() const;
|
||||
virtual String get_model_name() const;
|
||||
virtual int get_screen_dpi(int p_screen = 0) const;
|
||||
|
||||
virtual String get_unique_id() const;
|
||||
|
||||
virtual String get_system_dir(SystemDir p_dir) const;
|
||||
|
||||
void process_accelerometer(const Vector3 &p_accelerometer);
|
||||
void process_gravity(const Vector3 &p_gravity);
|
||||
void process_magnetometer(const Vector3 &p_magnetometer);
|
||||
void process_gyroscope(const Vector3 &p_gyroscope);
|
||||
void process_touch(int p_what, int p_pointer, const Vector<TouchPos> &p_points);
|
||||
void process_hover(int p_type, Point2 p_pos);
|
||||
void process_double_tap(Point2 p_pos);
|
||||
void process_scroll(Point2 p_pos);
|
||||
void process_joy_event(JoypadEvent p_event);
|
||||
void process_event(Ref<InputEvent> p_event);
|
||||
void init_video_mode(int p_video_width, int p_video_height);
|
||||
|
||||
virtual Error native_video_play(String p_path, float p_volume, String p_audio_track, String p_subtitle_track);
|
||||
virtual bool native_video_is_playing() const;
|
||||
virtual void native_video_pause();
|
||||
virtual void native_video_stop();
|
||||
|
||||
virtual bool is_joy_known(int p_device);
|
||||
virtual String get_joy_guid(int p_device) const;
|
||||
void joy_connection_changed(int p_device, bool p_connected, String p_name);
|
||||
void vibrate_handheld(int p_duration_ms);
|
||||
|
||||
virtual bool _check_internal_feature_support(const String &p_feature);
|
||||
|
|
|
|||
|
|
@ -33,7 +33,7 @@
|
|||
|
||||
#define VMA_IMPLEMENTATION
|
||||
#ifdef DEBUG_ENABLED
|
||||
#ifndef _MSC_VER
|
||||
#ifndef _DEBUG
|
||||
#define _DEBUG
|
||||
#endif
|
||||
#endif
|
||||
|
|
@ -46,17 +46,17 @@ const char *VulkanContextAndroid::_get_platform_surface_extension() const {
|
|||
int VulkanContextAndroid::window_create(ANativeWindow *p_window, int p_width, int p_height) {
|
||||
VkAndroidSurfaceCreateInfoKHR createInfo;
|
||||
createInfo.sType = VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR;
|
||||
createInfo.pNext = NULL;
|
||||
createInfo.pNext = nullptr;
|
||||
createInfo.flags = 0;
|
||||
createInfo.window = p_window;
|
||||
|
||||
VkSurfaceKHR surface;
|
||||
VkResult err = vkCreateAndroidSurfaceKHR(_get_instance(), &createInfo, NULL, &surface);
|
||||
VkResult err = vkCreateAndroidSurfaceKHR(_get_instance(), &createInfo, nullptr, &surface);
|
||||
if (err != VK_SUCCESS) {
|
||||
ERR_FAIL_V_MSG(-1, "vkCreateAndroidSurfaceKHR failed with error " + itos(err));
|
||||
}
|
||||
|
||||
return _window_create(surface, p_width, p_height);
|
||||
return _window_create(DisplayServer::MAIN_WINDOW_ID, surface, p_width, p_height);
|
||||
}
|
||||
|
||||
VulkanContextAndroid::VulkanContextAndroid() {
|
||||
|
|
|
|||
|
|
@ -180,7 +180,7 @@ public:
|
|||
};
|
||||
|
||||
virtual void screen_set_orientation(ScreenOrientation p_orientation, int p_screen = SCREEN_OF_MAIN_WINDOW);
|
||||
ScreenOrientation screen_get_orientation(int p_screen = SCREEN_OF_MAIN_WINDOW) const;
|
||||
virtual ScreenOrientation screen_get_orientation(int p_screen = SCREEN_OF_MAIN_WINDOW) const;
|
||||
|
||||
virtual void screen_set_keep_on(bool p_enable); //disable screensaver
|
||||
virtual bool screen_is_kept_on() const;
|
||||
|
|
|
|||
Loading…
Reference in New Issue