Skip to content

Upgrade ILSpy to 11.0 #444

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
nikitalita merged 18 commits into from
Aug 15, 2026
Merged

Upgrade ILSpy to 11.0 #444

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
18 commits
Select commit Hold shift + click to select a range
3a4b5c7
scene: set option to retarget skeleton to unique node
nikitalita Aug 12, 2026
c67c575
add support for exporting `animation_library` imports
nikitalita Aug 12, 2026
0a53950
add support for exporting `MeshLibrary` and `ArrayMesh` imports
nikitalita Aug 12, 2026
62c9b19
fix animation library glbs being exported with incorrect nodes
nikitalita Aug 12, 2026
9b1fdcf
scene: only set bone rest/pose when bone doesn't exist
nikitalita Aug 12, 2026
aa69cb6
update `discord-rpc-gd` source
nikitalita Aug 12, 2026
21ec0e4
update static plugin cache
nikitalita Aug 12, 2026
033ab5e
fix encoding variants when real_t is double
nikitalita Aug 13, 2026
2499457
fail silently when loading an import file explicitly marked invalid
nikitalita Aug 13, 2026
de03be9
add `set_importer` and `set_uid` methods to ImportInfo
nikitalita Aug 13, 2026
94bbe60
make TextureLoaderCompat::recognize fail silently if the file does no…
nikitalita Aug 13, 2026
0b41a7a
Set subprojects to already-existing subdirectories if they don't conf…
nikitalita Aug 13, 2026
86e5091
refactor csharp export logic in import_exporter
nikitalita Aug 13, 2026
9ec8716
speed up translation export, add option to only do stage 1
nikitalita Aug 14, 2026
3337002
wip ilspy upgrade
nikitalita Aug 15, 2026
2cbb38d
finish upgrade
nikitalita Aug 15, 2026
ea8754e
fix nullability errors after ILSpy AstNode nullability changes
nikitalita Aug 15, 2026
e1a11dc
remove old dependencies
nikitalita Aug 15, 2026
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
9 changes: 8 additions & 1 deletion compat/texture_loader_compat.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -105,7 +105,14 @@ TextureLoaderCompat::TextureVersionType TextureLoaderCompat::recognize(const Str
const String res_path = p_path;
Ref<FileAccess> f = FileAccess::open(res_path, FileAccess::READ, r_err);

ERR_FAIL_COND_V_MSG(*r_err != OK || f.is_null(), FORMAT_NOT_TEXTURE, "Can't open texture file " + p_path);
if (*r_err != OK || f.is_null()) {
// fail silently if the file doesn't exist
if (!FileAccess::exists(res_path)) {
*r_err = ERR_FILE_NOT_FOUND;
return FORMAT_NOT_TEXTURE;
}
ERR_FAIL_COND_V_MSG(*r_err != OK || f.is_null(), FORMAT_NOT_TEXTURE, "Can't open texture file " + p_path);
}

uint8_t header[4];
uint64_t got = f->get_buffer(header, 4);
Expand Down
102 changes: 52 additions & 50 deletions compat/variant_decoder_compat.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -4356,6 +4356,8 @@ Error VariantDecoderCompat::encode_variant_4(const Variant &p_variant, uint8_t *

uint32_t header = p_variant.get_type();

const int real_t_size = p_real_t_is_double ? sizeof(double) : sizeof(float);

switch (p_variant.get_type()) {
case Variant::INT: {
int64_t val = p_variant;
Expand Down Expand Up @@ -4530,10 +4532,10 @@ Error VariantDecoderCompat::encode_variant_4(const Variant &p_variant, uint8_t *
if (buf) {
Vector2 v2 = p_variant;
_encode_real(v2.x, &buf[0], p_real_t_is_double);
_encode_real(v2.y, &buf[sizeof(real_t)], p_real_t_is_double);
_encode_real(v2.y, &buf[real_t_size], p_real_t_is_double);
}

r_len += 2 * sizeof(real_t);
r_len += 2 * real_t_size;

} break;
case Variant::VECTOR2I: {
Expand All @@ -4550,11 +4552,11 @@ Error VariantDecoderCompat::encode_variant_4(const Variant &p_variant, uint8_t *
if (buf) {
Rect2 r2 = p_variant;
_encode_real(r2.position.x, &buf[0], p_real_t_is_double);
_encode_real(r2.position.y, &buf[sizeof(real_t)], p_real_t_is_double);
_encode_real(r2.size.x, &buf[sizeof(real_t) * 2], p_real_t_is_double);
_encode_real(r2.size.y, &buf[sizeof(real_t) * 3], p_real_t_is_double);
_encode_real(r2.position.y, &buf[real_t_size], p_real_t_is_double);
_encode_real(r2.size.x, &buf[real_t_size * 2], p_real_t_is_double);
_encode_real(r2.size.y, &buf[real_t_size * 3], p_real_t_is_double);
}
r_len += 4 * sizeof(real_t);
r_len += 4 * real_t_size;

} break;
case Variant::RECT2I: {
Expand All @@ -4572,11 +4574,11 @@ Error VariantDecoderCompat::encode_variant_4(const Variant &p_variant, uint8_t *
if (buf) {
Vector3 v3 = p_variant;
_encode_real(v3.x, &buf[0], p_real_t_is_double);
_encode_real(v3.y, &buf[sizeof(real_t)], p_real_t_is_double);
_encode_real(v3.z, &buf[sizeof(real_t) * 2], p_real_t_is_double);
_encode_real(v3.y, &buf[real_t_size], p_real_t_is_double);
_encode_real(v3.z, &buf[real_t_size * 2], p_real_t_is_double);
}

r_len += 3 * sizeof(real_t);
r_len += 3 * real_t_size;

} break;
case Variant::VECTOR3I: {
Expand All @@ -4595,24 +4597,24 @@ Error VariantDecoderCompat::encode_variant_4(const Variant &p_variant, uint8_t *
Transform2D val = p_variant;
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 2; j++) {
memcpy(&buf[(i * 2 + j) * sizeof(real_t)], &val.columns[i][j], sizeof(real_t));
memcpy(&buf[(i * 2 + j) * real_t_size], &val.columns[i][j], real_t_size);
}
}
}

r_len += 6 * sizeof(real_t);
r_len += 6 * real_t_size;

} break;
case Variant::VECTOR4: {
if (buf) {
Vector4 v4 = p_variant;
_encode_real(v4.x, &buf[0], p_real_t_is_double);
_encode_real(v4.y, &buf[sizeof(real_t)], p_real_t_is_double);
_encode_real(v4.z, &buf[sizeof(real_t) * 2], p_real_t_is_double);
_encode_real(v4.w, &buf[sizeof(real_t) * 3], p_real_t_is_double);
_encode_real(v4.y, &buf[real_t_size], p_real_t_is_double);
_encode_real(v4.z, &buf[real_t_size * 2], p_real_t_is_double);
_encode_real(v4.w, &buf[real_t_size * 3], p_real_t_is_double);
}

r_len += 4 * sizeof(real_t);
r_len += 4 * real_t_size;

} break;
case Variant::VECTOR4I: {
Expand All @@ -4631,81 +4633,81 @@ Error VariantDecoderCompat::encode_variant_4(const Variant &p_variant, uint8_t *
if (buf) {
Plane p = p_variant;
_encode_real(p.normal.x, &buf[0], p_real_t_is_double);
_encode_real(p.normal.y, &buf[sizeof(real_t)], p_real_t_is_double);
_encode_real(p.normal.z, &buf[sizeof(real_t) * 2], p_real_t_is_double);
_encode_real(p.d, &buf[sizeof(real_t) * 3], p_real_t_is_double);
_encode_real(p.normal.y, &buf[real_t_size], p_real_t_is_double);
_encode_real(p.normal.z, &buf[real_t_size * 2], p_real_t_is_double);
_encode_real(p.d, &buf[real_t_size * 3], p_real_t_is_double);
}

r_len += 4 * sizeof(real_t);
r_len += 4 * real_t_size;

} break;
case Variant::QUATERNION: {
if (buf) {
Quaternion q = p_variant;
_encode_real(q.x, &buf[0], p_real_t_is_double);
_encode_real(q.y, &buf[sizeof(real_t)], p_real_t_is_double);
_encode_real(q.z, &buf[sizeof(real_t) * 2], p_real_t_is_double);
_encode_real(q.w, &buf[sizeof(real_t) * 3], p_real_t_is_double);
_encode_real(q.y, &buf[real_t_size], p_real_t_is_double);
_encode_real(q.z, &buf[real_t_size * 2], p_real_t_is_double);
_encode_real(q.w, &buf[real_t_size * 3], p_real_t_is_double);
}

r_len += 4 * sizeof(real_t);
r_len += 4 * real_t_size;

} break;
case Variant::AABB: {
if (buf) {
AABB aabb = p_variant;
_encode_real(aabb.position.x, &buf[0], p_real_t_is_double);
_encode_real(aabb.position.y, &buf[sizeof(real_t)], p_real_t_is_double);
_encode_real(aabb.position.z, &buf[sizeof(real_t) * 2], p_real_t_is_double);
_encode_real(aabb.size.x, &buf[sizeof(real_t) * 3], p_real_t_is_double);
_encode_real(aabb.size.y, &buf[sizeof(real_t) * 4], p_real_t_is_double);
_encode_real(aabb.size.z, &buf[sizeof(real_t) * 5], p_real_t_is_double);
_encode_real(aabb.position.y, &buf[real_t_size], p_real_t_is_double);
_encode_real(aabb.position.z, &buf[real_t_size * 2], p_real_t_is_double);
_encode_real(aabb.size.x, &buf[real_t_size * 3], p_real_t_is_double);
_encode_real(aabb.size.y, &buf[real_t_size * 4], p_real_t_is_double);
_encode_real(aabb.size.z, &buf[real_t_size * 5], p_real_t_is_double);
}

r_len += 6 * sizeof(real_t);
r_len += 6 * real_t_size;

} break;
case Variant::BASIS: {
if (buf) {
Basis val = p_variant;
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
memcpy(&buf[(i * 3 + j) * sizeof(real_t)], &val.rows[i][j], sizeof(real_t));
_encode_real(val.rows[i][j], &buf[(i * 3 + j) * real_t_size], p_real_t_is_double);
}
}
}

r_len += 9 * sizeof(real_t);
r_len += 9 * real_t_size;

} break;
case Variant::TRANSFORM3D: {
if (buf) {
Transform3D val = p_variant;
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
memcpy(&buf[(i * 3 + j) * sizeof(real_t)], &val.basis.rows[i][j], sizeof(real_t));
_encode_real(val.basis.rows[i][j], &buf[(i * 3 + j) * real_t_size], p_real_t_is_double);
}
}

_encode_real(val.origin.x, &buf[sizeof(real_t) * 9], p_real_t_is_double);
_encode_real(val.origin.y, &buf[sizeof(real_t) * 10], p_real_t_is_double);
_encode_real(val.origin.z, &buf[sizeof(real_t) * 11], p_real_t_is_double);
_encode_real(val.origin.x, &buf[real_t_size * 9], p_real_t_is_double);
_encode_real(val.origin.y, &buf[real_t_size * 10], p_real_t_is_double);
_encode_real(val.origin.z, &buf[real_t_size * 11], p_real_t_is_double);
}

r_len += 12 * sizeof(real_t);
r_len += 12 * real_t_size;

} break;
case Variant::PROJECTION: {
if (buf) {
Projection val = p_variant;
for (int i = 0; i < 4; i++) {
for (int j = 0; j < 4; j++) {
memcpy(&buf[(i * 4 + j) * sizeof(real_t)], &val.columns[i][j], sizeof(real_t));
_encode_real(val.columns[i][j], &buf[(i * 4 + j) * real_t_size], p_real_t_is_double);
}
}
}

r_len += 16 * sizeof(real_t);
r_len += 16 * real_t_size;

} break;

Expand Down Expand Up @@ -5030,12 +5032,12 @@ Error VariantDecoderCompat::encode_variant_4(const Variant &p_variant, uint8_t *
Vector2 v = data.get(i);

_encode_real(v.x, &buf[0], p_real_t_is_double);
_encode_real(v.y, &buf[sizeof(real_t)], p_real_t_is_double);
buf += sizeof(real_t) * 2;
_encode_real(v.y, &buf[real_t_size], p_real_t_is_double);
buf += real_t_size * 2;
}
}

r_len += sizeof(real_t) * 2 * len;
r_len += real_t_size * 2 * len;

} break;
case Variant::PACKED_VECTOR3_ARRAY: {
Expand All @@ -5054,13 +5056,13 @@ Error VariantDecoderCompat::encode_variant_4(const Variant &p_variant, uint8_t *
Vector3 v = data.get(i);

_encode_real(v.x, &buf[0], p_real_t_is_double);
_encode_real(v.y, &buf[sizeof(real_t)], p_real_t_is_double);
_encode_real(v.z, &buf[sizeof(real_t) * 2], p_real_t_is_double);
buf += sizeof(real_t) * 3;
_encode_real(v.y, &buf[real_t_size], p_real_t_is_double);
_encode_real(v.z, &buf[real_t_size * 2], p_real_t_is_double);
buf += real_t_size * 3;
}
}

r_len += sizeof(real_t) * 3 * len;
r_len += real_t_size * 3 * len;

} break;
case Variant::PACKED_COLOR_ARRAY: {
Expand Down Expand Up @@ -5105,14 +5107,14 @@ Error VariantDecoderCompat::encode_variant_4(const Variant &p_variant, uint8_t *
Vector4 v = data.get(i);

_encode_real(v.x, &buf[0], p_real_t_is_double);
_encode_real(v.y, &buf[sizeof(real_t)], p_real_t_is_double);
_encode_real(v.z, &buf[sizeof(real_t) * 2], p_real_t_is_double);
_encode_real(v.w, &buf[sizeof(real_t) * 3], p_real_t_is_double);
buf += sizeof(real_t) * 4;
_encode_real(v.y, &buf[real_t_size], p_real_t_is_double);
_encode_real(v.z, &buf[real_t_size * 2], p_real_t_is_double);
_encode_real(v.w, &buf[real_t_size * 3], p_real_t_is_double);
buf += real_t_size * 4;
}
}

r_len += sizeof(real_t) * 4 * len;
r_len += real_t_size * 4 * len;

} break;
default: {
Expand Down
Loading
Loading