diff options
Diffstat (limited to 'platform')
53 files changed, 2070 insertions, 664 deletions
diff --git a/platform/android/AndroidManifest.xml.template b/platform/android/AndroidManifest.xml.template index 2a24c7cdc2..be5afb406a 100644 --- a/platform/android/AndroidManifest.xml.template +++ b/platform/android/AndroidManifest.xml.template @@ -31,7 +31,7 @@ $$ADD_APPLICATION_CHUNKS$$ </application> - <uses-feature android:glEsVersion="0x00020000"/> + <uses-feature android:glEsVersion="0x00030000"/> $$ADD_PERMISSION_CHUNKS$$ <uses-permission android:name="godot.ACCESS_CHECKIN_PROPERTIES"/> diff --git a/platform/android/build.gradle.template b/platform/android/build.gradle.template index 24aab8e01f..ec5bbb6630 100644 --- a/platform/android/build.gradle.template +++ b/platform/android/build.gradle.template @@ -12,6 +12,7 @@ apply plugin: 'com.android.application' allprojects { repositories { + jcenter() mavenCentral() $$GRADLE_REPOSITORY_URLS$$ } diff --git a/platform/android/detect.py b/platform/android/detect.py index d1b33fe649..0e78a4618d 100644 --- a/platform/android/detect.py +++ b/platform/android/detect.py @@ -168,9 +168,7 @@ def configure(env): env.Append(CPPFLAGS=["-isystem", sysroot + "/usr/include"]) env.Append(CPPFLAGS=string.split( - '-Wno-invalid-command-line-argument -Wno-unused-command-line-argument')) - env.Append(CPPFLAGS=string.split( - '-fpic -ffunction-sections -funwind-tables -fstack-protector-strong -fvisibility=hidden -fno-strict-aliasing -Wa,--noexecstack')) + '-fpic -ffunction-sections -funwind-tables -fstack-protector-strong -fvisibility=hidden -fno-strict-aliasing')) env.Append(CPPFLAGS=string.split('-DANDROID -DNO_STATVFS -DGLES2_ENABLED')) env['neon_enabled'] = False diff --git a/platform/android/export/export.cpp b/platform/android/export/export.cpp index 31fa4c18bd..2342829965 100644 --- a/platform/android/export/export.cpp +++ b/platform/android/export/export.cpp @@ -1792,7 +1792,6 @@ EditorExportPlatformAndroid::EditorExportPlatformAndroid() { name=""; _signed=true; apk_expansion=false; - device_lock = Mutex::create(); quit_request=false; orientation=0; remove_prev=true; @@ -1888,26 +1887,1672 @@ EditorExportPlatformAndroid::~EditorExportPlatformAndroid() { #endif -void register_android_exporter() { +static const char *android_perms[] = { + "ACCESS_CHECKIN_PROPERTIES", + "ACCESS_COARSE_LOCATION", + "ACCESS_FINE_LOCATION", + "ACCESS_LOCATION_EXTRA_COMMANDS", + "ACCESS_MOCK_LOCATION", + "ACCESS_NETWORK_STATE", + "ACCESS_SURFACE_FLINGER", + "ACCESS_WIFI_STATE", + "ACCOUNT_MANAGER", + "ADD_VOICEMAIL", + "AUTHENTICATE_ACCOUNTS", + "BATTERY_STATS", + "BIND_ACCESSIBILITY_SERVICE", + "BIND_APPWIDGET", + "BIND_DEVICE_ADMIN", + "BIND_INPUT_METHOD", + "BIND_NFC_SERVICE", + "BIND_NOTIFICATION_LISTENER_SERVICE", + "BIND_PRINT_SERVICE", + "BIND_REMOTEVIEWS", + "BIND_TEXT_SERVICE", + "BIND_VPN_SERVICE", + "BIND_WALLPAPER", + "BLUETOOTH", + "BLUETOOTH_ADMIN", + "BLUETOOTH_PRIVILEGED", + "BRICK", + "BROADCAST_PACKAGE_REMOVED", + "BROADCAST_SMS", + "BROADCAST_STICKY", + "BROADCAST_WAP_PUSH", + "CALL_PHONE", + "CALL_PRIVILEGED", + "CAMERA", + "CAPTURE_AUDIO_OUTPUT", + "CAPTURE_SECURE_VIDEO_OUTPUT", + "CAPTURE_VIDEO_OUTPUT", + "CHANGE_COMPONENT_ENABLED_STATE", + "CHANGE_CONFIGURATION", + "CHANGE_NETWORK_STATE", + "CHANGE_WIFI_MULTICAST_STATE", + "CHANGE_WIFI_STATE", + "CLEAR_APP_CACHE", + "CLEAR_APP_USER_DATA", + "CONTROL_LOCATION_UPDATES", + "DELETE_CACHE_FILES", + "DELETE_PACKAGES", + "DEVICE_POWER", + "DIAGNOSTIC", + "DISABLE_KEYGUARD", + "DUMP", + "EXPAND_STATUS_BAR", + "FACTORY_TEST", + "FLASHLIGHT", + "FORCE_BACK", + "GET_ACCOUNTS", + "GET_PACKAGE_SIZE", + "GET_TASKS", + "GET_TOP_ACTIVITY_INFO", + "GLOBAL_SEARCH", + "HARDWARE_TEST", + "INJECT_EVENTS", + "INSTALL_LOCATION_PROVIDER", + "INSTALL_PACKAGES", + "INSTALL_SHORTCUT", + "INTERNAL_SYSTEM_WINDOW", + "INTERNET", + "KILL_BACKGROUND_PROCESSES", + "LOCATION_HARDWARE", + "MANAGE_ACCOUNTS", + "MANAGE_APP_TOKENS", + "MANAGE_DOCUMENTS", + "MASTER_CLEAR", + "MEDIA_CONTENT_CONTROL", + "MODIFY_AUDIO_SETTINGS", + "MODIFY_PHONE_STATE", + "MOUNT_FORMAT_FILESYSTEMS", + "MOUNT_UNMOUNT_FILESYSTEMS", + "NFC", + "PERSISTENT_ACTIVITY", + "PROCESS_OUTGOING_CALLS", + "READ_CALENDAR", + "READ_CALL_LOG", + "READ_CONTACTS", + "READ_EXTERNAL_STORAGE", + "READ_FRAME_BUFFER", + "READ_HISTORY_BOOKMARKS", + "READ_INPUT_STATE", + "READ_LOGS", + "READ_PHONE_STATE", + "READ_PROFILE", + "READ_SMS", + "READ_SOCIAL_STREAM", + "READ_SYNC_SETTINGS", + "READ_SYNC_STATS", + "READ_USER_DICTIONARY", + "REBOOT", + "RECEIVE_BOOT_COMPLETED", + "RECEIVE_MMS", + "RECEIVE_SMS", + "RECEIVE_WAP_PUSH", + "RECORD_AUDIO", + "REORDER_TASKS", + "RESTART_PACKAGES", + "SEND_RESPOND_VIA_MESSAGE", + "SEND_SMS", + "SET_ACTIVITY_WATCHER", + "SET_ALARM", + "SET_ALWAYS_FINISH", + "SET_ANIMATION_SCALE", + "SET_DEBUG_APP", + "SET_ORIENTATION", + "SET_POINTER_SPEED", + "SET_PREFERRED_APPLICATIONS", + "SET_PROCESS_LIMIT", + "SET_TIME", + "SET_TIME_ZONE", + "SET_WALLPAPER", + "SET_WALLPAPER_HINTS", + "SIGNAL_PERSISTENT_PROCESSES", + "STATUS_BAR", + "SUBSCRIBED_FEEDS_READ", + "SUBSCRIBED_FEEDS_WRITE", + "SYSTEM_ALERT_WINDOW", + "TRANSMIT_IR", + "UNINSTALL_SHORTCUT", + "UPDATE_DEVICE_STATS", + "USE_CREDENTIALS", + "USE_SIP", + "VIBRATE", + "WAKE_LOCK", + "WRITE_APN_SETTINGS", + "WRITE_CALENDAR", + "WRITE_CALL_LOG", + "WRITE_CONTACTS", + "WRITE_EXTERNAL_STORAGE", + "WRITE_GSERVICES", + "WRITE_HISTORY_BOOKMARKS", + "WRITE_PROFILE", + "WRITE_SECURE_SETTINGS", + "WRITE_SETTINGS", + "WRITE_SMS", + "WRITE_SOCIAL_STREAM", + "WRITE_SYNC_SETTINGS", + "WRITE_USER_DICTIONARY", + NULL +}; + +class EditorExportAndroid : public EditorExportPlatform { + + GDCLASS(EditorExportAndroid, EditorExportPlatform) + + Ref<ImageTexture> logo; + + struct Device { + + String id; + String name; + String description; + }; + + struct APKExportData { + + zipFile apk; + EditorProgress *ep; + }; + + Vector<Device> devices; + bool devices_changed; + Mutex *device_lock; + Thread *device_thread; + volatile bool quit_request; + + static void _device_poll_thread(void *ud) { + + EditorExportAndroid *ea = (EditorExportAndroid *)ud; + + while (!ea->quit_request) { + + String adb = EditorSettings::get_singleton()->get("export/android/adb"); + if (FileAccess::exists(adb)) { + + String devices; + List<String> args; + args.push_back("devices"); + int ec; + OS::get_singleton()->execute(adb, args, true, NULL, &devices, &ec); + + Vector<String> ds = devices.split("\n"); + Vector<String> ldevices; + for (int i = 1; i < ds.size(); i++) { + + String d = ds[i]; + int dpos = d.find("device"); + if (dpos == -1) + continue; + d = d.substr(0, dpos).strip_edges(); + //print_line("found devuce: "+d); + ldevices.push_back(d); + } + + ea->device_lock->lock(); + + bool different = false; + + if (ea->devices.size() != ldevices.size()) { + + different = true; + } else { + + for (int i = 0; i < ea->devices.size(); i++) { + + if (ea->devices[i].id != ldevices[i]) { + different = true; + break; + } + } + } + + if (different) { + + print_line("DIFFERENT!"); + Vector<Device> ndevices; + + for (int i = 0; i < ldevices.size(); i++) { + + Device d; + d.id = ldevices[i]; + for (int j = 0; j < ea->devices.size(); j++) { + if (ea->devices[j].id == ldevices[i]) { + d.description = ea->devices[j].description; + d.name = ea->devices[j].name; + } + } + + if (d.description == "") { + //in the oven, request! + args.clear(); + args.push_back("-s"); + args.push_back(d.id); + args.push_back("shell"); + args.push_back("cat"); + args.push_back("/system/build.prop"); + int ec; + String dp; + + OS::get_singleton()->execute(adb, args, true, NULL, &dp, &ec); + + Vector<String> props = dp.split("\n"); + String vendor; + String device; + d.description + "Device ID: " + d.id + "\n"; + for (int j = 0; j < props.size(); j++) { + + String p = props[j]; + if (p.begins_with("ro.product.model=")) { + device = p.get_slice("=", 1).strip_edges(); + } else if (p.begins_with("ro.product.brand=")) { + vendor = p.get_slice("=", 1).strip_edges().capitalize(); + } else if (p.begins_with("ro.build.display.id=")) { + d.description += "Build: " + p.get_slice("=", 1).strip_edges() + "\n"; + } else if (p.begins_with("ro.build.version.release=")) { + d.description += "Release: " + p.get_slice("=", 1).strip_edges() + "\n"; + } else if (p.begins_with("ro.product.cpu.abi=")) { + d.description += "CPU: " + p.get_slice("=", 1).strip_edges() + "\n"; + } else if (p.begins_with("ro.product.manufacturer=")) { + d.description += "Manufacturer: " + p.get_slice("=", 1).strip_edges() + "\n"; + } else if (p.begins_with("ro.board.platform=")) { + d.description += "Chipset: " + p.get_slice("=", 1).strip_edges() + "\n"; + } else if (p.begins_with("ro.opengles.version=")) { + uint32_t opengl = p.get_slice("=", 1).to_int(); + d.description += "OpenGL: " + itos(opengl >> 16) + "." + itos((opengl >> 8) & 0xFF) + "." + itos((opengl)&0xFF) + "\n"; + } + } + + d.name = vendor + " " + device; + //print_line("name: "+d.name); + //print_line("description: "+d.description); + } + + ndevices.push_back(d); + } + + ea->devices = ndevices; + ea->devices_changed = true; + } + + ea->device_lock->unlock(); + } + + uint64_t wait = 3000000; + uint64_t time = OS::get_singleton()->get_ticks_usec(); + while (OS::get_singleton()->get_ticks_usec() - time < wait) { + OS::get_singleton()->delay_usec(1000); + if (ea->quit_request) + break; + } + } + + if (EditorSettings::get_singleton()->get("export/android/shutdown_adb_on_exit")) { + String adb = EditorSettings::get_singleton()->get("export/android/adb"); + if (!FileAccess::exists(adb)) { + return; //adb not configured + } + + List<String> args; + args.push_back("kill-server"); + OS::get_singleton()->execute(adb, args, true); + }; + } + + String get_project_name(const String &p_name) const { + + String aname; + if (p_name != "") { + aname = p_name; + } else { + aname = GlobalConfig::get_singleton()->get("application/name"); + } + + if (aname == "") { + aname = _MKSTR(VERSION_NAME); + } + + return aname; + } + + String get_package_name(const String &p_package) { + + String pname = p_package; + String basename = GlobalConfig::get_singleton()->get("application/name"); + basename = basename.to_lower(); + + String name; + bool first = true; + for (int i = 0; i < basename.length(); i++) { + CharType c = basename[i]; + if (c >= '0' && c <= '9' && first) { + continue; + } + if ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9')) { + name += String::chr(c); + first = false; + } + } + if (name == "") + name = "noname"; + + pname = pname.replace("$genname", name); + return pname; + } + + static bool _should_compress_asset(const String &p_path, const Vector<uint8_t> &p_data) { + + /* + * By not compressing files with little or not benefit in doing so, + * a performance gain is expected attime. Moreover, if the APK is + * zip-aligned, assets stored as they are can be efficiently read by + * Android by memory-mapping them. + */ + + // -- Unconditional uncompress to mimic AAPT plus some other + + static const char *unconditional_compress_ext[] = { + // From https://github.com/android/platform_frameworks_base/blob/master/tools/aapt/Package.cpp + // These formats are already compressed, or don't compress well: + ".jpg", ".jpeg", ".png", ".gif", + ".wav", ".mp2", ".mp3", ".ogg", ".aac", + ".mpg", ".mpeg", ".mid", ".midi", ".smf", ".jet", + ".rtttl", ".imy", ".xmf", ".mp4", ".m4a", + ".m4v", ".3gp", ".3gpp", ".3g2", ".3gpp2", + ".amr", ".awb", ".wma", ".wmv", + // Godot-specific: + ".webp", // Same reasoning as .png + ".cfb", // Don't let small config files slow-down startup + ".scn", // Binary scenes are usually already compressed + ".stex", // Streamable textures are usually already compressed + // Trailer for easier processing + NULL + }; + + for (const char **ext = unconditional_compress_ext; *ext; ++ext) { + if (p_path.to_lower().ends_with(String(*ext))) { + return false; + } + } + + // -- Compressed resource? + + if (p_data.size() >= 4 && p_data[0] == 'R' && p_data[1] == 'S' && p_data[2] == 'C' && p_data[3] == 'C') { + // Already compressed + return false; + } + + // --- TODO: Decide on texture resources according to their image compression setting + + return true; + } + + static zip_fileinfo get_zip_fileinfo() { + + OS::Time time = OS::get_singleton()->get_time(); + OS::Date date = OS::get_singleton()->get_date(); + + zip_fileinfo zipfi; + zipfi.tmz_date.tm_hour = time.hour; + zipfi.tmz_date.tm_mday = date.day; + zipfi.tmz_date.tm_min = time.min; + zipfi.tmz_date.tm_mon = date.month; + zipfi.tmz_date.tm_sec = time.sec; + zipfi.tmz_date.tm_year = date.year; + zipfi.dosDate = 0; + zipfi.external_fa = 0; + zipfi.internal_fa = 0; + + return zipfi; + } + + static Error save_apk_file(void *p_userdata, const String &p_path, const Vector<uint8_t> &p_data, int p_file, int p_total) { + + APKExportData *ed = (APKExportData *)p_userdata; + String dst_path = p_path; + dst_path = dst_path.replace_first("res://", "assets/"); + + zip_fileinfo zipfi = get_zip_fileinfo(); + + zipOpenNewFileInZip(ed->apk, + dst_path.utf8().get_data(), + &zipfi, + NULL, + 0, + NULL, + 0, + NULL, + _should_compress_asset(p_path, p_data) ? Z_DEFLATED : 0, + Z_DEFAULT_COMPRESSION); + + zipWriteInFileInZip(ed->apk, p_data.ptr(), p_data.size()); + zipCloseFileInZip(ed->apk); + ed->ep->step("File: " + p_path, 3 + p_file * 100 / p_total); + return OK; + } + + void _fix_manifest(const Ref<EditorExportPreset> &p_preset, Vector<uint8_t> &p_manifest, bool p_give_internet) { + + const int CHUNK_AXML_FILE = 0x00080003; + const int CHUNK_RESOURCEIDS = 0x00080180; + const int CHUNK_STRINGS = 0x001C0001; + const int CHUNK_XML_END_NAMESPACE = 0x00100101; + const int CHUNK_XML_END_TAG = 0x00100103; + const int CHUNK_XML_START_NAMESPACE = 0x00100100; + const int CHUNK_XML_START_TAG = 0x00100102; + const int CHUNK_XML_TEXT = 0x00100104; + const int UTF8_FLAG = 0x00000100; + + Vector<String> string_table; + + uint32_t ofs = 0; + + uint32_t header = decode_uint32(&p_manifest[ofs]); + uint32_t filesize = decode_uint32(&p_manifest[ofs + 4]); + ofs += 8; + + //print_line("FILESIZE: "+itos(filesize)+" ACTUAL: "+itos(p_manifest.size())); + + uint32_t string_count; + uint32_t styles_count; + uint32_t string_flags; + uint32_t string_data_offset; + + uint32_t styles_offset; + uint32_t string_table_begins; + uint32_t string_table_ends; + Vector<uint8_t> stable_extra; + + String version_name = p_preset->get("version/name"); + int version_code = p_preset->get("version/code"); + String package_name = p_preset->get("package/unique_name"); + + int orientation = p_preset->get("screen/orientation"); + + bool screen_support_small = p_preset->get("screen/support_small"); + bool screen_support_normal = p_preset->get("screen/support_normal"); + bool screen_support_large = p_preset->get("screen/support_large"); + bool screen_support_xlarge = p_preset->get("screen/support_xlarge"); + + String user_perms[MAX_USER_PERMISSIONS]; + + for (int i = 0; i < MAX_USER_PERMISSIONS; i++) { + + user_perms[i] = p_preset->get("user_permissions/" + itos(i)); + } + + Set<String> perms; + + const char **aperms = android_perms; + while (*aperms) { + + bool enabled = p_preset->get("permissions/" + String(*aperms).to_lower()); + if (enabled) + perms.insert(String(*aperms)); + aperms++; + } + + while (ofs < (uint32_t)p_manifest.size()) { + + uint32_t chunk = decode_uint32(&p_manifest[ofs]); + uint32_t size = decode_uint32(&p_manifest[ofs + 4]); + + switch (chunk) { + + case CHUNK_STRINGS: { + + int iofs = ofs + 8; + + string_count = decode_uint32(&p_manifest[iofs]); + styles_count = decode_uint32(&p_manifest[iofs + 4]); + string_flags = decode_uint32(&p_manifest[iofs + 8]); + string_data_offset = decode_uint32(&p_manifest[iofs + 12]); + styles_offset = decode_uint32(&p_manifest[iofs + 16]); + /* + printf("string count: %i\n",string_count); + printf("flags: %i\n",string_flags); + printf("sdata ofs: %i\n",string_data_offset); + printf("styles ofs: %i\n",styles_offset); + */ + uint32_t st_offset = iofs + 20; + string_table.resize(string_count); + uint32_t string_end = 0; + + string_table_begins = st_offset; + + for (uint32_t i = 0; i < string_count; i++) { + + uint32_t string_at = decode_uint32(&p_manifest[st_offset + i * 4]); + string_at += st_offset + string_count * 4; + + ERR_EXPLAIN("Unimplemented, can't read utf8 string table."); + ERR_FAIL_COND(string_flags & UTF8_FLAG); + + if (string_flags & UTF8_FLAG) { + + } else { + uint32_t len = decode_uint16(&p_manifest[string_at]); + Vector<CharType> ucstring; + ucstring.resize(len + 1); + for (uint32_t j = 0; j < len; j++) { + uint16_t c = decode_uint16(&p_manifest[string_at + 2 + 2 * j]); + ucstring[j] = c; + } + string_end = MAX(string_at + 2 + 2 * len, string_end); + ucstring[len] = 0; + string_table[i] = ucstring.ptr(); + } + + //print_line("String "+itos(i)+": "+string_table[i]); + } + + for (uint32_t i = string_end; i < (ofs + size); i++) { + stable_extra.push_back(p_manifest[i]); + } + + //printf("stable extra: %i\n",int(stable_extra.size())); + string_table_ends = ofs + size; + + //print_line("STABLE SIZE: "+itos(size)+" ACTUAL: "+itos(string_table_ends)); + + } break; + case CHUNK_XML_START_TAG: { + + int iofs = ofs + 8; + uint32_t line = decode_uint32(&p_manifest[iofs]); + uint32_t nspace = decode_uint32(&p_manifest[iofs + 8]); + uint32_t name = decode_uint32(&p_manifest[iofs + 12]); + uint32_t check = decode_uint32(&p_manifest[iofs + 16]); + + String tname = string_table[name]; + + //printf("NSPACE: %i\n",nspace); + //printf("NAME: %i (%s)\n",name,tname.utf8().get_data()); + //printf("CHECK: %x\n",check); + uint32_t attrcount = decode_uint32(&p_manifest[iofs + 20]); + iofs += 28; + //printf("ATTRCOUNT: %x\n",attrcount); + for (uint32_t i = 0; i < attrcount; i++) { + uint32_t attr_nspace = decode_uint32(&p_manifest[iofs]); + uint32_t attr_name = decode_uint32(&p_manifest[iofs + 4]); + uint32_t attr_value = decode_uint32(&p_manifest[iofs + 8]); + uint32_t attr_flags = decode_uint32(&p_manifest[iofs + 12]); + uint32_t attr_resid = decode_uint32(&p_manifest[iofs + 16]); + + String value; + if (attr_value != 0xFFFFFFFF) + value = string_table[attr_value]; + else + value = "Res #" + itos(attr_resid); + String attrname = string_table[attr_name]; + String nspace; + if (attr_nspace != 0xFFFFFFFF) + nspace = string_table[attr_nspace]; + else + nspace = ""; + + //printf("ATTR %i NSPACE: %i\n",i,attr_nspace); + //printf("ATTR %i NAME: %i (%s)\n",i,attr_name,attrname.utf8().get_data()); + //printf("ATTR %i VALUE: %i (%s)\n",i,attr_value,value.utf8().get_data()); + //printf("ATTR %i FLAGS: %x\n",i,attr_flags); + //printf("ATTR %i RESID: %x\n",i,attr_resid); + + //replace project information + if (tname == "manifest" && attrname == "package") { + + print_line("FOUND package"); + string_table[attr_value] = get_package_name(package_name); + } + + //print_line("tname: "+tname); + //print_line("nspace: "+nspace); + //print_line("attrname: "+attrname); + if (tname == "manifest" && /*nspace=="android" &&*/ attrname == "versionCode") { + + print_line("FOUND versionCode"); + encode_uint32(version_code, &p_manifest[iofs + 16]); + } + + if (tname == "manifest" && /*nspace=="android" &&*/ attrname == "versionName") { + + print_line("FOUND versionName"); + if (attr_value == 0xFFFFFFFF) { + WARN_PRINT("Version name in a resource, should be plaintext") + } else + string_table[attr_value] = version_name; + } + + if (tname == "activity" && /*nspace=="android" &&*/ attrname == "screenOrientation") { + + encode_uint32(orientation == 0 ? 0 : 1, &p_manifest[iofs + 16]); + /* + print_line("FOUND screen orientation"); + if (attr_value==0xFFFFFFFF) { + WARN_PRINT("Version name in a resource, should be plaintext") + } else { + string_table[attr_value]=(orientation==0?"landscape":"portrait"); + }*/ + } + + if (tname == "uses-permission" && /*nspace=="android" &&*/ attrname == "name") { + + if (value.begins_with("godot.custom")) { + + int which = value.get_slice(".", 2).to_int(); + if (which >= 0 && which < MAX_USER_PERMISSIONS && user_perms[which].strip_edges() != "") { + + string_table[attr_value] = user_perms[which].strip_edges(); + } + + } else if (value.begins_with("godot.")) { + String perm = value.get_slice(".", 1); + + if (perms.has(perm) || (p_give_internet && perm == "INTERNET")) { + + print_line("PERM: " + perm); + string_table[attr_value] = "android.permission." + perm; + } + } + } + + if (tname == "supports-screens") { + + if (attrname == "smallScreens") { + + encode_uint32(screen_support_small ? 0xFFFFFFFF : 0, &p_manifest[iofs + 16]); + + } else if (attrname == "normalScreens") { + + encode_uint32(screen_support_normal ? 0xFFFFFFFF : 0, &p_manifest[iofs + 16]); + + } else if (attrname == "largeScreens") { + + encode_uint32(screen_support_large ? 0xFFFFFFFF : 0, &p_manifest[iofs + 16]); + + } else if (attrname == "xlargeScreens") { + + encode_uint32(screen_support_xlarge ? 0xFFFFFFFF : 0, &p_manifest[iofs + 16]); + } + } + + iofs += 20; + } + + } break; + } + //printf("chunk %x: size: %d\n",chunk,size); + + ofs += size; + } + + //printf("end\n"); + + //create new andriodmanifest binary + + Vector<uint8_t> ret; + ret.resize(string_table_begins + string_table.size() * 4); + + for (uint32_t i = 0; i < string_table_begins; i++) { + + ret[i] = p_manifest[i]; + } + + ofs = 0; + for (int i = 0; i < string_table.size(); i++) { + + encode_uint32(ofs, &ret[string_table_begins + i * 4]); + ofs += string_table[i].length() * 2 + 2 + 2; + //print_line("ofs: "+itos(i)+": "+itos(ofs)); + } + ret.resize(ret.size() + ofs); + uint8_t *chars = &ret[ret.size() - ofs]; + for (int i = 0; i < string_table.size(); i++) { + + String s = string_table[i]; + //print_line("savint string :"+s); + encode_uint16(s.length(), chars); + chars += 2; + for (int j = 0; j < s.length(); j++) { //include zero? + encode_uint16(s[j], chars); + chars += 2; + } + encode_uint16(0, chars); + chars += 2; + } + + for (int i = 0; i < stable_extra.size(); i++) { + ret.push_back(stable_extra[i]); + } + + while (ret.size() % 4) + ret.push_back(0); + + uint32_t new_stable_end = ret.size(); + + uint32_t extra = (p_manifest.size() - string_table_ends); + ret.resize(new_stable_end + extra); + for (uint32_t i = 0; i < extra; i++) + ret[new_stable_end + i] = p_manifest[string_table_ends + i]; + + while (ret.size() % 4) + ret.push_back(0); + encode_uint32(ret.size(), &ret[4]); //update new file size + + encode_uint32(new_stable_end - 8, &ret[12]); //update new string table size + + //print_line("file size: "+itos(ret.size())); + + p_manifest = ret; #if 0 - String exe_ext=OS::get_singleton()->get_name()=="Windows"?"exe":""; - EDITOR_DEF("export/android/adb",""); - EditorSettings::get_singleton()->add_property_hint(PropertyInfo(Variant::STRING,"android/adb",PROPERTY_HINT_GLOBAL_FILE,exe_ext)); - EDITOR_DEF("export/android/jarsigner",""); - EditorSettings::get_singleton()->add_property_hint(PropertyInfo(Variant::STRING,"android/jarsigner",PROPERTY_HINT_GLOBAL_FILE,exe_ext)); - EDITOR_DEF("export/android/debug_keystore",""); - EditorSettings::get_singleton()->add_property_hint(PropertyInfo(Variant::STRING,"android/debug_keystore",PROPERTY_HINT_GLOBAL_FILE,"keystore")); - EDITOR_DEF("export/android/debug_keystore_user","androiddebugkey"); - EDITOR_DEF("export/android/debug_keystore_pass","android"); - //EDITOR_DEF("android/release_keystore",""); - //EDITOR_DEF("android/release_username",""); - //EditorSettings::get_singleton()->add_property_hint(PropertyInfo(Variant::STRING,"android/release_keystore",PROPERTY_HINT_GLOBAL_FILE,"*.keystore")); - EDITOR_DEF("export/android/timestamping_authority_url",""); - EDITOR_DEF("export/android/use_remote_debug_over_adb",false); - EDITOR_DEF("export/android/shutdown_adb_on_exit",true); - - Ref<EditorExportPlatformAndroid> exporter = Ref<EditorExportPlatformAndroid>( memnew(EditorExportPlatformAndroid) ); - EditorImportExport::get_singleton()->add_export_platform(exporter); + uint32_t header[9]; + for(int i=0;i<9;i++) { + header[i]=decode_uint32(&p_manifest[i*4]); + } + + //print_line("STO: "+itos(header[3])); + uint32_t st_offset=9*4; + //ERR_FAIL_COND(header[3]!=0x24) + uint32_t string_count=header[4]; + + + string_table.resize(string_count); + + for(int i=0;i<string_count;i++) { + + uint32_t string_at = decode_uint32(&p_manifest[st_offset+i*4]); + string_at+=st_offset+string_count*4; + uint32_t len = decode_uint16(&p_manifest[string_at]); + Vector<CharType> ucstring; + ucstring.resize(len+1); + for(int j=0;j<len;j++) { + uint16_t c=decode_uint16(&p_manifest[string_at+2+2*j]); + ucstring[j]=c; + } + ucstring[len]=0; + string_table[i]=ucstring.ptr(); + } + #endif + } + + static String _parse_string(const uint8_t *p_bytes, bool p_utf8) { + + uint32_t offset = 0; + uint32_t len = decode_uint16(&p_bytes[offset]); + + if (p_utf8) { + //don't know how to read extended utf8, this will have to be for now + len >>= 8; + } + offset += 2; + //printf("len %i, unicode: %i\n",len,int(p_utf8)); + + if (p_utf8) { + + Vector<uint8_t> str8; + str8.resize(len + 1); + for (uint32_t i = 0; i < len; i++) { + str8[i] = p_bytes[offset + i]; + } + str8[len] = 0; + String str; + str.parse_utf8((const char *)str8.ptr()); + return str; + } else { + + String str; + for (uint32_t i = 0; i < len; i++) { + CharType c = decode_uint16(&p_bytes[offset + i * 2]); + if (c == 0) + break; + str += String::chr(c); + } + return str; + } + } + void _fix_resources(const Ref<EditorExportPreset> &p_preset, Vector<uint8_t> &p_manifest) { + + const int UTF8_FLAG = 0x00000100; + print_line("*******************GORRRGLE***********************"); + + uint32_t header = decode_uint32(&p_manifest[0]); + uint32_t filesize = decode_uint32(&p_manifest[4]); + uint32_t string_block_len = decode_uint32(&p_manifest[16]); + uint32_t string_count = decode_uint32(&p_manifest[20]); + uint32_t string_flags = decode_uint32(&p_manifest[28]); + const uint32_t string_table_begins = 40; + + Vector<String> string_table; + + String package_name = p_preset->get("package/name"); + + //printf("stirng block len: %i\n",string_block_len); + //printf("stirng count: %i\n",string_count); + //printf("flags: %x\n",string_flags); + + for (uint32_t i = 0; i < string_count; i++) { + + uint32_t offset = decode_uint32(&p_manifest[string_table_begins + i * 4]); + offset += string_table_begins + string_count * 4; + + String str = _parse_string(&p_manifest[offset], string_flags & UTF8_FLAG); + + if (str.begins_with("godot-project-name")) { + + if (str == "godot-project-name") { + //project name + str = get_project_name(package_name); + + } else { + + String lang = str.substr(str.find_last("-") + 1, str.length()).replace("-", "_"); + String prop = "application/name_" + lang; + if (GlobalConfig::get_singleton()->has(prop)) { + str = GlobalConfig::get_singleton()->get(prop); + } else { + str = get_project_name(package_name); + } + } + } + + string_table.push_back(str); + } + + //write a new string table, but use 16 bits + Vector<uint8_t> ret; + ret.resize(string_table_begins + string_table.size() * 4); + + for (uint32_t i = 0; i < string_table_begins; i++) { + + ret[i] = p_manifest[i]; + } + + int ofs = 0; + for (int i = 0; i < string_table.size(); i++) { + + encode_uint32(ofs, &ret[string_table_begins + i * 4]); + ofs += string_table[i].length() * 2 + 2 + 2; + } + + ret.resize(ret.size() + ofs); + uint8_t *chars = &ret[ret.size() - ofs]; + for (int i = 0; i < string_table.size(); i++) { + + String s = string_table[i]; + encode_uint16(s.length(), chars); + chars += 2; + for (int j = 0; j < s.length(); j++) { + encode_uint16(s[j], chars); + chars += 2; + } + encode_uint16(0, chars); + chars += 2; + } + + //pad + while (ret.size() % 4) + ret.push_back(0); + + //change flags to not use utf8 + encode_uint32(string_flags & ~0x100, &ret[28]); + //change length + encode_uint32(ret.size() - 12, &ret[16]); + //append the rest... + int rest_from = 12 + string_block_len; + int rest_to = ret.size(); + int rest_len = (p_manifest.size() - rest_from); + ret.resize(ret.size() + (p_manifest.size() - rest_from)); + for (int i = 0; i < rest_len; i++) { + ret[rest_to + i] = p_manifest[rest_from + i]; + } + //finally update the size + encode_uint32(ret.size(), &ret[4]); + + p_manifest = ret; + //printf("end\n"); + } + +public: + enum { + MAX_USER_PERMISSIONS = 20 + }; + + typedef Error (*EditorExportSaveFunction)(void *p_userdata, const String &p_path, const Vector<uint8_t> &p_data, int p_file, int p_total); + +public: + virtual void get_preset_features(const Ref<EditorExportPreset> &p_preset, List<String> *r_features) { + + r_features->push_back("etc"); + } + + virtual void get_export_options(List<ExportOption> *r_options) { + + r_options->push_back(ExportOption(PropertyInfo(Variant::BOOL, "one_click_deploy/clear_previous_install"), true)); + r_options->push_back(ExportOption(PropertyInfo(Variant::STRING, "custom_package/debug", PROPERTY_HINT_GLOBAL_FILE, "apk"), "")); + r_options->push_back(ExportOption(PropertyInfo(Variant::STRING, "custom_package/release", PROPERTY_HINT_GLOBAL_FILE, "apk"), "")); + r_options->push_back(ExportOption(PropertyInfo(Variant::STRING, "command_line/extra_args"), "")); + r_options->push_back(ExportOption(PropertyInfo(Variant::INT, "version/code", PROPERTY_HINT_RANGE, "1,65535,1"), 1)); + r_options->push_back(ExportOption(PropertyInfo(Variant::STRING, "version/name"), "1.0")); + r_options->push_back(ExportOption(PropertyInfo(Variant::STRING, "package/unique_name"), "org.godotengine.$genname")); + r_options->push_back(ExportOption(PropertyInfo(Variant::STRING, "package/name"), "")); + r_options->push_back(ExportOption(PropertyInfo(Variant::STRING, "package/icon", PROPERTY_HINT_FILE, "png"), "")); + r_options->push_back(ExportOption(PropertyInfo(Variant::BOOL, "package/signed"), true)); + r_options->push_back(ExportOption(PropertyInfo(Variant::BOOL, "architecture/arm"), true)); + r_options->push_back(ExportOption(PropertyInfo(Variant::BOOL, "architecture/x86"), false)); + r_options->push_back(ExportOption(PropertyInfo(Variant::BOOL, "screen/use_32_bits_view"), true)); + r_options->push_back(ExportOption(PropertyInfo(Variant::BOOL, "screen/immersive_mode"), true)); + r_options->push_back(ExportOption(PropertyInfo(Variant::INT, "screen/orientation", PROPERTY_HINT_ENUM, "Landscape,Portrait"), 0)); + r_options->push_back(ExportOption(PropertyInfo(Variant::BOOL, "screen/support_small"), true)); + r_options->push_back(ExportOption(PropertyInfo(Variant::BOOL, "screen/support_normal"), true)); + r_options->push_back(ExportOption(PropertyInfo(Variant::BOOL, "screen/support_large"), true)); + r_options->push_back(ExportOption(PropertyInfo(Variant::BOOL, "screen/support_xlarge"), true)); + r_options->push_back(ExportOption(PropertyInfo(Variant::STRING, "keystore/release", PROPERTY_HINT_GLOBAL_FILE, "keystore"), "")); + r_options->push_back(ExportOption(PropertyInfo(Variant::STRING, "keystore/release_user"), "")); + r_options->push_back(ExportOption(PropertyInfo(Variant::STRING, "keystore/release_password"), "")); + r_options->push_back(ExportOption(PropertyInfo(Variant::BOOL, "apk_expansion/enable"), false)); + r_options->push_back(ExportOption(PropertyInfo(Variant::STRING, "apk_expansion/SALT"), "")); + r_options->push_back(ExportOption(PropertyInfo(Variant::STRING, "apk_expansion/public_key", PROPERTY_HINT_MULTILINE_TEXT), "")); + + const char **perms = android_perms; + while (*perms) { + + r_options->push_back(ExportOption(PropertyInfo(Variant::BOOL, "permissions/" + String(*perms).to_lower()), false)); + perms++; + } + + for (int i = 0; i < MAX_USER_PERMISSIONS; i++) { + + r_options->push_back(ExportOption(PropertyInfo(Variant::STRING, "user_permissions/" + itos(i)), false)); + } + + //r_options->push_back( PropertyInfo( Variant::INT, "resources/pack_mode", PROPERTY_HINT_ENUM,"Copy,Single Exec.,Pack (.pck),Bundles (Optical)")); + } + + virtual String get_name() const { + return "Android"; + } + virtual Ref<Texture> get_logo() const { + return logo; + } + + virtual bool poll_devices() { + + bool dc = devices_changed; + devices_changed = false; + return dc; + } + + virtual int get_device_count() const { + + device_lock->lock(); + int dc = devices.size(); + device_lock->unlock(); + + return dc; + } + + virtual String get_device_name(int p_device) const { + + ERR_FAIL_INDEX_V(p_device, devices.size(), ""); + device_lock->lock(); + String s = devices[p_device].name; + device_lock->unlock(); + return s; + } + + virtual String get_device_info(int p_device) const { + + ERR_FAIL_INDEX_V(p_device, devices.size(), ""); + device_lock->lock(); + String s = devices[p_device].description; + device_lock->unlock(); + return s; + } + + virtual Error run(const Ref<EditorExportPreset> &p_preset, int p_device, int p_debug_flags) { + + ERR_FAIL_INDEX_V(p_device, devices.size(), ERR_INVALID_PARAMETER); + device_lock->lock(); + + EditorProgress ep("run", "Running on " + devices[p_device].name, 3); + + String adb = EditorSettings::get_singleton()->get("export/android/adb"); + if (adb == "") { + + EditorNode::add_io_error("ADB executable not configured in settings, can't run."); + device_lock->unlock(); + return ERR_UNCONFIGURED; + } + + //export_temp + ep.step("Exporting APK", 0); + + bool use_adb_over_usb = bool(EDITOR_DEF("export/android/use_remote_debug_over_adb", true)); + + if (use_adb_over_usb) { + p_debug_flags |= DEBUG_FLAG_REMOTE_DEBUG_LOCALHOST; + } + + String export_to = EditorSettings::get_singleton()->get_settings_path() + "/tmp/tmpexport.apk"; + Error err = export_project(p_preset, true, export_to, p_debug_flags); + if (err) { + device_lock->unlock(); + return err; + } + + List<String> args; + int rv; + + bool remove_prev = p_preset->get("one_click_deploy/clear_previous_install"); + String version_name = p_preset->get("version/name"); + String package_name = p_preset->get("package/unique_name"); + + if (remove_prev) { + ep.step("Uninstalling..", 1); + + print_line("Uninstalling previous version: " + devices[p_device].name); + + args.push_back("-s"); + args.push_back(devices[p_device].id); + args.push_back("uninstall"); + args.push_back(get_package_name(package_name)); + + err = OS::get_singleton()->execute(adb, args, true, NULL, NULL, &rv); +#if 0 + if (err || rv!=0) { + EditorNode::add_io_error("Could not install to device."); + device_lock->unlock(); + return ERR_CANT_CREATE; + } +#endif + } + + print_line("Installing into device (please wait..): " + devices[p_device].name); + ep.step("Installing to Device (please wait..)..", 2); + + args.clear(); + args.push_back("-s"); + args.push_back(devices[p_device].id); + args.push_back("install"); + args.push_back("-r"); + args.push_back(export_to); + + err = OS::get_singleton()->execute(adb, args, true, NULL, NULL, &rv); + if (err || rv != 0) { + EditorNode::add_io_error("Could not install to device."); + device_lock->unlock(); + return ERR_CANT_CREATE; + } + + if (use_adb_over_usb) { + + args.clear(); + args.push_back("reverse"); + args.push_back("--remove-all"); + err = OS::get_singleton()->execute(adb, args, true, NULL, NULL, &rv); + + int port = GlobalConfig::get_singleton()->get("network/debug/remote_port"); + args.clear(); + args.push_back("reverse"); + args.push_back("tcp:" + itos(port)); + args.push_back("tcp:" + itos(port)); + + err = OS::get_singleton()->execute(adb, args, true, NULL, NULL, &rv); + print_line("Reverse result: " + itos(rv)); + + int fs_port = EditorSettings::get_singleton()->get("filesystem/file_server/port"); + + args.clear(); + args.push_back("reverse"); + args.push_back("tcp:" + itos(fs_port)); + args.push_back("tcp:" + itos(fs_port)); + + err = OS::get_singleton()->execute(adb, args, true, NULL, NULL, &rv); + print_line("Reverse result2: " + itos(rv)); + } + + ep.step("Running on Device..", 3); + args.clear(); + args.push_back("-s"); + args.push_back(devices[p_device].id); + args.push_back("shell"); + args.push_back("am"); + args.push_back("start"); + args.push_back("--user 0"); + args.push_back("-a"); + args.push_back("android.intent.action.MAIN"); + args.push_back("-n"); + args.push_back(get_package_name(package_name) + "/org.godotengine.godot.Godot"); + + err = OS::get_singleton()->execute(adb, args, true, NULL, NULL, &rv); + if (err || rv != 0) { + EditorNode::add_io_error("Could not execute ondevice."); + device_lock->unlock(); + return ERR_CANT_CREATE; + } + device_lock->unlock(); + return OK; + } + + virtual bool can_export(const Ref<EditorExportPreset> &p_preset, String &r_error, bool &r_missing_templates) const { + + r_missing_templates = find_export_template("android_debug.apk") == String() || find_export_template("android_release.apk") == String(); + + bool valid = !r_missing_templates; + + String adb = EditorSettings::get_singleton()->get("export/android/adb"); + String err; + + if (!FileAccess::exists(adb)) { + + valid = false; + err += "ADB executable not configured in editor settings.\n"; + } + + String js = EditorSettings::get_singleton()->get("export/android/jarsigner"); + + if (!FileAccess::exists(js)) { + + valid = false; + err += "OpenJDK 6 jarsigner not configured in editor settings.\n"; + } + + String dk = EditorSettings::get_singleton()->get("export/android/debug_keystore"); + + if (!FileAccess::exists(dk)) { + + valid = false; + err += "Debug Keystore not configured in editor settings.\n"; + } + + bool apk_expansion = p_preset->get("apk_expansion/enable"); + + if (apk_expansion) { + + /* + if (apk_expansion_salt=="") { + valid=false; + err+="Invalid SALT for apk expansion.\n"; + } + */ + + String apk_expansion_pkey = p_preset->get("apk_expansion/public_key"); + + if (apk_expansion_pkey == "") { + valid = false; + + err += "Invalid public key for apk expansion.\n"; + } + } + + r_error = err; + return valid; + } + + virtual String get_binary_extension() const { + return "apk"; + } + + virtual Error export_project(const Ref<EditorExportPreset> &p_preset, bool p_debug, const String &p_path, int p_flags = 0) { + + String src_apk; + + EditorProgress ep("export", "Exporting for Android", 105); + + if (p_debug) + src_apk = p_preset->get("custom_package/debug"); + else + src_apk = p_preset->get("custom_package/release"); + + src_apk = src_apk.strip_edges(); + if (src_apk == "") { + if (p_debug) { + src_apk = find_export_template("android_debug.apk"); + } else { + src_apk = find_export_template("android_release.apk"); + } + if (src_apk == "") { + EditorNode::add_io_error("Package not found: " + src_apk); + return ERR_FILE_NOT_FOUND; + } + } + + FileAccess *src_f = NULL; + zlib_filefunc_def io = zipio_create_io_from_file(&src_f); + + ep.step("Creating APK", 0); + + unzFile pkg = unzOpen2(src_apk.utf8().get_data(), &io); + if (!pkg) { + + EditorNode::add_io_error("Could not find template APK to export:\n" + src_apk); + return ERR_FILE_NOT_FOUND; + } + + ERR_FAIL_COND_V(!pkg, ERR_CANT_OPEN); + int ret = unzGoToFirstFile(pkg); + + zlib_filefunc_def io2 = io; + FileAccess *dst_f = NULL; + io2.opaque = &dst_f; + String unaligned_path = EditorSettings::get_singleton()->get_settings_path() + "/tmp/tmpexport-unaligned.apk"; + zipFile unaligned_apk = zipOpen2(unaligned_path.utf8().get_data(), APPEND_STATUS_CREATE, NULL, &io2); + + bool export_x86 = p_preset->get("architecture/x86"); + bool export_arm = p_preset->get("architecture/arm"); + + bool use_32_fb = p_preset->get("screen/use_32_bits_view"); + bool immersive = p_preset->get("screen/immersive_mode"); + + bool _signed = p_preset->get("package/signed"); + + bool apk_expansion = p_preset->get("apk_expansion/enable"); + + String cmdline = p_preset->get("command_line/extra_args"); + + int version_code = p_preset->get("version/code"); + String version_name = p_preset->get("version/name"); + String package_name = p_preset->get("package/unique_name"); + + String apk_expansion_pkey = p_preset->get("apk_expansion/public_key"); + + String release_keystore = p_preset->get("keystore/release"); + String release_username = p_preset->get("keystore/release_user"); + String release_password = p_preset->get("keystore/release_password"); + + while (ret == UNZ_OK) { + + //get filename + unz_file_info info; + char fname[16384]; + ret = unzGetCurrentFileInfo(pkg, &info, fname, 16384, NULL, 0, NULL, 0); + + bool skip = false; + + String file = fname; + + Vector<uint8_t> data; + data.resize(info.uncompressed_size); + + //read + unzOpenCurrentFile(pkg); + unzReadCurrentFile(pkg, data.ptr(), data.size()); + unzCloseCurrentFile(pkg); + + //write + + if (file == "AndroidManifest.xml") { + + _fix_manifest(p_preset, data, p_flags & (DEBUG_FLAG_DUMB_CLIENT | DEBUG_FLAG_REMOTE_DEBUG)); + } + + if (file == "resources.arsc") { + + _fix_resources(p_preset, data); + } + + if (file == "res/drawable/icon.png") { + + String icon = p_preset->get("package/icon"); + icon = icon.strip_edges(); + bool found = false; + + if (icon != "" && icon.ends_with(".png")) { + + FileAccess *f = FileAccess::open(icon, FileAccess::READ); + if (f) { + + data.resize(f->get_len()); + f->get_buffer(data.ptr(), data.size()); + memdelete(f); + found = true; + } + } + + if (!found) { + + String appicon = GlobalConfig::get_singleton()->get("application/icon"); + if (appicon != "" && appicon.ends_with(".png")) { + FileAccess *f = FileAccess::open(appicon, FileAccess::READ); + if (f) { + data.resize(f->get_len()); + f->get_buffer(data.ptr(), data.size()); + memdelete(f); + } + } + } + } + + if (file == "lib/x86/libgodot_android.so" && !export_x86) { + skip = true; + } + + if (file.match("lib/armeabi*/libgodot_android.so") && !export_arm) { + skip = true; + } + + if (file.begins_with("META-INF") && _signed) { + skip = true; + } + + print_line("ADDING: " + file); + + if (!skip) { + + // Respect decision on compression made by AAPT for the export template + const bool uncompressed = info.compression_method == 0; + + zip_fileinfo zipfi = get_zip_fileinfo(); + + zipOpenNewFileInZip(unaligned_apk, + file.utf8().get_data(), + &zipfi, + NULL, + 0, + NULL, + 0, + NULL, + uncompressed ? 0 : Z_DEFLATED, + Z_DEFAULT_COMPRESSION); + + zipWriteInFileInZip(unaligned_apk, data.ptr(), data.size()); + zipCloseFileInZip(unaligned_apk); + } + + ret = unzGoToNextFile(pkg); + } + + ep.step("Adding Files..", 1); + Error err = OK; + Vector<String> cl = cmdline.strip_edges().split(" "); + for (int i = 0; i < cl.size(); i++) { + if (cl[i].strip_edges().length() == 0) { + cl.remove(i); + i--; + } + } + + gen_export_flags(cl, p_flags); + + if (p_flags & DEBUG_FLAG_DUMB_CLIENT) { + + /*String host = EditorSettings::get_singleton()->get("filesystem/file_server/host"); + int port = EditorSettings::get_singleton()->get("filesystem/file_server/post"); + String passwd = EditorSettings::get_singleton()->get("filesystem/file_server/password"); + cl.push_back("-rfs"); + cl.push_back(host+":"+itos(port)); + if (passwd!="") { + cl.push_back("-rfs_pass"); + cl.push_back(passwd); + }*/ + + } else { + //all files + + if (apk_expansion) { + + String apkfname = "main." + itos(version_code) + "." + get_package_name(package_name) + ".obb"; + String fullpath = p_path.get_base_dir().plus_file(apkfname); + err = save_pack(p_preset, fullpath); + if (err != OK) { + EditorNode::add_io_error("Could not write expansion package file: " + apkfname); + return OK; + } + + cl.push_back("-use_apk_expansion"); + cl.push_back("-apk_expansion_md5"); + cl.push_back(FileAccess::get_md5(fullpath)); + cl.push_back("-apk_expansion_key"); + cl.push_back(apk_expansion_pkey.strip_edges()); + + } else { + + APKExportData ed; + ed.ep = &ep; + ed.apk = unaligned_apk; + + err = export_project_files(p_preset, save_apk_file, &ed); + } + } + + if (use_32_fb) + cl.push_back("-use_depth_32"); + + if (immersive) + cl.push_back("-use_immersive"); + + if (cl.size()) { + //add comandline + Vector<uint8_t> clf; + clf.resize(4); + encode_uint32(cl.size(), &clf[0]); + for (int i = 0; i < cl.size(); i++) { + + CharString txt = cl[i].utf8(); + int base = clf.size(); + clf.resize(base + 4 + txt.length()); + encode_uint32(txt.length(), &clf[base]); + copymem(&clf[base + 4], txt.ptr(), txt.length()); + print_line(itos(i) + " param: " + cl[i]); + } + + zip_fileinfo zipfi = get_zip_fileinfo(); + + zipOpenNewFileInZip(unaligned_apk, + "assets/_cl_", + &zipfi, + NULL, + 0, + NULL, + 0, + NULL, + 0, // No compress (little size gain and potentially slower startup) + Z_DEFAULT_COMPRESSION); + + zipWriteInFileInZip(unaligned_apk, clf.ptr(), clf.size()); + zipCloseFileInZip(unaligned_apk); + } + + zipClose(unaligned_apk, NULL); + unzClose(pkg); + + if (err) { + return err; + } + + if (_signed) { + + String jarsigner = EditorSettings::get_singleton()->get("export/android/jarsigner"); + if (!FileAccess::exists(jarsigner)) { + EditorNode::add_io_error("'jarsigner' could not be found.\nPlease supply a path in the editor settings.\nResulting apk is unsigned."); + return OK; + } + + String keystore; + String password; + String user; + if (p_debug) { + keystore = EditorSettings::get_singleton()->get("export/android/debug_keystore"); + password = EditorSettings::get_singleton()->get("export/android/debug_keystore_pass"); + user = EditorSettings::get_singleton()->get("export/android/debug_keystore_user"); + + ep.step("Signing Debug APK..", 103); + + } else { + keystore = release_keystore; + password = release_password; + user = release_username; + + ep.step("Signing Release APK..", 103); + } + + if (!FileAccess::exists(keystore)) { + EditorNode::add_io_error("Could not find keystore, unable to export."); + return ERR_FILE_CANT_OPEN; + } + + List<String> args; + args.push_back("-digestalg"); + args.push_back("SHA1"); + args.push_back("-sigalg"); + args.push_back("MD5withRSA"); + String tsa_url = EditorSettings::get_singleton()->get("export/android/timestamping_authority_url"); + if (tsa_url != "") { + args.push_back("-tsa"); + args.push_back(tsa_url); + } + args.push_back("-verbose"); + args.push_back("-keystore"); + args.push_back(keystore); + args.push_back("-storepass"); + args.push_back(password); + args.push_back(unaligned_path); + args.push_back(user); + int retval; + OS::get_singleton()->execute(jarsigner, args, true, NULL, NULL, &retval); + if (retval) { + EditorNode::add_io_error("'jarsigner' returned with error #" + itos(retval)); + return ERR_CANT_CREATE; + } + + ep.step("Verifying APK..", 104); + + args.clear(); + args.push_back("-verify"); + args.push_back("-keystore"); + args.push_back(keystore); + args.push_back(unaligned_path); + args.push_back("-verbose"); + + OS::get_singleton()->execute(jarsigner, args, true, NULL, NULL, &retval); + if (retval) { + EditorNode::add_io_error("'jarsigner' verification of APK failed. Make sure to use jarsigner from Java 6."); + return ERR_CANT_CREATE; + } + } + + // Let's zip-align (must be done after signing) + + static const int ZIP_ALIGNMENT = 4; + + ep.step("Aligning APK..", 105); + + unzFile tmp_unaligned = unzOpen2(unaligned_path.utf8().get_data(), &io); + if (!tmp_unaligned) { + + EditorNode::add_io_error("Could not find temp unaligned APK."); + return ERR_FILE_NOT_FOUND; + } + + ERR_FAIL_COND_V(!tmp_unaligned, ERR_CANT_OPEN); + ret = unzGoToFirstFile(tmp_unaligned); + + io2 = io; + dst_f = NULL; + io2.opaque = &dst_f; + zipFile final_apk = zipOpen2(p_path.utf8().get_data(), APPEND_STATUS_CREATE, NULL, &io2); + + // Take files from the unaligned APK and write them out to the aligned one + // in raw mode, i.e. not uncompressing and recompressing, aligning them as needed, + // following what is done in https://github.com/android/platform_build/blob/master/tools/zipalign/ZipAlign.cpp + int bias = 0; + while (ret == UNZ_OK) { + + unz_file_info info; + memset(&info, 0, sizeof(info)); + + char fname[16384]; + char extra[16384]; + ret = unzGetCurrentFileInfo(tmp_unaligned, &info, fname, 16384, extra, 16384 - ZIP_ALIGNMENT, NULL, 0); + + String file = fname; + + Vector<uint8_t> data; + data.resize(info.compressed_size); + + // read + int method, level; + unzOpenCurrentFile2(tmp_unaligned, &method, &level, 1); // raw read + long file_offset = unzGetCurrentFileZStreamPos64(tmp_unaligned); + unzReadCurrentFile(tmp_unaligned, data.ptr(), data.size()); + unzCloseCurrentFile(tmp_unaligned); + + // align + int padding = 0; + if (!info.compression_method) { + // Uncompressed file => Align + long new_offset = file_offset + bias; + padding = (ZIP_ALIGNMENT - (new_offset % ZIP_ALIGNMENT)) % ZIP_ALIGNMENT; + } + + memset(extra + info.size_file_extra, 0, padding); + + // write + zip_fileinfo zipfi = get_zip_fileinfo(); + + zipOpenNewFileInZip2(final_apk, + file.utf8().get_data(), + &zipfi, + extra, + info.size_file_extra + padding, + NULL, + 0, + NULL, + method, + level, + 1); // raw write + zipWriteInFileInZip(final_apk, data.ptr(), data.size()); + zipCloseFileInZipRaw(final_apk, info.uncompressed_size, info.crc); + + bias += padding; + + ret = unzGoToNextFile(tmp_unaligned); + } + + zipClose(final_apk, NULL); + unzClose(tmp_unaligned); + + if (err) { + return err; + } + + return OK; + } + + EditorExportAndroid() { + + Image img(_android_logo); + logo = Ref<ImageTexture>(memnew(ImageTexture)); + logo->create_from_image(img); + + device_lock = Mutex::create(); + device_thread = Thread::create(_device_poll_thread, this); + devices_changed = true; + quit_request = false; + } +}; + +void register_android_exporter() { + + String exe_ext; + if (OS::get_singleton()->get_name() == "Windows") { + exe_ext = "*.exe"; + } + + EDITOR_DEF("export/android/adb", ""); + EditorSettings::get_singleton()->add_property_hint(PropertyInfo(Variant::STRING, "export/android/adb", PROPERTY_HINT_GLOBAL_FILE, exe_ext)); + EDITOR_DEF("export/android/jarsigner", ""); + EditorSettings::get_singleton()->add_property_hint(PropertyInfo(Variant::STRING, "export/android/jarsigner", PROPERTY_HINT_GLOBAL_FILE, exe_ext)); + EDITOR_DEF("export/android/debug_keystore", ""); + EditorSettings::get_singleton()->add_property_hint(PropertyInfo(Variant::STRING, "export/android/debug_keystore", PROPERTY_HINT_GLOBAL_FILE, "keystore")); + EDITOR_DEF("export/android/debug_keystore_user", "androiddebugkey"); + EDITOR_DEF("export/android/debug_keystore_pass", "android"); + + EDITOR_DEF("export/android/timestamping_authority_url", ""); + EDITOR_DEF("export/android/use_remote_debug_over_adb", false); + EDITOR_DEF("export/android/shutdown_adb_on_exit", true); + + Ref<EditorExportAndroid> exporter = Ref<EditorExportAndroid>(memnew(EditorExportAndroid)); + EditorExport::get_singleton()->add_export_platform(exporter); } diff --git a/platform/android/java/src/com/android/vending/licensing/Obfuscator.java b/platform/android/java/src/com/android/vending/licensing/Obfuscator.java index b5d510d72d..88891728e6 100644 --- a/platform/android/java/src/com/android/vending/licensing/Obfuscator.java +++ b/platform/android/java/src/com/android/vending/licensing/Obfuscator.java @@ -20,7 +20,7 @@ package com.google.android.vending.licensing; * Interface used as part of a {@link Policy} to allow application authors to obfuscate * licensing data that will be stored into a SharedPreferences file. * <p> - * Any transformation scheme must be reversable. Implementing classes may optionally implement an + * Any transformation scheme must be reversible. Implementing classes may optionally implement an * integrity check to further prevent modification to preference data. Implementing classes * should use device-specific information as a key in the obfuscation algorithm to prevent * obfuscated preferences from being shared among devices. diff --git a/platform/android/java/src/org/godotengine/godot/Godot.java b/platform/android/java/src/org/godotengine/godot/Godot.java index 610f707b47..0cec0c5773 100644 --- a/platform/android/java/src/org/godotengine/godot/Godot.java +++ b/platform/android/java/src/org/godotengine/godot/Godot.java @@ -340,7 +340,7 @@ public class Godot extends Activity implements SensorEventListener, IDownloaderC r = is.read(len); if (r<4) { - Log.d("GODOT", "**ERROR** Wrong cmdline param lenght.\n"); + Log.d("GODOT", "**ERROR** Wrong cmdline param length.\n"); return new String[0]; } int strlen=((int)(len[3]&0xFF)<<24) | ((int)(len[2]&0xFF)<<16) | ((int)(len[1]&0xFF)<<8) | ((int)(len[0]&0xFF)); @@ -721,7 +721,7 @@ public class Godot extends Activity implements SensorEventListener, IDownloaderC @Override public void onBackPressed() { System.out.printf("** BACK REQUEST!\n"); - GodotLib.back(); + //GodotLib.back(); } public void forceQuit() { diff --git a/platform/android/java/src/org/godotengine/godot/GodotIO.java b/platform/android/java/src/org/godotengine/godot/GodotIO.java index 33c1c03ace..d6ceef8768 100644 --- a/platform/android/java/src/org/godotengine/godot/GodotIO.java +++ b/platform/android/java/src/org/godotengine/godot/GodotIO.java @@ -469,7 +469,7 @@ public class GodotIO { } ///////////////////////// - // MISCELANEOUS OS IO + // MISCELLANEOUS OS IO ///////////////////////// diff --git a/platform/android/java/src/org/godotengine/godot/GodotView.java b/platform/android/java/src/org/godotengine/godot/GodotView.java index 4cfe295835..a209bc7f5b 100644 --- a/platform/android/java/src/org/godotengine/godot/GodotView.java +++ b/platform/android/java/src/org/godotengine/godot/GodotView.java @@ -77,18 +77,18 @@ public class GodotView extends GLSurfaceView implements InputDeviceListener { private static GodotIO io; private static boolean firsttime=true; - private static boolean use_gl2=false; + private static boolean use_gl3=false; private static boolean use_32=false; private Godot activity; private InputManagerCompat mInputManager; - public GodotView(Context context,GodotIO p_io,boolean p_use_gl2, boolean p_use_32_bits, Godot p_activity) { + public GodotView(Context context,GodotIO p_io,boolean p_use_gl3, boolean p_use_32_bits, Godot p_activity) { super(context); ctx=context; io=p_io; - use_gl2=p_use_gl2; + use_gl3=p_use_gl3; use_32=p_use_32_bits; activity = p_activity; @@ -362,14 +362,15 @@ public class GodotView extends GLSurfaceView implements InputDeviceListener { private static class ContextFactory implements GLSurfaceView.EGLContextFactory { private static int EGL_CONTEXT_CLIENT_VERSION = 0x3098; public EGLContext createContext(EGL10 egl, EGLDisplay display, EGLConfig eglConfig) { - if (use_gl2) - Log.w(TAG, "creating OpenGL ES 2.0 context :"); + if (use_gl3) + Log.w(TAG, "creating OpenGL ES 3.0 context :"); else - Log.w(TAG, "creating OpenGL ES 1.1 context :"); + Log.w(TAG, "creating OpenGL ES 2.0 context :"); checkEglError("Before eglCreateContext", egl); int[] attrib_list2 = {EGL_CONTEXT_CLIENT_VERSION, 2, EGL10.EGL_NONE }; - EGLContext context = egl.eglCreateContext(display, eglConfig, EGL10.EGL_NO_CONTEXT, use_gl2?attrib_list2:null); + int[] attrib_list3 = {EGL_CONTEXT_CLIENT_VERSION, 3, EGL10.EGL_NONE }; + EGLContext context = egl.eglCreateContext(display, eglConfig, EGL10.EGL_NO_CONTEXT, use_gl3?attrib_list3:attrib_list2); checkEglError("After eglCreateContext", egl); return context; } @@ -432,13 +433,14 @@ public class GodotView extends GLSurfaceView implements InputDeviceListener { EGL10.EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT, EGL10.EGL_NONE }; - private static int[] s_configAttribs = + private static int[] s_configAttribs3 = { EGL10.EGL_RED_SIZE, 4, EGL10.EGL_GREEN_SIZE, 4, EGL10.EGL_BLUE_SIZE, 4, // EGL10.EGL_DEPTH_SIZE, 16, // EGL10.EGL_STENCIL_SIZE, EGL10.EGL_DONT_CARE, + EGL10.EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT, //apparently there is no EGL_OPENGL_ES3_BIT EGL10.EGL_NONE }; @@ -447,7 +449,7 @@ public class GodotView extends GLSurfaceView implements InputDeviceListener { /* Get the number of minimally matching EGL configurations */ int[] num_config = new int[1]; - egl.eglChooseConfig(display, use_gl2?s_configAttribs2:s_configAttribs, null, 0, num_config); + egl.eglChooseConfig(display, use_gl3?s_configAttribs3:s_configAttribs2, null, 0, num_config); int numConfigs = num_config[0]; @@ -458,7 +460,7 @@ public class GodotView extends GLSurfaceView implements InputDeviceListener { /* Allocate then read the array of minimally matching EGL configs */ EGLConfig[] configs = new EGLConfig[numConfigs]; - egl.eglChooseConfig(display, use_gl2?s_configAttribs2:s_configAttribs, configs, numConfigs, num_config); + egl.eglChooseConfig(display, use_gl3?s_configAttribs3:s_configAttribs2, configs, numConfigs, num_config); if (DEBUG) { printConfigs(egl, display, configs); diff --git a/platform/android/java_class_wrapper.h b/platform/android/java_class_wrapper.h index dcc9973446..12ef92c45b 100644 --- a/platform/android/java_class_wrapper.h +++ b/platform/android/java_class_wrapper.h @@ -68,9 +68,9 @@ class JavaClass : public Reference { jmethodID method; }; - _FORCE_INLINE_ static void _convert_to_variant_type(int p_sig, Variant::Type &r_type, float &likelyhood) { + _FORCE_INLINE_ static void _convert_to_variant_type(int p_sig, Variant::Type &r_type, float &likelihood) { - likelyhood = 1.0; + likelihood = 1.0; r_type = Variant::NIL; switch (p_sig) { @@ -81,37 +81,37 @@ class JavaClass : public Reference { case ARG_TYPE_BYTE | ARG_NUMBER_CLASS_BIT: case ARG_TYPE_BYTE: r_type = Variant::INT; - likelyhood = 0.1; + likelihood = 0.1; break; case ARG_TYPE_CHAR | ARG_NUMBER_CLASS_BIT: case ARG_TYPE_CHAR: r_type = Variant::INT; - likelyhood = 0.2; + likelihood = 0.2; break; case ARG_TYPE_SHORT | ARG_NUMBER_CLASS_BIT: case ARG_TYPE_SHORT: r_type = Variant::INT; - likelyhood = 0.3; + likelihood = 0.3; break; case ARG_TYPE_INT | ARG_NUMBER_CLASS_BIT: case ARG_TYPE_INT: r_type = Variant::INT; - likelyhood = 1.0; + likelihood = 1.0; break; case ARG_TYPE_LONG | ARG_NUMBER_CLASS_BIT: case ARG_TYPE_LONG: r_type = Variant::INT; - likelyhood = 0.5; + likelihood = 0.5; break; case ARG_TYPE_FLOAT | ARG_NUMBER_CLASS_BIT: case ARG_TYPE_FLOAT: r_type = Variant::REAL; - likelyhood = 1.0; + likelihood = 1.0; break; case ARG_TYPE_DOUBLE | ARG_NUMBER_CLASS_BIT: case ARG_TYPE_DOUBLE: r_type = Variant::REAL; - likelyhood = 0.5; + likelihood = 0.5; break; case ARG_TYPE_STRING: r_type = Variant::STRING; break; case ARG_TYPE_CLASS: r_type = Variant::OBJECT; break; @@ -119,31 +119,31 @@ class JavaClass : public Reference { case ARG_ARRAY_BIT | ARG_TYPE_BOOLEAN: r_type = Variant::ARRAY; break; case ARG_ARRAY_BIT | ARG_TYPE_BYTE: r_type = Variant::POOL_BYTE_ARRAY; - likelyhood = 1.0; + likelihood = 1.0; break; case ARG_ARRAY_BIT | ARG_TYPE_CHAR: r_type = Variant::POOL_BYTE_ARRAY; - likelyhood = 0.5; + likelihood = 0.5; break; case ARG_ARRAY_BIT | ARG_TYPE_SHORT: r_type = Variant::POOL_INT_ARRAY; - likelyhood = 0.3; + likelihood = 0.3; break; case ARG_ARRAY_BIT | ARG_TYPE_INT: r_type = Variant::POOL_INT_ARRAY; - likelyhood = 1.0; + likelihood = 1.0; break; case ARG_ARRAY_BIT | ARG_TYPE_LONG: r_type = Variant::POOL_INT_ARRAY; - likelyhood = 0.5; + likelihood = 0.5; break; case ARG_ARRAY_BIT | ARG_TYPE_FLOAT: r_type = Variant::POOL_REAL_ARRAY; - likelyhood = 1.0; + likelihood = 1.0; break; case ARG_ARRAY_BIT | ARG_TYPE_DOUBLE: r_type = Variant::POOL_REAL_ARRAY; - likelyhood = 0.5; + likelihood = 0.5; break; case ARG_ARRAY_BIT | ARG_TYPE_STRING: r_type = Variant::POOL_STRING_ARRAY; break; case ARG_ARRAY_BIT | ARG_TYPE_CLASS: r_type = Variant::ARRAY; break; diff --git a/platform/android/java_glue.cpp b/platform/android/java_glue.cpp index 3229c4c993..06ef581813 100644 --- a/platform/android/java_glue.cpp +++ b/platform/android/java_glue.cpp @@ -881,7 +881,7 @@ JNIEXPORT void JNICALL Java_org_godotengine_godot_GodotLib_initialize(JNIEnv *en __android_log_print(ANDROID_LOG_INFO, "godot", "*****SETUP OK"); - //video driver is determined here, because once initialized, it cant be changed + //video driver is determined here, because once initialized, it can't be changed String vd = GlobalConfig::get_singleton()->get("display/driver"); env->CallVoidMethod(_godot_instance, _on_video_init, (jboolean) true); @@ -929,7 +929,16 @@ JNIEXPORT void JNICALL Java_org_godotengine_godot_GodotLib_back(JNIEnv *env, job static void _initialize_java_modules() { + if (!GlobalConfig::get_singleton()->has("android/modules")) { + print_line("ANDROID MODULES: Nothing to load, aborting"); + return; + } + String modules = GlobalConfig::get_singleton()->get("android/modules"); + modules = modules.strip_edges(); + if (modules == String()) { + return; + } Vector<String> mods = modules.split(",", false); print_line("ANDROID MODULES : " + modules); __android_log_print(ANDROID_LOG_INFO, "godot", "mod count: %i", mods.size()); diff --git a/platform/android/os_android.cpp b/platform/android/os_android.cpp index 1484ccfb8c..77536448e4 100644 --- a/platform/android/os_android.cpp +++ b/platform/android/os_android.cpp @@ -129,7 +129,7 @@ void OS_Android::initialize(const VideoMode &p_desired, int p_video_driver, int RasterizerGLES3::make_current(); visual_server = memnew(VisualServerRaster); -/* if (get_render_thread_mode() != RENDER_THREAD_UNSAFE) { + /* if (get_render_thread_mode() != RENDER_THREAD_UNSAFE) { visual_server = memnew(VisualServerWrapMT(visual_server, false)); };*/ @@ -343,16 +343,16 @@ void OS_Android::process_joy_event(OS_Android::JoypadEvent p_event) { switch (p_event.type) { case JOY_EVENT_BUTTON: - last_id = input->joy_button(last_id, p_event.device, p_event.index, p_event.pressed); + 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; - last_id = input->joy_axis(last_id, p_event.device, p_event.index, value); + input->joy_axis(p_event.device, p_event.index, value); break; case JOY_EVENT_HAT: - last_id = input->joy_hat(last_id, p_event.device, p_event.hat); + input->joy_hat(p_event.device, p_event.hat); break; default: return; @@ -361,7 +361,6 @@ void OS_Android::process_joy_event(OS_Android::JoypadEvent p_event) { void OS_Android::process_event(InputEvent p_event) { - p_event.ID = last_id++; input->parse_input_event(p_event); } @@ -376,7 +375,6 @@ void OS_Android::process_touch(int p_what, int p_pointer, const Vector<TouchPos> //end all if exist InputEvent ev; ev.type = InputEvent::MOUSE_BUTTON; - ev.ID = last_id++; ev.mouse_button.button_index = BUTTON_LEFT; ev.mouse_button.button_mask = BUTTON_MASK_LEFT; ev.mouse_button.pressed = false; @@ -390,7 +388,6 @@ void OS_Android::process_touch(int p_what, int p_pointer, const Vector<TouchPos> InputEvent ev; ev.type = InputEvent::SCREEN_TOUCH; - ev.ID = last_id++; ev.screen_touch.index = touch[i].id; ev.screen_touch.pressed = false; ev.screen_touch.x = touch[i].pos.x; @@ -409,7 +406,6 @@ void OS_Android::process_touch(int p_what, int p_pointer, const Vector<TouchPos> //send mouse InputEvent ev; ev.type = InputEvent::MOUSE_BUTTON; - ev.ID = last_id++; ev.mouse_button.button_index = BUTTON_LEFT; ev.mouse_button.button_mask = BUTTON_MASK_LEFT; ev.mouse_button.pressed = true; @@ -417,7 +413,7 @@ void OS_Android::process_touch(int p_what, int p_pointer, const Vector<TouchPos> ev.mouse_button.y = touch[0].pos.y; ev.mouse_button.global_x = touch[0].pos.x; ev.mouse_button.global_y = touch[0].pos.y; - input->set_mouse_pos(Point2(touch[0].pos.x,touch[0].pos.y)); + input->set_mouse_pos(Point2(touch[0].pos.x, touch[0].pos.y)); last_mouse = touch[0].pos; input->parse_input_event(ev); } @@ -427,7 +423,6 @@ void OS_Android::process_touch(int p_what, int p_pointer, const Vector<TouchPos> InputEvent ev; ev.type = InputEvent::SCREEN_TOUCH; - ev.ID = last_id++; ev.screen_touch.index = touch[i].id; ev.screen_touch.pressed = true; ev.screen_touch.x = touch[i].pos.x; @@ -442,7 +437,6 @@ void OS_Android::process_touch(int p_what, int p_pointer, const Vector<TouchPos> //send mouse, should look for point 0? InputEvent ev; ev.type = InputEvent::MOUSE_MOTION; - ev.ID = last_id++; ev.mouse_motion.button_mask = BUTTON_MASK_LEFT; ev.mouse_motion.x = p_points[0].pos.x; ev.mouse_motion.y = p_points[0].pos.y; @@ -475,7 +469,6 @@ void OS_Android::process_touch(int p_what, int p_pointer, const Vector<TouchPos> InputEvent ev; ev.type = InputEvent::SCREEN_DRAG; - ev.ID = last_id++; ev.screen_drag.index = touch[i].id; ev.screen_drag.x = p_points[idx].pos.x; ev.screen_drag.y = p_points[idx].pos.y; @@ -492,7 +485,6 @@ void OS_Android::process_touch(int p_what, int p_pointer, const Vector<TouchPos> //end all if exist InputEvent ev; ev.type = InputEvent::MOUSE_BUTTON; - ev.ID = last_id++; ev.mouse_button.button_index = BUTTON_LEFT; ev.mouse_button.button_mask = BUTTON_MASK_LEFT; ev.mouse_button.pressed = false; @@ -500,14 +492,13 @@ void OS_Android::process_touch(int p_what, int p_pointer, const Vector<TouchPos> ev.mouse_button.y = touch[0].pos.y; ev.mouse_button.global_x = touch[0].pos.x; ev.mouse_button.global_y = touch[0].pos.y; - input->set_mouse_pos(Point2(touch[0].pos.x,touch[0].pos.y)); + input->set_mouse_pos(Point2(touch[0].pos.x, touch[0].pos.y)); input->parse_input_event(ev); for (int i = 0; i < touch.size(); i++) { InputEvent ev; ev.type = InputEvent::SCREEN_TOUCH; - ev.ID = last_id++; ev.screen_touch.index = touch[i].id; ev.screen_touch.pressed = false; ev.screen_touch.x = touch[i].pos.x; @@ -527,7 +518,6 @@ void OS_Android::process_touch(int p_what, int p_pointer, const Vector<TouchPos> InputEvent ev; ev.type = InputEvent::SCREEN_TOUCH; - ev.ID = last_id++; ev.screen_touch.index = tp.id; ev.screen_touch.pressed = true; ev.screen_touch.x = tp.pos.x; @@ -542,7 +532,6 @@ void OS_Android::process_touch(int p_what, int p_pointer, const Vector<TouchPos> InputEvent ev; ev.type = InputEvent::SCREEN_TOUCH; - ev.ID = last_id++; ev.screen_touch.index = touch[i].id; ev.screen_touch.pressed = false; ev.screen_touch.x = touch[i].pos.x; @@ -627,8 +616,8 @@ void OS_Android::reload_gfx() { if (gfx_init_func) gfx_init_func(gfx_init_ud, use_gl2); -// if (rasterizer) -// rasterizer->reload_vram(); + //if (rasterizer) + // rasterizer->reload_vram(); } Error OS_Android::shell_open(String p_uri) { @@ -746,9 +735,9 @@ void OS_Android::native_video_stop() { void OS_Android::set_context_is_16_bits(bool p_is_16) { -// use_16bits_fbo = p_is_16; -// if (rasterizer) -// rasterizer->set_force_16_bits_fbo(p_is_16); + //use_16bits_fbo = p_is_16; + //if (rasterizer) + // rasterizer->set_force_16_bits_fbo(p_is_16); } void OS_Android::joy_connection_changed(int p_device, bool p_connected, String p_name) { @@ -774,9 +763,8 @@ OS_Android::OS_Android(GFXInitFunc p_gfx_init_func, void *p_gfx_init_ud, OpenURI gfx_init_func = p_gfx_init_func; gfx_init_ud = p_gfx_init_ud; main_loop = NULL; - last_id = 1; gl_extensions = NULL; -// rasterizer = NULL; + //rasterizer = NULL; use_gl2 = false; open_uri_func = p_open_uri_func; diff --git a/platform/android/os_android.h b/platform/android/os_android.h index ad438d8626..28abbf934d 100644 --- a/platform/android/os_android.h +++ b/platform/android/os_android.h @@ -94,7 +94,6 @@ private: Vector<TouchPos> touch; Point2 last_mouse; - unsigned int last_id; GFXInitFunc gfx_init_func; void *gfx_init_ud; diff --git a/platform/bb10/os_bb10.cpp b/platform/bb10/os_bb10.cpp index 80e846d3cd..c8d5b82a98 100644 --- a/platform/bb10/os_bb10.cpp +++ b/platform/bb10/os_bb10.cpp @@ -282,7 +282,6 @@ void OSBB10::handle_screen_event(bps_event_t *event) { InputEvent ievent; ievent.type = InputEvent::SCREEN_TOUCH; - ievent.ID = ++last_id; ievent.device = 0; ievent.screen_touch.pressed = (screen_val == SCREEN_EVENT_MTOUCH_TOUCH); ievent.screen_touch.x = pos[0]; @@ -301,7 +300,6 @@ void OSBB10::handle_screen_event(bps_event_t *event) { InputEvent ievent; ievent.type = InputEvent::MOUSE_BUTTON; - ievent.ID = ++last_id; ievent.device = 0; ievent.mouse_button.pressed = (screen_val == SCREEN_EVENT_MTOUCH_TOUCH); ievent.mouse_button.button_index = BUTTON_LEFT; @@ -318,7 +316,6 @@ void OSBB10::handle_screen_event(bps_event_t *event) { InputEvent ievent; ievent.type = InputEvent::SCREEN_DRAG; - ievent.ID = ++last_id; ievent.device = 0; ievent.screen_drag.x = pos[0]; ievent.screen_drag.y = pos[1]; @@ -347,7 +344,6 @@ void OSBB10::handle_screen_event(bps_event_t *event) { InputEvent ievent; ievent.type = InputEvent::MOUSE_MOTION; - ievent.ID = ++last_id; ievent.device = 0; ievent.mouse_motion.x = ievent.mouse_motion.global_x = mpos.x; ievent.mouse_motion.y = ievent.mouse_motion.global_y = mpos.y; @@ -366,7 +362,6 @@ void OSBB10::handle_screen_event(bps_event_t *event) { InputEvent ievent; ievent.type = InputEvent::KEY; - ievent.ID = ++last_id; ievent.device = 0; int val = 0; screen_get_event_property_iv(screen_event, SCREEN_PROPERTY_KEY_SCAN, &val); @@ -595,7 +590,6 @@ int OSBB10::get_power_percent_left() { OSBB10::OSBB10() { main_loop = NULL; - last_id = 1; minimized = false; fullscreen = true; flip_accelerometer = true; diff --git a/platform/bb10/os_bb10.h b/platform/bb10/os_bb10.h index 313f9c9e6b..30978d2f60 100644 --- a/platform/bb10/os_bb10.h +++ b/platform/bb10/os_bb10.h @@ -48,8 +48,6 @@ class OSBB10 : public OS_Unix { - unsigned int last_id; - screen_context_t screen_cxt; float fullscreen_mixer_volume; float fullscreen_stream_volume; diff --git a/platform/haiku/detect.py b/platform/haiku/detect.py index 71202a9a49..54e227cd19 100644 --- a/platform/haiku/detect.py +++ b/platform/haiku/detect.py @@ -53,7 +53,7 @@ def configure(env): elif (env["target"] == "release_debug"): env.Append(CCFLAGS=['-O2', '-ffast-math', '-DDEBUG_ENABLED']) elif (env["target"] == "debug"): - env.Append(CCFLAGS=['-g2', '-Wall', '-DDEBUG_ENABLED', '-DDEBUG_MEMORY_ENABLED']) + env.Append(CCFLAGS=['-g2', '-DDEBUG_ENABLED', '-DDEBUG_MEMORY_ENABLED']) # env.Append(CCFLAGS=['-DFREETYPE_ENABLED']) env.Append(CPPFLAGS=['-DPTHREAD_NO_RENAME']) # TODO: enable when we have pthread_setname_np diff --git a/platform/haiku/haiku_direct_window.cpp b/platform/haiku/haiku_direct_window.cpp index bc2dbb9b8f..f64fb706c1 100644 --- a/platform/haiku/haiku_direct_window.cpp +++ b/platform/haiku/haiku_direct_window.cpp @@ -151,7 +151,6 @@ void HaikuDirectWindow::HandleMouseButton(BMessage *message) { */ InputEvent mouse_event; - mouse_event.ID = ++event_id; mouse_event.type = InputEvent::MOUSE_BUTTON; mouse_event.device = 0; @@ -208,7 +207,6 @@ void HaikuDirectWindow::HandleMouseMoved(BMessage *message) { Point2i rel = pos - last_mouse_position; InputEvent motion_event; - motion_event.ID = ++event_id; motion_event.type = InputEvent::MOUSE_MOTION; motion_event.device = 0; @@ -237,7 +235,6 @@ void HaikuDirectWindow::HandleMouseWheelChanged(BMessage *message) { } InputEvent mouse_event; - mouse_event.ID = ++event_id; mouse_event.type = InputEvent::MOUSE_BUTTON; mouse_event.device = 0; @@ -252,7 +249,6 @@ void HaikuDirectWindow::HandleMouseWheelChanged(BMessage *message) { mouse_event.mouse_button.pressed = true; input->parse_input_event(mouse_event); - mouse_event.ID = ++event_id; mouse_event.mouse_button.pressed = false; input->parse_input_event(mouse_event); } @@ -275,7 +271,6 @@ void HaikuDirectWindow::HandleKeyboardEvent(BMessage *message) { } InputEvent event; - event.ID = ++event_id; event.type = InputEvent::KEY; event.device = 0; event.key.mod = GetKeyModifierState(modifiers); @@ -289,7 +284,7 @@ void HaikuDirectWindow::HandleKeyboardEvent(BMessage *message) { event.key.unicode = BUnicodeChar::FromUTF8(&bytes); } - //make it consistent accross platforms. + //make it consistent across platforms. if (event.key.scancode == KEY_BACKTAB) { event.key.scancode = KEY_TAB; event.key.mod.shift = true; @@ -313,7 +308,6 @@ void HaikuDirectWindow::HandleKeyboardModifierEvent(BMessage *message) { int32 key = old_modifiers ^ modifiers; InputEvent event; - event.ID = ++event_id; event.type = InputEvent::KEY; event.device = 0; event.key.mod = GetKeyModifierState(modifiers); diff --git a/platform/haiku/haiku_direct_window.h b/platform/haiku/haiku_direct_window.h index 7fcea7a6f6..d4fd05e45f 100644 --- a/platform/haiku/haiku_direct_window.h +++ b/platform/haiku/haiku_direct_window.h @@ -43,7 +43,6 @@ class HaikuDirectWindow : public BDirectWindow { private: - unsigned int event_id; Point2i last_mouse_position; bool last_mouse_pos_valid; uint32 last_buttons_state; diff --git a/platform/iphone/app_delegate.mm b/platform/iphone/app_delegate.mm index 00bb4b9fad..e82649692c 100644 --- a/platform/iphone/app_delegate.mm +++ b/platform/iphone/app_delegate.mm @@ -299,8 +299,8 @@ static int frame_count = 0; if (!motionInitialised) { motionManager = [[CMMotionManager alloc] init]; if (motionManager.deviceMotionAvailable) { - motionManager.deviceMotionUpdateInterval = 1.0/70.0; - [motionManager startDeviceMotionUpdates]; + motionManager.deviceMotionUpdateInterval = 1.0/70.0; + [motionManager startDeviceMotionUpdatesUsingReferenceFrame:CMAttitudeReferenceFrameXMagneticNorthZVertical]; motionInitialised = YES; }; }; diff --git a/platform/iphone/detect.py b/platform/iphone/detect.py index fa6082a5a7..248c73982b 100644 --- a/platform/iphone/detect.py +++ b/platform/iphone/detect.py @@ -58,16 +58,16 @@ def configure(env): if (env["ios_sim"] == "yes" or env["arch"] == "x86"): # i386, simulator env["arch"] = "x86" env["bits"] = "32" - env['CCFLAGS'] = string.split('-arch i386 -fobjc-abi-version=2 -fobjc-legacy-dispatch -fmessage-length=0 -fpascal-strings -fasm-blocks -Wall -D__IPHONE_OS_VERSION_MIN_REQUIRED=40100 -isysroot $IPHONESDK -mios-simulator-version-min=4.3 -DCUSTOM_MATRIX_TRANSFORM_H=\\\"build/iphone/matrix4_iphone.h\\\" -DCUSTOM_VECTOR3_TRANSFORM_H=\\\"build/iphone/vector3_iphone.h\\\"') + env['CCFLAGS'] = string.split('-arch i386 -fobjc-abi-version=2 -fobjc-legacy-dispatch -fmessage-length=0 -fpascal-strings -fasm-blocks -D__IPHONE_OS_VERSION_MIN_REQUIRED=40100 -isysroot $IPHONESDK -mios-simulator-version-min=4.3 -DCUSTOM_MATRIX_TRANSFORM_H=\\\"build/iphone/matrix4_iphone.h\\\" -DCUSTOM_VECTOR3_TRANSFORM_H=\\\"build/iphone/vector3_iphone.h\\\"') elif (env["arch"] == "arm64"): # arm64 env["bits"] = "64" - env['CCFLAGS'] = string.split('-fno-objc-arc -arch arm64 -fmessage-length=0 -fno-strict-aliasing -fdiagnostics-print-source-range-info -fdiagnostics-show-category=id -fdiagnostics-parseable-fixits -Wno-trigraphs -fpascal-strings -Wmissing-prototypes -Wreturn-type -Wparentheses -Wswitch -Wno-unused-parameter -Wunused-variable -Wunused-value -Wno-shorten-64-to-32 -fvisibility=hidden -Wno-sign-conversion -MMD -MT dependencies -miphoneos-version-min=7.0 -isysroot $IPHONESDK') + env['CCFLAGS'] = string.split('-fno-objc-arc -arch arm64 -fmessage-length=0 -fno-strict-aliasing -fdiagnostics-print-source-range-info -fdiagnostics-show-category=id -fdiagnostics-parseable-fixits -fpascal-strings -fvisibility=hidden -MMD -MT dependencies -miphoneos-version-min=7.0 -isysroot $IPHONESDK') env.Append(CPPFLAGS=['-DNEED_LONG_INT']) env.Append(CPPFLAGS=['-DLIBYUV_DISABLE_NEON']) else: # armv7 env["arch"] = "arm" env["bits"] = "32" - env['CCFLAGS'] = string.split('-fno-objc-arc -arch armv7 -fmessage-length=0 -fno-strict-aliasing -fdiagnostics-print-source-range-info -fdiagnostics-show-category=id -fdiagnostics-parseable-fixits -Wno-trigraphs -fpascal-strings -Wmissing-prototypes -Wreturn-type -Wparentheses -Wswitch -Wno-unused-parameter -Wunused-variable -Wunused-value -Wno-shorten-64-to-32 -isysroot $IPHONESDK -fvisibility=hidden -Wno-sign-conversion -mthumb "-DIBOutlet=__attribute__((iboutlet))" "-DIBOutletCollection(ClassName)=__attribute__((iboutletcollection(ClassName)))" "-DIBAction=void)__attribute__((ibaction)" -miphoneos-version-min=7.0 -MMD -MT dependencies -isysroot $IPHONESDK') + env['CCFLAGS'] = string.split('-fno-objc-arc -arch armv7 -fmessage-length=0 -fno-strict-aliasing -fdiagnostics-print-source-range-info -fdiagnostics-show-category=id -fdiagnostics-parseable-fixits -fpascal-strings -isysroot $IPHONESDK -fvisibility=hidden -mthumb "-DIBOutlet=__attribute__((iboutlet))" "-DIBOutletCollection(ClassName)=__attribute__((iboutletcollection(ClassName)))" "-DIBAction=void)__attribute__((ibaction)" -miphoneos-version-min=7.0 -MMD -MT dependencies -isysroot $IPHONESDK') if (env["arch"] == "x86"): env['IPHONEPLATFORM'] = 'iPhoneSimulator' @@ -145,17 +145,17 @@ def configure(env): if (env["target"] == "release"): - env.Append(CCFLAGS=['-O3', '-DNS_BLOCK_ASSERTIONS=1', '-Wall', '-gdwarf-2']) # removed -ffast-math + env.Append(CCFLAGS=['-O3', '-DNS_BLOCK_ASSERTIONS=1', '-gdwarf-2']) # removed -ffast-math env.Append(LINKFLAGS=['-O3']) elif env["target"] == "release_debug": - env.Append(CCFLAGS=['-Os', '-DNS_BLOCK_ASSERTIONS=1', '-Wall', '-DDEBUG_ENABLED']) + env.Append(CCFLAGS=['-Os', '-DNS_BLOCK_ASSERTIONS=1', '-DDEBUG_ENABLED']) env.Append(LINKFLAGS=['-Os']) env.Append(CPPFLAGS=['-DDEBUG_MEMORY_ENABLED']) elif (env["target"] == "debug"): - env.Append(CCFLAGS=['-D_DEBUG', '-DDEBUG=1', '-gdwarf-2', '-Wall', '-O0', '-DDEBUG_ENABLED']) + env.Append(CCFLAGS=['-D_DEBUG', '-DDEBUG=1', '-gdwarf-2', '-O0', '-DDEBUG_ENABLED']) env.Append(CPPFLAGS=['-DDEBUG_MEMORY_ENABLED']) elif (env["target"] == "profile"): diff --git a/platform/iphone/gl_view.mm b/platform/iphone/gl_view.mm index adc76a622e..6850b6be38 100755 --- a/platform/iphone/gl_view.mm +++ b/platform/iphone/gl_view.mm @@ -331,7 +331,7 @@ static void clear_touches() { glBindFramebufferOES(GL_FRAMEBUFFER_OES, viewFramebuffer); glBindRenderbufferOES(GL_RENDERBUFFER_OES, viewRenderbuffer); // This call associates the storage for the current render buffer with the EAGLDrawable (our CAEAGLLayer) - // allowing us to draw into a buffer that will later be rendered to screen whereever the layer is (which corresponds with our view). + // allowing us to draw into a buffer that will later be rendered to screen wherever the layer is (which corresponds with our view). [context renderbufferStorage:GL_RENDERBUFFER_OES fromDrawable:(id<EAGLDrawable>)self.layer]; glFramebufferRenderbufferOES(GL_FRAMEBUFFER_OES, GL_COLOR_ATTACHMENT0_OES, GL_RENDERBUFFER_OES, viewRenderbuffer); diff --git a/platform/iphone/os_iphone.cpp b/platform/iphone/os_iphone.cpp index 57862131f9..576518011f 100644 --- a/platform/iphone/os_iphone.cpp +++ b/platform/iphone/os_iphone.cpp @@ -196,7 +196,6 @@ void OSIPhone::key(uint32_t p_key, bool p_pressed) { InputEvent ev; ev.type = InputEvent::KEY; - ev.ID = ++last_event_id; ev.key.echo = false; ev.key.pressed = p_pressed; ev.key.scancode = p_key; @@ -209,7 +208,6 @@ void OSIPhone::mouse_button(int p_idx, int p_x, int p_y, bool p_pressed, bool p_ if (!GLOBAL_DEF("debug/disable_touch", false)) { InputEvent ev; ev.type = InputEvent::SCREEN_TOUCH; - ev.ID = ++last_event_id; ev.screen_touch.index = p_idx; ev.screen_touch.pressed = p_pressed; ev.screen_touch.x = p_x; @@ -225,7 +223,6 @@ void OSIPhone::mouse_button(int p_idx, int p_x, int p_y, bool p_pressed, bool p_ ev.type = InputEvent::MOUSE_BUTTON; ev.device = 0; ev.mouse_button.pointer_index = p_idx; - ev.ID = ++last_event_id; // swaped it for tilted screen //ev.mouse_button.x = ev.mouse_button.global_x = video_mode.height - p_y; @@ -250,7 +247,6 @@ void OSIPhone::mouse_move(int p_idx, int p_prev_x, int p_prev_y, int p_x, int p_ InputEvent ev; ev.type = InputEvent::SCREEN_DRAG; - ev.ID = ++last_event_id; ev.screen_drag.index = p_idx; ev.screen_drag.x = p_x; ev.screen_drag.y = p_y; @@ -264,7 +260,6 @@ void OSIPhone::mouse_move(int p_idx, int p_prev_x, int p_prev_y, int p_x, int p_ ev.type = InputEvent::MOUSE_MOTION; ev.device = 0; ev.mouse_motion.pointer_index = p_idx; - ev.ID = ++last_event_id; if (true) { // vertical @@ -325,9 +320,8 @@ void OSIPhone::update_accelerometer(float p_x, float p_y, float p_z) { InputEvent ev; ev.type = InputEvent::JOYPAD_MOTION; ev.device = 0; - ev.joy_motion.axis = JOY_ANALOG_0_X; + ev.joy_motion.axis = JOY_ANALOG_0; ev.joy_motion.axis_value = (p_x / (float)ACCEL_RANGE); - ev.ID = ++last_event_id; last_accel.x = p_x; queue_event(ev); }; @@ -336,9 +330,8 @@ void OSIPhone::update_accelerometer(float p_x, float p_y, float p_z) { InputEvent ev; ev.type = InputEvent::JOYPAD_MOTION; ev.device = 0; - ev.joy_motion.axis = JOY_ANALOG_0_Y; + ev.joy_motion.axis = JOY_ANALOG_1; ev.joy_motion.axis_value = (p_y / (float)ACCEL_RANGE); - ev.ID = ++last_event_id; last_accel.y = p_y; queue_event(ev); }; @@ -347,9 +340,8 @@ void OSIPhone::update_accelerometer(float p_x, float p_y, float p_z) { InputEvent ev; ev.type = InputEvent::JOYPAD_MOTION; ev.device = 0; - ev.joy_motion.axis = JOY_ANALOG_1_X; + ev.joy_motion.axis = JOY_ANALOG_2; ev.joy_motion.axis_value = ( (1.0 - p_z) / (float)ACCEL_RANGE); - ev.ID = ++last_event_id; last_accel.z = p_z; queue_event(ev); }; @@ -566,7 +558,6 @@ OSIPhone::OSIPhone(int width, int height) { vm.resizable = false; set_video_mode(vm); event_count = 0; - last_event_id = 0; }; OSIPhone::~OSIPhone() { diff --git a/platform/iphone/os_iphone.h b/platform/iphone/os_iphone.h index 36261a62c2..7557453a02 100644 --- a/platform/iphone/os_iphone.h +++ b/platform/iphone/os_iphone.h @@ -119,7 +119,6 @@ private: InputEvent event_queue[MAX_EVENTS]; int event_count; - int last_event_id; void queue_event(const InputEvent &p_event); String data_dir; diff --git a/platform/iphone/rasterizer_iphone.cpp b/platform/iphone/rasterizer_iphone.cpp index 1a619f4305..14288e4ba0 100644 --- a/platform/iphone/rasterizer_iphone.cpp +++ b/platform/iphone/rasterizer_iphone.cpp @@ -1867,7 +1867,7 @@ void RasterizerIPhone::_setup_light(LightInstance *p_instance, int p_idx) { switch (ld->type) { case VS::LIGHT_DIRECTIONAL: { - /* This doesnt have attenuation */ + /* This doesn't have attenuation */ glMatrixMode(GL_MODELVIEW); glPushMatrix(); @@ -2088,7 +2088,7 @@ void RasterizerIPhone::_render_list_forward(RenderList *p_render_list) { uint64_t prev_light_hash = 0; const Skeleton *prev_skeleton = NULL; const Geometry *prev_geometry = NULL; - const ParamOverrideMap *prev_overrides = NULL; // make it diferent than NULL + const ParamOverrideMap *prev_overrides = NULL; // make it different than NULL Geometry::Type prev_geometry_type = Geometry::GEOMETRY_INVALID; diff --git a/platform/javascript/detect.py b/platform/javascript/detect.py index f82eae9ff2..41fe3fb027 100644 --- a/platform/javascript/detect.py +++ b/platform/javascript/detect.py @@ -73,11 +73,11 @@ def configure(env): env.Append(LINKFLAGS=['-O3']) elif (env["target"] == "release_debug"): env.Append(CCFLAGS=['-O2', '-DDEBUG_ENABLED']) - env.Append(LINKFLAGS=['-O2']) + env.Append(LINKFLAGS=['-O2', '-s', 'ASSERTIONS=1']) # retain function names at the cost of file size, for backtraces and profiling env.Append(LINKFLAGS=['--profiling-funcs']) elif (env["target"] == "debug"): - env.Append(CCFLAGS=['-O1', '-D_DEBUG', '-Wall', '-g', '-DDEBUG_ENABLED']) + env.Append(CCFLAGS=['-O1', '-D_DEBUG', '-g', '-DDEBUG_ENABLED']) env.Append(LINKFLAGS=['-O1', '-g']) # TODO: Move that to opus module's config diff --git a/platform/javascript/export/export.cpp b/platform/javascript/export/export.cpp index 4fdb6f39c8..9a1e6672cb 100644 --- a/platform/javascript/export/export.cpp +++ b/platform/javascript/export/export.cpp @@ -26,399 +26,303 @@ /* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ /*************************************************************************/ -#include "export.h" -#include "editor/editor_export.h" #include "editor/editor_node.h" -#include "editor/editor_settings.h" -#include "global_config.h" -#include "io/marshalls.h" +#include "editor_export.h" #include "io/zip_io.h" -#include "os/file_access.h" -#include "os/os.h" #include "platform/javascript/logo.h" -#include "string.h" -#include "version.h" -#if 0 -class EditorExportPlatformJavaScript : public EditorExportPlatform { - - GDCLASS( EditorExportPlatformJavaScript,EditorExportPlatform ); - - String custom_release_package; - String custom_debug_package; - - enum PackMode { - PACK_SINGLE_FILE, - PACK_MULTIPLE_FILES - }; - - void _fix_html(Vector<uint8_t>& p_html, const String& p_name, bool p_debug); +#define EXPORT_TEMPLATE_WEBASSEMBLY_RELEASE "webassembly_release.zip" +#define EXPORT_TEMPLATE_WEBASSEMBLY_DEBUG "webassembly_debug.zip" +#define EXPORT_TEMPLATE_ASMJS_RELEASE "javascript_release.zip" +#define EXPORT_TEMPLATE_ASMJS_DEBUG "javascript_debug.zip" - PackMode pack_mode; - - bool show_run; - - int max_memory; - int version_code; +class EditorExportPlatformJavaScript : public EditorExportPlatform { - String html_title; - String html_head_include; - String html_font_family; - String html_style_include; - bool html_controls_enabled; + GDCLASS(EditorExportPlatformJavaScript, EditorExportPlatform) Ref<ImageTexture> logo; -protected: - - bool _set(const StringName& p_name, const Variant& p_value); - bool _get(const StringName& p_name,Variant &r_ret) const; - void _get_property_list( List<PropertyInfo> *p_list) const; + void _fix_html(Vector<uint8_t> &p_html, const Ref<EditorExportPreset> &p_preset, const String &p_name, bool p_debug); + void _fix_fsloader_js(Vector<uint8_t> &p_js, const String &p_pack_name, uint64_t p_pack_size); public: + enum Target { + TARGET_WEBASSEMBLY, + TARGET_ASMJS + }; - virtual String get_name() const { return "HTML5"; } - virtual ImageCompression get_image_compression() const { return IMAGE_COMPRESSION_BC; } - virtual Ref<Texture> get_logo() const { return logo; } + virtual void get_preset_features(const Ref<EditorExportPreset> &p_preset, List<String> *r_features); + virtual void get_export_options(List<ExportOption> *r_options); + virtual bool get_option_visibility(const String &p_option, const Map<StringName, Variant> &p_options) const; - virtual bool poll_devices() { return show_run?true:false;} - virtual int get_device_count() const { return show_run?1:0; }; - virtual String get_device_name(int p_device) const { return "Run in Browser"; } - virtual String get_device_info(int p_device) const { return "Run exported HTML in the system's default browser."; } - virtual Error run(int p_device,int p_flags=0); + virtual String get_name() const; + virtual Ref<Texture> get_logo() const; - virtual bool requires_password(bool p_debug) const { return false; } - virtual String get_binary_extension() const { return "html"; } - virtual Error export_project(const String& p_path,bool p_debug,int p_flags=0); + virtual bool can_export(const Ref<EditorExportPreset> &p_preset, String &r_error, bool &r_missing_templates) const; + virtual String get_binary_extension() const; + virtual Error export_project(const Ref<EditorExportPreset> &p_preset, bool p_debug, const String &p_path, int p_flags = 0); - virtual bool can_export(String *r_error=NULL) const; + virtual int get_device_count() const { return 1; } + virtual String get_device_name(int p_device) const { return TTR("Run in Browser"); } + virtual String get_device_info(int p_device) const { return TTR("Run exported HTML in the system's default browser."); } + virtual Error run(const Ref<EditorExportPreset> &p_preset, int p_device, int p_debug_flags); EditorExportPlatformJavaScript(); - ~EditorExportPlatformJavaScript(); }; -bool EditorExportPlatformJavaScript::_set(const StringName& p_name, const Variant& p_value) { - - String n=p_name; - - if (n=="custom_package/debug") - custom_debug_package=p_value; - else if (n=="custom_package/release") - custom_release_package=p_value; - else if (n=="browser/enable_run") - show_run=p_value; - else if (n=="options/memory_size") - max_memory=p_value; - else if (n=="html/title") - html_title=p_value; - else if (n=="html/head_include") - html_head_include=p_value; - else if (n=="html/font_family") - html_font_family=p_value; - else if (n=="html/style_include") - html_style_include=p_value; - else if (n=="html/controls_enabled") - html_controls_enabled=p_value; - else - return false; +void EditorExportPlatformJavaScript::_fix_html(Vector<uint8_t> &p_html, const Ref<EditorExportPreset> &p_preset, const String &p_name, bool p_debug) { - return true; -} + String str_template = String::utf8(reinterpret_cast<const char *>(p_html.ptr()), p_html.size()); + String str_export; + Vector<String> lines = str_template.split("\n"); -bool EditorExportPlatformJavaScript::_get(const StringName& p_name,Variant &r_ret) const{ - - String n=p_name; - - if (n=="custom_package/debug") - r_ret=custom_debug_package; - else if (n=="custom_package/release") - r_ret=custom_release_package; - else if (n=="browser/enable_run") - r_ret=show_run; - else if (n=="options/memory_size") - r_ret=max_memory; - else if (n=="html/title") - r_ret=html_title; - else if (n=="html/head_include") - r_ret=html_head_include; - else if (n=="html/font_family") - r_ret=html_font_family; - else if (n=="html/style_include") - r_ret=html_style_include; - else if (n=="html/controls_enabled") - r_ret=html_controls_enabled; + int memory_mb; + if (p_preset->get("options/target").operator int() != TARGET_ASMJS) + // WebAssembly allows memory growth, so start with a reasonable default + memory_mb = 1 << 4; else - return false; - - return true; -} -void EditorExportPlatformJavaScript::_get_property_list( List<PropertyInfo> *p_list) const{ - - p_list->push_back( PropertyInfo( Variant::STRING, "custom_package/debug", PROPERTY_HINT_GLOBAL_FILE,"zip")); - p_list->push_back( PropertyInfo( Variant::STRING, "custom_package/release", PROPERTY_HINT_GLOBAL_FILE,"zip")); - p_list->push_back( PropertyInfo( Variant::INT, "options/memory_size",PROPERTY_HINT_ENUM,"32mb,64mb,128mb,256mb,512mb,1024mb")); - p_list->push_back( PropertyInfo( Variant::BOOL, "browser/enable_run")); - p_list->push_back( PropertyInfo( Variant::STRING, "html/title")); - p_list->push_back( PropertyInfo( Variant::STRING, "html/head_include",PROPERTY_HINT_MULTILINE_TEXT)); - p_list->push_back( PropertyInfo( Variant::STRING, "html/font_family")); - p_list->push_back( PropertyInfo( Variant::STRING, "html/style_include",PROPERTY_HINT_MULTILINE_TEXT)); - p_list->push_back( PropertyInfo( Variant::BOOL, "html/controls_enabled")); + memory_mb = 1 << (p_preset->get("options/memory_size").operator int() + 5); + for (int i = 0; i < lines.size(); i++) { - //p_list->push_back( PropertyInfo( Variant::INT, "resources/pack_mode", PROPERTY_HINT_ENUM,"Copy,Single Exec.,Pack (.pck),Bundles (Optical)")); + String current_line = lines[i]; + current_line = current_line.replace("$GODOT_TMEM", itos(memory_mb * 1024 * 1024)); + current_line = current_line.replace("$GODOT_BASE", p_name); + current_line = current_line.replace("$GODOT_HEAD_INCLUDE", p_preset->get("html/head_include")); + current_line = current_line.replace("$GODOT_DEBUG_ENABLED", p_debug ? "true" : "false"); + str_export += current_line + "\n"; + } + CharString cs = str_export.utf8(); + p_html.resize(cs.length()); + for (int i = 0; i < cs.length(); i++) { + p_html[i] = cs[i]; + } } +void EditorExportPlatformJavaScript::_fix_fsloader_js(Vector<uint8_t> &p_js, const String &p_pack_name, uint64_t p_pack_size) { -void EditorExportPlatformJavaScript::_fix_html(Vector<uint8_t>& p_html, const String& p_name, bool p_debug) { + String str_template = String::utf8(reinterpret_cast<const char *>(p_js.ptr()), p_js.size()); + String str_export; + Vector<String> lines = str_template.split("\n"); + for (int i = 0; i < lines.size(); i++) { + if (lines[i].find("$GODOT_PACK_NAME") != -1) { + str_export += lines[i].replace("$GODOT_PACK_NAME", p_pack_name); + } else if (lines[i].find("$GODOT_PACK_SIZE") != -1) { + str_export += lines[i].replace("$GODOT_PACK_SIZE", itos(p_pack_size)); + } else { + str_export += lines[i] + "\n"; + } + } + CharString cs = str_export.utf8(); + p_js.resize(cs.length()); + for (int i = 0; i < cs.length(); i++) { + p_js[i] = cs[i]; + } +} - String str; - String strnew; - str.parse_utf8((const char*)p_html.ptr(),p_html.size()); - Vector<String> lines=str.split("\n"); - for(int i=0;i<lines.size();i++) { +void EditorExportPlatformJavaScript::get_preset_features(const Ref<EditorExportPreset> &p_preset, List<String> *r_features) { - String current_line = lines[i]; - current_line = current_line.replace("$GODOT_TMEM",itos((1<<(max_memory+5))*1024*1024)); - current_line = current_line.replace("$GODOT_BASE",p_name); - current_line = current_line.replace("$GODOT_CANVAS_WIDTH",GlobalConfig::get_singleton()->get("display/window/width")); - current_line = current_line.replace("$GODOT_CANVAS_HEIGHT",GlobalConfig::get_singleton()->get("display/window/height")); - current_line = current_line.replace("$GODOT_HEAD_TITLE",!html_title.empty()?html_title:(String) GlobalConfig::get_singleton()->get("application/name")); - current_line = current_line.replace("$GODOT_HEAD_INCLUDE",html_head_include); - current_line = current_line.replace("$GODOT_STYLE_FONT_FAMILY",html_font_family); - current_line = current_line.replace("$GODOT_STYLE_INCLUDE",html_style_include); - current_line = current_line.replace("$GODOT_CONTROLS_ENABLED",html_controls_enabled?"true":"false"); - current_line = current_line.replace("$GODOT_DEBUG_ENABLED",p_debug?"true":"false"); - strnew += current_line+"\n"; + if (p_preset->get("texture_format/s3tc")) { + r_features->push_back("s3tc"); } - - CharString cs = strnew.utf8(); - p_html.resize(cs.length()); - for(int i=9;i<cs.length();i++) { - p_html[i]=cs[i]; + if (p_preset->get("texture_format/etc")) { + r_features->push_back("etc"); + } + if (p_preset->get("texture_format/etc2")) { + r_features->push_back("etc2"); } } -static void _fix_files(Vector<uint8_t>& html,uint64_t p_data_size) { +void EditorExportPlatformJavaScript::get_export_options(List<ExportOption> *r_options) { + r_options->push_back(ExportOption(PropertyInfo(Variant::INT, "options/target", PROPERTY_HINT_ENUM, "WebAssembly,asm.js"), TARGET_WEBASSEMBLY)); + r_options->push_back(ExportOption(PropertyInfo(Variant::INT, "options/memory_size", PROPERTY_HINT_ENUM, "32 MB,64 MB,128 MB,256 MB,512 MB,1 GB"), 3)); + r_options->push_back(ExportOption(PropertyInfo(Variant::BOOL, "texture_format/s3tc"), false)); + r_options->push_back(ExportOption(PropertyInfo(Variant::BOOL, "texture_format/etc"), true)); + r_options->push_back(ExportOption(PropertyInfo(Variant::BOOL, "texture_format/etc2"), false)); + r_options->push_back(ExportOption(PropertyInfo(Variant::STRING, "html/head_include", PROPERTY_HINT_MULTILINE_TEXT), "")); + r_options->push_back(ExportOption(PropertyInfo(Variant::STRING, "custom_template/release", PROPERTY_HINT_GLOBAL_FILE, "zip"), "")); + r_options->push_back(ExportOption(PropertyInfo(Variant::STRING, "custom_template/debug", PROPERTY_HINT_GLOBAL_FILE, "zip"), "")); +} - String str; - String strnew; - str.parse_utf8((const char*)html.ptr(),html.size()); - Vector<String> lines=str.split("\n"); - for(int i=0;i<lines.size();i++) { - if (lines[i].find("$DPLEN")!=-1) { - strnew+=lines[i].replace("$DPLEN",itos(p_data_size)); - } else { - strnew+=lines[i]+"\n"; - } - } +bool EditorExportPlatformJavaScript::get_option_visibility(const String &p_option, const Map<StringName, Variant> &p_options) const { - CharString cs = strnew.utf8(); - html.resize(cs.length()); - for(int i=9;i<cs.length();i++) { - html[i]=cs[i]; + if (p_option == "options/memory_size") { + return p_options["options/target"].operator int() == TARGET_ASMJS; } + return true; +} +String EditorExportPlatformJavaScript::get_name() const { + + return "HTML5"; } -struct JSExportData { +Ref<Texture> EditorExportPlatformJavaScript::get_logo() const { - EditorProgress *ep; - FileAccess *f; + return logo; +} -}; +bool EditorExportPlatformJavaScript::can_export(const Ref<EditorExportPreset> &p_preset, String &r_error, bool &r_missing_templates) const { + r_missing_templates = false; + if (p_preset->get("options/target").operator int() == TARGET_WEBASSEMBLY) { + if (find_export_template(EXPORT_TEMPLATE_WEBASSEMBLY_RELEASE) == String()) + r_missing_templates = true; + else if (find_export_template(EXPORT_TEMPLATE_WEBASSEMBLY_DEBUG) == String()) + r_missing_templates = true; + } else { + if (find_export_template(EXPORT_TEMPLATE_ASMJS_RELEASE) == String()) + r_missing_templates = true; + else if (find_export_template(EXPORT_TEMPLATE_ASMJS_DEBUG) == String()) + r_missing_templates = true; + } -Error EditorExportPlatformJavaScript::export_project(const String& p_path, bool p_debug, int p_flags) { + return !r_missing_templates; +} +String EditorExportPlatformJavaScript::get_binary_extension() const { - String src_template; + return "html"; +} - EditorProgress ep("export","Exporting for javascript",104); +Error EditorExportPlatformJavaScript::export_project(const Ref<EditorExportPreset> &p_preset, bool p_debug, const String &p_path, int p_flags) { - if (p_debug) - src_template=custom_debug_package; - else - src_template=custom_release_package; + String custom_debug = p_preset->get("custom_template/debug"); + String custom_release = p_preset->get("custom_template/release"); + + String template_path = p_debug ? custom_debug : custom_release; - if (src_template=="") { - String err; - if (p_debug) { - src_template=find_export_template("javascript_debug.zip", &err); + template_path = template_path.strip_edges(); + + if (template_path == String()) { + + if (p_preset->get("options/target").operator int() == TARGET_WEBASSEMBLY) { + if (p_debug) + template_path = find_export_template(EXPORT_TEMPLATE_WEBASSEMBLY_DEBUG); + else + template_path = find_export_template(EXPORT_TEMPLATE_WEBASSEMBLY_RELEASE); } else { - src_template=find_export_template("javascript_release.zip", &err); - } - if (src_template=="") { - EditorNode::add_io_error(err); - return ERR_FILE_NOT_FOUND; + if (p_debug) + template_path = find_export_template(EXPORT_TEMPLATE_ASMJS_DEBUG); + else + template_path = find_export_template(EXPORT_TEMPLATE_ASMJS_RELEASE); } } - FileAccess *src_f=NULL; - zlib_filefunc_def io = zipio_create_io_from_file(&src_f); - - ep.step("Exporting to HTML5",0); + if (template_path != String() && !FileAccess::exists(template_path)) { + EditorNode::get_singleton()->show_warning(TTR("Template file not found:\n") + template_path); + return ERR_FILE_NOT_FOUND; + } - ep.step("Finding Files..",1); + String pck_path = p_path.get_basename() + ".pck"; + Error error = save_pack(p_preset, pck_path); + if (error != OK) { + EditorNode::get_singleton()->show_warning(TTR("Could not write file:\n") + pck_path); + return error; + } - FileAccess *f=FileAccess::open(p_path.get_base_dir()+"/data.pck",FileAccess::WRITE); + FileAccess *f = FileAccess::open(pck_path, FileAccess::READ); if (!f) { - EditorNode::add_io_error("Could not create file for writing:\n"+p_path.get_basename()+"_files.js"); - return ERR_FILE_CANT_WRITE; + EditorNode::get_singleton()->show_warning(TTR("Could not read file:\n") + pck_path); + return ERR_FILE_CANT_READ; } - Error err = save_pack(f); - size_t len = f->get_len(); + size_t pack_size = f->get_len(); memdelete(f); - if (err) - return err; + FileAccess *src_f = NULL; + zlib_filefunc_def io = zipio_create_io_from_file(&src_f); + unzFile pkg = unzOpen2(template_path.utf8().get_data(), &io); - unzFile pkg = unzOpen2(src_template.utf8().get_data(), &io); if (!pkg) { - EditorNode::add_io_error("Could not find template HTML5 to export:\n"+src_template); + EditorNode::get_singleton()->show_warning(TTR("Could not open template for export:\n") + template_path); return ERR_FILE_NOT_FOUND; } - ERR_FAIL_COND_V(!pkg, ERR_CANT_OPEN); int ret = unzGoToFirstFile(pkg); - - - while(ret==UNZ_OK) { + while (ret == UNZ_OK) { //get filename unz_file_info info; char fname[16384]; - ret = unzGetCurrentFileInfo(pkg,&info,fname,16384,NULL,0,NULL,0); + ret = unzGetCurrentFileInfo(pkg, &info, fname, 16384, NULL, 0, NULL, 0); - String file=fname; + String file = fname; Vector<uint8_t> data; data.resize(info.uncompressed_size); //read unzOpenCurrentFile(pkg); - unzReadCurrentFile(pkg,data.ptr(),data.size()); + unzReadCurrentFile(pkg, data.ptr(), data.size()); unzCloseCurrentFile(pkg); //write - if (file=="godot.html") { + if (file == "godot.html") { - _fix_html(data,p_path.get_file().get_basename(), p_debug); - file=p_path.get_file(); - } - if (file=="godotfs.js") { - - _fix_files(data,len); - file=p_path.get_file().get_basename()+"fs.js"; - } - if (file=="godot.js") { + _fix_html(data, p_preset, p_path.get_file().get_basename(), p_debug); + file = p_path.get_file(); + } else if (file == "godotfs.js") { - file=p_path.get_file().get_basename()+".js"; - } + _fix_fsloader_js(data, pck_path.get_file(), pack_size); + file = p_path.get_file().get_basename() + "fs.js"; + } else if (file == "godot.js") { - if (file=="godot.asm.js") { + file = p_path.get_file().get_basename() + ".js"; + } else if (file == "godot.wasm") { - file=p_path.get_file().get_basename()+".asm.js"; - } + file = p_path.get_file().get_basename() + ".wasm"; + } else if (file == "godot.asm.js") { - if (file=="godot.mem") { + file = p_path.get_file().get_basename() + ".asm.js"; + } else if (file == "godot.mem") { - file=p_path.get_file().get_basename()+".mem"; - } - - if (file=="godot.wasm") { - - file=p_path.get_file().get_basename()+".wasm"; + file = p_path.get_file().get_basename() + ".mem"; } String dst = p_path.get_base_dir().plus_file(file); - FileAccess *f=FileAccess::open(dst,FileAccess::WRITE); + FileAccess *f = FileAccess::open(dst, FileAccess::WRITE); if (!f) { - EditorNode::add_io_error("Could not create file for writing:\n"+dst); + EditorNode::get_singleton()->show_warning(TTR("Could not write file:\n") + dst); unzClose(pkg); return ERR_FILE_CANT_WRITE; } - f->store_buffer(data.ptr(),data.size()); + f->store_buffer(data.ptr(), data.size()); memdelete(f); - ret = unzGoToNextFile(pkg); } - - return OK; - } +Error EditorExportPlatformJavaScript::run(const Ref<EditorExportPreset> &p_preset, int p_device, int p_debug_flags) { -Error EditorExportPlatformJavaScript::run(int p_device, int p_flags) { - - String path = EditorSettings::get_singleton()->get_settings_path()+"/tmp/tmp_export.html"; - Error err = export_project(path,true,p_flags); - if (err) + String path = EditorSettings::get_singleton()->get_settings_path() + "/tmp/tmp_export.html"; + Error err = export_project(p_preset, true, path, p_debug_flags); + if (err) { return err; - + } OS::get_singleton()->shell_open(path); - return OK; } - EditorExportPlatformJavaScript::EditorExportPlatformJavaScript() { - show_run=false; - Image img( _javascript_logo ); - logo = Ref<ImageTexture>( memnew( ImageTexture )); + Image img(_javascript_logo); + logo.instance(); logo->create_from_image(img); - max_memory=3; - html_title=""; - html_font_family="'Droid Sans',arial,sans-serif"; - html_controls_enabled=true; - pack_mode=PACK_SINGLE_FILE; -} - -bool EditorExportPlatformJavaScript::can_export(String *r_error) const { - - - bool valid=true; - String err; - - if (!exists_export_template("javascript_debug.zip") || !exists_export_template("javascript_release.zip")) { - valid=false; - err+="No export templates found.\nDownload and install export templates.\n"; - } - - if (custom_debug_package!="" && !FileAccess::exists(custom_debug_package)) { - valid=false; - err+="Custom debug package not found.\n"; - } - - if (custom_release_package!="" && !FileAccess::exists(custom_release_package)) { - valid=false; - err+="Custom release package not found.\n"; - } - - if (r_error) - *r_error=err; - - return valid; -} - - -EditorExportPlatformJavaScript::~EditorExportPlatformJavaScript() { - } -#endif void register_javascript_exporter() { - //Ref<EditorExportPlatformJavaScript> exporter = Ref<EditorExportPlatformJavaScript>( memnew(EditorExportPlatformJavaScript) ); - //EditorImportExport::get_singleton()->add_export_platform(exporter); + Ref<EditorExportPlatformJavaScript> platform; + platform.instance(); + EditorExport::get_singleton()->add_export_platform(platform); } diff --git a/platform/javascript/godot_shell.html b/platform/javascript/godot_shell.html index 65f3b4a340..6c7069a8f0 100644 --- a/platform/javascript/godot_shell.html +++ b/platform/javascript/godot_shell.html @@ -2,8 +2,7 @@ <html xmlns="http://www.w3.org/1999/xhtml" lang="" xml:lang=""> <head> <meta charset="utf-8" /> - <title>$GODOT_HEAD_TITLE</title> -$GODOT_HEAD_INCLUDE + <title></title> <style type="text/css"> body { margin: 0; @@ -11,7 +10,7 @@ $GODOT_HEAD_INCLUDE padding: 0; text-align: center; background-color: #222226; - font-family: $GODOT_STYLE_FONT_FAMILY; + font-family: 'Droid Sans', Arial, sans-serif; } @@ -27,7 +26,7 @@ $GODOT_HEAD_INCLUDE } button.godot { - font-family: $GODOT_STYLE_FONT_FAMILY; /* override user agent style */ + font-family: 'Droid Sans', Arial, sans-serif; /* override user agent style */ padding: 1px 5px; background-color: #37353f; background-image: linear-gradient(to bottom, #413e49, #3a3842); @@ -109,53 +108,12 @@ $GODOT_HEAD_INCLUDE } - /* On-hover controls - * ================= */ - - #controls { - visibility: hidden; - opacity: 0.0; - transition: opacity 500ms ease-in-out 200ms; - position: absolute; - right: 16px; - top: 16px; - padding: 3px 5px; - font-size: small; - -moz-user-select: none; - -webkit-user-select: none; - -ms-user-select: none; - } - - :hover > #controls { - opacity: 1.0; - transition: opacity 60ms ease-in-out; - } - - #controls > button, - #controls > label { - vertical-align: middle; - margin-left: 2px; - margin-right: 2px; - } - - #controls > label > input { - vertical-align: middle; - } - - #controls > label > input[type="checkbox"] { - /* override user agent style */ - margin-left: 0; - } - - #output-toggle { display: none; } - - /* Debug output * ============ */ #output-panel { display: none; - max-width: $GODOT_CANVAS_WIDTHpx; + max-width: 700px; font-size: small; margin: 6px auto 0; padding: 0 4px 4px; @@ -184,32 +142,18 @@ $GODOT_HEAD_INCLUDE font-size: small; font-family: "Lucida Console", Monaco, monospace; } - - -/* Export style include - * ==================== */ - -$GODOT_STYLE_INCLUDE - </style> +$GODOT_HEAD_INCLUDE </head> <body> <div id="container"> - <canvas id="canvas" width="$GODOT_CANVAS_WIDTH" height="$GODOT_CANVAS_HEIGHT" onclick="canvas.ownerDocument.defaultView.focus();" oncontextmenu="event.preventDefault();"> + <canvas id="canvas" width="640" height="480" onclick="canvas.ownerDocument.defaultView.focus();" oncontextmenu="event.preventDefault();"> HTML5 canvas appears to be unsupported in the current browser.<br /> Please try updating or use a different browser. </canvas> <div id="status-container"> <span id="status" class="godot" onclick="this.style.visibility='hidden';">Downloading page...</span> </div> - <div id="controls" class="godot"> - <label id="output-toggle"><input type="checkbox" checked="checked" autocomplete="off" onchange="Presentation.setOutputVisible(this.checked);" />Display Output</label> - <!-- hidden until implemented - <label><input class="postRun-enable" type="checkbox" disabled="disabled" autocomplete="off" />lock cursor</label> - <label><input class="postRun-enable" type="checkbox" disabled="disabled" autocomplete="off" onchange="Presentation.setCanvasMaximized(this.checked);" />maximize</label> - --> - <button id="fullscreen" class="godot postRun-enable" type="button" disabled="disabled" autocomplete="off" onclick="Presentation.requestFullscreen();">Fullscreen</button> - </div> </div> <div id="output-panel" class="godot"> <div id="output-header"> @@ -226,33 +170,9 @@ $GODOT_STYLE_INCLUDE var canvasElement = document.getElementById("canvas"); var presentation = { - postRun: [ - function() { - var elements = document.getElementsByClassName("postRun-enable"); - Array.prototype.slice.call(elements).forEach(function(element) { - element.disabled = false; - }); - } - ], - requestFullscreen: function requestFullscreen() { - if (typeof Module !== "undefined" && Module.requestFullscreen) { - Module.requestFullscreen(false, false); - } - }, - /* - requestPointerlock: function requestPointerlock() { - if (typeof Module !== "undefined" && Module.requestPointerlock) { - Module.requestPointerlock(false, false); - } - }, - setCanvasMaximized: function setCanvasMaximized(enabled) { - if (typeof Module !== "undefined" && Module.setCanvasMaximized) { - Module.setCanvasMaximized(enabled); - } - }, - */ + postRun: [], setStatusVisible: function setStatusVisible(visible) { - statusElement.style.visibility = (visible?"visible":"hidden"); + statusElement.style.visibility = (visible ? "visible" : "hidden"); }, setStatus: function setStatus(text) { if (text.length === 0) { @@ -288,18 +208,13 @@ $GODOT_STYLE_INCLUDE window.onerror = function(event) { presentation.setStatus("Failure during start-up\nSee JavaScript console") }; - if ($GODOT_CONTROLS_ENABLED) { // controls enabled - document.getElementById("controls").style.visibility="visible"; - } - if ($GODOT_DEBUG_ENABLED) { // debugging enabled var outputRoot = document.getElementById("output-panel"); var outputElement = document.getElementById("output-scroll"); - var outputToggle = document.getElementById("output-toggle"); const maxOutputMessages = 400; presentation.setOutputVisible = function setOutputVisible(visible) { - outputRoot.style.display = (visible?"block":"none"); + outputRoot.style.display = (visible ? "block" : "none"); }; presentation.clearOutput = function clearOutput() { while (outputElement.firstChild) { @@ -308,7 +223,6 @@ $GODOT_STYLE_INCLUDE }; presentation.setOutputVisible(true); - outputToggle.style.display = "inline"; presentation.print = function print(text) { if (arguments.length > 1) { @@ -347,56 +261,59 @@ $GODOT_STYLE_INCLUDE })(); // Emscripten interface - var Module = { - TOTAL_MEMORY: $GODOT_TMEM, - postRun: (function() { - if (typeof Presentation !== "undefined" && Presentation.postRun instanceof Array) { - return Presentation.postRun; - } - })(), - print: function print(text) { - if (arguments.length > 1) { - text = Array.prototype.slice.call(arguments).join(" "); - } - console.log(text); - if (typeof Presentation !== "undefined" && typeof Presentation.print === "function") { - Presentation.print(text); - } - }, - printErr: function printErr(text) { - if (arguments.length > 1) { - text = Array.prototype.slice.call(arguments).join(" "); - } - console.error(text); - if (typeof Presentation !== "undefined" && typeof Presentation.print === "function") { - Presentation.print("**ERROR**:", text) - } - }, - canvas: (function() { - var canvas = document.getElementById("canvas"); - // As a default initial behavior, pop up an alert when WebGL context is lost. To make your - // application robust, you may want to override this behavior before shipping! - // See http://www.khronos.org/registry/webgl/specs/latest/1.0/#5.15.2 - canvas.addEventListener("webglcontextlost", function(e) { alert("WebGL context lost. Plase reload the page."); e.preventDefault(); }, false); - return canvas; - - })(), - setStatus: function setStatus(text) { - var m = text.match(/([^(]+)\((\d+(\.\d+)?)\/(\d+)\)/); - var now = Date.now(); - if (m) { - if (now - Date.now() < 30) // if this is a progress update, skip it if too soon - return; - text = m[1]; - } - if (typeof Presentation !== "undefined" && typeof Presentation.setStatus == "function") { - Presentation.setStatus(text); + var Module = (function() { + const BASE_NAME = '$GODOT_BASE'; + var module = { + thisProgram: BASE_NAME, + wasmBinaryFile: BASE_NAME + '.wasm', + TOTAL_MEMORY: $GODOT_TMEM, + print: function print(text) { + if (arguments.length > 1) { + text = Array.prototype.slice.call(arguments).join(" "); + } + console.log(text); + if (typeof Presentation !== "undefined" && typeof Presentation.print === "function") { + Presentation.print(text); + } + }, + printErr: function printErr(text) { + if (arguments.length > 1) { + text = Array.prototype.slice.call(arguments).join(" "); + } + console.error(text); + if (typeof Presentation !== "undefined" && typeof Presentation.print === "function") { + Presentation.print("**ERROR**:", text) + } + }, + canvas: document.getElementById("canvas"), + setStatus: function setStatus(text) { + var m = text.match(/([^(]+)\((\d+(\.\d+)?)\/(\d+)\)/); + var now = Date.now(); + if (m) { + if (now - Date.now() < 30) // if this is a progress update, skip it if too soon + return; + text = m[1]; + } + if (typeof Presentation !== "undefined" && typeof Presentation.setStatus == "function") { + Presentation.setStatus(text); + } } + }; + + // As a default initial behavior, pop up an alert when WebGL context is lost. To make your + // application robust, you may want to override this behavior before shipping! + // See http://www.khronos.org/registry/webgl/specs/latest/1.0/#5.15.2 + module.canvas.addEventListener("webglcontextlost", function(e) { alert("WebGL context lost. Plase reload the page."); e.preventDefault(); }, false); + + if (typeof Presentation !== "undefined" && Presentation.postRun instanceof Array) { + module.postRun = Presentation.postRun; } - }; + + return module; + })(); if (!Presentation.isWebGL2Available()) { - Presentation.setStatus("WebGL2 appears to be unsupported in the current browser.\nPlease try updating or use a different browser."); + Presentation.setStatus("WebGL 2 appears to be unsupported.\nPlease update browser and drivers."); Presentation.preventLoading = true; } else { Presentation.setStatus("Downloading..."); diff --git a/platform/javascript/javascript_main.cpp b/platform/javascript/javascript_main.cpp index 00e531baa1..a0fb9b83e2 100644 --- a/platform/javascript/javascript_main.cpp +++ b/platform/javascript/javascript_main.cpp @@ -145,15 +145,10 @@ int main(int argc, char *argv[]) { /* Initialize the window */ printf("let it go dude!\n"); glutInit(&argc, argv); - os = new OS_JavaScript(_gfx_init, NULL, NULL); -#if 0 - char *args[]={"-test","gui","-v",NULL}; - Error err = Main::setup("apk",3,args); -#else - char *args[] = { "-main_pack", "data.pck", NULL }; //pass location of main pack manually, because it wont get an executable name - Error err = Main::setup("", 2, args); - -#endif + os = new OS_JavaScript(argv[0], _gfx_init, NULL, NULL); + + Error err = Main::setup(argv[0], argc - 1, &argv[1]); + ResourceLoader::set_abort_on_missing_resources(false); //ease up compatibility glutMouseFunc(_glut_mouse_button); diff --git a/platform/javascript/os_javascript.cpp b/platform/javascript/os_javascript.cpp index 83072c30aa..bcb7365204 100644 --- a/platform/javascript/os_javascript.cpp +++ b/platform/javascript/os_javascript.cpp @@ -520,7 +520,6 @@ void OS_JavaScript::main_loop_focusin() { void OS_JavaScript::push_input(const InputEvent &p_ev) { InputEvent ev = p_ev; - ev.ID = last_id++; if (ev.type == InputEvent::MOUSE_MOTION) { input->set_mouse_pos(Point2(ev.mouse_motion.x, ev.mouse_motion.y)); } else if (ev.type == InputEvent::MOUSE_BUTTON) { @@ -540,7 +539,6 @@ void OS_JavaScript::process_touch(int p_what, int p_pointer, const Vector<TouchP //end all if exist InputEvent ev; ev.type = InputEvent::MOUSE_BUTTON; - ev.ID = last_id++; ev.mouse_button.button_index = BUTTON_LEFT; ev.mouse_button.button_mask = BUTTON_MASK_LEFT; ev.mouse_button.pressed = false; @@ -554,7 +552,6 @@ void OS_JavaScript::process_touch(int p_what, int p_pointer, const Vector<TouchP InputEvent ev; ev.type = InputEvent::SCREEN_TOUCH; - ev.ID = last_id++; ev.screen_touch.index = touch[i].id; ev.screen_touch.pressed = false; ev.screen_touch.x = touch[i].pos.x; @@ -573,7 +570,6 @@ void OS_JavaScript::process_touch(int p_what, int p_pointer, const Vector<TouchP //send mouse InputEvent ev; ev.type = InputEvent::MOUSE_BUTTON; - ev.ID = last_id++; ev.mouse_button.button_index = BUTTON_LEFT; ev.mouse_button.button_mask = BUTTON_MASK_LEFT; ev.mouse_button.pressed = true; @@ -590,7 +586,6 @@ void OS_JavaScript::process_touch(int p_what, int p_pointer, const Vector<TouchP InputEvent ev; ev.type = InputEvent::SCREEN_TOUCH; - ev.ID = last_id++; ev.screen_touch.index = touch[i].id; ev.screen_touch.pressed = true; ev.screen_touch.x = touch[i].pos.x; @@ -605,7 +600,6 @@ void OS_JavaScript::process_touch(int p_what, int p_pointer, const Vector<TouchP //send mouse, should look for point 0? InputEvent ev; ev.type = InputEvent::MOUSE_MOTION; - ev.ID = last_id++; ev.mouse_motion.button_mask = BUTTON_MASK_LEFT; ev.mouse_motion.x = p_points[0].pos.x; ev.mouse_motion.y = p_points[0].pos.y; @@ -638,7 +632,6 @@ void OS_JavaScript::process_touch(int p_what, int p_pointer, const Vector<TouchP InputEvent ev; ev.type = InputEvent::SCREEN_DRAG; - ev.ID = last_id++; ev.screen_drag.index = touch[i].id; ev.screen_drag.x = p_points[idx].pos.x; ev.screen_drag.y = p_points[idx].pos.y; @@ -655,7 +648,6 @@ void OS_JavaScript::process_touch(int p_what, int p_pointer, const Vector<TouchP //end all if exist InputEvent ev; ev.type = InputEvent::MOUSE_BUTTON; - ev.ID = last_id++; ev.mouse_button.button_index = BUTTON_LEFT; ev.mouse_button.button_mask = BUTTON_MASK_LEFT; ev.mouse_button.pressed = false; @@ -669,7 +661,6 @@ void OS_JavaScript::process_touch(int p_what, int p_pointer, const Vector<TouchP InputEvent ev; ev.type = InputEvent::SCREEN_TOUCH; - ev.ID = last_id++; ev.screen_touch.index = touch[i].id; ev.screen_touch.pressed = false; ev.screen_touch.x = touch[i].pos.x; @@ -689,7 +680,6 @@ void OS_JavaScript::process_touch(int p_what, int p_pointer, const Vector<TouchP InputEvent ev; ev.type = InputEvent::SCREEN_TOUCH; - ev.ID = last_id++; ev.screen_touch.index = tp.id; ev.screen_touch.pressed = true; ev.screen_touch.x = tp.pos.x; @@ -704,7 +694,6 @@ void OS_JavaScript::process_touch(int p_what, int p_pointer, const Vector<TouchP InputEvent ev; ev.type = InputEvent::SCREEN_TOUCH; - ev.ID = last_id++; ev.screen_touch.index = touch[i].id; ev.screen_touch.pressed = false; ev.screen_touch.x = touch[i].pos.x; @@ -761,7 +750,7 @@ String OS_JavaScript::get_data_dir() const { String OS_JavaScript::get_executable_path() const { - return String(); + return OS::get_executable_path(); } void OS_JavaScript::_close_notification_funcs(const String &p_file, int p_flags) { @@ -790,9 +779,9 @@ void OS_JavaScript::process_joypads() { InputDefault::JoyAxis jx; jx.min = 0; jx.value = value; - last_id = input->joy_axis(last_id, i, j, jx); + input->joy_axis(i, j, jx); } else { - last_id = input->joy_button(last_id, i, j, value); + input->joy_button(i, j, value); } } for (int j = 0; j < num_axes; j++) { @@ -800,7 +789,7 @@ void OS_JavaScript::process_joypads() { InputDefault::JoyAxis jx; jx.min = -1; jx.value = state.axis[j]; - last_id = input->joy_axis(last_id, i, j, jx); + input->joy_axis(i, j, jx); } } } @@ -839,12 +828,12 @@ int OS_JavaScript::get_power_percent_left() { return power_manager->get_power_percent_left(); } -OS_JavaScript::OS_JavaScript(GFXInitFunc p_gfx_init_func, void *p_gfx_init_ud, GetDataDirFunc p_get_data_dir_func) { +OS_JavaScript::OS_JavaScript(const char *p_execpath, GFXInitFunc p_gfx_init_func, void *p_gfx_init_ud, GetDataDirFunc p_get_data_dir_func) { + set_cmdline(p_execpath, get_cmdline_args()); gfx_init_func = p_gfx_init_func; gfx_init_ud = p_gfx_init_ud; last_button_mask = 0; main_loop = NULL; - last_id = 1; gl_extensions = NULL; window_maximized = false; diff --git a/platform/javascript/os_javascript.h b/platform/javascript/os_javascript.h index b16918b2da..1bf001e46f 100644 --- a/platform/javascript/os_javascript.h +++ b/platform/javascript/os_javascript.h @@ -58,7 +58,6 @@ private: Vector<TouchPos> touch; Point2 last_mouse; int last_button_mask; - unsigned int last_id; GFXInitFunc gfx_init_func; void *gfx_init_ud; @@ -177,7 +176,7 @@ public: virtual int get_power_seconds_left(); virtual int get_power_percent_left(); - OS_JavaScript(GFXInitFunc p_gfx_init_func, void *p_gfx_init_ud, GetDataDirFunc p_get_data_dir_func); + OS_JavaScript(const char *p_execpath, GFXInitFunc p_gfx_init_func, void *p_gfx_init_ud, GetDataDirFunc p_get_data_dir_func); ~OS_JavaScript(); }; diff --git a/platform/osx/detect.py b/platform/osx/detect.py index b59dfe1afb..39ee33ae82 100644 --- a/platform/osx/detect.py +++ b/platform/osx/detect.py @@ -51,7 +51,7 @@ def configure(env): elif (env["target"] == "debug"): - env.Append(CCFLAGS=['-g3', '-Wall', '-DDEBUG_ENABLED', '-DDEBUG_MEMORY_ENABLED']) + env.Append(CCFLAGS=['-g3', '-DDEBUG_ENABLED', '-DDEBUG_MEMORY_ENABLED']) if (not os.environ.has_key("OSXCROSS_ROOT")): # regular native build diff --git a/platform/osx/joypad_osx.cpp b/platform/osx/joypad_osx.cpp index c2b0e1f052..7b77f3bb68 100644 --- a/platform/osx/joypad_osx.cpp +++ b/platform/osx/joypad_osx.cpp @@ -458,7 +458,7 @@ static const InputDefault::JoyAxis axis_correct(int p_value, int p_min, int p_ma return jx; } -uint32_t JoypadOSX::process_joypads(uint32_t p_last_id) { +void JoypadOSX::process_joypads() { poll_joypads(); for (int i = 0; i < device_list.size(); i++) { @@ -467,17 +467,17 @@ uint32_t JoypadOSX::process_joypads(uint32_t p_last_id) { for (int j = 0; j < joy.axis_elements.size(); j++) { rec_element &elem = joy.axis_elements[j]; int value = joy.get_hid_element_state(&elem); - p_last_id = input->joy_axis(p_last_id, joy.id, j, axis_correct(value, elem.min, elem.max)); + input->joy_axis(joy.id, j, axis_correct(value, elem.min, elem.max)); } for (int j = 0; j < joy.button_elements.size(); j++) { int value = joy.get_hid_element_state(&joy.button_elements[j]); - p_last_id = input->joy_button(p_last_id, joy.id, j, (value >= 1)); + input->joy_button(joy.id, j, (value >= 1)); } for (int j = 0; j < joy.hat_elements.size(); j++) { rec_element &elem = joy.hat_elements[j]; int value = joy.get_hid_element_state(&elem); int hat_value = process_hat_value(elem.min, elem.max, value); - p_last_id = input->joy_hat(p_last_id, joy.id, hat_value); + input->joy_hat(joy.id, hat_value); } if (joy.ffservice) { @@ -494,7 +494,6 @@ uint32_t JoypadOSX::process_joypads(uint32_t p_last_id) { } } } - return p_last_id; } void JoypadOSX::joypad_vibration_start(int p_id, float p_magnitude, float p_duration, uint64_t p_timestamp) { diff --git a/platform/osx/joypad_osx.h b/platform/osx/joypad_osx.h index dabd1b8aec..e565f4f46d 100644 --- a/platform/osx/joypad_osx.h +++ b/platform/osx/joypad_osx.h @@ -110,7 +110,7 @@ private: void joypad_vibration_stop(int p_id, uint64_t p_timestamp); public: - uint32_t process_joypads(uint32_t p_last_id); + void process_joypads(); void _device_added(IOReturn p_res, IOHIDDeviceRef p_device); void _device_removed(int p_id); diff --git a/platform/osx/os_osx.h b/platform/osx/os_osx.h index 2c7ad09b89..8676c86131 100644 --- a/platform/osx/os_osx.h +++ b/platform/osx/os_osx.h @@ -61,7 +61,6 @@ public: List<String> args; MainLoop *main_loop; - unsigned int event_id; PhysicsServer *physics_server; Physics2DServer *physics_2d_server; @@ -83,7 +82,6 @@ public: // pthread_key_t current; bool mouse_grab; Point2 mouse_pos; - uint32_t last_id; id delegate; id window_delegate; diff --git a/platform/osx/os_osx.mm b/platform/osx/os_osx.mm index 0699978caf..8411bdb114 100644 --- a/platform/osx/os_osx.mm +++ b/platform/osx/os_osx.mm @@ -1698,7 +1698,6 @@ void OS_OSX::process_events() { void OS_OSX::push_input(const InputEvent& p_event) { InputEvent ev=p_event; - ev.ID=last_id++; //print_line("EV: "+String(ev)); input->parse_input_event(ev); } @@ -1725,7 +1724,7 @@ void OS_OSX::run() { while (!force_quit) { process_events(); // get rid of pending events - last_id = joypad_osx->process_joypads(last_id); + joypad_osx->process_joypads(); if (Main::iteration()==true) break; }; @@ -1822,7 +1821,6 @@ OS_OSX::OS_OSX() { [NSApp setDelegate:delegate]; - last_id=1; cursor_shape=CURSOR_ARROW; current_screen = 0; diff --git a/platform/server/detect.py b/platform/server/detect.py index 8bc85f342d..32f3c55135 100644 --- a/platform/server/detect.py +++ b/platform/server/detect.py @@ -64,7 +64,7 @@ def configure(env): elif (env["target"] == "debug"): - env.Append(CCFLAGS=['-g2', '-Wall', '-DDEBUG_ENABLED', '-DDEBUG_MEMORY_ENABLED']) + env.Append(CCFLAGS=['-g2', '-DDEBUG_ENABLED', '-DDEBUG_MEMORY_ENABLED']) # Shared libraries, when requested diff --git a/platform/uwp/export/export.cpp b/platform/uwp/export/export.cpp index a9b26056fc..bef19d80ae 100644 --- a/platform/uwp/export/export.cpp +++ b/platform/uwp/export/export.cpp @@ -1032,7 +1032,7 @@ void AppxPackager::finish() { Error err = read_cert_file(certificate_path, certificate_pass, &cert_file); if (err != OK) { - EditorNode::add_io_error(TTR("Couldn't read the certficate file. Are the path and password both correct?")); + EditorNode::add_io_error(TTR("Couldn't read the certificate file. Are the path and password both correct?")); package->close(); memdelete(package); package = NULL; diff --git a/platform/uwp/joypad_uwp.cpp b/platform/uwp/joypad_uwp.cpp index dd57ed94ae..7860994a79 100644 --- a/platform/uwp/joypad_uwp.cpp +++ b/platform/uwp/joypad_uwp.cpp @@ -40,7 +40,7 @@ void JoypadUWP::register_events() { ref new EventHandler<Gamepad ^>(this, &JoypadUWP::OnGamepadRemoved); } -uint32_t JoypadUWP::process_controllers(uint32_t p_last_id) { +void JoypadUWP::process_controllers() { for (int i = 0; i < MAX_CONTROLLERS; i++) { @@ -55,23 +55,21 @@ uint32_t JoypadUWP::process_controllers(uint32_t p_last_id) { int button_mask = (int)GamepadButtons::Menu; for (int j = 0; j < 14; j++) { - p_last_id = input->joy_button(p_last_id, controllers[i].id, j, (int)reading.Buttons & button_mask); + input->joy_button(controllers[i].id, j, (int)reading.Buttons & button_mask); button_mask *= 2; } - p_last_id = input->joy_axis(p_last_id, controllers[i].id, JOY_AXIS_0, axis_correct(reading.LeftThumbstickX)); - p_last_id = input->joy_axis(p_last_id, controllers[i].id, JOY_AXIS_1, axis_correct(reading.LeftThumbstickY, true)); - p_last_id = input->joy_axis(p_last_id, controllers[i].id, JOY_AXIS_2, axis_correct(reading.RightThumbstickX)); - p_last_id = input->joy_axis(p_last_id, controllers[i].id, JOY_AXIS_3, axis_correct(reading.RightThumbstickY, true)); - p_last_id = input->joy_axis(p_last_id, controllers[i].id, JOY_AXIS_4, axis_correct(reading.LeftTrigger, false, true)); - p_last_id = input->joy_axis(p_last_id, controllers[i].id, JOY_AXIS_5, axis_correct(reading.RightTrigger, false, true)); + input->joy_axis(controllers[i].id, JOY_AXIS_0, axis_correct(reading.LeftThumbstickX)); + input->joy_axis(controllers[i].id, JOY_AXIS_1, axis_correct(reading.LeftThumbstickY, true)); + input->joy_axis(controllers[i].id, JOY_AXIS_2, axis_correct(reading.RightThumbstickX)); + input->joy_axis(controllers[i].id, JOY_AXIS_3, axis_correct(reading.RightThumbstickY, true)); + input->joy_axis(controllers[i].id, JOY_AXIS_4, axis_correct(reading.LeftTrigger, false, true)); + input->joy_axis(controllers[i].id, JOY_AXIS_5, axis_correct(reading.RightTrigger, false, true)); break; } } } - - return p_last_id; } JoypadUWP::JoypadUWP() { diff --git a/platform/uwp/joypad_uwp.h b/platform/uwp/joypad_uwp.h index e5a961e70e..a2572eae3d 100644 --- a/platform/uwp/joypad_uwp.h +++ b/platform/uwp/joypad_uwp.h @@ -37,7 +37,7 @@ ref class JoypadUWP sealed { /* clang-format off */ internal: void register_events(); - uint32_t process_controllers(uint32_t p_last_id); + void process_controllers(); /* clang-format on */ JoypadUWP(); diff --git a/platform/uwp/os_uwp.cpp b/platform/uwp/os_uwp.cpp index 19ed2b57a3..907156d280 100644 --- a/platform/uwp/os_uwp.cpp +++ b/platform/uwp/os_uwp.cpp @@ -344,15 +344,12 @@ String OSUWP::get_clipboard() const { void OSUWP::input_event(InputEvent &p_event) { - p_event.ID = ++last_id; - input->parse_input_event(p_event); if (p_event.type == InputEvent::MOUSE_BUTTON && p_event.mouse_button.pressed && p_event.mouse_button.button_index > 3) { //send release for mouse wheel p_event.mouse_button.pressed = false; - p_event.ID = ++last_id; input->parse_input_event(p_event); } }; @@ -680,7 +677,7 @@ uint64_t OSUWP::get_ticks_usec() const { void OSUWP::process_events() { - last_id = joypad->process_controllers(last_id); + joypad->process_controllers(); process_key_events(); } @@ -907,7 +904,6 @@ OSUWP::OSUWP() { pressrc = 0; old_invalid = true; - last_id = 0; mouse_mode = MOUSE_MODE_VISIBLE; #ifdef STDOUT_FILE stdo = fopen("stdout.txt", "wb"); diff --git a/platform/uwp/os_uwp.h b/platform/uwp/os_uwp.h index ebbb8af39c..95b834acc4 100644 --- a/platform/uwp/os_uwp.h +++ b/platform/uwp/os_uwp.h @@ -92,7 +92,6 @@ private: bool outside; int old_x, old_y; Point2i center; - unsigned int last_id; VisualServer *visual_server; Rasterizer *rasterizer; PhysicsServer *physics_server; diff --git a/platform/windows/context_gl_win.cpp b/platform/windows/context_gl_win.cpp index d737502bf5..449ac264a6 100644 --- a/platform/windows/context_gl_win.cpp +++ b/platform/windows/context_gl_win.cpp @@ -169,7 +169,7 @@ Error ContextGL_Win::initialize() { if (wglCreateContextAttribsARB == NULL) //OpenGL 3.0 is not supported { - MessageBox(NULL, "Cannot get Proc Adress for CreateContextAttribs", "ERROR", MB_OK | MB_ICONEXCLAMATION); + MessageBox(NULL, "Cannot get Proc Address for CreateContextAttribs", "ERROR", MB_OK | MB_ICONEXCLAMATION); wglDeleteContext(hRC); return ERR_CANT_CREATE; } diff --git a/platform/windows/detect.py b/platform/windows/detect.py index 382783d6bc..6080c6f1dc 100644 --- a/platform/windows/detect.py +++ b/platform/windows/detect.py @@ -283,7 +283,7 @@ def configure(env): + " will be executed and inform you.") sys.exit() - # Forcing bits argument because MSVC does not have a flag to set this through SCons... it's different compilers (cl.exe's) called from the propper command prompt + # Forcing bits argument because MSVC does not have a flag to set this through SCons... it's different compilers (cl.exe's) called from the proper command prompt # that decide the architecture that is build for. Scons can only detect the os.getenviron (because vsvarsall.bat sets a lot of stuff for cl.exe to work with) env["bits"] = "32" env["x86_libtheora_opt_vc"] = True @@ -361,7 +361,7 @@ def configure(env): elif (env["target"] == "debug"): - env.Append(CCFLAGS=['-g', '-Wall', '-DDEBUG_ENABLED', '-DDEBUG_MEMORY_ENABLED']) + env.Append(CCFLAGS=['-g', '-DDEBUG_ENABLED', '-DDEBUG_MEMORY_ENABLED']) env["CC"] = mingw_prefix + "gcc" env['AS'] = mingw_prefix + "as" diff --git a/platform/windows/joypad.cpp b/platform/windows/joypad.cpp index 2472940ef3..86f7033d40 100644 --- a/platform/windows/joypad.cpp +++ b/platform/windows/joypad.cpp @@ -319,7 +319,7 @@ void JoypadWindows::probe_joypads() { } } -unsigned int JoypadWindows::process_joypads(unsigned int p_last_id) { +void JoypadWindows::process_joypads() { HRESULT hr; @@ -337,16 +337,16 @@ unsigned int JoypadWindows::process_joypads(unsigned int p_last_id) { int button_mask = XINPUT_GAMEPAD_DPAD_UP; for (int i = 0; i <= 16; i++) { - p_last_id = input->joy_button(p_last_id, joy.id, i, joy.state.Gamepad.wButtons & button_mask); + input->joy_button(joy.id, i, joy.state.Gamepad.wButtons & button_mask); button_mask = button_mask * 2; } - p_last_id = input->joy_axis(p_last_id, joy.id, JOY_AXIS_0, axis_correct(joy.state.Gamepad.sThumbLX, true)); - p_last_id = input->joy_axis(p_last_id, joy.id, JOY_AXIS_1, axis_correct(joy.state.Gamepad.sThumbLY, true, false, true)); - p_last_id = input->joy_axis(p_last_id, joy.id, JOY_AXIS_2, axis_correct(joy.state.Gamepad.sThumbRX, true)); - p_last_id = input->joy_axis(p_last_id, joy.id, JOY_AXIS_3, axis_correct(joy.state.Gamepad.sThumbRY, true, false, true)); - p_last_id = input->joy_axis(p_last_id, joy.id, JOY_AXIS_4, axis_correct(joy.state.Gamepad.bLeftTrigger, true, true)); - p_last_id = input->joy_axis(p_last_id, joy.id, JOY_AXIS_5, axis_correct(joy.state.Gamepad.bRightTrigger, true, true)); + input->joy_axis(joy.id, JOY_AXIS_0, axis_correct(joy.state.Gamepad.sThumbLX, true)); + input->joy_axis(joy.id, JOY_AXIS_1, axis_correct(joy.state.Gamepad.sThumbLY, true, false, true)); + input->joy_axis(joy.id, JOY_AXIS_2, axis_correct(joy.state.Gamepad.sThumbRX, true)); + input->joy_axis(joy.id, JOY_AXIS_3, axis_correct(joy.state.Gamepad.sThumbRY, true, false, true)); + input->joy_axis(joy.id, JOY_AXIS_4, axis_correct(joy.state.Gamepad.bLeftTrigger, true, true)); + input->joy_axis(joy.id, JOY_AXIS_5, axis_correct(joy.state.Gamepad.bRightTrigger, true, true)); joy.last_packet = joy.state.dwPacketNumber; } uint64_t timestamp = input->get_joy_vibration_timestamp(joy.id); @@ -384,7 +384,7 @@ unsigned int JoypadWindows::process_joypads(unsigned int p_last_id) { continue; } - p_last_id = post_hat(p_last_id, joy->id, js.rgdwPOV[0]); + post_hat(joy->id, js.rgdwPOV[0]); for (int j = 0; j < 128; j++) { @@ -392,14 +392,14 @@ unsigned int JoypadWindows::process_joypads(unsigned int p_last_id) { if (!joy->last_buttons[j]) { - p_last_id = input->joy_button(p_last_id, joy->id, j, true); + input->joy_button(joy->id, j, true); joy->last_buttons[j] = true; } } else { if (joy->last_buttons[j]) { - p_last_id = input->joy_button(p_last_id, joy->id, j, false); + input->joy_button(joy->id, j, false); joy->last_buttons[j] = false; } } @@ -414,16 +414,16 @@ unsigned int JoypadWindows::process_joypads(unsigned int p_last_id) { for (int k = 0; k < count; k++) { if (joy->joy_axis[j] == axes[k]) { - p_last_id = input->joy_axis(p_last_id, joy->id, j, axis_correct(values[k])); + input->joy_axis(joy->id, j, axis_correct(values[k])); break; }; }; }; } - return p_last_id; + return; } -unsigned int JoypadWindows::post_hat(unsigned int p_last_id, int p_device, DWORD p_dpad) { +void JoypadWindows::post_hat(int p_device, DWORD p_dpad) { int dpad_val = 0; @@ -462,7 +462,7 @@ unsigned int JoypadWindows::post_hat(unsigned int p_last_id, int p_device, DWORD dpad_val = (InputDefault::HAT_MASK_LEFT | InputDefault::HAT_MASK_UP); } - return input->joy_hat(p_last_id, p_device, dpad_val); + input->joy_hat(p_device, dpad_val); }; InputDefault::JoyAxis JoypadWindows::axis_correct(int p_val, bool p_xinput, bool p_trigger, bool p_negate) const { diff --git a/platform/windows/joypad.h b/platform/windows/joypad.h index 7e4f6ff328..9e6aa41a34 100644 --- a/platform/windows/joypad.h +++ b/platform/windows/joypad.h @@ -53,7 +53,7 @@ public: ~JoypadWindows(); void probe_joypads(); - unsigned int process_joypads(unsigned int p_last_id); + void process_joypads(); private: enum { @@ -130,7 +130,7 @@ private: void load_xinput(); void unload_xinput(); - unsigned int post_hat(unsigned int p_last_id, int p_device, DWORD p_dpad); + void post_hat(int p_device, DWORD p_dpad); bool have_device(const GUID &p_guid); bool is_xinput_device(const GUID *p_guid); diff --git a/platform/windows/os_windows.cpp b/platform/windows/os_windows.cpp index 2046ae9f44..83a6aa6079 100644 --- a/platform/windows/os_windows.cpp +++ b/platform/windows/os_windows.cpp @@ -216,7 +216,6 @@ void OS_Windows::_touch_event(bool p_pressed, int p_x, int p_y, int idx) { InputEvent event; event.type = InputEvent::SCREEN_TOUCH; - event.ID = ++last_id; event.screen_touch.index = idx; event.screen_touch.pressed = p_pressed; @@ -233,7 +232,6 @@ void OS_Windows::_drag_event(int p_x, int p_y, int idx) { InputEvent event; event.type = InputEvent::SCREEN_DRAG; - event.ID = ++last_id; event.screen_drag.index = idx; event.screen_drag.x = p_x; @@ -370,7 +368,6 @@ LRESULT OS_Windows::WndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam) InputEvent event; event.type = InputEvent::MOUSE_MOTION; - event.ID = ++last_id; InputEventMouseMotion &mm = event.mouse_motion; mm.mod.control = (wParam & MK_CONTROL) != 0; @@ -451,7 +448,6 @@ LRESULT OS_Windows::WndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam) InputEvent event; event.type = InputEvent::MOUSE_BUTTON; - event.ID = ++last_id; InputEventMouseButton &mb = event.mouse_button; switch (uMsg) { @@ -582,7 +578,6 @@ LRESULT OS_Windows::WndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam) if (mb.pressed && mb.button_index > 3) { //send release for mouse wheel mb.pressed = false; - event.ID = ++last_id; input->parse_input_event(event); } } @@ -780,7 +775,6 @@ void OS_Windows::process_key_events() { if ((i == 0 && ke.uMsg == WM_CHAR) || (i > 0 && key_event_buffer[i - 1].uMsg == WM_CHAR)) { InputEvent event; event.type = InputEvent::KEY; - event.ID = ++last_id; InputEventKey &k = event.key; k.mod = ke.mod_state; @@ -805,7 +799,6 @@ void OS_Windows::process_key_events() { InputEvent event; event.type = InputEvent::KEY; - event.ID = ++last_id; InputEventKey &k = event.key; k.mod = ke.mod_state; @@ -1819,7 +1812,7 @@ void OS_Windows::process_events() { MSG msg; - last_id = joypad->process_joypads(last_id); + joypad->process_joypads(); while (PeekMessageW(&msg, NULL, 0, 0, PM_REMOVE)) { @@ -2174,6 +2167,9 @@ void OS_Windows::run() { if (!main_loop) return; + // Process all events before the main initialization so the cursor will get initialized properly + process_events(); // get rid of pending events + main_loop->init(); uint64_t last_ticks = get_ticks_usec(); @@ -2303,7 +2299,6 @@ OS_Windows::OS_Windows(HINSTANCE _hInstance) { hInstance = _hInstance; pressrc = 0; old_invalid = true; - last_id = 0; mouse_mode = MOUSE_MODE_VISIBLE; #ifdef STDOUT_FILE stdo = fopen("stdout.txt", "wb"); diff --git a/platform/windows/os_windows.h b/platform/windows/os_windows.h index e7376d6800..25c3102ee6 100644 --- a/platform/windows/os_windows.h +++ b/platform/windows/os_windows.h @@ -83,7 +83,6 @@ class OS_Windows : public OS { bool outside; int old_x, old_y; Point2i center; - unsigned int last_id; #if defined(OPENGL_ENABLED) ContextGL_Win *gl_context; #endif diff --git a/platform/windows/packet_peer_udp_winsock.cpp b/platform/windows/packet_peer_udp_winsock.cpp index 2df8addece..d98b64df7c 100644 --- a/platform/windows/packet_peer_udp_winsock.cpp +++ b/platform/windows/packet_peer_udp_winsock.cpp @@ -82,7 +82,7 @@ Error PacketPeerUDPWinsock::put_packet(const uint8_t *p_buffer, int p_buffer_siz struct sockaddr_storage addr; size_t addr_size = _set_sockaddr(&addr, peer_addr, peer_port, sock_type); - _set_blocking(true); + _set_sock_blocking(blocking); errno = 0; int err; @@ -90,7 +90,9 @@ Error PacketPeerUDPWinsock::put_packet(const uint8_t *p_buffer, int p_buffer_siz if (WSAGetLastError() != WSAEWOULDBLOCK) { return FAILED; - }; + } else if (!blocking) { + return ERR_UNAVAILABLE; + } } return OK; @@ -101,15 +103,13 @@ int PacketPeerUDPWinsock::get_max_packet_size() const { return 512; // uhm maybe not } -void PacketPeerUDPWinsock::_set_blocking(bool p_blocking) { - //am no windows expert - //hope this is the right thing +void PacketPeerUDPWinsock::_set_sock_blocking(bool p_blocking) { - if (blocking == p_blocking) + if (sock_blocking == p_blocking) return; - blocking = p_blocking; - unsigned long par = blocking ? 0 : 1; + sock_blocking = p_blocking; + unsigned long par = sock_blocking ? 0 : 1; if (ioctlsocket(sockfd, FIONBIO, &par)) { perror("setting non-block mode"); //close(); @@ -139,8 +139,6 @@ Error PacketPeerUDPWinsock::listen(int p_port, IP_Address p_bind_address, int p_ return ERR_UNAVAILABLE; } - blocking = true; - printf("UDP Connection listening on port %i\n", p_port); rb.resize(nearest_shift(p_recv_buffer_size)); return OK; @@ -166,7 +164,7 @@ Error PacketPeerUDPWinsock::_poll(bool p_wait) { return FAILED; } - _set_blocking(p_wait); + _set_sock_blocking(p_wait); struct sockaddr_storage from = { 0 }; int len = sizeof(struct sockaddr_storage); @@ -252,6 +250,9 @@ int PacketPeerUDPWinsock::_get_socket() { sockfd = _socket_create(sock_type, SOCK_DGRAM, IPPROTO_UDP); + if (sockfd != -1) + _set_sock_blocking(false); + return sockfd; } @@ -273,6 +274,8 @@ PacketPeerUDP *PacketPeerUDPWinsock::_create() { PacketPeerUDPWinsock::PacketPeerUDPWinsock() { + blocking = true; + sock_blocking = true; sockfd = -1; packet_port = 0; queue_count = 0; diff --git a/platform/windows/packet_peer_udp_winsock.h b/platform/windows/packet_peer_udp_winsock.h index 62107364af..6b37aefead 100644 --- a/platform/windows/packet_peer_udp_winsock.h +++ b/platform/windows/packet_peer_udp_winsock.h @@ -45,6 +45,7 @@ class PacketPeerUDPWinsock : public PacketPeerUDP { mutable int packet_port; mutable int queue_count; int sockfd; + bool sock_blocking; IP::Type sock_type; IP_Address peer_addr; @@ -54,8 +55,7 @@ class PacketPeerUDPWinsock : public PacketPeerUDP { static PacketPeerUDP *_create(); - bool blocking; - void _set_blocking(bool p_blocking); + void _set_sock_blocking(bool p_blocking); Error _poll(bool p_wait); diff --git a/platform/x11/detect.py b/platform/x11/detect.py index 89cf639114..34306c8d0f 100644 --- a/platform/x11/detect.py +++ b/platform/x11/detect.py @@ -133,7 +133,7 @@ def configure(env): elif (env["target"] == "debug"): - env.Prepend(CCFLAGS=['-g2', '-Wall', '-DDEBUG_ENABLED', '-DDEBUG_MEMORY_ENABLED']) + env.Prepend(CCFLAGS=['-g2', '-DDEBUG_ENABLED', '-DDEBUG_MEMORY_ENABLED']) env.ParseConfig('pkg-config x11 --cflags --libs') env.ParseConfig('pkg-config xinerama --cflags --libs') @@ -227,7 +227,7 @@ def configure(env): env.Append(LIBS=['dl']) # env.Append(CPPFLAGS=['-DMPC_FIXED_POINT']) -# host compiler is default.. + # host compiler is default.. if (is64 and env["bits"] == "32"): env.Append(CPPFLAGS=['-m32']) diff --git a/platform/x11/joypad_linux.cpp b/platform/x11/joypad_linux.cpp index 62ece58f58..db4a501b4c 100644 --- a/platform/x11/joypad_linux.cpp +++ b/platform/x11/joypad_linux.cpp @@ -454,10 +454,10 @@ InputDefault::JoyAxis JoypadLinux::axis_correct(const input_absinfo *p_abs, int return jx; } -uint32_t JoypadLinux::process_joypads(uint32_t p_event_id) { +void JoypadLinux::process_joypads() { if (joy_mutex->try_lock() != OK) { - return p_event_id; + return; } for (int i = 0; i < JOYPADS_MAX; i++) { @@ -477,11 +477,11 @@ uint32_t JoypadLinux::process_joypads(uint32_t p_event_id) { // ev may be tainted and out of MAX_KEY range, which will cause // joy->key_map[ev.code] to crash if (ev.code < 0 || ev.code >= MAX_KEY) - return p_event_id; + return; switch (ev.type) { case EV_KEY: - p_event_id = input->joy_button(p_event_id, i, joy->key_map[ev.code], ev.value); + input->joy_button(i, joy->key_map[ev.code], ev.value); break; case EV_ABS: @@ -496,7 +496,7 @@ uint32_t JoypadLinux::process_joypads(uint32_t p_event_id) { } else joy->dpad &= ~(InputDefault::HAT_MASK_LEFT | InputDefault::HAT_MASK_RIGHT); - p_event_id = input->joy_hat(p_event_id, i, joy->dpad); + input->joy_hat(i, joy->dpad); break; case ABS_HAT0Y: @@ -508,7 +508,7 @@ uint32_t JoypadLinux::process_joypads(uint32_t p_event_id) { } else joy->dpad &= ~(InputDefault::HAT_MASK_UP | InputDefault::HAT_MASK_DOWN); - p_event_id = input->joy_hat(p_event_id, i, joy->dpad); + input->joy_hat(i, joy->dpad); break; default: @@ -525,7 +525,7 @@ uint32_t JoypadLinux::process_joypads(uint32_t p_event_id) { for (int j = 0; j < MAX_ABS; j++) { int index = joy->abs_map[j]; if (index != -1) { - p_event_id = input->joy_axis(p_event_id, i, index, joy->curr_axis[index]); + input->joy_axis(i, index, joy->curr_axis[index]); } } if (len == 0 || (len < 0 && errno != EAGAIN)) { @@ -546,6 +546,5 @@ uint32_t JoypadLinux::process_joypads(uint32_t p_event_id) { } } joy_mutex->unlock(); - return p_event_id; } #endif diff --git a/platform/x11/joypad_linux.h b/platform/x11/joypad_linux.h index f90ca9319a..7b8ebf5bc3 100644 --- a/platform/x11/joypad_linux.h +++ b/platform/x11/joypad_linux.h @@ -42,7 +42,7 @@ class JoypadLinux { public: JoypadLinux(InputDefault *in); ~JoypadLinux(); - uint32_t process_joypads(uint32_t p_event_id); + void process_joypads(); private: enum { diff --git a/platform/x11/os_x11.cpp b/platform/x11/os_x11.cpp index d7cb69f2b9..4606a90835 100644 --- a/platform/x11/os_x11.cpp +++ b/platform/x11/os_x11.cpp @@ -94,7 +94,6 @@ void OS_X11::initialize(const VideoMode &p_desired, int p_video_driver, int p_au last_button_state = 0; xmbstring = NULL; - event_id = 0; x11_window = 0; last_click_ms = 0; args = OS::get_singleton()->get_cmdline_args(); @@ -1019,7 +1018,7 @@ void OS_X11::handle_key_event(XKeyEvent *p_event, bool p_echo) { // XKeycodeToKeysym to obtain internationalized // input.. WRONG!! // you must use XLookupString (???) which not only wastes - // cycles generating an unnecesary string, but also + // cycles generating an unnecessary string, but also // still works in half the cases. (won't handle deadkeys) // For more complex input methods (deadkeys and more advanced) // you have to use XmbLookupString (??). @@ -1075,7 +1074,7 @@ void OS_X11::handle_key_event(XKeyEvent *p_event, bool p_echo) { /* Phase 4, determine if event must be filtered */ // This seems to be a side-effect of using XIM. - // XEventFilter looks like a core X11 funciton, + // XEventFilter looks like a core X11 function, // but it's actually just used to see if we must // ignore a deadkey, or events XIM determines // must not reach the actual gui. @@ -1143,7 +1142,6 @@ void OS_X11::handle_key_event(XKeyEvent *p_event, bool p_echo) { /* Phase 7, send event to Window */ InputEvent event; - event.ID = ++event_id; event.type = InputEvent::KEY; event.device = 0; event.key.mod = state; @@ -1157,7 +1155,7 @@ void OS_X11::handle_key_event(XKeyEvent *p_event, bool p_echo) { event.key.echo = p_echo; if (event.key.scancode == KEY_BACKTAB) { - //make it consistent accross platforms. + //make it consistent across platforms. event.key.scancode = KEY_TAB; event.key.mod.shift = true; } @@ -1279,8 +1277,12 @@ void OS_X11::process_xevents() { case EnterNotify: { if (main_loop && !mouse_mode_grab) main_loop->notification(MainLoop::NOTIFICATION_WM_MOUSE_ENTER); - if (input) + if (input) { + // Update mouse position. It is triggered before mouse motion. + Point2i pos(event.xmotion.x, event.xmotion.y); + input->set_mouse_pos(pos); input->set_mouse_in_window(true); + } } break; case FocusIn: minimized = false; @@ -1334,7 +1336,6 @@ void OS_X11::process_xevents() { } InputEvent mouse_event; - mouse_event.ID = ++event_id; mouse_event.type = InputEvent::MOUSE_BUTTON; mouse_event.device = 0; mouse_event.mouse_button.mod = get_key_modifier_state(event.xbutton.state); @@ -1360,7 +1361,6 @@ void OS_X11::process_xevents() { last_click_ms = 0; last_click_pos = Point2(-100, -100); mouse_event.mouse_button.doubleclick = true; - mouse_event.ID = ++event_id; } else { last_click_ms += diff; @@ -1447,7 +1447,6 @@ void OS_X11::process_xevents() { Point2i rel = pos - last_mouse_pos; InputEvent motion_event; - motion_event.ID = ++event_id; motion_event.type = InputEvent::MOUSE_MOTION; motion_event.device = 0; @@ -1905,6 +1904,9 @@ void OS_X11::run() { if (!main_loop) return; + // Process all events before the main initialization so the cursor will get initialized properly + process_xevents(); // get rid of pending events + main_loop->init(); //uint64_t last_ticks=get_ticks_usec(); @@ -1916,7 +1918,7 @@ void OS_X11::run() { process_xevents(); // get rid of pending events #ifdef JOYDEV_ENABLED - event_id = joypad->process_joypads(event_id); + joypad->process_joypads(); #endif if (Main::iteration() == true) break; diff --git a/platform/x11/os_x11.h b/platform/x11/os_x11.h index cbda18c0bc..b5a74c68b8 100644 --- a/platform/x11/os_x11.h +++ b/platform/x11/os_x11.h @@ -116,7 +116,6 @@ class OS_X11 : public OS_Unix { bool last_mouse_pos_valid; Point2i last_click_pos; uint64_t last_click_ms; - unsigned int event_id; uint32_t last_button_state; PhysicsServer *physics_server; |