Merge pull request #17560 from akien-mga/2to3-exporter

2 to 3 converter: More fixes to the property renames

editor/editor_export_godot3.cpp

@@ -188,331 +188,278 @@ static const char *globals_renames[][2] = {
 };
 
 static const char *prop_renames[][2] = {
-	{ "script/script", "script" },
-	{ "pause/pause_mode", "pause_mode" },
-	{ "anchor/left", "anchor_left" },
-	{ "anchor/right", "anchor_right" },
-	{ "anchor/bottom", "anchor_bottom" },
-	{ "anchor/top", "anchor_top" },
-	{ "focus_neighbour/left", "focus_neighbour_left" },
-	{ "focus_neighbour/right", "focus_neighbour_right" },
-	{ "focus_neighbour/bottom", "focus_neighbour_bottom" },
-	{ "focus_neighbour/top", "focus_neighbour_top" },
-	{ "focus/ignore_mouse", "focus_ignore_mouse" },
-	{ "focus/stop_mouse", "focus_stop_mouse" },
-	{ "size_flags/horizontal", "size_flags_horizontal" }, // TODO: Fix enum order got inverted Expand,Fill -> Fill,Expand
-	{ "size_flags/vertical", "size_flags_vertical" }, // TODO: Fix enum order got inverted Expand,Fill -> Fill,Expand
-	{ "size_flags/stretch_ratio", "size_flags_stretch_ratio" },
-	{ "theme/theme", "theme" },
-	{ "visibility/visible", "visible" },
-	{ "visibility/behind_parent", "show_behind_parent" },
-	{ "visibility/on_top", "show_on_top" },
-	{ "visibility/light_mask", "light_mask" },
-	{ "material/material", "material" },
-	{ "material/use_parent", "use_parent_material" },
-	{ "resource/path", "resource_path" },
-	{ "resource/name", "resource_name" },
-	{ "collision/layers", "collision_layers" },
-	{ "collision/mask", "collision_mask" },
-	{ "limit/left", "limit_left" },
-	{ "limit/right", "limit_right" },
-	{ "limit/bottom", "limit_bottom" },
-	{ "limit/top", "limit_top" },
-	{ "limit/smoothed", "limit_smoothed" },
-	{ "draw_margin/h_enabled", "draw_margin_h_enabled" },
-	{ "draw_margin/v_enabled", "draw_margin_v_enabled" },
-	{ "smoothing/enable", "smoothing_enabled" },
-	{ "smoothing/speed", "smoothing_speed" },
-	{ "drag_margin/left", "drag_margin_left" },
-	{ "drag_margin/top", "drag_margin_top" },
-	{ "drag_margin/right", "drag_margin_right" },
-	{ "drag_margin/bottom", "drag_margin_bottom" },
-	{ "input/pickable", "input_pickable" },
-	{ "bias/bias", "bias" },
-	{ "collision/exclude_nodes", "disable_collision" },
-	{ "range/height", "range_height" },
-	{ "range/z_min", "range_z_min" },
-	{ "range/z_max", "range_z_max" },
-	{ "range/layer_max", "range_layer_max" },
-	{ "range/item_cull_mask", "range_item_cull_max" },
-	{ "shadow/enabled", "shadow_enabled" },
-	{ "shadow/color", "shadow_color" },
-	{ "shadow/buffer_size", "shadow_buffer_size" },
-	{ "shadow/gradient_length", "shadow_gradient_length" },
-	{ "shadow/filter", "shadow_filter" },
-	{ "shadow/item_cull_mask", "shadow_item_cull_mask" },
-	{ "transform/pos", "position" },
-	{ "transform/rot", "rotation_degrees" },
-	{ "transform/scale", "scale" },
-	{ "z/z", "z" },
-	{ "z/relative", "z_as_relative" },
-	{ "scroll/offset", "scroll_offset" },
-	{ "scroll/base_offset", "scroll_base_offset" },
-	{ "scroll/base_scale", "scroll_base_scale" },
-	{ "scroll/limit_begin", "scroll_limit_begin" },
-	{ "scroll/limit_end", "scroll_limit_end" },
-	{ "scroll/ignore_camera_zoom", "scroll_ignore_camera_zoom" },
-	{ "motion/scale", "motion_scale" },
-	{ "motion/offset", "motion_offset" },
-	{ "motion/mirroring", "motion_mirroring" },
-	{ "collision/layers", "collision_layer" },
-	{ "collision/mask", "collision_mask" },
-	{ "texture/texture", "texture" },
-	{ "texture/offset", "texture_offset" },
-	{ "texture/rotation", "texture_rotation" },
-	{ "texture/scale", "texture_scale" },
-	{ "invert/enable", "invert_enable" },
-	{ "invert/border", "invert_border" },
-	{ "config/polyphony", "polyphony" },
-	{ "config/samples", "samples" },
-	{ "config/pitch_random", "random_pitch" },
-	{ "params/volume_db", "volume_db" },
-	{ "params/pitch_scale", "pitch_scale" },
-	{ "params/attenuation/min_distance", "attenuation_min_distance" },
-	{ "params/attenuation/max_distance", "attenuation_max_distance" },
+	{ "anchor/bottom", "anchor_bottom" }, // Control
+	{ "anchor/left", "anchor_left" }, // Control
+	{ "anchor/right", "anchor_right" }, // Control
+	{ "anchor/top", "anchor_top" }, // Control
+	{ "bbcode/bbcode", "bbcode_text" }, // RichTextLabel
+	{ "bbcode/enabled", "bbcode_enabled" }, // RichTextLabel
+	{ "bias/bias", "bias" }, // Joints2D
+	{ "caret/block_caret", "caret_block_mode" }, // TextEdit
+	{ "caret/caret_blink", "caret_blink" }, // LineEdit, TextEdit
+	{ "caret/caret_blink_speed", "caret_blink_speed" }, // LineEdit, TextEdit
+	{ "cell/center_x", "cell_center_x" }, // GridMap
+	{ "cell/center_y", "cell_center_y" }, // GridMap
+	{ "cell/center_z", "cell_center_z" }, // GridMap
+	{ "cell/custom_transform", "cell_custom_transform" }, // TileMap
+	{ "cell/half_offset", "cell_half_offset" }, // TileMap
+	{ "cell/octant_size", "cell_octant_size" }, // GridMap
+	{ "cell/quadrant_size", "cell_quadrant_size" }, // TileMap
+	{ "cell/scale", "cell_scale" }, // GridMap
+	{ "cell/size", "cell_size" }, // GridMap, TileMap
+	{ "cell/tile_origin", "cell_tile_origin" }, // TileMap
+	{ "cell/y_sort", "cell_y_sort" }, // TileMap
+	{ "collision/bounce", "collision_bounce" }, // TileMap
+	//{ "collision/exclude_nodes", "disable_collision" }, // Joint, Joint2D // Joint2D can be converted, not Joint, handle manually
+	{ "collision/friction", "collision_friction" }, // TileMap
+	{ "collision/layers", "collision_layer" }, // Area, Area2D, PhysicsBody, PhysicsBody2D, TileMap
+	{ "collision/margin", "collision/safe_margin" }, // PhysicsBody, PhysicsBody2D
+	{ "collision/mask", "collision_mask" }, // Area, Area2D, PhysicsBody, PhysicsBody2D, TileMap
+	{ "collision/use_kinematic", "collision_use_kinematic" }, // TileMap
+	{ "content_margin/bottom", "content_margin_bottom" }, // StyleBox
+	{ "content_margin/left", "content_margin_left" }, // StyleBox
+	{ "content_margin/right", "content_margin_right" }, // StyleBox
+	{ "content_margin/top", "content_margin_top" }, // StyleBox
+	{ "damping/compression", "damping_compression" }, // VehicleWheel
+	{ "damping/relaxation", "damping_relaxation" }, // VehicleWheel
+	{ "damp_override/angular", "angular_damp" }, // PhysicsBody, PhysicsBody2D
+	{ "damp_override/linear", "linear_damp" }, // PhysicsBody, PhysicsBody2D
+	{ "dialog/hide_on_ok", "dialog_hide_on_ok" }, // AcceptDialog
+	{ "dialog/text", "dialog_text" }, // AcceptDialog
+	{ "drag_margin/bottom", "drag_margin_bottom" }, // Camera2D
+	{ "drag_margin/h_enabled", "drag_margin_h_enabled" }, // Camera2D
+	{ "drag_margin/left", "drag_margin_left" }, // Camera2D
+	{ "drag_margin/right", "drag_margin_right" }, // Camera2D
+	{ "drag_margin/top", "drag_margin_top" }, // Camera2D
+	{ "drag_margin/v_enabled", "drag_margin_v_enabled" }, // Camera2D
+	{ "enabler/fixed_process_parent", "physics_process_parent" }, // VisibilityEnabler2D
+	{ "enabler/freeze_bodies", "freeze_bodies" }, // VisibilityEnabler, VisibilityEnabler2D
+	{ "enabler/pause_animated_sprites", "pause_animated_sprites" }, // VisibilityEnabler2D
+	{ "enabler/pause_animations", "pause_animations" }, // VisibilityEnabler, VisibilityEnabler2D
+	{ "enabler/pause_particles", "pause_particles" }, // VisibilityEnabler2D
+	{ "enabler/process_parent", "process_parent" }, // VisibilityEnabler2D
+	{ "expand_margin/bottom", "expand_margin_bottom" }, // StyleBox
+	{ "expand_margin/left", "expand_margin_left" }, // StyleBox
+	{ "expand_margin/right", "expand_margin_right" }, // StyleBox
+	{ "expand_margin/top", "expand_margin_top" }, // StyleBox
+	{ "extra_spacing/bottom", "extra_spacing_bottom" }, // DynamicFont
+	{ "extra_spacing/char", "extra_spacing_char" }, // DynamicFont
+	{ "extra_spacing/space", "extra_spacing_space" }, // DynamicFont
+	{ "extra_spacing/top", "extra_spacing_top" }, // DynamicFont
+	{ "flags/alpha_cut", "alpha_cut" }, // Sprite3D
+	{ "flags/double_sided", "double_sided" }, // Sprite3D
+	{ "flags/shaded", "shaded" }, // Sprite3D
+	{ "flags/transparent", "transparent" }, // Sprite3D
+	{ "focus_neighbour/bottom", "focus_neighbour_bottom" }, // Control
+	{ "focus_neighbour/left", "focus_neighbour_left" }, // Control
+	{ "focus_neighbour/right", "focus_neighbour_right" }, // Control
+	{ "focus_neighbour/top", "focus_neighbour_top" }, // Control
+	{ "font/font", "font_data" }, // DynamicFont
+	{ "font/size", "size" }, // DynamicFont
+	{ "font/use_filter", "use_filter" }, // DynamicFont
+	{ "font/use_mipmaps", "use_mipmaps" }, // DynamicFont
+	{ "geometry/cast_shadow", "cast_shadow" }, // GeometryInstance
+	{ "geometry/extra_cull_margin", "extra_cull_margin" }, // GeometryInstance
+	{ "geometry/material_override", "material_override" }, // GeometryInstance
+	{ "geometry/use_baked_light", "use_in_baked_light" }, // GeometryInstance
+	{ "hint/tooltip", "hint_tooltip" }, // Control
+	{ "input/capture_on_drag", "input_capture_on_drag" }, // CollisionObject
+	{ "input/pickable", "input_pickable" }, // CollisionObject2D
+	{ "input/ray_pickable", "input_ray_pickable" }, // CollisionObject
+	{ "invert/border", "invert_border" }, // Polygon2D
+	{ "invert/enable", "invert_enable" }, // Polygon2D
+	{ "limit/bottom", "limit_bottom" }, // Camera2D
+	{ "limit/left", "limit_left" }, // Camera2D
+	{ "limit/right", "limit_right" }, // Camera2D
+	{ "limit/top", "limit_top" }, // Camera2D
+	{ "margin/bottom", "margin_bottom" }, // Control, StyleBox
+	{ "margin/left", "margin_left" }, // Control, StyleBox
+	{ "margin/right", "margin_right" }, // Control, StyleBox
+	{ "margin/top", "margin_top" }, // Control, StyleBox
+	{ "material/material", "material" }, // CanvasItem
+	{ "material/use_parent", "use_parent_material" }, // CanvasItem
+	{ "mesh/mesh", "mesh" }, // MeshInstance
+	{ "mesh/skeleton", "skeleton" }, // MeshInstance
+	//{ "mode", "fill_mode" }, // TextureProgress & others // Would break TileMap and others, handle manually
+	{ "motion/brake", "brake" }, // VehicleBody
+	{ "motion/engine_force", "engine_force" }, // VehicleBody
+	{ "motion/mirroring", "motion_mirroring" }, // ParallaxLayer
+	{ "motion/offset", "motion_offset" }, // ParallaxLayer
+	{ "motion/scale", "motion_scale" }, // ParallaxLayer
+	{ "motion/steering", "steering" }, // VehicleBody
+	{ "occluder/light_mask", "occluder_light_mask" }, // TileMap
 	{ "params/attenuation/distance_exp", "attenuation_distance_exp" },
-	{ "cell/size", "cell_size" },
-	{ "cell/quadrant_size", "cell_quadrant_size" },
-	{ "cell/half_offset", "cell_half_offset" },
-	{ "cell/tile_origin", "cell_tile_origin" },
-	{ "cell/y_sort", "cell_y_sort" },
-	{ "collision/use_kinematic", "collision_use_kinematic" },
-	{ "collision/friction", "collision_friction" },
-	{ "collision/bounce", "collision_bounce" },
-	{ "collision/layers", "collision_layers" },
-	{ "collision/mask", "collision_mask" },
-	{ "occluder/light_mask", "occluder_light_mask" },
-	{ "enabler/pause_animations", "pause_animations" },
-	{ "enabler/freeze_bodies", "freeze_bodies" },
-	{ "enabler/pause_particles", "pause_particles" },
-	{ "enabler/pause_animated_sprites", "pause_animated_sprites" },
-	{ "enabler/process_parent", "process_parent" },
-	{ "enabler/fixed_process_parent", "fixed_process_parent" },
-	{ "sort/enabled", "sort_enabled" },
-	{ "collision/layers", "collision_layers" },
-	{ "collision/mask", "collision_mask" },
-	{ "input/ray_pickable", "input_ray_pickable" },
-	{ "input/capture_on_drag", "input_capture_on_drag" },
-	{ "light/color", "light_color" },
-	{ "light/energy", "light_energy" },
-	{ "light/negative", "light_negative" },
-	{ "light/specular", "light_specular" },
-	{ "light/cull_mask", "light_cull_mask" },
-	{ "shadow/enabled", "shadow_enabled" },
-	{ "shadow/color", "shadow_color" },
-	{ "shadow/bias", "shadow_bias" },
-	{ "shadow/max_distance", "shadow_max_distance" },
-	{ "editor/editor_only", "editor_only" },
-	{ "directional_shadow/mode", "directional_shadow_mode" },
-	{ "directional_shadow/split_1", "directional_shadow_split_1" },
-	{ "directional_shadow/split_2", "directional_shadow_split_2" },
-	{ "directional_shadow/split_3", "directional_shadow_split_3" },
-	{ "directional_shadow/blend_splits", "directional_shadow_blend_splits" },
-	{ "directional_shadow/normal_bias", "directional_shadow_normal_bias" },
-	{ "directional_shadow/bias_split_scale", "directional_shadow_bias_split_scale" },
-	{ "omni/range", "omni_range" },
-	{ "omni/attenuation", "omni_attenuation" },
-	{ "omni/shadow_mode", "omni_shadow_mode" },
-	{ "omni/shadow_detail", "omni_shadow_detail" },
-	{ "spot/range", "spot_range" },
-	{ "spot/attenuation", "spot_attenuation" },
-	{ "spot/angle", "spot_angle" },
-	{ "spot/spot_attenuation", "spot_angle_attenuation" },
-	{ "mesh/mesh", "mesh" },
-	{ "mesh/skeleton", "skeleton" },
-	{ "collision/layers", "collision_layer" },
-	{ "collision/mask", "collision_mask" },
-	{ "quad/axis", "axis" },
-	{ "quad/size", "size" },
-	{ "quad/offset", "offset" },
-	{ "quad/centered", "centered" },
-	{ "transform/local", "transform" },
-	{ "transform/translation", "translation" },
-	{ "transform/rotation", "rotation_degrees" },
-	{ "transform/scale", "scale" },
-	{ "visibility/visible", "visible" },
-	{ "params/volume_db", "volume_db" },
-	{ "params/pitch_scale", "pitch_scale" },
-	{ "params/attenuation/min_distance", "attenuation_min_distance" },
 	{ "params/attenuation/max_distance", "attenuation_max_distance" },
-	{ "params/attenuation/distance_exp", "attenuation_distance_exp" },
-	{ "params/emission_cone/degrees", "emission_cone_degrees" },
+	{ "params/attenuation/min_distance", "attenuation_min_distance" },
 	{ "params/emission_cone/attenuation_db", "emission_cone_attenuation_db" },
-	{ "config/polyphony", "polyphony" },
-	{ "config/samples", "samples" },
-	{ "flags/transparent", "transparent" },
-	{ "flags/shaded", "shaded" },
-	{ "flags/alpha_cut", "alpha_cut" },
-	{ "type/traction", "use_as_traction" },
-	{ "type/steering", "use_as_steering" },
-	{ "wheel/radius", "wheel_radius" },
-	{ "wheel/rest_length", "wheel_rest_length" },
-	{ "wheel/friction_slip", "wheel_friction_sleep" },
-	{ "suspension/travel", "suspension_travel" },
-	{ "suspension/stiffness", "suspension_stiffness" },
-	{ "suspension/max_force", "suspension_max_force" },
-	{ "damping/compression", "damping_compression" },
-	{ "damping/relaxation", "damping_relaxation" },
-	{ "motion/engine_force", "engine_force" },
-	{ "motion/breake", "breake" },
-	{ "motion/steering", "steering" },
-	{ "body/mass", "mass" },
-	{ "body/friction", "friction" },
-	{ "enabler/pause_animations", "pause_animations" },
-	{ "enabler/freeze_bodies", "freeze_bodies" },
-	{ "geometry/material_override", "material_override" },
-	{ "geometry/cast_shadow", "cast_shadow" },
-	{ "geometry/extra_cull_margin", "extra_cull_margin" },
-	{ "geometry/billboard", "use_as_billboard" },
-	{ "geometry/billboard_y", "use_as_y_billboard" },
-	{ "geometry/depth_scale", "use_depth_scale" },
-	{ "geometry/visible_in_all_rooms", "visible_in_all_rooms" },
-	{ "geometry/use_baked_light", "use_in_baked_light" },
-	// Properly renamed for AnimationPlayer, but not AnimationTreePlayer, so handle manually
-	//{ "playback/active", "playback_active" },
-	{ "playback/default_blend_time", "playback_default_blend_time" },
-	{ "playback/process_mode", "playback_process_mode" },
-	{ "playback/speed", "playback_speed" },
-	{ "root/root", "root_node" },
-	{ "stream/stream", "stream" },
-	{ "stream/play", "playing" },
-	{ "stream/loop", "loop" },
-	{ "stream/volume_db", "volume_db" },
-	{ "stream/autoplay", "autoplay" },
-	{ "stream/paused", "paused" },
-	{ "stream/loop_restart_time", "loop_restart_time" },
-	{ "stream/buffering_ms", "buffering_ms" },
-	{ "stream/pitch_scale", "pitch_scale" },
-	{ "stream/tempo_scale", "tempo_scale" },
-	{ "stream/audio_track", "audio_track" },
-	{ "stream/autoplay", "stream_autoplay" },
-	{ "stream/paused", "stream_paused" },
-	{ "window/title", "window_title" },
-	{ "dialog/text", "dialog_text" },
-	{ "dialog/hide_on_ok", "dialog_hide_on_ok" },
-	{ "placeholder/text", "placeholder_text" },
-	{ "placeholder/alpha", "placeholder_alpha" },
-	{ "caret/caret_blink", "caret_blink" },
-	{ "caret/caret_blink_speed", "caret_blink_speed" },
-	{ "patch_margin/left", "patch_margin_left" },
-	{ "patch_margin/right", "patch_margin_right" },
-	{ "patch_margin/top", "patch_margin_top" },
-	{ "patch_margin/bottom", "patch_margin_bottom" },
-	{ "popup/exclusive", "popup_exclusive" },
-	{ "percent/visible", "percent_visible" },
-	{ "range/min", "min_value" },
-	{ "range/max", "max_value" },
-	{ "range/step", "step" },
-	{ "range/page", "page" },
-	{ "range/value", "value" },
-	{ "range/exp_edit", "exp_edit" },
-	{ "range/rounded", "rounded" },
-	{ "velocity/linear", "linear_velocity" },
-	{ "velocity/angular", "angular_velocity" },
-	{ "damp_override_linear", "linear_damp" },
-	{ "damp_override_angular", "angular_damp" },
-	{ "velocity/linear", "linear_velocity" },
-	{ "velocity/angular", "angular_velocity" },
-	{ "damp_override_linear", "linear_damp" },
-	{ "damp_override_angular", "angular_damp" },
-	{ "bbcode/enabled", "bbcode_enabled" },
-	{ "bbcode/bbcode", "bbcode_text" },
-	{ "scroll/horizontal", "scroll_horizontal" },
-	{ "scroll/vertical", "scroll_vertical" },
-	{ "split/offset", "split_offset" },
-	{ "split/collapsed", "collapsed" },
-	{ "split/dragger_visibility", "dragger_visibility" },
-	{ "caret/block_caret", "caret_block_mode" },
-	{ "caret/caret_blink", "caret_blink" },
-	{ "caret/caret_blink_speed", "caret_blink_speed" },
-	{ "textures/normal", "texture_normal" },
-	{ "textures/pressed", "texture_pressed" },
-	{ "textures/hover", "texture_hover" },
-	{ "textures/disabled", "texture_disabled" },
-	{ "textures/focused", "texture_focused" },
-	{ "textures/click_mask", "texture_click_mask" },
-	{ "params/scale", "texture_scale" },
+	{ "params/emission_cone/degrees", "emission_cone_degrees" },
 	{ "params/modulate", "self_modulate" },
-	{ "texture/under", "texture_under" },
-	{ "texture/over", "texture_over" },
-	{ "texture/progress", "texture_progress" },
-	//{ "mode", "fill_mode" }, breaks tilemap :\
-	{ "radial_fill/initial_angle", "radial_initial_angle" },
-	{ "radial_fill/fill_degrees", "radial_fill_degrees" },
-	{ "radial_fill/center_offset", "radial_center_offset" },
-	{ "font/size", "size" },
-	{ "extra_spacing/top", "extra_spacing_top" },
-	{ "extra_spacing/bottom", "extra_spacing_bottom" },
-	{ "extra_spacing/char", "extra_spacing_char" },
-	{ "extra_spacing/space", "extra_spacing_space" },
-	{ "font/use_mipmaps", "use_mipmaps" },
-	{ "font/use_filter", "use_filter" },
-	{ "font/font", "font_data" },
-	{ "content_margin/left", "content_margin_left" },
-	{ "content_margin/right", "content_margin_right" },
-	{ "content_margin/bottom", "content_margin_bottom" },
-	{ "content_margin/top", "content_margin_top" },
-	{ "margin/left", "margin_left" },
-	{ "margin/top", "margin_top" },
-	{ "margin/bottom", "margin_bottom" },
-	{ "margin/right", "margin_right" },
-	{ "expand_margin/left", "expand_margin_left" },
-	{ "expand_margin/top", "expand_margin_top" },
-	{ "expand_margin/bottom", "expand_margin_bottom" },
-	{ "expand_margin/right", "expand_margin_right" },
-	{ "modulate/color", "modulate_color" },
-	{ "modulate", "self_modulate" },
-	{ "cell/size", "cell_size" },
-	{ "cell/octant_size", "cell_octant_size" },
-	{ "cell/center_x", "cell_center_x" },
-	{ "cell/center_y", "cell_center_y" },
-	{ "cell/center_z", "cell_center_z" },
-	{ "cell/scale", "cell_scale" },
-	{ "region", "region_enabled" },
-	{ "rect/min_size", "rect_min_size" },
-	{ "rect/rotation", "rect_rotation" },
-	{ "rect/scale", "rect_scale" },
-	{ "process/pause_mode", "pause_mode" },
+	{ "params/pitch_scale", "pitch_scale" },
+	{ "params/scale", "texture_scale" },
+	{ "params/volume_db", "volume_db" },
+	{ "patch_margin/bottom", "patch_margin_bottom" }, // Patch9Frame
+	{ "patch_margin/left", "patch_margin_left" }, // Patch9Frame
+	{ "patch_margin/right", "patch_margin_right" }, // Patch9Frame
+	{ "patch_margin/top", "patch_margin_top" }, // Patch9Frame
+	{ "percent/visible", "percent_visible" }, // ProgressBar
+	{ "placeholder/alpha", "placeholder_alpha" }, // LineEdit
+	{ "placeholder/text", "placeholder_text" }, // LineEdit
+	//{ "playback/active", "playback_active" }, // AnimationPlayer, AnimationTreePlayer // properly renamed for AnimationPlayer, but not AnimationTreePlayer, handle manually
+	{ "playback/default_blend_time", "playback_default_blend_time" }, // AnimationPlayer
+	{ "playback/process_mode", "playback_process_mode" }, // AnimationPlayer, AnimationTreePlayer, Tween
+	{ "playback/speed", "playback_speed" }, // AnimationPlayer, Tween
+	{ "playback/repeat", "playback_speed" }, // AnimationPlayer
+	{ "popup/exclusive", "popup_exclusive" }, // Popup
+	{ "process/pause_mode", "pause_mode" }, // Node
+	{ "radial_fill/center_offset", "radial_center_offset" }, // TextureProgress
+	{ "radial_fill/fill_degrees", "radial_fill_degrees" }, // TextureProgress
+	{ "radial_fill/initial_angle", "radial_initial_angle" }, // TextureProgress
+	{ "range/exp_edit", "exp_edit" }, // Range
+	{ "range/height", "range_height" }, // Light2D
+	{ "range/item_mask", "range_item_cull_mask" }, // Light2D
+	{ "range/layer_max", "range_layer_max" }, // Light2D
+	{ "range/layer_min", "range_layer_min" }, // Light2D
+	{ "range/max", "max_value" }, // Range
+	{ "range/min", "min_value" }, // Range
+	{ "range/page", "page" }, // Range
+	{ "range/rounded", "rounded" }, // Range
+	{ "range/step", "step" }, // Range
+	{ "range/value", "value" }, // Range
+	{ "range/z_max", "range_z_max" }, // Light2D
+	{ "range/z_min", "range_z_min" }, // Light2D
+	{ "rect/min_size", "rect_min_size" }, // Control
+	{ "rect/pos", "rect_position" }, // Control
+	{ "rect/rotation", "rect_rotation" }, // Control
+	{ "rect/scale", "rect_scale" }, // Control
+	{ "rect/size", "rect_size" }, // Control
+	//{ "region", "region_enabled" }, // Sprite, Sprite3D // Not renamed for Texture, handle manually
+	{ "resource/name", "resource_name" }, // Resource
+	{ "resource/path", "resource_path" }, // Resource
+	{ "root/root", "root_node" }, // AnimationPlayer
+	{ "script/script", "script" }, // Object
+	{ "scroll/base_offset", "scroll_base_offset" }, // ParallaxBackground
+	{ "scroll/base_scale", "scroll_base_scale" }, // ParallaxBackground
+	{ "scroll/horizontal", "scroll_horizontal_enabled" }, // ScrollContainer
+	{ "scroll/ignore_camera_zoom", "scroll_ignore_camera_zoom" }, // ParallaxBackground
+	{ "scroll/limit_begin", "scroll_limit_begin" }, // ParallaxBackground
+	{ "scroll/limit_end", "scroll_limit_end" }, // ParallaxBackground
+	{ "scroll/offset", "scroll_offset" }, // ParallaxBackground
+	{ "scroll/vertical", "scroll_vertical_enabled" }, // ScrollContainer
+	{ "shadow/buffer_size", "shadow_buffer_size" }, // Light2D
+	{ "shadow/color", "shadow_color" }, // Light2D
+	{ "shadow/enabled", "shadow_enabled" }, // Light2D
+	{ "shadow/item_mask", "shadow_item_cull_mask" }, // Light2D
+	{ "size_flags/horizontal", "size_flags_horizontal" }, // Control // Enum order got inverted Expand,Fill -> Fill,Expand, handle manually after rename
+	{ "size_flags/stretch_ratio", "size_flags_stretch_ratio" }, // Control
+	{ "size_flags/vertical", "size_flags_vertical" }, // Control // Enum order got inverted Expand,Fill -> Fill,Expand, handle manually after rename
+	{ "smoothing/enable", "smoothing_enabled" }, // Camera2D
+	{ "smoothing/speed", "smoothing_speed" }, // Camera2D
+	{ "sort/enabled", "sort_enabled" }, // YSort
+	{ "split/collapsed", "collapsed" }, // SplitContainer
+	{ "split/dragger_visibility", "dragger_visibility" }, // SplitContainer
+	{ "split/offset", "split_offset" }, // SplitContainer
+	{ "stream/audio_track", "audio_track" }, // VideoPlayer
+	{ "stream/autoplay", "autoplay" }, // VideoPlayer
+	{ "stream/buffering_ms", "buffering_msec" }, // VideoPlayer
+	{ "stream/loop", "loop" }, // Audio*
+	{ "stream/loop_restart_time", "loop_offset" }, // Audio*
+	{ "stream/paused", "paused" }, // VideoPlayer
+	{ "stream/pitch_scale", "pitch_scale" }, // Audio*
+	{ "stream/play", "playing" }, // Audio*
+	{ "stream/stream", "stream" }, // VideoPlayer
+	{ "stream/volume_db", "volume_db" }, // VideoPlayer
+	{ "suspension/max_force", "suspension_max_force" }, // VehicleWheel
+	{ "suspension/stiffness", "suspension_stiffness" }, // VehicleWheel
+	{ "suspension/travel", "suspension_travel" }, // VehicleWheel
+	{ "texture/offset", "texture_offset" }, // Polygon2D
+	{ "texture/over", "texture_over" }, // TextureProgress
+	{ "texture/progress", "texture_progress" }, // TextureProgress
+	{ "texture/rotation", "texture_rotation_degrees" }, // Polygon2D
+	{ "texture/scale", "texture_scale" }, // Polygon2D
+	{ "textures/click_mask", "texture_click_mask" }, // TextureButton
+	{ "textures/disabled", "texture_disabled" }, // TextureButton
+	{ "textures/focused", "texture_focused" }, // TextureButton
+	{ "textures/hover", "texture_hover" }, // TextureButton
+	{ "textures/normal", "texture_normal" }, // TextureButton
+	{ "textures/pressed", "texture_pressed" }, // TextureButton
+	{ "texture/texture", "texture" }, // Polygon2D
+	{ "texture/under", "texture_under" }, // TextureProgress
+	{ "theme/theme", "theme" }, // Control
+	{ "transform/local", "transform" }, // Spatial
+	{ "transform/pos", "position" }, // Node2D
+	{ "transform/rotation", "rotation_degrees" }, // Spatial
+	{ "transform/rotation_rad", "rotation" }, // Spatial
+	{ "transform/rot", "rotation_degrees" }, // Node2D
+	{ "transform/scale", "scale" }, // Node2D, Spatial
+	{ "transform/translation", "translation" }, // Spatial
+	{ "type/steering", "use_as_steering" }, // VehicleWheel
+	{ "type/traction", "use_as_traction" }, // VehicleWheel
+	{ "velocity/angular", "angular_velocity" }, // PhysicsBody, PhysicsBody2D
+	{ "velocity/linear", "linear_velocity" }, // PhysicsBody, PhysicsBody2D
+	{ "visibility/behind_parent", "show_behind_parent" }, // CanvasItem
+	{ "visibility/light_mask", "light_mask" }, // CanvasItem
+	{ "visibility/on_top", "show_on_top" }, // CanvasItem
+	//{ "visibility/opacity", "modulate" }, // CanvasItem // Can't be converted this way, handle manually
+	//{ "visibility/self_opacity", "self_modulate" }, // CanvasItem // Can't be converted this way, handle manually
+	{ "visibility/visible", "visible" }, // CanvasItem, Spatial
+	{ "wheel/friction_slip", "wheel_friction_slip" }, // VehicleWheel
+	{ "wheel/radius", "wheel_radius" }, // VehicleWheel
+	{ "wheel/rest_length", "wheel_rest_length" }, // VehicleWheel
+	{ "wheel/roll_influence", "wheel_roll_influence" }, // VehicleWheel
+	{ "window/title", "window_title" }, // Dialogs
+	{ "z/relative", "z_as_relative" }, // Node2D
+	{ "z/z", "z_index" }, // Node2D
 	{ NULL, NULL }
 };
 
 static const char *type_renames[][2] = {
-	{ "StreamPlayer", "AudioStreamPlayer" },
-	{ "SpatialSamplePlayer", "AudioStreamPlayer3D" },
-	{ "SpatialStreamPlayer", "AudioStreamPlayer3D" },
-	{ "SamplePlayer", "Node" },
-	{ "SamplePlayer2D", "AudioStreamPlayer2D" },
-	{ "SoundPlayer2D", "Node2D" },
-	{ "SampleLibrary", "Resource" },
+	{ "CanvasItemMaterial", "ShaderMaterial" },
+	{ "CanvasItemShader", "Shader" },
 	{ "ColorFrame", "ColorRect" },
+	{ "ColorRamp", "Gradient" },
+	{ "FixedMaterial", "SpatialMaterial" },
+	{ "Patch9Frame", "NinePatchRect" },
 	{ "ReferenceFrame", "ReferenceRect" },
+	{ "SampleLibrary", "Resource" },
+	{ "SamplePlayer2D", "AudioStreamPlayer2D" },
+	{ "SamplePlayer", "Node" },
+	{ "SoundPlayer2D", "Node2D" },
+	{ "SpatialSamplePlayer", "AudioStreamPlayer3D" },
+	{ "SpatialStreamPlayer", "AudioStreamPlayer3D" },
+	{ "StreamPlayer", "AudioStreamPlayer" },
+	{ "TestCube", "MeshInstance" },
 	{ "TextureFrame", "TextureRect" },
-	{ "Patch9Frame", "NinePatchRect" },
-	{ "FixedMaterial", "SpatialMaterial" },
-	{ "ColorRamp", "Gradient" },
-	{ "CanvasItemShader", "Shader" },
-	{ "CanvasItemMaterial", "ShaderMaterial" },
-	{ "TestCube", "MeshInstance" }, // TODO: Handle assignment of CubeMesh + default material?
 	{ NULL, NULL }
 };
 
 static const char *signal_renames[][2] = {
-	{ "area_enter", "area_entered" },
-	{ "area_exit", "area_exited" },
-	{ "area_enter_shape", "area_shape_entered" },
-	{ "area_exit_shape", "area_shape_exited" },
-	{ "body_enter", "body_entered" },
-	{ "body_exit", "body_exited" },
-	{ "body_enter_shape", "body_shape_entered" },
-	{ "body_exit_shape", "body_shape_exited" },
-	{ "mouse_enter", "mouse_entered" },
-	{ "mouse_exit", "mouse_exited" },
-	{ "focus_enter", "focus_entered" },
-	{ "focus_exit", "focus_exited" },
-	{ "modal_close", "modal_closed" },
-	{ "enter_tree", "tree_entered" },
-	{ "exit_tree", "tree_exited" },
-	{ "input_event", "gui_input" },
+	{ "area_enter", "area_entered" }, // Area, Area2D
+	{ "area_enter_shape", "area_shape_entered" }, // Area, Area2D
+	{ "area_exit", "area_exited" }, // Area, Area2D
+	{ "area_exit_shape", "area_shape_exited" }, // Area, Area2D
+	{ "body_enter", "body_entered" }, // Area, Area2D, PhysicsBody, PhysicsBody2D
+	{ "body_enter_shape", "body_shape_entered" }, // Area, Area2D, PhysicsBody, PhysicsBody2D
+	{ "body_exit", "body_exited" }, // Area, Area2D, PhysicsBody, PhysicsBody2D
+	{ "body_exit_shape", "body_shape_exited" }, // Area, Area2D, PhysicsBody, PhysicsBody2D
+	{ "enter_camera", "camera_entered" }, // VisibilityNotifier
+	{ "enter_screen", "screen_entered" }, // VisibilityNotifier, VisibilityNotifier2D
+	{ "enter_tree", "tree_entered" }, // Node
+	{ "enter_viewport", "viewport_entered" }, // VisibilityNotifier2D
+	{ "exit_camera", "camera_exited" }, // VisibilityNotifier
+	{ "exit_screen", "screen_exited" }, // VisibilityNotifier, VisibilityNotifier2D
+	{ "exit_tree", "tree_exited" }, // Node
+	{ "exit_viewport", "viewport_exited" }, // VisibilityNotifier2D
+	//{ "finished", "animation_finished" }, // AnimationPlayer, AnimatedSprite, but not StreamPlayer, handle manually
+	{ "fixed_frame", "physics_frame" }, // SceneTree
+	{ "focus_enter", "focus_entered" }, // Control
+	{ "focus_exit", "focus_exited" }, // Control
+	{ "input_event", "gui_input" }, // Control // FIXME: but not CollisionObject and CollisionObject2D, it should be handled manually
+	{ "item_pressed", "id_pressed" }, // PopupMenu
+	{ "modal_close", "modal_closed" }, // Control
+	{ "mouse_enter", "mouse_entered" }, // CollisionObject, CollisionObject2D, Control
+	{ "mouse_exit", "mouse_exited" }, // CollisionObject, CollisionObject2D, Control
+	{ "tween_start", "tween_started" }, // Tween
+	{ "tween_complete", "tween_completed" }, // Tween
 	{ NULL, NULL }
 };
 
@@ -542,7 +489,7 @@ void EditorExportGodot3::_rename_properties(const String &p_type, List<ExportDat
 		// Do this before the renaming, as afterwards we can't distinguish
 		// between 2D and 3D rotations_degrees
 		if (E->get().name == "transform/rot") {
-			E->get().value = E->get().value.operator real_t() * -1.0;
+			E->get().value = (real_t)E->get().value * -1.0;
 		}
 
 		// To fix 2D rotations in the properties of Animation tracks (see below),
@@ -573,6 +520,16 @@ void EditorExportGodot3::_rename_properties(const String &p_type, List<ExportDat
 					if (prop_rename_map.has(track_prop)) {
 						track_prop = prop_rename_map[track_prop];
 					}
+
+					// "[self_]opacity" was removed, and is replaced by the alpha component of "[self_]modulate"
+					// "modulate" may already exist, but we posit that the "opacity" value is more important
+					// Thankfully in NodePaths we can access the alpha property directly
+					if (track_prop == "visibility/opacity") {
+						track_prop = "modulate:a";
+					} else if (track_prop == "visibility/self_opacity") {
+						track_prop = "self_modulate:a";
+					}
+
 					E->get().value = NodePath(track_nodepath + ":" + track_prop);
 				}
 			} else if (found_track_number != "" && prop_name.begins_with("tracks/") && prop_name.ends_with("/keys") && prop_name.find(found_track_number) != -1) {
@@ -582,10 +539,11 @@ void EditorExportGodot3::_rename_properties(const String &p_type, List<ExportDat
 				if (track_keys.has("values")) {
 					Array values = track_keys["values"];
 					for (int i = 0; i < values.size(); i++) {
-						values[i] = values[i].operator real_t() * -1.0;
+						values[i] = (real_t)values[i] * -1.0;
 					}
 					track_keys["values"] = values;
 					E->get().value = track_keys;
+					found_track_number = "";
 				} else {
 					print_line("Tried to change rotation in Animation tracks, but no value set found.");
 				}
@@ -602,7 +560,8 @@ void EditorExportGodot3::_rename_properties(const String &p_type, List<ExportDat
 
 		// Anchors changed from Begin,End,Ratio,Center to Begin,End,Center
 		if (E->get().name.begins_with("anchor_")) {
-			switch (E->get().value.operator int()) {
+			int prop_value = (int)E->get().value;
+			switch (prop_value) {
 				case 0: // Begin
 				case 1: // End
 					break;
@@ -613,11 +572,50 @@ void EditorExportGodot3::_rename_properties(const String &p_type, List<ExportDat
 			}
 		}
 
-		// AnimationPlayer's "playback/active" was renamed to "playback_active", but not AnimationTrrePlayer's
-		// We rename manually only for AnimationPlayer
-		if (E->get().name == "playback/active" && p_type == "AnimationPlayer") {
+		// Size flags enum changed ordering from "Expand,Fill" to "Fill,Expand,..."
+		// So we swap 1 (Expand) and 2 (Fill), keep 0 (none) and 3 (Expand + Fill)
+		if (E->get().name == "size_flags_horizontal" || E->get().name == "size_flags_vertical") {
+			int prop_value = (int)E->get().value;
+			switch (prop_value) {
+				case 1: // Expand -> Fill
+					E->get().value = 2;
+				case 2: // Fill -> Expand
+					E->get().value = 1;
+				default: // none or both, keep
+					break;
+			}
+		}
+
+		// "[self_]opacity" was removed, and is replaced by the alpha component of "[self_]modulate"
+		// "modulate" may already exist, but we posit that the "opacity" value is more important
+		if (E->get().name == "visibility/opacity" || E->get().name == "visibility/self_opacity") {
+			if (E->get().name == "visibility/self_opacity") {
+				E->get().name = "self_modulate";
+			} else {
+				E->get().name = "modulate";
+			}
+			E->get().value = Color(1.0, 1.0, 1.0, (float)E->get().value);
+		}
+
+		// AnimationPlayer's "playback/active" was renamed to "playback_active", but not AnimationTreePlayer's
+		if (p_type == "AnimationPlayer" && E->get().name == "playback/active") {
 			E->get().name = "playback_active";
 		}
+
+		// Joint2D's "collision/exclude_nodes" was renamed to "disable_collision", but not Joint's
+		if (p_type == "Joint2D" && E->get().name == "collision/exclude_nodes") {
+			E->get().name = "disable_collision";
+		}
+
+		// TextureProgress' "mode" was renamed to "fill_mode", but not that of other nodes like TileMap
+		if (p_type == "TextureProgress" && E->get().name == "mode") {
+			E->get().name = "fill_mode";
+		}
+
+		// Sprite and Sprite3D's "region" was renamed to "region_enabled", but not Texture's
+		if ((p_type == "Sprite" || p_type == "Sprite3D") && E->get().name == "region") {
+			E->get().name = "region_enabled";
+		}
 	}
 }
 
@@ -646,6 +644,32 @@ void EditorExportGodot3::_convert_resources(ExportData &resource) {
 		if (signal_rename_map.has(resource.connections[i].signal)) {
 			resource.connections[i].signal = signal_rename_map[resource.connections[i].signal];
 		}
+
+		/* Manual handling for signals which need to be conditionally renamed based on their Node's type */
+
+		// AnimationPlayer and AnimatedSprite's "finished" signal was renamed to "animation_finished",
+		// but not that of StreamPlayer. Since node information is missing from the connection data
+		// (we only have the NodePath), we'll have to compare against the nodes array to find out.
+		if (resource.connections[i].signal == "finished") {
+			String from = resource.connections[i].from;
+			// NodePath "from" is relative to root node, can be direct child (no '/') or further down
+			int slice_count = from.get_slice_count("/");
+			String parent = ".";
+			String nodename = from;
+			if (slice_count > 1) {
+				parent = from.get_slice("/", slice_count - 2);
+				nodename = from.get_slice("/", slice_count - 1);
+			}
+
+			for (int j = 0; j < resource.nodes.size(); j++) {
+				if (resource.nodes[j].name == nodename && resource.nodes[j].parent == parent) {
+					if (resource.nodes[j].type == "AnimationPlayer" || resource.nodes[j].type == "AnimatedSprite") {
+						resource.connections[i].signal = "animation_finished";
+						break;
+					}
+				}
+			}
+		}
 	}
 }
 
@@ -1421,10 +1445,10 @@ void EditorExportGodot3::_save_text(const String &p_path, ExportData &resource)
 
 	for (int i = 0; i < resource.connections.size(); i++) {
 
-		String prop;
-		_get_property_as_text(resource.connections[i].binds, prop);
+		String binds_array;
+		_get_property_as_text(resource.connections[i].binds, binds_array);
 
-		f->store_line("\n[connection signal=\"" + resource.connections[i].signal + "\"  from=\"" + String(resource.connections[i].from).c_escape() + "\"  to=\"" + String(resource.connections[i].to).c_escape() + "\" method=\"" + resource.connections[i].method + "\" binds=" + prop + "]");
+		f->store_line("\n[connection signal=\"" + resource.connections[i].signal + "\" from=\"" + String(resource.connections[i].from).c_escape() + "\" to=\"" + String(resource.connections[i].to).c_escape() + "\" method=\"" + resource.connections[i].method + "\" binds=" + binds_array + "]");
 	}
 
 	for (int i = 0; i < resource.editables.size(); i++) {
@@ -2078,27 +2102,11 @@ Error EditorExportGodot3::_convert_script(const String &p_path, const String &p_
 		}
 		regexp.clear();
 
-		// Convert RawArray() => PoolByteArray()
-		regexp.compile("(.*)RawArray\\(\\)(.*)");
-		res = regexp.find(line);
-		if (res >= 0 && regexp.get_capture_count() == 3) {
-			line = regexp.get_capture(1) + "PoolByteArray()" + regexp.get_capture(2);
-		}
-		regexp.clear();
-
-		// Convert Vector2Array() => PoolVector2Array()
-		regexp.compile("(.*)Vector2Array\\(\\)(.*)");
+		// Convert _input_event( => _gui_input(
+		regexp.compile("(.*)_input_event\\((.*)");
 		res = regexp.find(line);
 		if (res >= 0 && regexp.get_capture_count() == 3) {
-			line = regexp.get_capture(1) + "PoolVector2Array()" + regexp.get_capture(2);
-		}
-		regexp.clear();
-
-		// Convert ReferenceFrame => Control
-		regexp.compile("(.*)ReferenceFrame(.*)");
-		res = regexp.find(line);
-		if (res >= 0 && regexp.get_capture_count() == 3) {
-			line = regexp.get_capture(1) + "Control" + regexp.get_capture(2);
+			line = regexp.get_capture(1) + "_gui_input(" + regexp.get_capture(2);
 		}
 		regexp.clear();
 
@@ -2120,11 +2128,84 @@ Error EditorExportGodot3::_convert_script(const String &p_path, const String &p_
 			regexp.clear();
 		}
 
+		// The following replacements may be needed more than once per line, hence the loop
 		int count;
 		int tries = 0;
 		do {
 			count = 0;
 
+			// Convert RawArray() => PoolByteArray()
+			regexp.compile("(.*)RawArray\\(\\)(.*)");
+			res = regexp.find(line);
+			if (res >= 0 && regexp.get_capture_count() == 3) {
+				line = regexp.get_capture(1) + "PoolByteArray()" + regexp.get_capture(2);
+				count++;
+			}
+			regexp.clear();
+
+			// Convert IntArray() => PoolIntArray()
+			regexp.compile("(.*)IntArray\\(\\)(.*)");
+			res = regexp.find(line);
+			if (res >= 0 && regexp.get_capture_count() == 3) {
+				line = regexp.get_capture(1) + "PoolIntArray()" + regexp.get_capture(2);
+				count++;
+			}
+			regexp.clear();
+
+			// Convert RealArray() => PoolRealArray()
+			regexp.compile("(.*)RealArray\\(\\)(.*)");
+			res = regexp.find(line);
+			if (res >= 0 && regexp.get_capture_count() == 3) {
+				line = regexp.get_capture(1) + "PoolRealArray()" + regexp.get_capture(2);
+				count++;
+			}
+			regexp.clear();
+
+			// Convert StringArray() => PoolStringArray()
+			regexp.compile("(.*)StringArray\\(\\)(.*)");
+			res = regexp.find(line);
+			if (res >= 0 && regexp.get_capture_count() == 3) {
+				line = regexp.get_capture(1) + "PoolStringArray()" + regexp.get_capture(2);
+				count++;
+			}
+			regexp.clear();
+
+			// Convert Vector2Array() => PoolVector2Array()
+			regexp.compile("(.*)Vector2Array\\(\\)(.*)");
+			res = regexp.find(line);
+			if (res >= 0 && regexp.get_capture_count() == 3) {
+				line = regexp.get_capture(1) + "PoolVector2Array()" + regexp.get_capture(2);
+				count++;
+			}
+			regexp.clear();
+
+			// Convert Vector3Array() => PoolVector3Array()
+			regexp.compile("(.*)Vector3Array\\(\\)(.*)");
+			res = regexp.find(line);
+			if (res >= 0 && regexp.get_capture_count() == 3) {
+				line = regexp.get_capture(1) + "PoolVector3Array()" + regexp.get_capture(2);
+				count++;
+			}
+			regexp.clear();
+
+			// Convert ColorArray() => PoolColorArray()
+			regexp.compile("(.*)ColorArray\\(\\)(.*)");
+			res = regexp.find(line);
+			if (res >= 0 && regexp.get_capture_count() == 3) {
+				line = regexp.get_capture(1) + "PoolColorArray()" + regexp.get_capture(2);
+				count++;
+			}
+			regexp.clear();
+
+			// Convert ReferenceFrame => ReferenceRect
+			regexp.compile("(.*)ReferenceFrame(.*)");
+			res = regexp.find(line);
+			if (res >= 0 && regexp.get_capture_count() == 3) {
+				line = regexp.get_capture(1) + "ReferenceRect" + regexp.get_capture(2);
+				count++;
+			}
+			regexp.clear();
+
 			// Convert _pos( => _position(
 			regexp.compile("(.*)_pos\\((.*)");
 			res = regexp.find(line);
@@ -2161,6 +2242,24 @@ Error EditorExportGodot3::_convert_script(const String &p_path, const String &p_
 			}
 			regexp.clear();
 
+			// Convert .get_self_opacity() => .self_modulate.a
+			regexp.compile("(.*)\\.get_self_opacity\\(\\)(.*)");
+			res = regexp.find(line);
+			if (res >= 0 && regexp.get_capture_count() == 3) {
+				line = regexp.get_capture(1) + ".self_modulate.a" + regexp.get_capture(2);
+				count++;
+			}
+			regexp.clear();
+
+			// Convert .set_self_opacity(var) => .self_modulate.a = var
+			regexp.compile("(.*)\\.set_self_opacity\\((.*)\\)(.*)");
+			res = regexp.find(line);
+			if (res >= 0 && regexp.get_capture_count() == 4) {
+				line = regexp.get_capture(1) + ".self_modulate.a = " + regexp.get_capture(2) + regexp.get_capture(3);
+				count++;
+			}
+			regexp.clear();
+
 			// Convert var.type == InputEvent.KEY => var is InputEventKey
 			regexp.compile("(.*)\\.type == InputEvent.KEY(.*)");
 			res = regexp.find(line);