if (!p_obj) {

return;

}

id = p_obj->get_instance_id();

class_name = p_obj->get_class();

if (ScriptInstance *si = p_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>(p_obj)) {

// For debugging multiplayer.

{

PropertyInfo pi(Variant::INT, String("Node/multiplayer_authority"), PROPERTY_HINT_NONE, "", PROPERTY_USAGE_DEFAULT | PROPERTY_USAGE_READ_ONLY);

properties.push_back(SceneDebuggerProperty(pi, node->get_multiplayer_authority()));

}

// 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>(p_obj)) {

// Add script constants (no instance).

_parse_script_properties(s, nullptr);

}

// Add base object properties.

List<PropertyInfo> pinfo;

p_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, p_obj->get(E.name)));

}

}

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();

}

HashSet<String> exported_members;

HashMap<String, PropertyInfo> non_exported_members;

if (p_instance) {

List<PropertyInfo> pinfo;

p_instance->get_property_list(&pinfo);

for (const PropertyInfo &E : pinfo) {

if (E.usage & (PROPERTY_USAGE_EDITOR | PROPERTY_USAGE_CATEGORY)) {

exported_members.insert(E.name);

} else {

PropertyInfo pi = E;

pi.usage |= PROPERTY_USAGE_EDITOR;

non_exported_members.insert(E.name, pi);

}

}

}

// Members

for (KeyValue<const Script *, HashSet<StringName>> sm : members) {

for (const StringName &E : sm.value) {

if (exported_members.has(E)) {

continue; // Exported variables already show up in the inspector.

}

if (String(E).begins_with("@")) {

continue; // Skip groups.

}

Variant m;

if (p_instance->get(E, m)) {

const String script_path = sm.key == p_script ? "" : sm.key->get_path().get_file() + "/";

PropertyInfo pi;

const PropertyInfo *pi_ptr = non_exported_members.getptr(E);

if (pi_ptr == nullptr) {

pi.type = m.get_type();

} else {

pi = *pi_ptr;

}

pi.name = "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 inst_id = ((Object *)E.value)->get_instance_id();

PropertyInfo pi(inst_id.get_type(), "Constants/" + E.key, PROPERTY_HINT_OBJECT_ID, "Object", PROPERTY_USAGE_DEFAULT | PROPERTY_USAGE_READ_ONLY);

properties.push_back(SceneDebuggerProperty(pi, inst_id));

} else {

PropertyInfo pi(E.value.get_type(), "Constants/" + script_path + E.key);

pi.usage |= PROPERTY_USAGE_READ_ONLY;

properties.push_back(SceneDebuggerProperty(pi, E.value));

}

}

}

Array send_props;

for (SceneDebuggerProperty &property : properties) {

const PropertyInfo &pi = property.first;

Variant &var = property.second;

Ref<Resource> res = var;

Array prop = { pi.name, pi.type };

PropertyHint hint = pi.hint;

String hint_string = pi.hint_string;

if (res.is_valid() && !res->get_path().is_empty()) {

// HACK: Overwrite `PropertyInfo` with the current runtime type.

// This allows untyped variables to be displayed correctly.

prop[1] = Variant::OBJECT;

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);

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);

deserialize(uint64_t(p_arr[0]), p_arr[1], p_arr[2]);

id = p_id;

class_name = p_class_name;

for (int i = 0; i < p_props.size(); i++) {

CHECK_TYPE(p_props[i], ARRAY);

Array prop = p_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));

}

// Flatten tree into list, depth first, use stack to avoid recursion.

List<Node *> stack;

stack.push_back(p_root);

bool is_root = true;

const StringName &is_visible_sn = SNAME("is_visible");

const StringName &is_visible_in_tree_sn = SNAME("is_visible_in_tree");

while (stack.size()) {

Node *n = stack.front()->get();

stack.pop_front();

int count = n->get_child_count();

for (int i = 0; i < count; i++) {

stack.push_front(n->get_child(count - i - 1));

}

int view_flags = 0;

if (is_root) {

// Prevent root window visibility from being changed.

is_root = false;

} else if (n->has_method(is_visible_sn)) {

const Variant visible = n->call(is_visible_sn);

if (visible.get_type() == Variant::BOOL) {

view_flags = RemoteNode::VIEW_HAS_VISIBLE_METHOD;

view_flags |= uint8_t(visible) * RemoteNode::VIEW_VISIBLE;

}

if (n->has_method(is_visible_in_tree_sn)) {

const Variant visible_in_tree = n->call(is_visible_in_tree_sn);

if (visible_in_tree.get_type() == Variant::BOOL) {

view_flags |= uint8_t(visible_in_tree) * RemoteNode::VIEW_VISIBLE_IN_TREE;

}

}

}

String class_name;

ScriptInstance *script_instance = n->get_script_instance();

if (script_instance) {

Ref<Script> script = script_instance->get_script();

if (script.is_valid()) {

class_name = script->get_global_name();

if (class_name.is_empty()) {

// If there is no class_name in this script we just take the script path.

class_name = script->get_path();

}

}

}

nodes.push_back(RemoteNode(count, n->get_name(), class_name.is_empty() ? n->get_class() : class_name, n->get_instance_id(), n->get_scene_file_path(), view_flags));

}

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);

p_arr.push_back(n.scene_file_path);

p_arr.push_back(n.view_flags);

}

int idx = 0;

while (p_arr.size() > idx) {

ERR_FAIL_COND(p_arr.size() < 6);

CHECK_TYPE(p_arr[idx], INT); // child_count.

CHECK_TYPE(p_arr[idx + 1], STRING); // name.

CHECK_TYPE(p_arr[idx + 2], STRING); // type_name.

CHECK_TYPE(p_arr[idx + 3], INT); // id.

CHECK_TYPE(p_arr[idx + 4], STRING); // scene_file_path.

CHECK_TYPE(p_arr[idx + 5], INT); // view_flags.

nodes.push_back(RemoteNode(p_arr[idx], p_arr[idx + 1], p_arr[idx + 2], p_arr[idx + 3], p_arr[idx + 4], p_arr[idx + 5]));

idx += 6;

}