diff --git a/doc/classes/ProjectSettings.xml b/doc/classes/ProjectSettings.xml index 4ae422934..28da1ef69 100644 --- a/doc/classes/ProjectSettings.xml +++ b/doc/classes/ProjectSettings.xml @@ -610,6 +610,12 @@ Color to use to display disabled navigation link connections, visible when "Visible Navigation" is enabled in the Debug menu. + + Color of the curve path geometry, visible when "Visible Paths" is enabled in the Debug menu. + + + Line width of the curve path geometry, visible when "Visible Paths" is enabled in the Debug menu. + Custom image for the mouse cursor (limited to 256×256). diff --git a/doc/classes/SceneTree.xml b/doc/classes/SceneTree.xml index ea68b51b8..2c3b9becb 100644 --- a/doc/classes/SceneTree.xml +++ b/doc/classes/SceneTree.xml @@ -232,6 +232,9 @@ If [code]true[/code], navigation polygons will be visible when running the game from the editor for debugging purposes. [b]Note:[/b] This property is not designed to be changed at run-time. Changing the value of [member debug_navigation_hint] while the project is running will not have the desired effect. + + If [code]true[/code], curves from [Path2D] and [Path3D] nodes will be visible when running the game from the editor for debugging purposes. + The root of the edited scene. diff --git a/editor/editor_export.cpp b/editor/editor_export.cpp index b9f703d61..776d708d9 100644 --- a/editor/editor_export.cpp +++ b/editor/editor_export.cpp @@ -371,6 +371,10 @@ void EditorExportPlatform::gen_debug_flags(Vector &r_flags, int p_flags) r_flags.push_back("--debug-avoidance"); } + if (p_flags & DEBUG_FLAG_VIEW_PATHS) { + r_flags.push_back("--debug-paths"); + } + if (p_flags & DEBUG_FLAG_SHADER_FALLBACKS) { r_flags.push_back("--debug-shader-fallbacks"); } @@ -1301,6 +1305,10 @@ void EditorExportPlatform::gen_export_flags(Vector &r_flags, int p_flags if (p_flags & DEBUG_FLAG_VIEW_AVOIDANCE) { r_flags.push_back("--debug-avoidance"); } + + if (p_flags & DEBUG_FLAG_VIEW_PATHS) { + r_flags.push_back("--debug-paths"); + } } EditorExportPlatform::EditorExportPlatform() { } diff --git a/editor/editor_export.h b/editor/editor_export.h index 5db12cd42..9071131ae 100644 --- a/editor/editor_export.h +++ b/editor/editor_export.h @@ -322,7 +322,8 @@ public: DEBUG_FLAG_VIEW_COLLISONS = 8, DEBUG_FLAG_VIEW_NAVIGATION = 16, DEBUG_FLAG_VIEW_AVOIDANCE = 32, - DEBUG_FLAG_SHADER_FALLBACKS = 64, + DEBUG_FLAG_VIEW_PATHS = 64, + DEBUG_FLAG_SHADER_FALLBACKS = 128, }; virtual Error run(const Ref &p_preset, int p_device, int p_debug_flags) { return OK; } diff --git a/editor/editor_node.cpp b/editor/editor_node.cpp index 46812f475..69d28743c 100644 --- a/editor/editor_node.cpp +++ b/editor/editor_node.cpp @@ -2777,6 +2777,14 @@ void EditorNode::_menu_option_confirm(int p_option, bool p_confirmed) { editor_run.set_debug_avoidance(!ischecked); EditorSettings::get_singleton()->set_project_metadata("debug_options", "run_debug_avoidance", !ischecked); + } break; + case RUN_DEBUG_PATHS: { + bool ischecked = debug_menu->get_popup()->is_item_checked(debug_menu->get_popup()->get_item_index(RUN_DEBUG_PATHS)); + debug_menu->get_popup()->set_item_checked(debug_menu->get_popup()->get_item_index(RUN_DEBUG_PATHS), !ischecked); + run_native->set_debug_paths(!ischecked); + editor_run.set_debug_paths(!ischecked); + EditorSettings::get_singleton()->set_project_metadata("debug_options", "run_debug_paths", !ischecked); + } break; case RUN_DEBUG_SHADER_FALLBACKS: { bool ischecked = debug_menu->get_popup()->is_item_checked(debug_menu->get_popup()->get_item_index(RUN_DEBUG_SHADER_FALLBACKS)); @@ -3070,6 +3078,7 @@ void EditorNode::_update_debug_options() { bool check_debug_collisons = EditorSettings::get_singleton()->get_project_metadata("debug_options", "run_debug_collisons", false); bool check_debug_navigation = EditorSettings::get_singleton()->get_project_metadata("debug_options", "run_debug_navigation", false); bool check_debug_avoidance = EditorSettings::get_singleton()->get_project_metadata("debug_options", "run_debug_avoidance", false); + bool check_debug_paths = EditorSettings::get_singleton()->get_project_metadata("debug_options", "run_debug_paths", false); bool check_debug_shader_fallbacks = EditorSettings::get_singleton()->get_project_metadata("debug_options", "run_debug_shader_fallbacks", false); bool check_live_debug = EditorSettings::get_singleton()->get_project_metadata("debug_options", "run_live_debug", true); bool check_reload_scripts = EditorSettings::get_singleton()->get_project_metadata("debug_options", "run_reload_scripts", true); @@ -3089,6 +3098,9 @@ void EditorNode::_update_debug_options() { if (check_debug_avoidance) { _menu_option_confirm(RUN_DEBUG_AVOIDANCE, true); } + if (check_debug_paths) { + _menu_option_confirm(RUN_DEBUG_PATHS, true); + } if (check_debug_shader_fallbacks) { _menu_option_confirm(RUN_DEBUG_SHADER_FALLBACKS, true); } @@ -6528,6 +6540,10 @@ EditorNode::EditorNode() { p->get_item_count() - 1, TTR("When this option is enabled, avoidance debug information will be visible in the running project.")); + p->add_check_shortcut(ED_SHORTCUT("editor/visible_paths", TTR("Visible Paths")), RUN_DEBUG_PATHS); + p->set_item_tooltip(-1, + TTR("When this option is enabled, curve resources used by path nodes will be visible in the running project.")); + if (GLOBAL_GET("rendering/quality/driver/driver_name") == "GLES3") { p->add_separator(); diff --git a/editor/editor_node.h b/editor/editor_node.h index 0b5593093..022def5d5 100644 --- a/editor/editor_node.h +++ b/editor/editor_node.h @@ -448,6 +448,7 @@ private: RUN_DEBUG_COLLISONS, RUN_DEBUG_NAVIGATION, RUN_DEBUG_AVOIDANCE, + RUN_DEBUG_PATHS, RUN_DEBUG_SHADER_FALLBACKS, RUN_DEPLOY_REMOTE_DEBUG, RUN_RELOAD_SCRIPTS, diff --git a/editor/editor_run.cpp b/editor/editor_run.cpp index 35251688b..c235aa315 100644 --- a/editor/editor_run.cpp +++ b/editor/editor_run.cpp @@ -94,6 +94,10 @@ Error EditorRun::run(const String &p_scene, const String &p_custom_args, const L args.push_back("--debug-avoidance"); } + if (debug_paths) { + args.push_back("--debug-paths"); + } + if (debug_shader_fallbacks) { args.push_back("--debug-shader-fallbacks"); } @@ -309,6 +313,14 @@ bool EditorRun::get_debug_avoidance() const { return debug_avoidance; } +void EditorRun::set_debug_paths(bool p_debug) { + debug_paths = p_debug; +} + +bool EditorRun::get_debug_paths() const { + return debug_paths; +} + void EditorRun::set_debug_shader_fallbacks(bool p_debug) { debug_shader_fallbacks = p_debug; } @@ -323,5 +335,6 @@ EditorRun::EditorRun() { debug_collisions = false; debug_navigation = false; debug_avoidance = false; + debug_paths = false; debug_shader_fallbacks = false; } diff --git a/editor/editor_run.h b/editor/editor_run.h index bc2db5ce1..3e5cb99c2 100644 --- a/editor/editor_run.h +++ b/editor/editor_run.h @@ -51,6 +51,7 @@ private: bool debug_collisions; bool debug_navigation; bool debug_avoidance; + bool debug_paths; bool debug_shader_fallbacks; Status status; String running_scene; @@ -73,6 +74,9 @@ public: void set_debug_avoidance(bool p_debug); bool get_debug_avoidance() const; + void set_debug_paths(bool p_debug); + bool get_debug_paths() const; + void set_debug_shader_fallbacks(bool p_debug); bool get_debug_shader_fallbacks() const; diff --git a/editor/editor_run_native.cpp b/editor/editor_run_native.cpp index 410ccc31a..8f9ef2a7b 100644 --- a/editor/editor_run_native.cpp +++ b/editor/editor_run_native.cpp @@ -159,6 +159,9 @@ void EditorRunNative::_run_native(int p_idx, int p_platform) { if (debug_avoidance) { flags |= EditorExportPlatform::DEBUG_FLAG_VIEW_AVOIDANCE; } + if (debug_paths) { + flags |= EditorExportPlatform::DEBUG_FLAG_VIEW_PATHS; + } if (debug_shader_fallbacks) { flags |= EditorExportPlatform::DEBUG_FLAG_SHADER_FALLBACKS; } @@ -221,6 +224,14 @@ bool EditorRunNative::get_debug_avoidance() const { return debug_avoidance; } +void EditorRunNative::set_debug_paths(bool p_debug) { + debug_paths = p_debug; +} + +bool EditorRunNative::get_debug_paths() const { + return debug_paths; +} + void EditorRunNative::set_debug_shader_fallbacks(bool p_debug) { debug_shader_fallbacks = p_debug; } @@ -246,6 +257,7 @@ EditorRunNative::EditorRunNative() { debug_collisions = false; debug_navigation = false; debug_avoidance = false; + debug_paths = false; debug_shader_fallbacks = false; resume_idx = 0; resume_platform = 0; diff --git a/editor/editor_run_native.h b/editor/editor_run_native.h index b1e3742d1..69a4b4d92 100644 --- a/editor/editor_run_native.h +++ b/editor/editor_run_native.h @@ -52,6 +52,7 @@ class EditorRunNative : public HBoxContainer { bool debug_collisions; bool debug_navigation; bool debug_avoidance; + bool debug_paths; bool debug_shader_fallbacks; int resume_idx; @@ -79,6 +80,9 @@ public: void set_debug_avoidance(bool p_debug); bool get_debug_avoidance() const; + void set_debug_paths(bool p_debug); + bool get_debug_paths() const; + void set_debug_shader_fallbacks(bool p_debug); bool get_debug_shader_fallbacks() const; diff --git a/main/main.cpp b/main/main.cpp index 02d1ae2a1..1b3d03edd 100644 --- a/main/main.cpp +++ b/main/main.cpp @@ -160,6 +160,7 @@ static bool use_debug_profiler = false; static bool debug_collisions = false; static bool debug_navigation = false; static bool debug_avoidance = false; +static bool debug_paths = false; static bool debug_shader_fallbacks = false; #endif static int frame_delay = 0; @@ -376,7 +377,8 @@ void Main::print_help(const char *p_binary) { #if defined(DEBUG_ENABLED) && !defined(SERVER_ENABLED) OS::get_singleton()->print(" --debug-collisions Show collision shapes when running the scene.\n"); OS::get_singleton()->print(" --debug-navigation Show navigation polygons when running the scene.\n"); - OS::get_singleton()->print(" --debug-avoidance Show navigation polygons when running the scene.\n"); + OS::get_singleton()->print(" --debug-avoidance Show navigation polygons when running the scene.\n"); + OS::get_singleton()->print(" --debug-paths Show path lines when running the scene.\n"); OS::get_singleton()->print(" --debug-shader-fallbacks Use the fallbacks of the shaders which have one when running the scene (GL ES 3 only).\n"); #endif OS::get_singleton()->print(" --frame-delay Simulate high CPU load (delay each frame by milliseconds).\n"); @@ -916,6 +918,8 @@ Error Main::setup(const char *execpath, int argc, char *argv[], bool p_second_ph debug_navigation = true; } else if (I->get() == "--debug-avoidance") { debug_avoidance = true; + } else if (I->get() == "--debug-paths") { + debug_paths = true; } else if (I->get() == "--debug-shader-fallbacks") { debug_shader_fallbacks = true; #endif @@ -1936,6 +1940,9 @@ bool Main::start() { if (debug_avoidance) { sml->set_debug_avoidance_hint(true); } + if (debug_paths) { + sml->set_debug_paths_hint(true); + } if (debug_navigation || debug_avoidance) { NavigationServer::get_singleton()->set_active(true); NavigationServer::get_singleton()->set_debug_enabled(true); diff --git a/scene/2d/path_2d.cpp b/scene/2d/path_2d.cpp index ec438962d..85234097c 100644 --- a/scene/2d/path_2d.cpp +++ b/scene/2d/path_2d.cpp @@ -91,7 +91,7 @@ void Path2D::_notification(int p_what) { if (p_what == NOTIFICATION_DRAW && curve.is_valid()) { //draw the curve!! - if (!Engine::get_singleton()->is_editor_hint() && !get_tree()->is_debugging_navigation_hint()) { + if (!Engine::get_singleton()->is_editor_hint() && !get_tree()->is_debugging_paths_hint()) { return; } @@ -100,11 +100,10 @@ void Path2D::_notification(int p_what) { } #ifdef TOOLS_ENABLED - const float line_width = 2 * EDSCALE; + const float line_width = get_tree()->get_debug_paths_width() * EDSCALE; #else - const float line_width = 2; + const float line_width = get_tree()->get_debug_paths_width(); #endif - const Color color = Color(1.0, 1.0, 1.0, 1.0); _cached_draw_pts.resize(curve->get_point_count() * 8); int count = 0; @@ -117,7 +116,7 @@ void Path2D::_notification(int p_what) { } } - draw_polyline(_cached_draw_pts, color, line_width, true); + draw_polyline(_cached_draw_pts, get_tree()->get_debug_paths_color(), line_width, true); } } @@ -126,7 +125,7 @@ void Path2D::_curve_changed() { return; } - if (!Engine::get_singleton()->is_editor_hint() && !get_tree()->is_debugging_navigation_hint()) { + if (!Engine::get_singleton()->is_editor_hint() && !get_tree()->is_debugging_paths_hint()) { return; } diff --git a/scene/3d/path.cpp b/scene/3d/path.cpp index 004f7d520..7bfad434d 100644 --- a/scene/3d/path.cpp +++ b/scene/3d/path.cpp @@ -32,9 +32,97 @@ #include "core/config/engine.h" #include "scene/resources/curve.h" +#include "scene/resources/mesh.h" +#include "scene/resources/world_3d.h" #include "scene/scene_string_names.h" +#include "servers/rendering_server.h" + +Path::Path() { + SceneTree *st = SceneTree::get_singleton(); + if (st && st->is_debugging_paths_hint()) { + debug_instance = RS::get_singleton()->instance_create(); + set_notify_transform(true); + } + + set_curve(Ref(memnew(Curve3D))); //create one by default +} + +Path::~Path() { + if (debug_instance.is_valid()) { + RS::get_singleton()->free(debug_instance); + } + if (debug_mesh.is_valid()) { + RS::get_singleton()->free(debug_mesh->get_rid()); + } +} void Path::_notification(int p_what) { + switch (p_what) { + case NOTIFICATION_ENTER_TREE: { + SceneTree *st = SceneTree::get_singleton(); + if (st && st->is_debugging_paths_hint()) { + _update_debug_mesh(); + } + } break; + + case NOTIFICATION_EXIT_TREE: { + SceneTree *st = SceneTree::get_singleton(); + if (st && st->is_debugging_paths_hint()) { + RS::get_singleton()->instance_set_visible(debug_instance, false); + } + } break; + + case NOTIFICATION_TRANSFORM_CHANGED: { + if (is_inside_tree() && debug_instance.is_valid()) { + RS::get_singleton()->instance_set_transform(debug_instance, get_global_transform()); + } + } break; + } +} + +void Path::_update_debug_mesh() { + SceneTree *st = SceneTree::get_singleton(); + if (!(st && st->is_debugging_paths_hint())) { + return; + } + + if (!debug_mesh.is_valid()) { + debug_mesh = Ref(memnew(ArrayMesh)); + } + + if (!(curve.is_valid())) { + RS::get_singleton()->instance_set_visible(debug_instance, false); + return; + } + if (curve->get_point_count() < 2) { + RS::get_singleton()->instance_set_visible(debug_instance, false); + return; + } + + Vector vertex_array; + + for (int i = 1; i < curve->get_point_count(); i++) { + Vector3 line_end = curve->get_point_position(i); + Vector3 line_start = curve->get_point_position(i - 1); + vertex_array.push_back(line_start); + vertex_array.push_back(line_end); + } + + Array mesh_array; + mesh_array.resize(Mesh::ARRAY_MAX); + mesh_array[Mesh::ARRAY_VERTEX] = vertex_array; + + debug_mesh->clear_surfaces(); + debug_mesh->add_surface_from_arrays(Mesh::PRIMITIVE_LINES, mesh_array); + + RS::get_singleton()->instance_set_base(debug_instance, debug_mesh->get_rid()); + RS::get_singleton()->mesh_surface_set_material(debug_mesh->get_rid(), 0, st->get_debug_paths_material()->get_rid()); + + if (is_inside_tree()) { + RS::get_singleton()->instance_set_scenario(debug_instance, get_world_3d()->get_scenario()); + RS::get_singleton()->instance_set_transform(debug_instance, get_global_transform()); + RS::get_singleton()->instance_set_visible(debug_instance, is_visible_in_tree()); + } } void Path::_curve_changed() { @@ -55,6 +143,11 @@ void Path::_curve_changed() { } } } + + SceneTree *st = SceneTree::get_singleton(); + if (st && st->is_debugging_paths_hint()) { + _update_debug_mesh(); + } } void Path::set_curve(const Ref &p_curve) { @@ -84,10 +177,6 @@ void Path::_bind_methods() { ADD_SIGNAL(MethodInfo("curve_changed")); } -Path::Path() { - set_curve(Ref(memnew(Curve3D))); //create one by default -} - ////////////// void PathFollow::_update_transform(bool p_update_xyz_rot) { diff --git a/scene/3d/path.h b/scene/3d/path.h index c057cb7a1..cc81e84f1 100644 --- a/scene/3d/path.h +++ b/scene/3d/path.h @@ -42,6 +42,12 @@ class Path : public Spatial { void _curve_changed(); + RID debug_instance; + Ref debug_mesh; + +private: + void _update_debug_mesh(); + protected: void _notification(int p_what); static void _bind_methods(); @@ -51,6 +57,7 @@ public: Ref get_curve() const; Path(); + ~Path(); }; class PathFollow : public Spatial { diff --git a/scene/main/scene_tree.cpp b/scene/main/scene_tree.cpp index 4b6f70164..226ee1770 100644 --- a/scene/main/scene_tree.cpp +++ b/scene/main/scene_tree.cpp @@ -992,6 +992,15 @@ void SceneTree::set_debug_avoidance_hint(bool p_enabled) { bool SceneTree::is_debugging_avoidance_hint() const { return debug_avoidance_hint; } + +void SceneTree::set_debug_paths_hint(bool p_enabled) { + debug_paths_hint = p_enabled; +} + +bool SceneTree::is_debugging_paths_hint() const { + return debug_paths_hint; +} + #endif void SceneTree::set_debug_collisions_color(const Color &p_color) { @@ -1010,6 +1019,39 @@ Color SceneTree::get_debug_collision_contact_color() const { return debug_collision_contact_color; } +void SceneTree::set_debug_paths_color(const Color &p_color) { + debug_paths_color = p_color; +} + +Color SceneTree::get_debug_paths_color() const { + return debug_paths_color; +} + +void SceneTree::set_debug_paths_width(float p_width) { + debug_paths_width = p_width; +} + +float SceneTree::get_debug_paths_width() const { + return debug_paths_width; +} + +Ref SceneTree::get_debug_paths_material() { + if (debug_paths_material.is_valid()) { + return debug_paths_material; + } + + Ref _debug_material = Ref(memnew(SpatialMaterial)); + _debug_material->set_flag(SpatialMaterial::FLAG_UNSHADED, true); + _debug_material->set_feature(SpatialMaterial::FEATURE_TRANSPARENT, true); + _debug_material->set_flag(SpatialMaterial::FLAG_SRGB_VERTEX_COLOR, true); + _debug_material->set_flag(SpatialMaterial::FLAG_ALBEDO_FROM_VERTEX_COLOR, true); + _debug_material->set_albedo(get_debug_paths_color()); + + debug_paths_material = _debug_material; + + return debug_paths_material; +} + Ref SceneTree::get_debug_collision_material() { _THREAD_SAFE_METHOD_ @@ -2152,6 +2194,8 @@ void SceneTree::_bind_methods() { ClassDB::bind_method(D_METHOD("is_debugging_navigation_hint"), &SceneTree::is_debugging_navigation_hint); ClassDB::bind_method(D_METHOD("set_debug_avoidance_hint", "enable"), &SceneTree::set_debug_avoidance_hint); ClassDB::bind_method(D_METHOD("is_debugging_avoidance_hint"), &SceneTree::is_debugging_avoidance_hint); + ClassDB::bind_method(D_METHOD("set_debug_paths_hint", "enable"), &SceneTree::set_debug_paths_hint); + ClassDB::bind_method(D_METHOD("is_debugging_paths_hint"), &SceneTree::is_debugging_paths_hint); ClassDB::bind_method(D_METHOD("set_edited_scene_root", "scene"), &SceneTree::set_edited_scene_root); ClassDB::bind_method(D_METHOD("get_edited_scene_root"), &SceneTree::get_edited_scene_root); @@ -2233,6 +2277,7 @@ void SceneTree::_bind_methods() { ADD_PROPERTY(PropertyInfo(Variant::BOOL, "debug_collisions_hint"), "set_debug_collisions_hint", "is_debugging_collisions_hint"); ADD_PROPERTY(PropertyInfo(Variant::BOOL, "debug_navigation_hint"), "set_debug_navigation_hint", "is_debugging_navigation_hint"); + ADD_PROPERTY(PropertyInfo(Variant::BOOL, "debug_paths_hint"), "set_debug_paths_hint", "is_debugging_paths_hint"); ADD_PROPERTY(PropertyInfo(Variant::BOOL, "paused"), "set_pause", "is_paused"); ADD_PROPERTY(PropertyInfo(Variant::BOOL, "refuse_new_network_connections"), "set_refuse_new_network_connections", "is_refusing_new_network_connections"); ADD_PROPERTY_DEFAULT("refuse_new_network_connections", false); @@ -2356,9 +2401,12 @@ SceneTree::SceneTree() { debug_collisions_hint = false; debug_navigation_hint = false; debug_avoidance_hint = false; + debug_paths_hint = false; #endif debug_collisions_color = GLOBAL_DEF("debug/shapes/collision/shape_color", Color(0.0, 0.6, 0.7, 0.42)); debug_collision_contact_color = GLOBAL_DEF("debug/shapes/collision/contact_color", Color(1.0, 0.2, 0.1, 0.8)); + debug_paths_color = GLOBAL_DEF("debug/shapes/paths/geometry_color", Color(0.1, 1.0, 0.7, 0.4)); + debug_paths_width = GLOBAL_DEF("debug/shapes/paths/geometry_width", 2.0); collision_debug_contacts = GLOBAL_DEF("debug/shapes/collision/max_contacts_displayed", 10000); ProjectSettings::get_singleton()->set_custom_property_info("debug/shapes/collision/max_contacts_displayed", PropertyInfo(Variant::INT, "debug/shapes/collision/max_contacts_displayed", PROPERTY_HINT_RANGE, "0,20000,1")); // No negative diff --git a/scene/main/scene_tree.h b/scene/main/scene_tree.h index 8ccee4412..8833625cf 100644 --- a/scene/main/scene_tree.h +++ b/scene/main/scene_tree.h @@ -119,6 +119,7 @@ private: bool debug_collisions_hint; bool debug_navigation_hint; bool debug_avoidance_hint; + bool debug_paths_hint; #endif bool pause; int root_lock; @@ -182,9 +183,12 @@ private: Color debug_collision_contact_color; Color debug_navigation_color; Color debug_navigation_disabled_color; + Color debug_paths_color; + float debug_paths_width = 1.0f; Ref debug_contact_mesh; Ref navigation_material; Ref navigation_disabled_material; + Ref debug_paths_material; Ref collision_material; int collision_debug_contacts; @@ -356,6 +360,9 @@ public: void set_debug_avoidance_hint(bool p_enabled); bool is_debugging_avoidance_hint() const; + + void set_debug_paths_hint(bool p_enabled); + bool is_debugging_paths_hint() const; #else void set_debug_collisions_hint(bool p_enabled) {} bool is_debugging_collisions_hint() const { @@ -371,6 +378,11 @@ public: bool is_debugging_avoidance_hint() const { return false; } + + void set_debug_paths_hint(bool p_enabled) {} + bool is_debugging_paths_hint() const { + return false; + } #endif void set_debug_collisions_color(const Color &p_color); @@ -379,6 +391,13 @@ public: void set_debug_collision_contact_color(const Color &p_color); Color get_debug_collision_contact_color() const; + void set_debug_paths_color(const Color &p_color); + Color get_debug_paths_color() const; + + void set_debug_paths_width(float p_width); + float get_debug_paths_width() const; + + Ref get_debug_paths_material(); Ref get_debug_collision_material(); Ref get_debug_contact_mesh();