Team-Immerse-Yourself/YouDunIt
6
0
Fork 0
Code Issues Pull requests Projects 2 Releases Packages Wiki Activity Actions

feat: modules moved and engine moved to submodule

Browse source
This commit is contained in:
Jan van der Weide 2025-04-12 18:40:44 +02:00
parent dfb5e645cd
commit c33d2130cc
5136 changed files with 225275 additions and 64485 deletions
Download patch file Download diff file Expand all files Collapse all files

531
engine/platform/android/java_class_wrapper.cpp
View file

@ -108,18 +108,21 @@ bool JavaClass::_call_method(JavaObject *p_instance, const StringName &p_method,
}
} break;
case ARG_TYPE_CLASS: {
if (p_args[i]->get_type() != Variant::OBJECT && p_args[i]->get_type() != Variant::NIL) {
String cn = E.param_sigs[i].operator String();
if (cn.begins_with("L") && cn.ends_with(";")) {
cn = cn.substr(1, cn.length() - 2);
}
if (cn == "org/godotengine/godot/Dictionary") {
if (p_args[i]->get_type() != Variant::DICTIONARY) {
arg_expected = Variant::DICTIONARY;
}
} else if (p_args[i]->get_type() != Variant::OBJECT && p_args[i]->get_type() != Variant::NIL) {
arg_expected = Variant::OBJECT;
} else {
Ref<RefCounted> ref = *p_args[i];
if (ref.is_valid()) {
if (Object::cast_to<JavaObject>(ref.ptr())) {
Ref<JavaObject> jo = ref;
//could be faster
String cn = E.param_sigs[i].operator String();
if (cn.begins_with("L") && cn.ends_with(";")) {
cn = cn.substr(1, cn.length() - 2);
}
jclass c = env->FindClass(cn.utf8().get_data());
if (!c || !env->IsInstanceOf(jo->instance, c)) {
arg_expected = Variant::OBJECT;
@ -132,6 +135,116 @@ bool JavaClass::_call_method(JavaObject *p_instance, const StringName &p_method,
}
}
} break;
case ARG_ARRAY_BIT | ARG_TYPE_BOOLEAN: {
if (p_args[i]->get_type() == Variant::ARRAY) {
Array arr = *p_args[i];
if (arr.is_typed() && arr.get_typed_builtin() != Variant::BOOL) {
arg_expected = Variant::ARRAY;
}
} else {
arg_expected = Variant::ARRAY;
}
} break;
case ARG_ARRAY_BIT | ARG_TYPE_BYTE:
case ARG_ARRAY_BIT | ARG_TYPE_CHAR: {
if (p_args[i]->get_type() != Variant::PACKED_BYTE_ARRAY) {
arg_expected = Variant::PACKED_BYTE_ARRAY;
}
} break;
case ARG_ARRAY_BIT | ARG_TYPE_SHORT:
case ARG_ARRAY_BIT | ARG_TYPE_INT: {
if (p_args[i]->get_type() == Variant::ARRAY) {
Array arr = *p_args[i];
if (arr.is_typed() && arr.get_typed_builtin() != Variant::INT) {
arg_expected = Variant::ARRAY;
}
} else if (p_args[i]->get_type() != Variant::PACKED_INT32_ARRAY) {
arg_expected = Variant::ARRAY;
}
} break;
case ARG_ARRAY_BIT | ARG_TYPE_LONG: {
if (p_args[i]->get_type() == Variant::ARRAY) {
Array arr = *p_args[i];
if (arr.is_typed() && arr.get_typed_builtin() != Variant::INT) {
arg_expected = Variant::ARRAY;
}
} else if (p_args[i]->get_type() != Variant::PACKED_INT64_ARRAY) {
arg_expected = Variant::ARRAY;
}
} break;
case ARG_ARRAY_BIT | ARG_TYPE_FLOAT: {
if (p_args[i]->get_type() == Variant::ARRAY) {
Array arr = *p_args[i];
if (arr.is_typed() && arr.get_typed_builtin() != Variant::FLOAT) {
arg_expected = Variant::ARRAY;
}
} else if (p_args[i]->get_type() != Variant::PACKED_FLOAT32_ARRAY) {
arg_expected = Variant::ARRAY;
}
} break;
case ARG_ARRAY_BIT | ARG_TYPE_DOUBLE: {
if (p_args[i]->get_type() == Variant::ARRAY) {
Array arr = *p_args[i];
if (arr.is_typed() && arr.get_typed_builtin() != Variant::FLOAT) {
arg_expected = Variant::ARRAY;
}
} else if (p_args[i]->get_type() != Variant::PACKED_FLOAT64_ARRAY) {
arg_expected = Variant::ARRAY;
}
} break;
case ARG_ARRAY_BIT | ARG_TYPE_STRING:
case ARG_ARRAY_BIT | ARG_TYPE_CHARSEQUENCE: {
if (p_args[i]->get_type() == Variant::ARRAY) {
Array arr = *p_args[i];
if (arr.is_typed() && arr.get_typed_builtin() != Variant::STRING) {
arg_expected = Variant::ARRAY;
}
} else if (p_args[i]->get_type() != Variant::PACKED_STRING_ARRAY) {
arg_expected = Variant::ARRAY;
}
} break;
case ARG_ARRAY_BIT | ARG_TYPE_CALLABLE: {
if (p_args[i]->get_type() == Variant::ARRAY) {
Array arr = *p_args[i];
if (arr.is_typed() && arr.get_typed_builtin() != Variant::CALLABLE) {
arg_expected = Variant::ARRAY;
}
} else {
arg_expected = Variant::ARRAY;
}
} break;
case ARG_ARRAY_BIT | ARG_TYPE_CLASS: {
if (p_args[i]->get_type() == Variant::ARRAY) {
Array arr = *p_args[i];
if (arr.is_typed() && arr.get_typed_builtin() != Variant::OBJECT) {
arg_expected = Variant::ARRAY;
} else {
String cn = E.param_sigs[i].operator String();
if (cn.begins_with("[L") && cn.ends_with(";")) {
cn = cn.substr(2, cn.length() - 3);
}
jclass c = env->FindClass(cn.utf8().get_data());
if (c) {
for (int j = 0; j < arr.size(); j++) {
Ref<JavaObject> jo = arr[j];
if (jo.is_valid()) {
if (!env->IsInstanceOf(jo->instance, c)) {
arg_expected = Variant::ARRAY;
break;
}
} else {
arg_expected = Variant::ARRAY;
break;
}
}
} else {
arg_expected = Variant::ARRAY;
}
}
} else {
arg_expected = Variant::ARRAY;
}
} break;
default: {
if (p_args[i]->get_type() != Variant::ARRAY) {
arg_expected = Variant::ARRAY;
@ -287,13 +400,16 @@ bool JavaClass::_call_method(JavaObject *p_instance, const StringName &p_method,
to_free.push_back(jcallable);
} break;
case ARG_TYPE_CLASS: {
Ref<JavaObject> jo = *p_args[i];
if (jo.is_valid()) {
argv[i].l = jo->instance;
if (p_args[i]->get_type() == Variant::DICTIONARY) {
argv[i].l = _variant_to_jvalue(env, Variant::DICTIONARY, p_args[i]).obj;
} else {
argv[i].l = nullptr; //I hope this works
Ref<JavaObject> jo = *p_args[i];
if (jo.is_valid()) {
argv[i].l = jo->instance;
} else {
argv[i].l = nullptr; //I hope this works
}
}
} break;
case ARG_ARRAY_BIT | ARG_TYPE_BOOLEAN: {
Array arr = *p_args[i];
@ -307,90 +423,171 @@ bool JavaClass::_call_method(JavaObject *p_instance, const StringName &p_method,
} break;
case ARG_ARRAY_BIT | ARG_TYPE_BYTE: {
Array arr = *p_args[i];
jbyteArray a = env->NewByteArray(arr.size());
for (int j = 0; j < arr.size(); j++) {
jbyte val = arr[j];
env->SetByteArrayRegion(a, j, 1, &val);
jbyteArray a = nullptr;
if (p_args[i]->get_type() == Variant::ARRAY) {
Array arr = *p_args[i];
a = env->NewByteArray(arr.size());
for (int j = 0; j < arr.size(); j++) {
jbyte val = arr[j];
env->SetByteArrayRegion(a, j, 1, &val);
}
} else if (p_args[i]->get_type() == Variant::PACKED_BYTE_ARRAY) {
PackedByteArray arr = *p_args[i];
a = env->NewByteArray(arr.size());
env->SetByteArrayRegion(a, 0, arr.size(), (const jbyte *)arr.ptr());
}
argv[i].l = a;
to_free.push_back(a);
} break;
case ARG_ARRAY_BIT | ARG_TYPE_CHAR: {
Array arr = *p_args[i];
jcharArray a = env->NewCharArray(arr.size());
for (int j = 0; j < arr.size(); j++) {
jchar val = arr[j];
env->SetCharArrayRegion(a, j, 1, &val);
jcharArray a = nullptr;
if (p_args[i]->get_type() == Variant::ARRAY) {
Array arr = *p_args[i];
a = env->NewCharArray(arr.size());
for (int j = 0; j < arr.size(); j++) {
jchar val = arr[j];
env->SetCharArrayRegion(a, j, 1, &val);
}
} else if (p_args[i]->get_type() == Variant::PACKED_BYTE_ARRAY) {
PackedByteArray arr = *p_args[i];
// The data is expected to be UTF-16 encoded, so the length is half the size of the byte array.
int size = arr.size() / 2;
a = env->NewCharArray(size);
env->SetCharArrayRegion(a, 0, size, (const jchar *)arr.ptr());
}
argv[i].l = a;
to_free.push_back(a);
} break;
case ARG_ARRAY_BIT | ARG_TYPE_SHORT: {
Array arr = *p_args[i];
jshortArray a = env->NewShortArray(arr.size());
for (int j = 0; j < arr.size(); j++) {
jshort val = arr[j];
env->SetShortArrayRegion(a, j, 1, &val);
jshortArray a = nullptr;
if (p_args[i]->get_type() == Variant::ARRAY) {
Array arr = *p_args[i];
a = env->NewShortArray(arr.size());
for (int j = 0; j < arr.size(); j++) {
jshort val = arr[j];
env->SetShortArrayRegion(a, j, 1, &val);
}
} else if (p_args[i]->get_type() == Variant::PACKED_INT32_ARRAY) {
PackedInt32Array arr = *p_args[i];
a = env->NewShortArray(arr.size());
for (int j = 0; j < arr.size(); j++) {
jshort val = arr[j];
env->SetShortArrayRegion(a, j, 1, &val);
}
}
argv[i].l = a;
to_free.push_back(a);
} break;
case ARG_ARRAY_BIT | ARG_TYPE_INT: {
Array arr = *p_args[i];
jintArray a = env->NewIntArray(arr.size());
for (int j = 0; j < arr.size(); j++) {
jint val = arr[j];
env->SetIntArrayRegion(a, j, 1, &val);
jintArray a = nullptr;
if (p_args[i]->get_type() == Variant::ARRAY) {
Array arr = *p_args[i];
a = env->NewIntArray(arr.size());
for (int j = 0; j < arr.size(); j++) {
jint val = arr[j];
env->SetIntArrayRegion(a, j, 1, &val);
}
} else if (p_args[i]->get_type() == Variant::PACKED_INT32_ARRAY) {
PackedInt32Array arr = *p_args[i];
a = env->NewIntArray(arr.size());
env->SetIntArrayRegion(a, 0, arr.size(), arr.ptr());
}
argv[i].l = a;
to_free.push_back(a);
} break;
case ARG_ARRAY_BIT | ARG_TYPE_LONG: {
Array arr = *p_args[i];
jlongArray a = env->NewLongArray(arr.size());
for (int j = 0; j < arr.size(); j++) {
jlong val = (int64_t)arr[j];
env->SetLongArrayRegion(a, j, 1, &val);
jlongArray a = nullptr;
if (p_args[i]->get_type() == Variant::ARRAY) {
Array arr = *p_args[i];
a = env->NewLongArray(arr.size());
for (int j = 0; j < arr.size(); j++) {
jlong val = (int64_t)arr[j];
env->SetLongArrayRegion(a, j, 1, &val);
}
} else if (p_args[i]->get_type() == Variant::PACKED_INT64_ARRAY) {
PackedInt64Array arr = *p_args[i];
a = env->NewLongArray(arr.size());
env->SetLongArrayRegion(a, 0, arr.size(), arr.ptr());
}
argv[i].l = a;
to_free.push_back(a);
} break;
case ARG_ARRAY_BIT | ARG_TYPE_FLOAT: {
Array arr = *p_args[i];
jfloatArray a = env->NewFloatArray(arr.size());
for (int j = 0; j < arr.size(); j++) {
jfloat val = arr[j];
env->SetFloatArrayRegion(a, j, 1, &val);
jfloatArray a = nullptr;
if (p_args[i]->get_type() == Variant::ARRAY) {
Array arr = *p_args[i];
a = env->NewFloatArray(arr.size());
for (int j = 0; j < arr.size(); j++) {
jfloat val = arr[j];
env->SetFloatArrayRegion(a, j, 1, &val);
}
} else if (p_args[i]->get_type() == Variant::PACKED_FLOAT32_ARRAY) {
PackedFloat32Array arr = *p_args[i];
a = env->NewFloatArray(arr.size());
env->SetFloatArrayRegion(a, 0, arr.size(), arr.ptr());
}
argv[i].l = a;
to_free.push_back(a);
} break;
case ARG_ARRAY_BIT | ARG_TYPE_DOUBLE: {
Array arr = *p_args[i];
jdoubleArray a = env->NewDoubleArray(arr.size());
for (int j = 0; j < arr.size(); j++) {
jdouble val = arr[j];
env->SetDoubleArrayRegion(a, j, 1, &val);
jdoubleArray a = nullptr;
if (p_args[i]->get_type() == Variant::ARRAY) {
Array arr = *p_args[i];
a = env->NewDoubleArray(arr.size());
for (int j = 0; j < arr.size(); j++) {
jdouble val = arr[j];
env->SetDoubleArrayRegion(a, j, 1, &val);
}
} else if (p_args[i]->get_type() == Variant::PACKED_FLOAT64_ARRAY) {
PackedFloat64Array arr = *p_args[i];
a = env->NewDoubleArray(arr.size());
env->SetDoubleArrayRegion(a, 0, arr.size(), arr.ptr());
}
argv[i].l = a;
to_free.push_back(a);
} break;
case ARG_ARRAY_BIT | ARG_TYPE_STRING:
case ARG_ARRAY_BIT | ARG_TYPE_CHARSEQUENCE: {
Array arr = *p_args[i];
jobjectArray a = env->NewObjectArray(arr.size(), env->FindClass("java/lang/String"), nullptr);
for (int j = 0; j < arr.size(); j++) {
String s = arr[j];
jstring jStr = env->NewStringUTF(s.utf8().get_data());
env->SetObjectArrayElement(a, j, jStr);
to_free.push_back(jStr);
jobjectArray a = nullptr;
if (p_args[i]->get_type() == Variant::ARRAY) {
Array arr = *p_args[i];
a = env->NewObjectArray(arr.size(), env->FindClass("java/lang/String"), nullptr);
for (int j = 0; j < arr.size(); j++) {
String s = arr[j];
jstring jStr = env->NewStringUTF(s.utf8().get_data());
env->SetObjectArrayElement(a, j, jStr);
to_free.push_back(jStr);
}
} else if (p_args[i]->get_type() == Variant::PACKED_STRING_ARRAY) {
PackedStringArray arr = *p_args[i];
a = env->NewObjectArray(arr.size(), env->FindClass("java/lang/String"), nullptr);
for (int j = 0; j < arr.size(); j++) {
String s = arr[j];
jstring jStr = env->NewStringUTF(s.utf8().get_data());
env->SetObjectArrayElement(a, j, jStr);
to_free.push_back(jStr);
}
}
argv[i].l = a;
@ -410,7 +607,22 @@ bool JavaClass::_call_method(JavaObject *p_instance, const StringName &p_method,
to_free.push_back(jarr);
} break;
case ARG_ARRAY_BIT | ARG_TYPE_CLASS: {
argv[i].l = nullptr;
String cn = method->param_sigs[i].operator String();
if (cn.begins_with("[L") && cn.ends_with(";")) {
cn = cn.substr(2, cn.length() - 3);
}
jclass c = env->FindClass(cn.utf8().get_data());
if (c) {
Array arr = *p_args[i];
jobjectArray jarr = env->NewObjectArray(arr.size(), c, nullptr);
for (int j = 0; j < arr.size(); j++) {
Ref<JavaObject> jo = arr[j];
env->SetObjectArrayElement(jarr, j, jo->instance);
}
argv[i].l = jarr;
to_free.push_back(jarr);
}
} break;
}
}
@ -718,7 +930,7 @@ bool JavaClassWrapper::_get_type_sig(JNIEnv *env, jobject obj, uint32_t &sig, St
if (str_type.begins_with("[")) {
t = JavaClass::ARG_ARRAY_BIT;
strsig = "[";
str_type = str_type.substr(1, str_type.length() - 1);
str_type = str_type.substr(1);
if (str_type.begins_with("[")) {
print_line("Nested arrays not supported for type: " + str_type);
return false;
@ -790,7 +1002,7 @@ bool JavaClassWrapper::_get_type_sig(JNIEnv *env, jobject obj, uint32_t &sig, St
strsig += "Ljava/lang/Double;";
} else {
//a class likely
strsig += "L" + str_type.replace(".", "/") + ";";
strsig += "L" + str_type.replace_char('.', '/') + ";";
t |= JavaClass::ARG_TYPE_CLASS;
}
@ -865,8 +1077,13 @@ bool JavaClass::_convert_object_to_variant(JNIEnv *env, jobject obj, Variant &va
env->DeleteLocalRef(java_class);
if (java_class_wrapped.is_valid()) {
Ref<JavaObject> ret = Ref<JavaObject>(memnew(JavaObject(java_class_wrapped, obj)));
var = ret;
String cn = java_class_wrapped->get_java_class_name();
if (cn == "org.godotengine.godot.Dictionary" || cn == "java.util.HashMap") {
var = _jobject_to_variant(env, obj);
} else {
Ref<JavaObject> ret = Ref<JavaObject>(memnew(JavaObject(java_class_wrapped, obj)));
var = ret;
}
return true;
}
@ -881,11 +1098,12 @@ bool JavaClass::_convert_object_to_variant(JNIEnv *env, jobject obj, Variant &va
jobjectArray arr = (jobjectArray)obj;
int count = env->GetArrayLength(arr);
ret.resize(count);
for (int i = 0; i < count; i++) {
jboolean val;
env->GetBooleanArrayRegion((jbooleanArray)arr, 0, 1, &val);
ret.push_back(val);
env->GetBooleanArrayRegion((jbooleanArray)arr, i, 1, &val);
ret[i] = (bool)val;
}
var = ret;
@ -893,106 +1111,85 @@ bool JavaClass::_convert_object_to_variant(JNIEnv *env, jobject obj, Variant &va
} break;
case ARG_ARRAY_BIT | ARG_TYPE_BYTE: {
Array ret;
PackedByteArray ret;
jobjectArray arr = (jobjectArray)obj;
int count = env->GetArrayLength(arr);
for (int i = 0; i < count; i++) {
jbyte val;
env->GetByteArrayRegion((jbyteArray)arr, 0, 1, &val);
ret.push_back(val);
}
ret.resize(count);
env->GetByteArrayRegion((jbyteArray)arr, 0, count, (int8_t *)ret.ptrw());
var = ret;
return true;
} break;
case ARG_ARRAY_BIT | ARG_TYPE_CHAR: {
Array ret;
PackedByteArray ret;
jobjectArray arr = (jobjectArray)obj;
int count = env->GetArrayLength(arr);
for (int i = 0; i < count; i++) {
jchar val;
env->GetCharArrayRegion((jcharArray)arr, 0, 1, &val);
ret.push_back(val);
}
// Char arrays are UTF-16 encoded, so it's double the length.
ret.resize(count * 2);
env->GetCharArrayRegion((jcharArray)arr, 0, count, (jchar *)ret.ptrw());
var = ret;
return true;
} break;
case ARG_ARRAY_BIT | ARG_TYPE_SHORT: {
Array ret;
PackedInt32Array ret;
jobjectArray arr = (jobjectArray)obj;
int count = env->GetArrayLength(arr);
ret.resize(count);
int32_t *ptr = ret.ptrw();
for (int i = 0; i < count; i++) {
jshort val;
env->GetShortArrayRegion((jshortArray)arr, 0, 1, &val);
ret.push_back(val);
env->GetShortArrayRegion((jshortArray)arr, i, 1, &val);
ptr[i] = val;
}
var = ret;
return true;
} break;
case ARG_ARRAY_BIT | ARG_TYPE_INT: {
Array ret;
PackedInt32Array ret;
jobjectArray arr = (jobjectArray)obj;
int count = env->GetArrayLength(arr);
for (int i = 0; i < count; i++) {
jint val;
env->GetIntArrayRegion((jintArray)arr, 0, 1, &val);
ret.push_back(val);
}
ret.resize(count);
env->GetIntArrayRegion((jintArray)arr, 0, count, ret.ptrw());
var = ret;
return true;
} break;
case ARG_ARRAY_BIT | ARG_TYPE_LONG: {
Array ret;
PackedInt64Array ret;
jobjectArray arr = (jobjectArray)obj;
int count = env->GetArrayLength(arr);
for (int i = 0; i < count; i++) {
jlong val;
env->GetLongArrayRegion((jlongArray)arr, 0, 1, &val);
ret.push_back((int64_t)val);
}
ret.resize(count);
env->GetLongArrayRegion((jlongArray)arr, 0, count, ret.ptrw());
var = ret;
return true;
} break;
case ARG_ARRAY_BIT | ARG_TYPE_FLOAT: {
Array ret;
PackedFloat32Array ret;
jobjectArray arr = (jobjectArray)obj;
int count = env->GetArrayLength(arr);
for (int i = 0; i < count; i++) {
jfloat val;
env->GetFloatArrayRegion((jfloatArray)arr, 0, 1, &val);
ret.push_back(val);
}
ret.resize(count);
env->GetFloatArrayRegion((jfloatArray)arr, 0, count, ret.ptrw());
var = ret;
return true;
} break;
case ARG_ARRAY_BIT | ARG_TYPE_DOUBLE: {
Array ret;
PackedFloat64Array ret;
jobjectArray arr = (jobjectArray)obj;
int count = env->GetArrayLength(arr);
for (int i = 0; i < count; i++) {
jdouble val;
env->GetDoubleArrayRegion((jdoubleArray)arr, 0, 1, &val);
ret.push_back(val);
}
ret.resize(count);
env->GetDoubleArrayRegion((jdoubleArray)arr, 0, count, ret.ptrw());
var = ret;
return true;
@ -1002,14 +1199,13 @@ bool JavaClass::_convert_object_to_variant(JNIEnv *env, jobject obj, Variant &va
jobjectArray arr = (jobjectArray)obj;
int count = env->GetArrayLength(arr);
ret.resize(count);
for (int i = 0; i < count; i++) {
jobject o = env->GetObjectArrayElement(arr, i);
if (!o) {
ret.push_back(Variant());
} else {
if (o) {
bool val = env->CallBooleanMethod(o, JavaClassWrapper::singleton->Boolean_booleanValue);
ret.push_back(val);
ret[i] = val;
}
env->DeleteLocalRef(o);
}
@ -1019,18 +1215,20 @@ bool JavaClass::_convert_object_to_variant(JNIEnv *env, jobject obj, Variant &va
} break;
case ARG_NUMBER_CLASS_BIT | ARG_ARRAY_BIT | ARG_TYPE_BYTE: {
Array ret;
PackedByteArray ret;
jobjectArray arr = (jobjectArray)obj;
int count = env->GetArrayLength(arr);
ret.resize(count);
uint8_t *ptr = ret.ptrw();
for (int i = 0; i < count; i++) {
jobject o = env->GetObjectArrayElement(arr, i);
if (!o) {
ret.push_back(Variant());
ptr[i] = 0;
} else {
int val = env->CallByteMethod(o, JavaClassWrapper::singleton->Byte_byteValue);
ret.push_back(val);
ptr[i] = (uint8_t)val;
}
env->DeleteLocalRef(o);
}
@ -1039,18 +1237,22 @@ bool JavaClass::_convert_object_to_variant(JNIEnv *env, jobject obj, Variant &va
return true;
} break;
case ARG_NUMBER_CLASS_BIT | ARG_ARRAY_BIT | ARG_TYPE_CHAR: {
Array ret;
PackedByteArray ret;
jobjectArray arr = (jobjectArray)obj;
int count = env->GetArrayLength(arr);
// Char arrays are UTF-16 encoded, so it's double the length.
ret.resize(count * 2);
jchar *ptr = (jchar *)ret.ptrw();
for (int i = 0; i < count; i++) {
jobject o = env->GetObjectArrayElement(arr, i);
if (!o) {
ret.push_back(Variant());
count = i;
break;
} else {
int val = env->CallCharMethod(o, JavaClassWrapper::singleton->Character_characterValue);
ret.push_back(val);
ptr[i] = (jchar)val;
}
env->DeleteLocalRef(o);
}
@ -1059,18 +1261,20 @@ bool JavaClass::_convert_object_to_variant(JNIEnv *env, jobject obj, Variant &va
return true;
} break;
case ARG_NUMBER_CLASS_BIT | ARG_ARRAY_BIT | ARG_TYPE_SHORT: {
Array ret;
PackedInt32Array ret;
jobjectArray arr = (jobjectArray)obj;
int count = env->GetArrayLength(arr);
ret.resize(count);
int32_t *ptr = ret.ptrw();
for (int i = 0; i < count; i++) {
jobject o = env->GetObjectArrayElement(arr, i);
if (!o) {
ret.push_back(Variant());
ptr[i] = 0;
} else {
int val = env->CallShortMethod(o, JavaClassWrapper::singleton->Short_shortValue);
ret.push_back(val);
ptr[i] = val;
}
env->DeleteLocalRef(o);
}
@ -1079,18 +1283,20 @@ bool JavaClass::_convert_object_to_variant(JNIEnv *env, jobject obj, Variant &va
return true;
} break;
case ARG_NUMBER_CLASS_BIT | ARG_ARRAY_BIT | ARG_TYPE_INT: {
Array ret;
PackedInt32Array ret;
jobjectArray arr = (jobjectArray)obj;
int count = env->GetArrayLength(arr);
ret.resize(count);
int32_t *ptr = ret.ptrw();
for (int i = 0; i < count; i++) {
jobject o = env->GetObjectArrayElement(arr, i);
if (!o) {
ret.push_back(Variant());
ptr[i] = 0;
} else {
int val = env->CallIntMethod(o, JavaClassWrapper::singleton->Integer_integerValue);
ret.push_back(val);
ptr[i] = val;
}
env->DeleteLocalRef(o);
}
@ -1099,18 +1305,20 @@ bool JavaClass::_convert_object_to_variant(JNIEnv *env, jobject obj, Variant &va
return true;
} break;
case ARG_NUMBER_CLASS_BIT | ARG_ARRAY_BIT | ARG_TYPE_LONG: {
Array ret;
PackedInt64Array ret;
jobjectArray arr = (jobjectArray)obj;
int count = env->GetArrayLength(arr);
ret.resize(count);
int64_t *ptr = ret.ptrw();
for (int i = 0; i < count; i++) {
jobject o = env->GetObjectArrayElement(arr, i);
if (!o) {
ret.push_back(Variant());
ptr[i] = 0;
} else {
int64_t val = env->CallLongMethod(o, JavaClassWrapper::singleton->Long_longValue);
ret.push_back(val);
ptr[i] = val;
}
env->DeleteLocalRef(o);
}
@ -1119,18 +1327,20 @@ bool JavaClass::_convert_object_to_variant(JNIEnv *env, jobject obj, Variant &va
return true;
} break;
case ARG_NUMBER_CLASS_BIT | ARG_ARRAY_BIT | ARG_TYPE_FLOAT: {
Array ret;
PackedFloat32Array ret;
jobjectArray arr = (jobjectArray)obj;
int count = env->GetArrayLength(arr);
ret.resize(count);
float *ptr = ret.ptrw();
for (int i = 0; i < count; i++) {
jobject o = env->GetObjectArrayElement(arr, i);
if (!o) {
ret.push_back(Variant());
ptr[i] = 0.0;
} else {
float val = env->CallFloatMethod(o, JavaClassWrapper::singleton->Float_floatValue);
ret.push_back(val);
ptr[i] = val;
}
env->DeleteLocalRef(o);
}
@ -1139,18 +1349,20 @@ bool JavaClass::_convert_object_to_variant(JNIEnv *env, jobject obj, Variant &va
return true;
} break;
case ARG_NUMBER_CLASS_BIT | ARG_ARRAY_BIT | ARG_TYPE_DOUBLE: {
Array ret;
PackedFloat64Array ret;
jobjectArray arr = (jobjectArray)obj;
int count = env->GetArrayLength(arr);
ret.resize(count);
double *ptr = ret.ptrw();
for (int i = 0; i < count; i++) {
jobject o = env->GetObjectArrayElement(arr, i);
if (!o) {
ret.push_back(Variant());
ptr[i] = 0.0;
} else {
double val = env->CallDoubleMethod(o, JavaClassWrapper::singleton->Double_doubleValue);
ret.push_back(val);
ptr[i] = val;
}
env->DeleteLocalRef(o);
}
@ -1160,18 +1372,18 @@ bool JavaClass::_convert_object_to_variant(JNIEnv *env, jobject obj, Variant &va
} break;
case ARG_ARRAY_BIT | ARG_TYPE_STRING: {
Array ret;
PackedStringArray ret;
jobjectArray arr = (jobjectArray)obj;
int count = env->GetArrayLength(arr);
ret.resize(count);
String *ptr = ret.ptrw();
for (int i = 0; i < count; i++) {
jobject o = env->GetObjectArrayElement(arr, i);
if (!o) {
ret.push_back(Variant());
} else {
if (o) {
String val = jstring_to_string((jstring)o, env);
ret.push_back(val);
ptr[i] = val;
}
env->DeleteLocalRef(o);
}
@ -1180,18 +1392,18 @@ bool JavaClass::_convert_object_to_variant(JNIEnv *env, jobject obj, Variant &va
return true;
} break;
case ARG_ARRAY_BIT | ARG_TYPE_CHARSEQUENCE: {
Array ret;
PackedStringArray ret;
jobjectArray arr = (jobjectArray)obj;
int count = env->GetArrayLength(arr);
ret.resize(count);
String *ptr = ret.ptrw();
for (int i = 0; i < count; i++) {
jobject o = env->GetObjectArrayElement(arr, i);
if (!o) {
ret.push_back(Variant());
} else {
if (o) {
String val = charsequence_to_string(env, o);
ret.push_back(val);
ptr[i] = val;
}
env->DeleteLocalRef(o);
}
@ -1203,13 +1415,12 @@ bool JavaClass::_convert_object_to_variant(JNIEnv *env, jobject obj, Variant &va
Array ret;
jobjectArray jarr = (jobjectArray)obj;
int count = env->GetArrayLength(jarr);
ret.resize(count);
for (int i = 0; i < count; i++) {
jobject o = env->GetObjectArrayElement(jarr, i);
if (!o) {
ret.push_back(Variant());
} else {
if (o) {
Callable callable = jcallable_to_callable(env, o);
ret.push_back(callable);
ret[i] = callable;
}
env->DeleteLocalRef(o);
}
@ -1218,6 +1429,32 @@ bool JavaClass::_convert_object_to_variant(JNIEnv *env, jobject obj, Variant &va
return true;
} break;
case ARG_ARRAY_BIT | ARG_TYPE_CLASS: {
Array ret;
jobjectArray jarr = (jobjectArray)obj;
int count = env->GetArrayLength(jarr);
ret.resize(count);
for (int i = 0; i < count; i++) {
jobject obj = env->GetObjectArrayElement(jarr, i);
if (obj) {
jclass java_class = env->GetObjectClass(obj);
Ref<JavaClass> java_class_wrapped = JavaClassWrapper::singleton->wrap_jclass(java_class);
env->DeleteLocalRef(java_class);
if (java_class_wrapped.is_valid()) {
String cn = java_class_wrapped->get_java_class_name();
if (cn == "org.godotengine.godot.Dictionary" || cn == "java.util.HashMap") {
ret[i] = _jobject_to_variant(env, obj);
} else {
Ref<JavaObject> java_obj_wrapped = Ref<JavaObject>(memnew(JavaObject(java_class_wrapped, obj)));
ret[i] = java_obj_wrapped;
}
}
}
env->DeleteLocalRef(obj);
}
var = ret;
return true;
} break;
}
@ -1225,7 +1462,7 @@ bool JavaClass::_convert_object_to_variant(JNIEnv *env, jobject obj, Variant &va
}
Ref<JavaClass> JavaClassWrapper::_wrap(const String &p_class, bool p_allow_private_methods_access) {
String class_name_dots = p_class.replace("/", ".");
String class_name_dots = p_class.replace_char('/', '.');
if (class_cache.has(class_name_dots)) {
return class_cache[class_name_dots];
}
@ -1233,8 +1470,8 @@ Ref<JavaClass> JavaClassWrapper::_wrap(const String &p_class, bool p_allow_priva
JNIEnv *env = get_jni_env();
ERR_FAIL_NULL_V(env, Ref<JavaClass>());
jclass bclass = env->FindClass(class_name_dots.replace(".", "/").utf8().get_data());
ERR_FAIL_NULL_V(bclass, Ref<JavaClass>());
jclass bclass = env->FindClass(class_name_dots.replace_char('.', '/').utf8().get_data());
ERR_FAIL_NULL_V_MSG(bclass, Ref<JavaClass>(), vformat("Java class '%s' not found.", p_class));
jobjectArray constructors = (jobjectArray)env->CallObjectMethod(bclass, Class_getDeclaredConstructors);
ERR_FAIL_NULL_V(constructors, Ref<JavaClass>());