/*************************************************************************/ /* scene_debugger.cpp */ /*************************************************************************/ /* This file is part of: */ /* GODOT ENGINE */ /* https://godotengine.org */ /*************************************************************************/ /* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur. */ /* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md). */ /* */ /* Permission is hereby granted, free of charge, to any person obtaining */ /* a copy of this software and associated documentation files (the */ /* "Software"), to deal in the Software without restriction, including */ /* without limitation the rights to use, copy, modify, merge, publish, */ /* distribute, sublicense, and/or sell copies of the Software, and to */ /* permit persons to whom the Software is furnished to do so, subject to */ /* the following conditions: */ /* */ /* The above copyright notice and this permission notice shall be */ /* included in all copies or substantial portions of the Software. */ /* */ /* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ /* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ /* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ /* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ /* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ /* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ /*************************************************************************/ #include "scene_debugger.h" #include "core/debugger/engine_debugger.h" #include "core/debugger/engine_profiler.h" #include "core/io/marshalls.h" #include "core/object/script_language.h" #include "core/templates/local_vector.h" #include "scene/main/scene_tree.h" #include "scene/main/window.h" #include "scene/resources/packed_scene.h" Array SceneDebugger::RPCProfilerFrame::serialize() { Array arr; arr.push_back(infos.size() * 4); for (int i = 0; i < infos.size(); ++i) { arr.push_back(uint64_t(infos[i].node)); arr.push_back(infos[i].node_path); arr.push_back(infos[i].incoming_rpc); arr.push_back(infos[i].outgoing_rpc); } return arr; } bool SceneDebugger::RPCProfilerFrame::deserialize(const Array &p_arr) { ERR_FAIL_COND_V(p_arr.size() < 1, false); uint32_t size = p_arr[0]; ERR_FAIL_COND_V(size % 4, false); ERR_FAIL_COND_V((uint32_t)p_arr.size() != size + 1, false); infos.resize(size / 4); int idx = 1; for (uint32_t i = 0; i < size / 4; ++i) { infos.write[i].node = uint64_t(p_arr[idx]); infos.write[i].node_path = p_arr[idx + 1]; infos.write[i].incoming_rpc = p_arr[idx + 2]; infos.write[i].outgoing_rpc = p_arr[idx + 3]; } return true; } class SceneDebugger::RPCProfiler : public EngineProfiler { HashMap<ObjectID, RPCNodeInfo> rpc_node_data; uint64_t last_profile_time = 0; void init_node(const ObjectID p_node) { if (rpc_node_data.has(p_node)) { return; } rpc_node_data.insert(p_node, RPCNodeInfo()); rpc_node_data[p_node].node = p_node; rpc_node_data[p_node].node_path = Object::cast_to<Node>(ObjectDB::get_instance(p_node))->get_path(); rpc_node_data[p_node].incoming_rpc = 0; rpc_node_data[p_node].outgoing_rpc = 0; } public: void toggle(bool p_enable, const Array &p_opts) { rpc_node_data.clear(); } void add(const Array &p_data) { ERR_FAIL_COND(p_data.size() < 2); const ObjectID id = p_data[0]; const String what = p_data[1]; init_node(id); RPCNodeInfo &info = rpc_node_data[id]; if (what == "rpc_in") { info.incoming_rpc++; } else if (what == "rpc_out") { info.outgoing_rpc++; } } void tick(double p_frame_time, double p_process_time, double p_physics_time, double p_physics_frame_time) { uint64_t pt = OS::get_singleton()->get_ticks_msec(); if (pt - last_profile_time > 100) { last_profile_time = pt; RPCProfilerFrame frame; for (const KeyValue<ObjectID, RPCNodeInfo> &E : rpc_node_data) { frame.infos.push_back(E.value); } rpc_node_data.clear(); EngineDebugger::get_singleton()->send_message("multiplayer:rpc", frame.serialize()); } } }; SceneDebugger *SceneDebugger::singleton = nullptr; SceneDebugger::SceneDebugger() { singleton = this; rpc_profiler.instantiate(); rpc_profiler->bind("rpc"); #ifdef DEBUG_ENABLED LiveEditor::singleton = memnew(LiveEditor); EngineDebugger::register_message_capture("scene", EngineDebugger::Capture(nullptr, SceneDebugger::parse_message)); #endif } SceneDebugger::~SceneDebugger() { #ifdef DEBUG_ENABLED if (LiveEditor::singleton) { EngineDebugger::unregister_message_capture("scene"); memdelete(LiveEditor::singleton); LiveEditor::singleton = nullptr; } #endif singleton = nullptr; } void SceneDebugger::initialize() { if (EngineDebugger::is_active()) { memnew(SceneDebugger); } } void SceneDebugger::deinitialize() { if (singleton) { memdelete(singleton); } } #ifdef DEBUG_ENABLED Error SceneDebugger::parse_message(void *p_user, const String &p_msg, const Array &p_args, bool &r_captured) { SceneTree *scene_tree = SceneTree::get_singleton(); if (!scene_tree) { return ERR_UNCONFIGURED; } LiveEditor *live_editor = LiveEditor::get_singleton(); if (!live_editor) { return ERR_UNCONFIGURED; } r_captured = true; if (p_msg == "request_scene_tree") { // Scene tree live_editor->_send_tree(); } else if (p_msg == "save_node") { // Save node. ERR_FAIL_COND_V(p_args.size() < 2, ERR_INVALID_DATA); _save_node(p_args[0], p_args[1]); } else if (p_msg == "inspect_object") { // Object Inspect ERR_FAIL_COND_V(p_args.size() < 1, ERR_INVALID_DATA); ObjectID id = p_args[0]; _send_object_id(id); } else if (p_msg == "override_camera_2D:set") { // Camera ERR_FAIL_COND_V(p_args.size() < 1, ERR_INVALID_DATA); bool enforce = p_args[0]; scene_tree->get_root()->enable_canvas_transform_override(enforce); } else if (p_msg == "override_camera_2D:transform") { ERR_FAIL_COND_V(p_args.size() < 1, ERR_INVALID_DATA); Transform2D transform = p_args[0]; scene_tree->get_root()->set_canvas_transform_override(transform); #ifndef _3D_DISABLED } else if (p_msg == "override_camera_3D:set") { ERR_FAIL_COND_V(p_args.size() < 1, ERR_INVALID_DATA); bool enable = p_args[0]; scene_tree->get_root()->enable_camera_3d_override(enable); } else if (p_msg == "override_camera_3D:transform") { ERR_FAIL_COND_V(p_args.size() < 5, ERR_INVALID_DATA); Transform3D transform = p_args[0]; bool is_perspective = p_args[1]; float size_or_fov = p_args[2]; float near = p_args[3]; float far = p_args[4]; if (is_perspective) { scene_tree->get_root()->set_camera_3d_override_perspective(size_or_fov, near, far); } else { scene_tree->get_root()->set_camera_3d_override_orthogonal(size_or_fov, near, far); } scene_tree->get_root()->set_camera_3d_override_transform(transform); #endif // _3D_DISABLED } else if (p_msg == "set_object_property") { ERR_FAIL_COND_V(p_args.size() < 3, ERR_INVALID_DATA); _set_object_property(p_args[0], p_args[1], p_args[2]); } else if (!p_msg.begins_with("live_")) { // Live edits below. return ERR_SKIP; } else if (p_msg == "live_set_root") { ERR_FAIL_COND_V(p_args.size() < 2, ERR_INVALID_DATA); live_editor->_root_func(p_args[0], p_args[1]); } else if (p_msg == "live_node_path") { ERR_FAIL_COND_V(p_args.size() < 2, ERR_INVALID_DATA); live_editor->_node_path_func(p_args[0], p_args[1]); } else if (p_msg == "live_res_path") { ERR_FAIL_COND_V(p_args.size() < 2, ERR_INVALID_DATA); live_editor->_res_path_func(p_args[0], p_args[1]); } else if (p_msg == "live_node_prop_res") { ERR_FAIL_COND_V(p_args.size() < 3, ERR_INVALID_DATA); live_editor->_node_set_res_func(p_args[0], p_args[1], p_args[2]); } else if (p_msg == "live_node_prop") { ERR_FAIL_COND_V(p_args.size() < 3, ERR_INVALID_DATA); live_editor->_node_set_func(p_args[0], p_args[1], p_args[2]); } else if (p_msg == "live_res_prop_res") { ERR_FAIL_COND_V(p_args.size() < 3, ERR_INVALID_DATA); live_editor->_res_set_res_func(p_args[0], p_args[1], p_args[2]); } else if (p_msg == "live_res_prop") { ERR_FAIL_COND_V(p_args.size() < 3, ERR_INVALID_DATA); live_editor->_res_set_func(p_args[0], p_args[1], p_args[2]); } else if (p_msg == "live_node_call") { LocalVector<Variant> args; LocalVector<Variant *> argptrs; args.resize(p_args.size() - 2); argptrs.resize(args.size()); for (uint32_t i = 0; i < args.size(); i++) { args[i] = p_args[i + 2]; argptrs[i] = &args[i]; } live_editor->_node_call_func(p_args[0], p_args[1], (const Variant **)argptrs.ptr(), argptrs.size()); } else if (p_msg == "live_res_call") { ERR_FAIL_COND_V(p_args.size() < 10, ERR_INVALID_DATA); LocalVector<Variant> args; LocalVector<Variant *> argptrs; args.resize(p_args.size() - 2); argptrs.resize(args.size()); for (uint32_t i = 0; i < args.size(); i++) { args[i] = p_args[i + 2]; argptrs[i] = &args[i]; } live_editor->_res_call_func(p_args[0], p_args[1], (const Variant **)argptrs.ptr(), argptrs.size()); } else if (p_msg == "live_create_node") { ERR_FAIL_COND_V(p_args.size() < 3, ERR_INVALID_DATA); live_editor->_create_node_func(p_args[0], p_args[1], p_args[2]); } else if (p_msg == "live_instance_node") { ERR_FAIL_COND_V(p_args.size() < 3, ERR_INVALID_DATA); live_editor->_instance_node_func(p_args[0], p_args[1], p_args[2]); } else if (p_msg == "live_remove_node") { ERR_FAIL_COND_V(p_args.size() < 1, ERR_INVALID_DATA); live_editor->_remove_node_func(p_args[0]); } else if (p_msg == "live_remove_and_keep_node") { ERR_FAIL_COND_V(p_args.size() < 2, ERR_INVALID_DATA); live_editor->_remove_and_keep_node_func(p_args[0], p_args[1]); } else if (p_msg == "live_restore_node") { ERR_FAIL_COND_V(p_args.size() < 3, ERR_INVALID_DATA); live_editor->_restore_node_func(p_args[0], p_args[1], p_args[2]); } else if (p_msg == "live_duplicate_node") { ERR_FAIL_COND_V(p_args.size() < 2, ERR_INVALID_DATA); live_editor->_duplicate_node_func(p_args[0], p_args[1]); } else if (p_msg == "live_reparent_node") { ERR_FAIL_COND_V(p_args.size() < 4, ERR_INVALID_DATA); live_editor->_reparent_node_func(p_args[0], p_args[1], p_args[2], p_args[3]); } else { r_captured = false; } return OK; } void SceneDebugger::_save_node(ObjectID id, const String &p_path) { Node *node = Object::cast_to<Node>(ObjectDB::get_instance(id)); ERR_FAIL_COND(!node); Ref<PackedScene> ps = memnew(PackedScene); ps->pack(node); ResourceSaver::save(p_path, ps); } void SceneDebugger::_send_object_id(ObjectID p_id, int p_max_size) { SceneDebuggerObject obj(p_id); if (obj.id.is_null()) { return; } Array arr; obj.serialize(arr); EngineDebugger::get_singleton()->send_message("scene:inspect_object", arr); } void SceneDebugger::_set_object_property(ObjectID p_id, const String &p_property, const Variant &p_value) { Object *obj = ObjectDB::get_instance(p_id); if (!obj) { return; } String prop_name = p_property; if (p_property.begins_with("Members/")) { Vector<String> ss = p_property.split("/"); prop_name = ss[ss.size() - 1]; } obj->set(prop_name, p_value); } void SceneDebugger::add_to_cache(const String &p_filename, Node *p_node) { LiveEditor *debugger = LiveEditor::get_singleton(); if (!debugger) { return; } if (EngineDebugger::get_script_debugger() && !p_filename.is_empty()) { debugger->live_scene_edit_cache[p_filename].insert(p_node); } } void SceneDebugger::remove_from_cache(const String &p_filename, Node *p_node) { LiveEditor *debugger = LiveEditor::get_singleton(); if (!debugger) { return; } HashMap<String, HashSet<Node *>> &edit_cache = debugger->live_scene_edit_cache; HashMap<String, HashSet<Node *>>::Iterator E = edit_cache.find(p_filename); if (E) { E->value.erase(p_node); if (E->value.size() == 0) { edit_cache.remove(E); } } HashMap<Node *, HashMap<ObjectID, Node *>> &remove_list = debugger->live_edit_remove_list; HashMap<Node *, HashMap<ObjectID, Node *>>::Iterator F = remove_list.find(p_node); if (F) { for (const KeyValue<ObjectID, Node *> &G : F->value) { memdelete(G.value); } remove_list.remove(F); } } /// SceneDebuggerObject SceneDebuggerObject::SceneDebuggerObject(ObjectID p_id) { id = ObjectID(); Object *obj = ObjectDB::get_instance(p_id); if (!obj) { return; } id = p_id; class_name = obj->get_class(); if (ScriptInstance *si = obj->get_script_instance()) { // Read script instance constants and variables if (!si->get_script().is_null()) { Script *s = si->get_script().ptr(); _parse_script_properties(s, si); } } if (Node *node = Object::cast_to<Node>(obj)) { // Add specialized NodePath info (if inside tree). if (node->is_inside_tree()) { PropertyInfo pi(Variant::NODE_PATH, String("Node/path")); properties.push_back(SceneDebuggerProperty(pi, node->get_path())); } else { // Can't ask for path if a node is not in tree. PropertyInfo pi(Variant::STRING, String("Node/path")); properties.push_back(SceneDebuggerProperty(pi, "[Orphan]")); } } else if (Script *s = Object::cast_to<Script>(obj)) { // Add script constants (no instance). _parse_script_properties(s, nullptr); } // Add base object properties. List<PropertyInfo> pinfo; obj->get_property_list(&pinfo, true); for (const PropertyInfo &E : pinfo) { if (E.usage & (PROPERTY_USAGE_EDITOR | PROPERTY_USAGE_CATEGORY)) { properties.push_back(SceneDebuggerProperty(E, obj->get(E.name))); } } } void SceneDebuggerObject::_parse_script_properties(Script *p_script, ScriptInstance *p_instance) { typedef HashMap<const Script *, HashSet<StringName>> ScriptMemberMap; typedef HashMap<const Script *, HashMap<StringName, Variant>> ScriptConstantsMap; ScriptMemberMap members; if (p_instance) { members[p_script] = HashSet<StringName>(); p_script->get_members(&(members[p_script])); } ScriptConstantsMap constants; constants[p_script] = HashMap<StringName, Variant>(); p_script->get_constants(&(constants[p_script])); Ref<Script> base = p_script->get_base_script(); while (base.is_valid()) { if (p_instance) { members[base.ptr()] = HashSet<StringName>(); base->get_members(&(members[base.ptr()])); } constants[base.ptr()] = HashMap<StringName, Variant>(); base->get_constants(&(constants[base.ptr()])); base = base->get_base_script(); } // Members for (KeyValue<const Script *, HashSet<StringName>> sm : members) { for (const StringName &E : sm.value) { Variant m; if (p_instance->get(E, m)) { String script_path = sm.key == p_script ? "" : sm.key->get_path().get_file() + "/"; PropertyInfo pi(m.get_type(), "Members/" + script_path + E); properties.push_back(SceneDebuggerProperty(pi, m)); } } } // Constants for (KeyValue<const Script *, HashMap<StringName, Variant>> &sc : constants) { for (const KeyValue<StringName, Variant> &E : sc.value) { String script_path = sc.key == p_script ? "" : sc.key->get_path().get_file() + "/"; if (E.value.get_type() == Variant::OBJECT) { Variant id = ((Object *)E.value)->get_instance_id(); PropertyInfo pi(id.get_type(), "Constants/" + E.key, PROPERTY_HINT_OBJECT_ID, "Object"); properties.push_back(SceneDebuggerProperty(pi, id)); } else { PropertyInfo pi(E.value.get_type(), "Constants/" + script_path + E.key); properties.push_back(SceneDebuggerProperty(pi, E.value)); } } } } void SceneDebuggerObject::serialize(Array &r_arr, int p_max_size) { Array send_props; for (int i = 0; i < properties.size(); i++) { const PropertyInfo &pi = properties[i].first; Variant &var = properties[i].second; Ref<Resource> res = var; Array prop; prop.push_back(pi.name); prop.push_back(pi.type); PropertyHint hint = pi.hint; String hint_string = pi.hint_string; if (!res.is_null() && !res->get_path().is_empty()) { var = res->get_path(); } else { //only send information that can be sent.. int len = 0; //test how big is this to encode encode_variant(var, nullptr, len); if (len > p_max_size) { //limit to max size hint = PROPERTY_HINT_OBJECT_TOO_BIG; hint_string = ""; var = Variant(); } } prop.push_back(hint); prop.push_back(hint_string); prop.push_back(pi.usage); prop.push_back(var); send_props.push_back(prop); } r_arr.push_back(uint64_t(id)); r_arr.push_back(class_name); r_arr.push_back(send_props); } void SceneDebuggerObject::deserialize(const Array &p_arr) { #define CHECK_TYPE(p_what, p_type) ERR_FAIL_COND(p_what.get_type() != Variant::p_type); ERR_FAIL_COND(p_arr.size() < 3); CHECK_TYPE(p_arr[0], INT); CHECK_TYPE(p_arr[1], STRING); CHECK_TYPE(p_arr[2], ARRAY); id = uint64_t(p_arr[0]); class_name = p_arr[1]; Array props = p_arr[2]; for (int i = 0; i < props.size(); i++) { CHECK_TYPE(props[i], ARRAY); Array prop = props[i]; ERR_FAIL_COND(prop.size() != 6); CHECK_TYPE(prop[0], STRING); CHECK_TYPE(prop[1], INT); CHECK_TYPE(prop[2], INT); CHECK_TYPE(prop[3], STRING); CHECK_TYPE(prop[4], INT); PropertyInfo pinfo; pinfo.name = prop[0]; pinfo.type = Variant::Type(int(prop[1])); pinfo.hint = PropertyHint(int(prop[2])); pinfo.hint_string = prop[3]; pinfo.usage = PropertyUsageFlags(int(prop[4])); Variant var = prop[5]; if (pinfo.type == Variant::OBJECT) { if (var.is_zero()) { var = Ref<Resource>(); } else if (var.get_type() == Variant::OBJECT) { if (((Object *)var)->is_class("EncodedObjectAsID")) { var = Object::cast_to<EncodedObjectAsID>(var)->get_object_id(); pinfo.type = var.get_type(); pinfo.hint = PROPERTY_HINT_OBJECT_ID; pinfo.hint_string = "Object"; } } } properties.push_back(SceneDebuggerProperty(pinfo, var)); } } /// SceneDebuggerTree SceneDebuggerTree::SceneDebuggerTree(Node *p_root) { // Flatten tree into list, depth first, use stack to avoid recursion. List<Node *> stack; stack.push_back(p_root); while (stack.size()) { Node *n = stack[0]; stack.pop_front(); int count = n->get_child_count(); nodes.push_back(RemoteNode(count, n->get_name(), n->get_class(), n->get_instance_id())); for (int i = 0; i < count; i++) { stack.push_front(n->get_child(count - i - 1)); } } } void SceneDebuggerTree::serialize(Array &p_arr) { for (const RemoteNode &n : nodes) { p_arr.push_back(n.child_count); p_arr.push_back(n.name); p_arr.push_back(n.type_name); p_arr.push_back(n.id); } } void SceneDebuggerTree::deserialize(const Array &p_arr) { int idx = 0; while (p_arr.size() > idx) { ERR_FAIL_COND(p_arr.size() < 4); CHECK_TYPE(p_arr[idx], INT); CHECK_TYPE(p_arr[idx + 1], STRING); CHECK_TYPE(p_arr[idx + 2], STRING); CHECK_TYPE(p_arr[idx + 3], INT); nodes.push_back(RemoteNode(p_arr[idx], p_arr[idx + 1], p_arr[idx + 2], p_arr[idx + 3])); idx += 4; } } /// LiveEditor LiveEditor *LiveEditor::singleton = nullptr; LiveEditor *LiveEditor::get_singleton() { return singleton; } void LiveEditor::_send_tree() { SceneTree *scene_tree = SceneTree::get_singleton(); if (!scene_tree) { return; } Array arr; // Encoded as a flat list depth first. SceneDebuggerTree tree(scene_tree->root); tree.serialize(arr); EngineDebugger::get_singleton()->send_message("scene:scene_tree", arr); } void LiveEditor::_node_path_func(const NodePath &p_path, int p_id) { live_edit_node_path_cache[p_id] = p_path; } void LiveEditor::_res_path_func(const String &p_path, int p_id) { live_edit_resource_cache[p_id] = p_path; } void LiveEditor::_node_set_func(int p_id, const StringName &p_prop, const Variant &p_value) { SceneTree *scene_tree = SceneTree::get_singleton(); if (!scene_tree) { return; } if (!live_edit_node_path_cache.has(p_id)) { return; } NodePath np = live_edit_node_path_cache[p_id]; Node *base = nullptr; if (scene_tree->root->has_node(live_edit_root)) { base = scene_tree->root->get_node(live_edit_root); } HashMap<String, HashSet<Node *>>::Iterator E = live_scene_edit_cache.find(live_edit_scene); if (!E) { return; //scene not editable } for (Node *F : E->value) { Node *n = F; if (base && !base->is_ancestor_of(n)) { continue; } if (!n->has_node(np)) { continue; } Node *n2 = n->get_node(np); n2->set(p_prop, p_value); } } void LiveEditor::_node_set_res_func(int p_id, const StringName &p_prop, const String &p_value) { Ref<Resource> r = ResourceLoader::load(p_value); if (!r.is_valid()) { return; } _node_set_func(p_id, p_prop, r); } void LiveEditor::_node_call_func(int p_id, const StringName &p_method, const Variant **p_args, int p_argcount) { SceneTree *scene_tree = SceneTree::get_singleton(); if (!scene_tree) { return; } if (!live_edit_node_path_cache.has(p_id)) { return; } NodePath np = live_edit_node_path_cache[p_id]; Node *base = nullptr; if (scene_tree->root->has_node(live_edit_root)) { base = scene_tree->root->get_node(live_edit_root); } HashMap<String, HashSet<Node *>>::Iterator E = live_scene_edit_cache.find(live_edit_scene); if (!E) { return; //scene not editable } for (Node *F : E->value) { Node *n = F; if (base && !base->is_ancestor_of(n)) { continue; } if (!n->has_node(np)) { continue; } Node *n2 = n->get_node(np); Callable::CallError ce; n2->callp(p_method, p_args, p_argcount, ce); } } void LiveEditor::_res_set_func(int p_id, const StringName &p_prop, const Variant &p_value) { if (!live_edit_resource_cache.has(p_id)) { return; } String resp = live_edit_resource_cache[p_id]; if (!ResourceCache::has(resp)) { return; } Ref<Resource> r = ResourceCache::get(resp); if (!r.is_valid()) { return; } r->set(p_prop, p_value); } void LiveEditor::_res_set_res_func(int p_id, const StringName &p_prop, const String &p_value) { Ref<Resource> r = ResourceLoader::load(p_value); if (!r.is_valid()) { return; } _res_set_func(p_id, p_prop, r); } void LiveEditor::_res_call_func(int p_id, const StringName &p_method, const Variant **p_args, int p_argcount) { if (!live_edit_resource_cache.has(p_id)) { return; } String resp = live_edit_resource_cache[p_id]; if (!ResourceCache::has(resp)) { return; } Ref<Resource> r = ResourceCache::get(resp); if (!r.is_valid()) { return; } Callable::CallError ce; r->callp(p_method, p_args, p_argcount, ce); } void LiveEditor::_root_func(const NodePath &p_scene_path, const String &p_scene_from) { live_edit_root = p_scene_path; live_edit_scene = p_scene_from; } void LiveEditor::_create_node_func(const NodePath &p_parent, const String &p_type, const String &p_name) { SceneTree *scene_tree = SceneTree::get_singleton(); if (!scene_tree) { return; } Node *base = nullptr; if (scene_tree->root->has_node(live_edit_root)) { base = scene_tree->root->get_node(live_edit_root); } HashMap<String, HashSet<Node *>>::Iterator E = live_scene_edit_cache.find(live_edit_scene); if (!E) { return; //scene not editable } for (Node *F : E->value) { Node *n = F; if (base && !base->is_ancestor_of(n)) { continue; } if (!n->has_node(p_parent)) { continue; } Node *n2 = n->get_node(p_parent); Node *no = Object::cast_to<Node>(ClassDB::instantiate(p_type)); if (!no) { continue; } no->set_name(p_name); n2->add_child(no); } } void LiveEditor::_instance_node_func(const NodePath &p_parent, const String &p_path, const String &p_name) { SceneTree *scene_tree = SceneTree::get_singleton(); if (!scene_tree) { return; } Ref<PackedScene> ps = ResourceLoader::load(p_path); if (!ps.is_valid()) { return; } Node *base = nullptr; if (scene_tree->root->has_node(live_edit_root)) { base = scene_tree->root->get_node(live_edit_root); } HashMap<String, HashSet<Node *>>::Iterator E = live_scene_edit_cache.find(live_edit_scene); if (!E) { return; //scene not editable } for (Node *F : E->value) { Node *n = F; if (base && !base->is_ancestor_of(n)) { continue; } if (!n->has_node(p_parent)) { continue; } Node *n2 = n->get_node(p_parent); Node *no = ps->instantiate(); if (!no) { continue; } no->set_name(p_name); n2->add_child(no); } } void LiveEditor::_remove_node_func(const NodePath &p_at) { SceneTree *scene_tree = SceneTree::get_singleton(); if (!scene_tree) { return; } Node *base = nullptr; if (scene_tree->root->has_node(live_edit_root)) { base = scene_tree->root->get_node(live_edit_root); } HashMap<String, HashSet<Node *>>::Iterator E = live_scene_edit_cache.find(live_edit_scene); if (!E) { return; //scene not editable } Vector<Node *> to_delete; for (HashSet<Node *>::Iterator F = E->value.begin(); F; ++F) { Node *n = *F; if (base && !base->is_ancestor_of(n)) { continue; } if (!n->has_node(p_at)) { continue; } Node *n2 = n->get_node(p_at); to_delete.push_back(n2); } for (int i = 0; i < to_delete.size(); i++) { memdelete(to_delete[i]); } } void LiveEditor::_remove_and_keep_node_func(const NodePath &p_at, ObjectID p_keep_id) { SceneTree *scene_tree = SceneTree::get_singleton(); if (!scene_tree) { return; } Node *base = nullptr; if (scene_tree->root->has_node(live_edit_root)) { base = scene_tree->root->get_node(live_edit_root); } HashMap<String, HashSet<Node *>>::Iterator E = live_scene_edit_cache.find(live_edit_scene); if (!E) { return; //scene not editable } Vector<Node *> to_remove; for (HashSet<Node *>::Iterator F = E->value.begin(); F; ++F) { Node *n = *F; if (base && !base->is_ancestor_of(n)) { continue; } if (!n->has_node(p_at)) { continue; } to_remove.push_back(n); } for (int i = 0; i < to_remove.size(); i++) { Node *n = to_remove[i]; Node *n2 = n->get_node(p_at); n2->get_parent()->remove_child(n2); live_edit_remove_list[n][p_keep_id] = n2; } } void LiveEditor::_restore_node_func(ObjectID p_id, const NodePath &p_at, int p_at_pos) { SceneTree *scene_tree = SceneTree::get_singleton(); if (!scene_tree) { return; } Node *base = nullptr; if (scene_tree->root->has_node(live_edit_root)) { base = scene_tree->root->get_node(live_edit_root); } HashMap<String, HashSet<Node *>>::Iterator E = live_scene_edit_cache.find(live_edit_scene); if (!E) { return; //scene not editable } for (HashSet<Node *>::Iterator F = E->value.begin(); F;) { HashSet<Node *>::Iterator N = F; ++N; Node *n = *F; if (base && !base->is_ancestor_of(n)) { continue; } if (!n->has_node(p_at)) { continue; } Node *n2 = n->get_node(p_at); HashMap<Node *, HashMap<ObjectID, Node *>>::Iterator EN = live_edit_remove_list.find(n); if (!EN) { continue; } HashMap<ObjectID, Node *>::Iterator FN = EN->value.find(p_id); if (!FN) { continue; } n2->add_child(FN->value); EN->value.remove(FN); if (EN->value.size() == 0) { live_edit_remove_list.remove(EN); } F = N; } } void LiveEditor::_duplicate_node_func(const NodePath &p_at, const String &p_new_name) { SceneTree *scene_tree = SceneTree::get_singleton(); if (!scene_tree) { return; } Node *base = nullptr; if (scene_tree->root->has_node(live_edit_root)) { base = scene_tree->root->get_node(live_edit_root); } HashMap<String, HashSet<Node *>>::Iterator E = live_scene_edit_cache.find(live_edit_scene); if (!E) { return; //scene not editable } for (Node *F : E->value) { Node *n = F; if (base && !base->is_ancestor_of(n)) { continue; } if (!n->has_node(p_at)) { continue; } Node *n2 = n->get_node(p_at); Node *dup = n2->duplicate(Node::DUPLICATE_SIGNALS | Node::DUPLICATE_GROUPS | Node::DUPLICATE_SCRIPTS); if (!dup) { continue; } dup->set_name(p_new_name); n2->get_parent()->add_child(dup); } } void LiveEditor::_reparent_node_func(const NodePath &p_at, const NodePath &p_new_place, const String &p_new_name, int p_at_pos) { SceneTree *scene_tree = SceneTree::get_singleton(); if (!scene_tree) { return; } Node *base = nullptr; if (scene_tree->root->has_node(live_edit_root)) { base = scene_tree->root->get_node(live_edit_root); } HashMap<String, HashSet<Node *>>::Iterator E = live_scene_edit_cache.find(live_edit_scene); if (!E) { return; //scene not editable } for (Node *F : E->value) { Node *n = F; if (base && !base->is_ancestor_of(n)) { continue; } if (!n->has_node(p_at)) { continue; } Node *nfrom = n->get_node(p_at); if (!n->has_node(p_new_place)) { continue; } Node *nto = n->get_node(p_new_place); nfrom->get_parent()->remove_child(nfrom); nfrom->set_name(p_new_name); nto->add_child(nfrom); if (p_at_pos >= 0) { nto->move_child(nfrom, p_at_pos); } } } #endif