godotengine
/
godot
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge pull request #18867 from fire/better_vx_us_rebase_02 

Improve VisualScript UX
This commit is contained in:
Juan Linietsky 2018-07-24 18:02:10 -03:00 committed by GitHub
parent 62f2a8aadb 85670726fd
commit 2e67fc57e6
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
12 changed files with 1197 additions and 207 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
modules/visual_script/visual_script.cpp
View File

@ -1333,6 +1333,19 @@ VisualScript::VisualScript() {
base_type = "Object"; base_type = "Object";
} }
Set<int> VisualScript::get_output_sequence_ports_connected(const String &edited_func, int from_node) {
List<VisualScript::SequenceConnection> *sc = memnew(List<VisualScript::SequenceConnection>);
get_sequence_connection_list(edited_func, sc);
Set<int> connected;
for (List<VisualScript::SequenceConnection>::Element *E = sc->front(); E; E = E->next()) {
if (E->get().from_node == from_node) {
connected.insert(E->get().from_output);
}
}
memdelete(sc);
return connected;
}
VisualScript::~VisualScript() { VisualScript::~VisualScript() {
while (!functions.empty()) { while (!functions.empty()) {

1
modules/visual_script/visual_script.h
View File

@ -319,6 +319,7 @@ public:
void custom_signal_swap_argument(const StringName &p_func, int p_argidx, int p_with_argidx); void custom_signal_swap_argument(const StringName &p_func, int p_argidx, int p_with_argidx);
void remove_custom_signal(const StringName &p_name); void remove_custom_signal(const StringName &p_name);
void rename_custom_signal(const StringName &p_name, const StringName &p_new_name); void rename_custom_signal(const StringName &p_name, const StringName &p_new_name);
Set<int> get_output_sequence_ports_connected(const String &edited_func, int from_node);
void get_custom_signal_list(List<StringName> *r_custom_signals) const; void get_custom_signal_list(List<StringName> *r_custom_signals) const;

506
modules/visual_script/visual_script_editor.cpp
View File

@ -33,8 +33,10 @@
#include "core/script_language.h" #include "core/script_language.h"
#include "editor/editor_node.h" #include "editor/editor_node.h"
#include "editor/editor_resource_preview.h" #include "editor/editor_resource_preview.h"
#include "object.h"
#include "os/input.h" #include "os/input.h"
#include "os/keyboard.h" #include "os/keyboard.h"
#include "variant.h"
#include "visual_script_expression.h" #include "visual_script_expression.h"
#include "visual_script_flow_control.h" #include "visual_script_flow_control.h"
#include "visual_script_func_nodes.h" #include "visual_script_func_nodes.h"
@ -1325,6 +1327,12 @@ void VisualScriptEditor::_input(const Ref<InputEvent> &p_event) {
if (mb.is_valid() && !mb->is_pressed() && mb->get_button_index() == BUTTON_LEFT) { if (mb.is_valid() && !mb->is_pressed() && mb->get_button_index() == BUTTON_LEFT) {
revert_on_drag = String(); //so we can still drag functions revert_on_drag = String(); //so we can still drag functions
} }
Ref<InputEventKey> k = p_event;
if (k.is_valid() && k->get_scancode() == KEY_A && k->get_shift() && k->is_pressed()) {
new_connect_node_select->select_from_visual_script(String(""));
accept_event();
}
} }
void VisualScriptEditor::_members_gui_input(const Ref<InputEvent> &p_event) { void VisualScriptEditor::_members_gui_input(const Ref<InputEvent> &p_event) {
@ -1780,7 +1788,7 @@ void VisualScriptEditor::drop_data_fw(const Point2 &p_point, const Variant &p_da
call->set_base_type(node->get_class()); call->set_base_type(node->get_class());
n = call; n = call;
method_select->select_method_from_instance(node); method_select->select_from_instance(node);
selecting_method_id = base_id; selecting_method_id = base_id;
} }
@ -1917,7 +1925,7 @@ void VisualScriptEditor::drop_data_fw(const Point2 &p_point, const Variant &p_da
} }
} }
void VisualScriptEditor::_selected_method(const String &p_method) { void VisualScriptEditor::_selected_method(const String &p_method, const String &p_type) {
Ref<VisualScriptFunctionCall> vsfc = script->get_node(edited_func, selecting_method_id); Ref<VisualScriptFunctionCall> vsfc = script->get_node(edited_func, selecting_method_id);
if (!vsfc.is_valid()) if (!vsfc.is_valid())
@ -2435,33 +2443,19 @@ void VisualScriptEditor::_graph_connect_to_empty(const String &p_from, int p_fro
if (!vsn.is_valid()) if (!vsn.is_valid())
return; return;
if (p_from_slot < vsn->get_output_sequence_port_count()) { port_action_pos = p_release_pos;
port_action_popup->clear(); if (p_from_slot < vsn->get_output_sequence_port_count()) {
port_action_popup->add_item(TTR("Condition"), CREATE_COND);
port_action_popup->add_item(TTR("Sequence"), CREATE_SEQUENCE);
port_action_popup->add_item(TTR("Switch"), CREATE_SWITCH);
port_action_popup->add_item(TTR("Iterator"), CREATE_ITERATOR);
port_action_popup->add_item(TTR("While"), CREATE_WHILE);
port_action_popup->add_item(TTR("Return"), CREATE_RETURN);
port_action_node = p_from.to_int(); port_action_node = p_from.to_int();
port_action_output = p_from_slot; port_action_output = p_from_slot;
_port_action_menu(CREATE_ACTION);
} else { } else {
port_action_popup->clear();
port_action_popup->add_item(TTR("Call"), CREATE_CALL);
port_action_popup->add_item(TTR("Get"), CREATE_GET);
port_action_popup->add_item(TTR("Set"), CREATE_SET);
port_action_output = p_from_slot - vsn->get_output_sequence_port_count(); port_action_output = p_from_slot - vsn->get_output_sequence_port_count();
port_action_node = p_from.to_int(); port_action_node = p_from.to_int();
_port_action_menu(CREATE_CALL_SET_GET);
} }
port_action_pos = p_release_pos;
port_action_popup->set_size(Size2(1, 1));
port_action_popup->set_position(graph->get_global_position() + p_release_pos);
port_action_popup->popup();
} }
VisualScriptNode::TypeGuess VisualScriptEditor::_guess_output_type(int p_port_action_node, int p_port_action_output, Set<int> &visited_nodes) { VisualScriptNode::TypeGuess VisualScriptEditor::_guess_output_type(int p_port_action_node, int p_port_action_output, Set<int> &visited_nodes) {
@ -2529,159 +2523,62 @@ void VisualScriptEditor::_port_action_menu(int p_option) {
bool seq_connect = false; bool seq_connect = false;
Ref<VisualScriptNode> vnode;
Set<int> vn; Set<int> vn;
switch (p_option) { switch (p_option) {
case CREATE_CALL: { case CREATE_CALL_SET_GET: {
Ref<VisualScriptFunctionCall> n; Ref<VisualScriptFunctionCall> n;
n.instance(); n.instance();
vnode = n;
VisualScriptNode::TypeGuess tg = _guess_output_type(port_action_node, port_action_output, vn); VisualScriptNode::TypeGuess tg = _guess_output_type(port_action_node, port_action_output, vn);
if (tg.type == Variant::OBJECT) { if (tg.gdclass != StringName()) {
n->set_call_mode(VisualScriptFunctionCall::CALL_MODE_INSTANCE); n->set_base_type(tg.gdclass);
if (tg.gdclass != StringName()) {
n->set_base_type(tg.gdclass);
} else {
n->set_base_type("Object");
}
if (tg.script.is_valid()) {
n->set_base_script(tg.script->get_path());
new_connect_node_select->select_method_from_script(tg.script);
} else {
new_connect_node_select->select_method_from_base_type(n->get_base_type());
}
} else { } else {
n->set_call_mode(VisualScriptFunctionCall::CALL_MODE_BASIC_TYPE); n->set_base_type("Object");
n->set_basic_type(tg.type);
new_connect_node_select->select_method_from_basic_type(tg.type);
} }
String type_string = script->get_node(edited_func, port_action_node)->get_output_value_port_info(port_action_output).hint_string;
if (tg.type == Variant::OBJECT) {
if (tg.script.is_valid()) {
new_connect_node_select->select_from_script(tg.script, "");
} else if (type_string != String()) {
new_connect_node_select->select_from_base_type(type_string);
} else {
new_connect_node_select->select_from_base_type(n->get_base_type());
}
} else if (tg.type == Variant::NIL) {
new_connect_node_select->select_from_base_type("");
} else {
new_connect_node_select->select_from_basic_type(tg.type);
}
} break; } break;
case CREATE_SET: { case CREATE_ACTION: {
seq_connect = true;
Ref<VisualScriptPropertySet> n;
n.instance();
vnode = n;
VisualScriptNode::TypeGuess tg = _guess_output_type(port_action_node, port_action_output, vn); VisualScriptNode::TypeGuess tg = _guess_output_type(port_action_node, port_action_output, vn);
PropertyInfo property_info = script->get_node(edited_func, port_action_node)->get_output_value_port_info(port_action_output);
if (tg.type == Variant::OBJECT) { if (tg.type == Variant::OBJECT) {
n->set_call_mode(VisualScriptPropertySet::CALL_MODE_INSTANCE); if (property_info.type == Variant::OBJECT && property_info.hint_string != String()) {
new_connect_node_select->select_from_action(property_info.hint_string);
if (tg.gdclass != StringName()) {
n->set_base_type(tg.gdclass);
} else { } else {
n->set_base_type("Object"); new_connect_node_select->select_from_action("");
} }
} else if (tg.type == Variant::NIL) {
if (tg.script.is_valid()) { new_connect_node_select->select_from_action("");
n->set_base_script(tg.script->get_path());
new_connect_node_select->select_property_from_script(tg.script);
} else {
new_connect_node_select->select_property_from_base_type(n->get_base_type());
}
} else { } else {
n->set_call_mode(VisualScriptPropertySet::CALL_MODE_BASIC_TYPE); new_connect_node_select->select_from_action(Variant::get_type_name(tg.type));
n->set_basic_type(tg.type);
new_connect_node_select->select_property_from_basic_type(tg.type);
} }
} break; } break;
case CREATE_GET: {
Ref<VisualScriptPropertyGet> n;
n.instance();
vnode = n;
VisualScriptNode::TypeGuess tg = _guess_output_type(port_action_node, port_action_output, vn);
if (tg.type == Variant::OBJECT) {
n->set_call_mode(VisualScriptPropertyGet::CALL_MODE_INSTANCE);
if (tg.gdclass != StringName()) {
n->set_base_type(tg.gdclass);
} else {
n->set_base_type("Object");
}
if (tg.script.is_valid()) {
n->set_base_script(tg.script->get_path());
new_connect_node_select->select_property_from_script(tg.script);
} else {
new_connect_node_select->select_property_from_base_type(n->get_base_type());
}
} else {
n->set_call_mode(VisualScriptPropertyGet::CALL_MODE_BASIC_TYPE);
n->set_basic_type(tg.type);
new_connect_node_select->select_property_from_basic_type(tg.type);
}
} break;
case CREATE_COND: {
Ref<VisualScriptCondition> n;
n.instance();
vnode = n;
seq_connect = true;
} break;
case CREATE_SEQUENCE: {
Ref<VisualScriptSequence> n;
n.instance();
vnode = n;
seq_connect = true;
} break;
case CREATE_SWITCH: {
Ref<VisualScriptSwitch> n;
n.instance();
vnode = n;
seq_connect = true;
} break;
case CREATE_ITERATOR: {
Ref<VisualScriptIterator> n;
n.instance();
vnode = n;
seq_connect = true;
} break;
case CREATE_WHILE: {
Ref<VisualScriptWhile> n;
n.instance();
vnode = n;
seq_connect = true;
} break;
case CREATE_RETURN: {
Ref<VisualScriptReturn> n;
n.instance();
vnode = n;
seq_connect = true;
} break;
} }
}
void VisualScriptEditor::new_node(Ref<VisualScriptNode> vnode, Vector2 ofs) {
Set<int> vn;
Ref<VisualScriptNode> vnode_old = script->get_node(edited_func, port_action_node);
int new_id = script->get_available_id(); int new_id = script->get_available_id();
undo_redo->create_action(TTR("Add Node")); undo_redo->create_action(TTR("Add Node"));
undo_redo->add_do_method(script.ptr(), "add_node", edited_func, new_id, vnode, ofs); undo_redo->add_do_method(script.ptr(), "add_node", edited_func, new_id, vnode, ofs);
if (seq_connect) {
undo_redo->add_do_method(script.ptr(), "sequence_connect", edited_func, port_action_node, port_action_output, new_id);
}
undo_redo->add_undo_method(script.ptr(), "remove_node", edited_func, new_id); undo_redo->add_undo_method(script.ptr(), "remove_node", edited_func, new_id);
undo_redo->add_do_method(this, "_update_graph", new_id); undo_redo->add_do_method(this, "_update_graph", new_id);
undo_redo->add_undo_method(this, "_update_graph", new_id); undo_redo->add_undo_method(this, "_update_graph", new_id);
@ -2690,7 +2587,138 @@ void VisualScriptEditor::_port_action_menu(int p_option) {
port_action_new_node = new_id; port_action_new_node = new_id;
} }
void VisualScriptEditor::_selected_connect_node_method_or_setget(const String &p_text) { void VisualScriptEditor::connect_data(Ref<VisualScriptNode> vnode_old, Ref<VisualScriptNode> vnode, int new_id) {
undo_redo->create_action(TTR("Connect Node Data"));
VisualScriptReturn *vnode_return = Object::cast_to<VisualScriptReturn>(vnode.ptr());
if (vnode_return != NULL && vnode_old->get_output_value_port_count() > 0) {
vnode_return->set_enable_return_value(true);
}
if (vnode_old->get_output_value_port_count() <= 0) {
undo_redo->commit_action();
return;
}
if (vnode->get_input_value_port_count() <= 0) {
undo_redo->commit_action();
return;
}
int port = port_action_output;
int value_count = vnode_old->get_output_value_port_count();
if (port >= value_count) {
port = 0;
}
int count = vnode_old->get_output_value_port_count() + vnode_old->get_output_sequence_port_count();
undo_redo->add_do_method(script.ptr(), "data_connect", edited_func, port_action_node, port, new_id, 0);
undo_redo->add_undo_method(script.ptr(), "data_disconnect", edited_func, port_action_node, port, new_id, 0);
undo_redo->commit_action();
}
void VisualScriptEditor::_selected_connect_node(const String &p_text, const String &p_category) {
Vector2 ofs = graph->get_scroll_ofs() + port_action_pos;
if (graph->is_using_snap()) {
int snap = graph->get_snap();
ofs = ofs.snapped(Vector2(snap, snap));
}
ofs /= EDSCALE;
Set<int> vn;
if (p_category == "visualscript") {
Ref<VisualScriptNode> vnode_new = VisualScriptLanguage::singleton->create_node_from_name(p_text);
Ref<VisualScriptNode> vnode_old = script->get_node(edited_func, port_action_node);
int new_id = script->get_available_id();
if (Object::cast_to<VisualScriptOperator>(vnode_new.ptr())) {
Variant::Type type = script->get_node(edited_func, port_action_node)->get_output_value_port_info(port_action_output).type;
Object::cast_to<VisualScriptOperator>(vnode_new.ptr())->set_typed(type);
}
if (Object::cast_to<VisualScriptTypeCast>(vnode_new.ptr())) {
Variant::Type type = script->get_node(edited_func, port_action_node)->get_output_value_port_info(port_action_output).type;
String hint_name = script->get_node(edited_func, port_action_node)->get_output_value_port_info(port_action_output).hint_string;
if (type == Variant::OBJECT) {
Object::cast_to<VisualScriptTypeCast>(vnode_new.ptr())->set_base_type(hint_name);
} else if (type == Variant::NIL) {
Object::cast_to<VisualScriptTypeCast>(vnode_new.ptr())->set_base_type("");
} else {
Object::cast_to<VisualScriptTypeCast>(vnode_new.ptr())->set_base_type(Variant::get_type_name(type));
}
}
undo_redo->create_action(TTR("Add Node"));
undo_redo->add_do_method(script.ptr(), "add_node", edited_func, new_id, vnode_new, ofs);
connect_seq(vnode_old, vnode_new, new_id);
connect_data(vnode_old, vnode_new, new_id);
undo_redo->add_undo_method(script.ptr(), "remove_node", edited_func, new_id);
undo_redo->add_do_method(this, "_update_graph");
undo_redo->add_undo_method(this, "_update_graph");
undo_redo->commit_action();
return;
}
Ref<VisualScriptNode> vnode;
seq_connect = false;
if (p_category == String("method")) {
Ref<VisualScriptFunctionCall> n;
n.instance();
vnode = n;
} else if (p_category == String("set")) {
Ref<VisualScriptPropertySet> n;
n.instance();
n->set_property(p_text);
vnode = n;
} else if (p_category == String("get")) {
Ref<VisualScriptPropertyGet> n;
n.instance();
n->set_property(p_text);
vnode = n;
}
if (p_category == String("action")) {
if (p_text == "VisualScriptCondition") {
Ref<VisualScriptCondition> n;
n.instance();
vnode = n;
seq_connect = true;
}
if (p_text == "VisualScriptSwitch") {
Ref<VisualScriptSwitch> n;
n.instance();
vnode = n;
seq_connect = true;
} else if (p_text == "VisualScriptSequence") {
Ref<VisualScriptSequence> n;
n.instance();
vnode = n;
seq_connect = true;
} else if (p_text == "VisualScriptIterator") {
Ref<VisualScriptIterator> n;
n.instance();
vnode = n;
seq_connect = true;
} else if (p_text == "VisualScriptWhile") {
Ref<VisualScriptWhile> n;
n.instance();
vnode = n;
seq_connect = true;
} else if (p_text == "VisualScriptReturn") {
Ref<VisualScriptReturn> n;
n.instance();
vnode = n;
seq_connect = true;
}
}
new_node(vnode, ofs);
Ref<VisualScriptNode> vsn = script->get_node(edited_func, port_action_new_node); Ref<VisualScriptNode> vsn = script->get_node(edited_func, port_action_new_node);
@ -2698,28 +2726,152 @@ void VisualScriptEditor::_selected_connect_node_method_or_setget(const String &p
Ref<VisualScriptFunctionCall> vsfc = vsn; Ref<VisualScriptFunctionCall> vsfc = vsn;
vsfc->set_function(p_text); vsfc->set_function(p_text);
script->data_connect(edited_func, port_action_node, port_action_output, port_action_new_node, 0);
VisualScriptNode::TypeGuess tg = _guess_output_type(port_action_node, port_action_output, vn);
if (tg.type == Variant::OBJECT) {
vsfc->set_call_mode(VisualScriptFunctionCall::CALL_MODE_INSTANCE);
if (tg.gdclass != StringName()) {
vsfc->set_base_type(tg.gdclass);
} else {
PropertyHint hint = script->get_node(edited_func, port_action_node)->get_output_value_port_info(port_action_output).hint;
String base_type = script->get_node(edited_func, port_action_node)->get_output_value_port_info(port_action_output).hint_string;
if (base_type != String() && hint == PROPERTY_HINT_TYPE_STRING) {
vsfc->set_base_type(base_type);
}
if (p_text == "call" || p_text == "call_deferred") {
vsfc->set_function("");
}
}
if (tg.script.is_valid()) {
vsfc->set_base_script(tg.script->get_path());
}
} else if (tg.type == Variant::NIL) {
vsfc->set_call_mode(VisualScriptFunctionCall::CALL_MODE_INSTANCE);
vsfc->set_base_type(script->get_instance_base_type());
} else {
vsfc->set_call_mode(VisualScriptFunctionCall::CALL_MODE_BASIC_TYPE);
vsfc->set_basic_type(tg.type);
}
} }
if (Object::cast_to<VisualScriptPropertySet>(vsn.ptr())) { if (Object::cast_to<VisualScriptPropertySet>(vsn.ptr())) {
Ref<VisualScriptPropertySet> vsp = vsn; Ref<VisualScriptPropertySet> vsp = vsn;
vsp->set_property(p_text);
script->data_connect(edited_func, port_action_node, port_action_output, port_action_new_node, 0); VisualScriptNode::TypeGuess tg = _guess_output_type(port_action_node, port_action_output, vn);
if (tg.type == Variant::OBJECT) {
vsp->set_call_mode(VisualScriptPropertySet::CALL_MODE_INSTANCE);
if (tg.gdclass != StringName()) {
vsp->set_base_type(tg.gdclass);
} else {
PropertyHint hint = script->get_node(edited_func, port_action_node)->get_output_value_port_info(port_action_output).hint;
String base_type = script->get_node(edited_func, port_action_node)->get_output_value_port_info(port_action_output).hint_string;
if (base_type != String() && hint == PROPERTY_HINT_TYPE_STRING) {
vsp->set_base_type(base_type);
}
}
if (tg.script.is_valid()) {
vsp->set_base_script(tg.script->get_path());
}
} else if (tg.type == Variant::NIL) {
vsp->set_call_mode(VisualScriptPropertySet::CALL_MODE_INSTANCE);
vsp->set_base_type(script->get_instance_base_type());
} else {
vsp->set_call_mode(VisualScriptPropertySet::CALL_MODE_BASIC_TYPE);
vsp->set_basic_type(tg.type);
}
} }
if (Object::cast_to<VisualScriptPropertyGet>(vsn.ptr())) { if (Object::cast_to<VisualScriptPropertyGet>(vsn.ptr())) {
Ref<VisualScriptPropertyGet> vsp = vsn; Ref<VisualScriptPropertyGet> vsp = vsn;
vsp->set_property(p_text);
script->data_connect(edited_func, port_action_node, port_action_output, port_action_new_node, 0); VisualScriptNode::TypeGuess tg = _guess_output_type(port_action_node, port_action_output, vn);
if (tg.type == Variant::OBJECT) {
vsp->set_call_mode(VisualScriptPropertyGet::CALL_MODE_INSTANCE);
if (tg.gdclass != StringName()) {
vsp->set_base_type(tg.gdclass);
} else {
PropertyHint hint = script->get_node(edited_func, port_action_node)->get_output_value_port_info(port_action_output).hint;
String base_type = script->get_node(edited_func, port_action_node)->get_output_value_port_info(port_action_output).hint_string;
if (base_type != String() && hint == PROPERTY_HINT_TYPE_STRING) {
vsp->set_base_type(base_type);
}
}
if (tg.script.is_valid()) {
vsp->set_base_script(tg.script->get_path());
}
} else if (tg.type == Variant::NIL) {
vsp->set_call_mode(VisualScriptPropertyGet::CALL_MODE_INSTANCE);
vsp->set_base_type(script->get_instance_base_type());
} else {
vsp->set_call_mode(VisualScriptPropertyGet::CALL_MODE_BASIC_TYPE);
vsp->set_basic_type(tg.type);
}
} }
Ref<VisualScriptNode> vnode_old = script->get_node(edited_func, port_action_node);
connect_seq(vnode_old, vnode, port_action_new_node);
connect_data(vnode_old, vnode, port_action_new_node);
_update_graph(port_action_new_node); _update_graph(port_action_new_node);
_update_graph_connections(); _update_graph_connections();
} }
void VisualScriptEditor::_selected_new_virtual_method(const String &p_text) { void VisualScriptEditor::connect_seq(Ref<VisualScriptNode> vnode_old, Ref<VisualScriptNode> vnode_new, int new_id) {
int seq_count = vnode_old->get_output_sequence_port_count();
VisualScriptOperator *vnode_operator = Object::cast_to<VisualScriptOperator>(vnode_new.ptr());
if (vnode_operator != NULL && vnode_operator->has_input_sequence_port() == false) {
return;
}
VisualScriptConstructor *vnode_constructor = Object::cast_to<VisualScriptConstructor>(vnode_new.ptr());
if (vnode_constructor != NULL) {
return;
}
if (vnode_old->get_output_sequence_port_count() <= 0) {
return;
}
if (vnode_new->has_input_sequence_port() == false) {
return;
}
VisualScriptFunction *vnode_function = Object::cast_to<VisualScriptFunction>(vnode_old.ptr());
undo_redo->create_action(TTR("Connect Node Sequence"));
int pass_port = -vnode_old->get_output_sequence_port_count() + 1;
int return_port = port_action_output - 1;
if (vnode_old->get_output_value_port_info(port_action_output).name == String("pass") &&
!script->get_output_sequence_ports_connected(edited_func, port_action_node).has(pass_port)) {
undo_redo->add_do_method(script.ptr(), "sequence_connect", edited_func, port_action_node, pass_port, new_id);
undo_redo->add_undo_method(script.ptr(), "sequence_disconnect", edited_func, port_action_node, pass_port, new_id);
} else if (vnode_old->get_output_value_port_info(port_action_output).name == String("return") &&
!script->get_output_sequence_ports_connected(edited_func, port_action_node).has(return_port)) {
undo_redo->add_do_method(script.ptr(), "sequence_connect", edited_func, port_action_node, return_port, new_id);
undo_redo->add_undo_method(script.ptr(), "sequence_disconnect", edited_func, port_action_node, return_port, new_id);
} else {
for (int port = 0; port < vnode_old->get_output_sequence_port_count(); port++) {
int count = vnode_old->get_output_sequence_port_count();
if (port_action_output < count && !script->get_output_sequence_ports_connected(edited_func, port_action_node).has(port_action_output)) {
undo_redo->add_do_method(script.ptr(), "sequence_connect", edited_func, port_action_node, port_action_output, new_id);
undo_redo->add_undo_method(script.ptr(), "sequence_disconnect", edited_func, port_action_node, port_action_output, new_id);
break;
} else if (!script->get_output_sequence_ports_connected(edited_func, port_action_node).has(port)) {
undo_redo->add_do_method(script.ptr(), "sequence_connect", edited_func, port_action_node, port, new_id);
undo_redo->add_undo_method(script.ptr(), "sequence_disconnect", edited_func, port_action_node, port, new_id);
break;
}
}
}
undo_redo->commit_action();
}
void VisualScriptEditor::_selected_new_virtual_method(const String &p_text, const String &p_category) {
String name = p_text; String name = p_text;
if (script->has_function(name)) { if (script->has_function(name)) {
@ -2776,12 +2928,29 @@ void VisualScriptEditor::_selected_new_virtual_method(const String &p_text) {
_update_graph(); _update_graph();
} }
void VisualScriptEditor::_cancel_connect_node_method_or_setget() { void VisualScriptEditor::_cancel_connect_node() {
// Causes crashes
script->remove_node(edited_func, port_action_new_node); //script->remove_node(edited_func, port_action_new_node);
_update_graph(); _update_graph();
} }
void VisualScriptEditor::_create_new_node(const String &p_text, const String &p_category, const Vector2 &p_point) {
Vector2 ofs = graph->get_scroll_ofs() + p_point;
if (graph->is_using_snap()) {
int snap = graph->get_snap();
ofs = ofs.snapped(Vector2(snap, snap));
}
ofs /= EDSCALE;
Ref<VisualScriptNode> vnode = VisualScriptLanguage::singleton->create_node_from_name(p_text);
int new_id = script->get_available_id();
undo_redo->create_action(TTR("Add Node"));
undo_redo->add_do_method(script.ptr(), "add_node", edited_func, new_id, vnode, ofs);
undo_redo->add_undo_method(script.ptr(), "remove_node", edited_func, new_id);
undo_redo->add_do_method(this, "_update_graph");
undo_redo->add_undo_method(this, "_update_graph");
undo_redo->commit_action();
}
void VisualScriptEditor::_default_value_changed() { void VisualScriptEditor::_default_value_changed() {
Ref<VisualScriptNode> vsn = script->get_node(edited_func, editing_id); Ref<VisualScriptNode> vsn = script->get_node(edited_func, editing_id);
@ -3285,10 +3454,11 @@ void VisualScriptEditor::_bind_methods() {
ClassDB::bind_method("_comment_node_resized", &VisualScriptEditor::_comment_node_resized); ClassDB::bind_method("_comment_node_resized", &VisualScriptEditor::_comment_node_resized);
ClassDB::bind_method("_button_resource_previewed", &VisualScriptEditor::_button_resource_previewed); ClassDB::bind_method("_button_resource_previewed", &VisualScriptEditor::_button_resource_previewed);
ClassDB::bind_method("_port_action_menu", &VisualScriptEditor::_port_action_menu); ClassDB::bind_method("_port_action_menu", &VisualScriptEditor::_port_action_menu);
ClassDB::bind_method("_selected_connect_node_method_or_setget", &VisualScriptEditor::_selected_connect_node_method_or_setget); ClassDB::bind_method("_selected_connect_node", &VisualScriptEditor::_selected_connect_node);
ClassDB::bind_method("_selected_new_virtual_method", &VisualScriptEditor::_selected_new_virtual_method); ClassDB::bind_method("_selected_new_virtual_method", &VisualScriptEditor::_selected_new_virtual_method);
ClassDB::bind_method("_cancel_connect_node_method_or_setget", &VisualScriptEditor::_cancel_connect_node_method_or_setget); ClassDB::bind_method("_cancel_connect_node", &VisualScriptEditor::_cancel_connect_node);
ClassDB::bind_method("_create_new_node", &VisualScriptEditor::_create_new_node);
ClassDB::bind_method("_expression_text_changed", &VisualScriptEditor::_expression_text_changed); ClassDB::bind_method("_expression_text_changed", &VisualScriptEditor::_expression_text_changed);
ClassDB::bind_method("get_drag_data_fw", &VisualScriptEditor::get_drag_data_fw); ClassDB::bind_method("get_drag_data_fw", &VisualScriptEditor::get_drag_data_fw);
@ -3479,25 +3649,21 @@ VisualScriptEditor::VisualScriptEditor() {
add_child(default_value_edit); add_child(default_value_edit);
default_value_edit->connect("variant_changed", this, "_default_value_changed"); default_value_edit->connect("variant_changed", this, "_default_value_changed");
method_select = memnew(PropertySelector); method_select = memnew(VisualScriptPropertySelector);
add_child(method_select); add_child(method_select);
method_select->connect("selected", this, "_selected_method"); method_select->connect("selected", this, "_selected_method");
error_line = -1; error_line = -1;
new_connect_node_select = memnew(PropertySelector); new_connect_node_select = memnew(VisualScriptPropertySelector);
add_child(new_connect_node_select); add_child(new_connect_node_select);
new_connect_node_select->connect("selected", this, "_selected_connect_node_method_or_setget"); new_connect_node_select->connect("selected", this, "_selected_connect_node");
new_connect_node_select->get_cancel()->connect("pressed", this, "_cancel_connect_node_method_or_setget"); new_connect_node_select->get_cancel()->connect("pressed", this, "_cancel_connect_node");
new_virtual_method_select = memnew(PropertySelector); new_virtual_method_select = memnew(VisualScriptPropertySelector);
add_child(new_virtual_method_select); add_child(new_virtual_method_select);
new_virtual_method_select->connect("selected", this, "_selected_new_virtual_method"); new_virtual_method_select->connect("selected", this, "_selected_new_virtual_method");
new_virtual_method_select->get_cancel()->connect("pressed", this, "_selected_new_virtual_method"); new_virtual_method_select->get_cancel()->connect("pressed", this, "_selected_new_virtual_method");
port_action_popup = memnew(PopupMenu);
add_child(port_action_popup);
port_action_popup->connect("id_pressed", this, "_port_action_menu");
member_popup = memnew(PopupMenu); member_popup = memnew(PopupMenu);
add_child(member_popup); add_child(member_popup);
members->connect("item_rmb_selected", this, "_member_rmb_selected"); members->connect("item_rmb_selected", this, "_member_rmb_selected");

39
modules/visual_script/visual_script_editor.h
View File

@ -34,9 +34,9 @@
#include "editor/create_dialog.h" #include "editor/create_dialog.h"
#include "editor/plugins/script_editor_plugin.h" #include "editor/plugins/script_editor_plugin.h"
#include "editor/property_editor.h" #include "editor/property_editor.h"
#include "editor/property_selector.h"
#include "scene/gui/graph_edit.h" #include "scene/gui/graph_edit.h"
#include "visual_script.h" #include "visual_script.h"
#include "visual_script_property_selector.h"
class VisualScriptEditorSignalEdit; class VisualScriptEditorSignalEdit;
class VisualScriptEditorVariableEdit; class VisualScriptEditorVariableEdit;
@ -62,15 +62,8 @@ class VisualScriptEditor : public ScriptEditorBase {
enum PortAction { enum PortAction {
CREATE_CALL, CREATE_CALL_SET_GET,
CREATE_SET, CREATE_ACTION,
CREATE_GET,
CREATE_COND,
CREATE_SEQUENCE,
CREATE_SWITCH,
CREATE_ITERATOR,
CREATE_WHILE,
CREATE_RETURN,
}; };
enum MemberAction { enum MemberAction {
@ -102,9 +95,9 @@ class VisualScriptEditor : public ScriptEditorBase {
AcceptDialog *edit_signal_dialog; AcceptDialog *edit_signal_dialog;
PropertyEditor *edit_signal_edit; PropertyEditor *edit_signal_edit;
PropertySelector *method_select; VisualScriptPropertySelector *method_select;
PropertySelector *new_connect_node_select; VisualScriptPropertySelector *new_connect_node_select;
PropertySelector *new_virtual_method_select; VisualScriptPropertySelector *new_virtual_method_select;
VisualScriptEditorVariableEdit *variable_editor; VisualScriptEditorVariableEdit *variable_editor;
@ -162,21 +155,29 @@ class VisualScriptEditor : public ScriptEditorBase {
static Clipboard *clipboard; static Clipboard *clipboard;
PopupMenu *port_action_popup;
PopupMenu *member_popup; PopupMenu *member_popup;
MemberType member_type; MemberType member_type;
String member_name; String member_name;
bool seq_connect = false;
PortAction port_action; PortAction port_action;
int port_action_node; int port_action_node;
int port_action_output; int port_action_output;
Vector2 port_action_pos; Vector2 port_action_pos;
int port_action_new_node; int port_action_new_node;
void _port_action_menu(int p_option); void _port_action_menu(int p_option);
void _selected_connect_node_method_or_setget(const String &p_text);
void _cancel_connect_node_method_or_setget(); void new_node(Ref<VisualScriptNode> vnode, Vector2 ofs);
void _selected_new_virtual_method(const String &p_text);
void connect_data(Ref<VisualScriptNode> vnode_old, Ref<VisualScriptNode> vnode, int new_id);
void _selected_connect_node(const String &p_text, const String &p_category);
void connect_seq(Ref<VisualScriptNode> vnode_old, Ref<VisualScriptNode> vnode_new, int new_id);
void _cancel_connect_node();
void _create_new_node(const String &p_text, const String &p_category, const Vector2 &p_point);
void _selected_new_virtual_method(const String &p_text, const String &p_category);
int error_line; int error_line;
@ -231,7 +232,7 @@ class VisualScriptEditor : public ScriptEditorBase {
void _comment_node_resized(const Vector2 &p_new_size, int p_node); void _comment_node_resized(const Vector2 &p_new_size, int p_node);
int selecting_method_id; int selecting_method_id;
void _selected_method(const String &p_method); void _selected_method(const String &p_method, const String &p_type);
void _draw_color_over_button(Object *obj, Color p_color); void _draw_color_over_button(Object *obj, Color p_color);
void _button_resource_previewed(const String &p_path, const Ref<Texture> &p_preview, Variant p_ud); void _button_resource_previewed(const String &p_path, const Ref<Texture> &p_preview, Variant p_ud);

2
modules/visual_script/visual_script_flow_control.cpp
View File

@ -767,7 +767,7 @@ PropertyInfo VisualScriptTypeCast::get_input_value_port_info(int p_idx) const {
PropertyInfo VisualScriptTypeCast::get_output_value_port_info(int p_idx) const { PropertyInfo VisualScriptTypeCast::get_output_value_port_info(int p_idx) const {
return PropertyInfo(Variant::OBJECT, ""); return PropertyInfo(Variant::OBJECT, "", PROPERTY_HINT_TYPE_STRING, get_base_type());
} }
String VisualScriptTypeCast::get_caption() const { String VisualScriptTypeCast::get_caption() const {

8
modules/visual_script/visual_script_func_nodes.cpp
View File

@ -43,7 +43,7 @@
int VisualScriptFunctionCall::get_output_sequence_port_count() const { int VisualScriptFunctionCall::get_output_sequence_port_count() const {
if (method_cache.flags & METHOD_FLAG_CONST || (call_mode == CALL_MODE_BASIC_TYPE && Variant::is_method_const(basic_type, function))) if ((method_cache.flags & METHOD_FLAG_CONST && call_mode != CALL_MODE_INSTANCE) || (call_mode == CALL_MODE_BASIC_TYPE && Variant::is_method_const(basic_type, function)))
return 0; return 0;
else else
return 1; return 1;
@ -51,7 +51,7 @@ int VisualScriptFunctionCall::get_output_sequence_port_count() const {
bool VisualScriptFunctionCall::has_input_sequence_port() const { bool VisualScriptFunctionCall::has_input_sequence_port() const {
if (method_cache.flags & METHOD_FLAG_CONST || (call_mode == CALL_MODE_BASIC_TYPE && Variant::is_method_const(basic_type, function))) if ((method_cache.flags & METHOD_FLAG_CONST && call_mode != CALL_MODE_INSTANCE) || (call_mode == CALL_MODE_BASIC_TYPE && Variant::is_method_const(basic_type, function)))
return false; return false;
else else
return true; return true;
@ -231,7 +231,7 @@ PropertyInfo VisualScriptFunctionCall::get_output_value_port_info(int p_idx) con
if (call_mode == CALL_MODE_INSTANCE) { if (call_mode == CALL_MODE_INSTANCE) {
if (p_idx == 0) { if (p_idx == 0) {
return PropertyInfo(Variant::OBJECT, "pass"); return PropertyInfo(Variant::OBJECT, "pass", PROPERTY_HINT_TYPE_STRING, get_base_type());
} else { } else {
p_idx--; p_idx--;
} }
@ -1055,7 +1055,7 @@ PropertyInfo VisualScriptPropertySet::get_output_value_port_info(int p_idx) cons
if (call_mode == CALL_MODE_BASIC_TYPE) { if (call_mode == CALL_MODE_BASIC_TYPE) {
return PropertyInfo(basic_type, "out"); return PropertyInfo(basic_type, "out");
} else if (call_mode == CALL_MODE_INSTANCE) { } else if (call_mode == CALL_MODE_INSTANCE) {
return PropertyInfo(Variant::OBJECT, "pass"); return PropertyInfo(Variant::OBJECT, "pass", PROPERTY_HINT_TYPE_STRING, get_base_type());
} else { } else {
return PropertyInfo(); return PropertyInfo();
} }

2
modules/visual_script/visual_script_nodes.cpp
View File

@ -2198,7 +2198,7 @@ PropertyInfo VisualScriptSceneTree::get_input_value_port_info(int p_idx) const {
PropertyInfo VisualScriptSceneTree::get_output_value_port_info(int p_idx) const { PropertyInfo VisualScriptSceneTree::get_output_value_port_info(int p_idx) const {
return PropertyInfo(Variant::OBJECT, "Scene Tree"); return PropertyInfo(Variant::OBJECT, "Scene Tree", PROPERTY_HINT_TYPE_STRING, "SceneTree");
} }
String VisualScriptSceneTree::get_caption() const { String VisualScriptSceneTree::get_caption() const {

705
modules/visual_script/visual_script_property_selector.cpp Normal file
View File

@ -0,0 +1,705 @@
/*************************************************************************/
/* visual_script_property_selector.cpp */
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* https://godotengine.org */
/*************************************************************************/
/* Copyright (c) 2007-2018 Juan Linietsky, Ariel Manzur. */
/* Copyright (c) 2014-2018 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 "visual_script_property_selector.h"
#include "editor_scale.h"
#include "modules/visual_script/visual_script.h"
#include "modules/visual_script/visual_script_builtin_funcs.h"
#include "modules/visual_script/visual_script_flow_control.h"
#include "modules/visual_script/visual_script_func_nodes.h"
#include "modules/visual_script/visual_script_nodes.h"
#include "os/keyboard.h"
#include "scene/main/node.h"
#include "scene/main/viewport.h"
void VisualScriptPropertySelector::_text_changed(const String &p_newtext) {
_update_search();
}
void VisualScriptPropertySelector::_sbox_input(const Ref<InputEvent> &p_ie) {
Ref<InputEventKey> k = p_ie;
if (k.is_valid()) {
switch (k->get_scancode()) {
case KEY_UP:
case KEY_DOWN:
case KEY_PAGEUP:
case KEY_PAGEDOWN: {
search_options->call("_gui_input", k);
search_box->accept_event();
TreeItem *root = search_options->get_root();
if (!root->get_children())
break;
TreeItem *current = search_options->get_selected();
TreeItem *item = search_options->get_next_selected(root);
while (item) {
item->deselect(0);
item = search_options->get_next_selected(item);
}
current->select(0);
} break;
}
}
}
void VisualScriptPropertySelector::_update_search() {
set_title(TTR("Search VisualScript"));
search_options->clear();
help_bit->set_text("");
TreeItem *root = search_options->create_item();
bool found = false;
if (properties) {
List<PropertyInfo> props;
if (instance) {
instance->get_property_list(&props, true);
} else if (type != Variant::NIL) {
Variant v;
Variant::CallError ce;
v = Variant::construct(type, NULL, 0, ce);
v.get_property_list(&props);
} else {
Object *obj = ObjectDB::get_instance(script);
if (Object::cast_to<Script>(obj)) {
props.push_back(PropertyInfo(Variant::NIL, "Script Variables", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_CATEGORY));
Object::cast_to<Script>(obj)->get_script_property_list(&props);
}
StringName base = base_type;
while (base) {
props.push_back(PropertyInfo(Variant::NIL, base, PROPERTY_HINT_NONE, "", PROPERTY_USAGE_CATEGORY));
ClassDB::get_property_list(base, &props, true);
base = ClassDB::get_parent_class_nocheck(base);
}
}
TreeItem *category = NULL;
Ref<Texture> type_icons[Variant::VARIANT_MAX] = {
Control::get_icon("Variant", "EditorIcons"),
Control::get_icon("bool", "EditorIcons"),
Control::get_icon("int", "EditorIcons"),
Control::get_icon("float", "EditorIcons"),
Control::get_icon("String", "EditorIcons"),
Control::get_icon("Vector2", "EditorIcons"),
Control::get_icon("Rect2", "EditorIcons"),
Control::get_icon("Vector3", "EditorIcons"),
Control::get_icon("Transform2D", "EditorIcons"),
Control::get_icon("Plane", "EditorIcons"),
Control::get_icon("Quat", "EditorIcons"),
Control::get_icon("AABB", "EditorIcons"),
Control::get_icon("Basis", "EditorIcons"),
Control::get_icon("Transform", "EditorIcons"),
Control::get_icon("Color", "EditorIcons"),
Control::get_icon("Path", "EditorIcons"),
Control::get_icon("RID", "EditorIcons"),
Control::get_icon("Object", "EditorIcons"),
Control::get_icon("Dictionary", "EditorIcons"),
Control::get_icon("Array", "EditorIcons"),
Control::get_icon("PoolByteArray", "EditorIcons"),
Control::get_icon("PoolIntArray", "EditorIcons"),
Control::get_icon("PoolRealArray", "EditorIcons"),
Control::get_icon("PoolStringArray", "EditorIcons"),
Control::get_icon("PoolVector2Array", "EditorIcons"),
Control::get_icon("PoolVector3Array", "EditorIcons"),
Control::get_icon("PoolColorArray", "EditorIcons")
};
if (!seq_connect && visual_script_generic == false) {
get_visual_node_names("flow_control/type_cast", Set<String>(), found, root, search_box);
get_visual_node_names("functions/built_in/print", Set<String>(), found, root, search_box);
get_visual_node_names("functions/by_type/" + Variant::get_type_name(type), Set<String>(), found, root, search_box);
get_visual_node_names("operators/compare/", Set<String>(), found, root, search_box);
if (type == Variant::INT) {
get_visual_node_names("operators/bitwise/", Set<String>(), found, root, search_box);
}
if (type == Variant::BOOL) {
get_visual_node_names("operators/logic/", Set<String>(), found, root, search_box);
}
if (type == Variant::BOOL || type == Variant::INT || type == Variant::REAL || type == Variant::VECTOR2 || type == Variant::VECTOR3) {
get_visual_node_names("operators/math/", Set<String>(), found, root, search_box);
}
}
for (List<PropertyInfo>::Element *E = props.front(); E; E = E->next()) {
if (E->get().usage == PROPERTY_USAGE_CATEGORY) {
if (category && category->get_children() == NULL) {
memdelete(category); //old category was unused
}
category = search_options->create_item(root);
category->set_text(0, E->get().name);
category->set_selectable(0, false);
Ref<Texture> icon;
if (E->get().name == "Script Variables") {
icon = get_icon("Script", "EditorIcons");
} else if (has_icon(E->get().name, "EditorIcons")) {
icon = get_icon(E->get().name, "EditorIcons");
} else {
icon = get_icon("Object", "EditorIcons");
}
category->set_icon(0, icon);
continue;
}
if (!(E->get().usage & PROPERTY_USAGE_EDITOR) && !(E->get().usage & PROPERTY_USAGE_SCRIPT_VARIABLE))
continue;
if (type_filter.size() && type_filter.find(E->get().type) == -1)
continue;
String get_text_raw = String(TTR("Get")) + String(" ") + E->get().name;
String get_text = get_text_raw.capitalize();
String set_text_raw = String(TTR("Set ")) + String(" ") + E->get().name;
String set_text = set_text_raw.capitalize();
String input = search_box->get_text().capitalize();
if (input == String() ||
get_text_raw.findn(input) != -1 ||
get_text.findn(input) != -1) {
TreeItem *item = search_options->create_item(category ? category : root);
item->set_text(0, get_text);
item->set_metadata(0, E->get().name);
item->set_icon(0, type_icons[E->get().type]);
item->set_metadata(1, "get");
item->set_collapsed(1);
item->set_selectable(1, false);
item->set_selectable(0, true);
}
if (input == String() ||
set_text_raw.findn(input) != -1 &&
set_text.findn(input) != -1) {
TreeItem *item = search_options->create_item(category ? category : root);
item->set_text(0, set_text);
item->set_metadata(0, E->get().name);
item->set_icon(0, type_icons[E->get().type]);
item->set_metadata(1, "set");
item->set_selectable(1, false);
item->set_selectable(0, true);
}
}
}
if (seq_connect == true && visual_script_generic == false) {
String text = search_box->get_text();
create_visualscript_item(String("VisualScriptCondition"), root, text, String("Condition"));
create_visualscript_item(String("VisualScriptSwitch"), root, text, String("Switch"));
create_visualscript_item(String("VisualScriptSequence"), root, text, String("Sequence"));
create_visualscript_item(String("VisualScriptIterator"), root, text, String("Iterator"));
create_visualscript_item(String("VisualScriptWhile"), root, text, String("While"));
create_visualscript_item(String("VisualScriptReturn"), root, text, String("Return"));
get_visual_node_names("flow_control/type_cast", Set<String>(), found, root, search_box);
get_visual_node_names("functions/built_in/print", Set<String>(), found, root, search_box);
}
if (visual_script_generic) {
get_visual_node_names("", Set<String>(), found, root, search_box);
}
List<MethodInfo> methods;
if (type != Variant::NIL) {
Variant v;
Variant::CallError ce;
v = Variant::construct(type, NULL, 0, ce);
v.get_method_list(&methods);
} else {
Object *obj = ObjectDB::get_instance(script);
if (Object::cast_to<Script>(obj)) {
methods.push_back(MethodInfo("*Script Methods"));
Object::cast_to<Script>(obj)->get_script_method_list(&methods);
}
StringName base = base_type;
while (base) {
methods.push_back(MethodInfo("*" + String(base)));
ClassDB::get_method_list(base, &methods, true, true);
base = ClassDB::get_parent_class_nocheck(base);
}
}
TreeItem *category = NULL;
bool script_methods = false;
for (List<MethodInfo>::Element *E = methods.front(); E; E = E->next()) {
if (E->get().name.begins_with("*")) {
if (category && category->get_children() == NULL) {
memdelete(category); //old category was unused
}
category = search_options->create_item(root);
category->set_text(0, E->get().name.replace_first("*", ""));
category->set_selectable(0, false);
Ref<Texture> icon;
script_methods = false;
print_line("name: " + E->get().name);
String rep = E->get().name.replace("*", "");
if (E->get().name == "*Script Methods") {
icon = get_icon("Script", "EditorIcons");
script_methods = true;
} else if (has_icon(rep, "EditorIcons")) {
icon = get_icon(rep, "EditorIcons");
} else {
icon = get_icon("Object", "EditorIcons");
}
category->set_icon(0, icon);
continue;
}
String name = E->get().name.get_slice(":", 0);
if (!script_methods && name.begins_with("_") && !(E->get().flags & METHOD_FLAG_VIRTUAL))
continue;
if (virtuals_only && !(E->get().flags & METHOD_FLAG_VIRTUAL))
continue;
if (!virtuals_only && (E->get().flags & METHOD_FLAG_VIRTUAL))
continue;
MethodInfo mi = E->get();
String desc = mi.name.capitalize() + " (";
if (search_box->get_text() != String() &&
name.findn(search_box->get_text()) == -1 &&
desc.findn(search_box->get_text()) == -1)
continue;
TreeItem *item = search_options->create_item(category ? category : root);
for (int i = 0; i < mi.arguments.size(); i++) {
if (i > 0)
desc += ", ";
if (mi.arguments[i].type == Variant::NIL)
desc += "var";
else if (mi.arguments[i].name.find(":") != -1) {
desc += mi.arguments[i].name.get_slice(":", 1);
mi.arguments[i].name = mi.arguments[i].name.get_slice(":", 0);
} else
desc += Variant::get_type_name(mi.arguments[i].type);
}
desc += ")";
item->set_text(0, desc);
item->set_icon(0, get_icon("MemberMethod", "EditorIcons"));
item->set_metadata(0, name);
item->set_selectable(0, true);
item->set_metadata(1, "method");
item->set_collapsed(1);
item->set_selectable(1, false);
if (category && category->get_children() == NULL) {
memdelete(category); //old category was unused
}
}
TreeItem *selected_item = search_options->search_item_text(search_box->get_text());
if (!found && selected_item != NULL) {
selected_item->select(0);
found = true;
}
get_ok()->set_disabled(root->get_children() == NULL);
}
void VisualScriptPropertySelector::create_visualscript_item(const String &name, TreeItem *const root, const String &search_input, const String &text) {
if (search_input == String() || text.findn(search_input) != -1) {
TreeItem *item = search_options->create_item(root);
item->set_text(0, text);
item->set_icon(0, get_icon("VisualScript", "EditorIcons"));
item->set_metadata(0, name);
item->set_metadata(1, "action");
item->set_selectable(0, true);
item->set_collapsed(1);
item->set_selectable(1, false);
}
}
void VisualScriptPropertySelector::get_visual_node_names(const String &root_filter, const Set<String> &filter, bool &found, TreeItem *const root, LineEdit *const search_box) {
Map<String, TreeItem *> path_cache;
List<String> fnodes;
VisualScriptLanguage::singleton->get_registered_node_names(&fnodes);
for (List<String>::Element *E = fnodes.front(); E; E = E->next()) {
if (!E->get().begins_with(root_filter)) {
continue;
}
Vector<String> path = E->get().split("/");
bool is_filter = false;
for (Set<String>::Element *E = filter.front(); E; E = E->next()) {
if (path.size() >= 2 && path[1].findn(E->get()) != -1) {
is_filter = true;
break;
}
}
if (is_filter == true) {
continue;
}
if (search_box->get_text() != String() && E->get().findn(search_box->get_text()) == -1) {
continue;
}
TreeItem *item = search_options->create_item(root);
VisualScriptOperator *vnode_operator = Object::cast_to<VisualScriptOperator>(*VisualScriptLanguage::singleton->create_node_from_name(E->get()));
String type_name;
if (vnode_operator != NULL) {
String type;
if (path.size() >= 2) {
type = path[1];
}
type_name = type.capitalize() + " ";
}
VisualScriptFunctionCall *vnode_function_call = Object::cast_to<VisualScriptFunctionCall>(*VisualScriptLanguage::singleton->create_node_from_name(E->get()));
if (vnode_function_call != NULL) {
String basic_type = Variant::get_type_name(vnode_function_call->get_basic_type());
type_name = basic_type.capitalize() + " ";
}
VisualScriptBuiltinFunc *vnode_builtin_function_call = Object::cast_to<VisualScriptBuiltinFunc>(*VisualScriptLanguage::singleton->create_node_from_name(E->get()));
if (vnode_builtin_function_call != NULL) {
type_name = "Builtin ";
}
item->set_text(0, type_name + path[path.size() - 1].capitalize());
item->set_icon(0, get_icon("VisualScript", "EditorIcons"));
item->set_selectable(0, true);
item->set_metadata(0, E->get());
item->set_selectable(0, true);
item->set_metadata(1, "visualscript");
item->set_selectable(1, false);
}
}
void VisualScriptPropertySelector::_confirmed() {
TreeItem *ti = search_options->get_selected();
if (!ti)
return;
emit_signal("selected", ti->get_metadata(0), ti->get_metadata(1));
hide();
}
void VisualScriptPropertySelector::_item_selected() {
help_bit->set_text("");
TreeItem *item = search_options->get_selected();
if (!item)
return;
String name = item->get_metadata(0);
String class_type;
if (type) {
class_type = Variant::get_type_name(type);
} else {
class_type = base_type;
}
DocData *dd = EditorHelp::get_doc_data();
String text;
String at_class = class_type;
while (at_class != String()) {
Map<String, DocData::ClassDoc>::Element *E = dd->class_list.find(at_class);
if (E) {
for (int i = 0; i < E->get().properties.size(); i++) {
if (E->get().properties[i].name == name) {
text = E->get().properties[i].description;
}
}
}
at_class = ClassDB::get_parent_class_nocheck(at_class);
}
at_class = class_type;
while (at_class != String()) {
Map<String, DocData::ClassDoc>::Element *E = dd->class_list.find(at_class);
if (E) {
for (int i = 0; i < E->get().methods.size(); i++) {
if (E->get().methods[i].name == name) {
text = E->get().methods[i].description;
}
}
}
at_class = ClassDB::get_parent_class_nocheck(at_class);
}
Map<String, DocData::ClassDoc>::Element *E = dd->class_list.find(class_type);
if (E) {
for (int i = 0; i < E->get().methods.size(); i++) {
Vector<String> functions = name.rsplit("/", false, 1);
if (E->get().methods[i].name == functions[functions.size() - 1]) {
text = E->get().methods[i].description;
}
}
}
List<String> *names = memnew(List<String>);
VisualScriptLanguage::singleton->get_registered_node_names(names);
if (names->find(name) != NULL) {
Ref<VisualScriptOperator> operator_node = VisualScriptLanguage::singleton->create_node_from_name(name);
if (operator_node.is_valid()) {
Map<String, DocData::ClassDoc>::Element *E = dd->class_list.find(operator_node->get_class_name());
if (E) {
text = Variant::get_operator_name(operator_node->get_operator());
}
}
Ref<VisualScriptTypeCast> typecast_node = VisualScriptLanguage::singleton->create_node_from_name(name);
if (typecast_node.is_valid()) {
Map<String, DocData::ClassDoc>::Element *E = dd->class_list.find(typecast_node->get_class_name());
if (E) {
text = E->get().description;
}
}
Ref<VisualScriptBuiltinFunc> builtin_node = VisualScriptLanguage::singleton->create_node_from_name(name);
if (builtin_node.is_valid()) {
Map<String, DocData::ClassDoc>::Element *E = dd->class_list.find(builtin_node->get_class_name());
if (E) {
for (int i = 0; i < E->get().constants.size(); i++) {
if (E->get().constants[i].value.to_int() == int(builtin_node->get_func())) {
text = E->get().constants[i].description;
}
}
}
}
}
memdelete(names);
if (text == String())
return;
help_bit->set_text(text);
}
void VisualScriptPropertySelector::_notification(int p_what) {
if (p_what == NOTIFICATION_ENTER_TREE) {
connect("confirmed", this, "_confirmed");
}
}
void VisualScriptPropertySelector::select_method_from_base_type(const String &p_base, const String &p_current, bool p_virtuals_only) {
base_type = p_base;
selected = p_current;
type = Variant::NIL;
script = 0;
properties = false;
instance = NULL;
virtuals_only = p_virtuals_only;
show_window(.5f);
search_box->set_text("");
search_box->grab_focus();
_update_search();
}
void VisualScriptPropertySelector::set_type_filter(const Vector<Variant::Type> &p_type_filter) {
type_filter = p_type_filter;
}
void VisualScriptPropertySelector::select_from_base_type(const String &p_base, const String &p_current /*= ""*/, bool p_virtuals_only /*= false*/, bool p_seq_connect /*= false*/) {
base_type = p_base;
selected = p_current;
type = Variant::NIL;
script = 0;
properties = true;
instance = NULL;
virtuals_only = p_virtuals_only;
show_window(.5f);
search_box->set_text("");
search_box->grab_focus();
seq_connect = p_seq_connect;
_update_search();
}
void VisualScriptPropertySelector::select_from_script(const Ref<Script> &p_script, const String &p_current /*= ""*/) {
ERR_FAIL_COND(p_script.is_null());
base_type = p_script->get_instance_base_type();
selected = p_current;
type = Variant::NIL;
script = p_script->get_instance_id();
properties = true;
instance = NULL;
virtuals_only = false;
show_window(.5f);
search_box->set_text("");
search_box->grab_focus();
seq_connect = false;
_update_search();
}
void VisualScriptPropertySelector::select_from_basic_type(Variant::Type p_type, const String &p_current /*= ""*/) {
ERR_FAIL_COND(p_type == Variant::NIL);
base_type = "";
selected = p_current;
type = p_type;
script = 0;
properties = true;
instance = NULL;
virtuals_only = false;
show_window(.5f);
search_box->set_text("");
search_box->grab_focus();
seq_connect = false;
_update_search();
}
void VisualScriptPropertySelector::select_from_action(const String &p_type, const String &p_current /*= ""*/) {
base_type = p_type;
selected = p_current;
type = Variant::NIL;
script = 0;
properties = false;
instance = NULL;
virtuals_only = false;
show_window(.5f);
search_box->set_text("");
search_box->grab_focus();
seq_connect = true;
_update_search();
}
void VisualScriptPropertySelector::select_from_instance(Object *p_instance, const String &p_current /*= ""*/) {
base_type = "";
selected = p_current;
type = Variant::NIL;
script = 0;
properties = true;
instance = p_instance;
virtuals_only = false;
show_window(.5f);
search_box->set_text("");
search_box->grab_focus();
seq_connect = false;
_update_search();
}
void VisualScriptPropertySelector::select_from_visual_script(const String &p_base) {
base_type = p_base;
selected = "";
type = Variant::NIL;
script = 0;
properties = true;
visual_script_generic = true;
instance = NULL;
virtuals_only = false;
show_window(.5f);
search_box->set_text("");
search_box->grab_focus();
_update_search();
}
void VisualScriptPropertySelector::show_window(float p_screen_ratio) {
Rect2 rect;
Point2 window_size = get_viewport_rect().size;
rect.size = (window_size * p_screen_ratio).floor();
rect.size.x = rect.size.x / 1.25f;
rect.position = ((window_size - rect.size) / 2.0f).floor();
popup(rect);
}
void VisualScriptPropertySelector::_bind_methods() {
ClassDB::bind_method(D_METHOD("_text_changed"), &VisualScriptPropertySelector::_text_changed);
ClassDB::bind_method(D_METHOD("_confirmed"), &VisualScriptPropertySelector::_confirmed);
ClassDB::bind_method(D_METHOD("_sbox_input"), &VisualScriptPropertySelector::_sbox_input);
ClassDB::bind_method(D_METHOD("_item_selected"), &VisualScriptPropertySelector::_item_selected);
ADD_SIGNAL(MethodInfo("selected", PropertyInfo(Variant::STRING, "name")));
}
VisualScriptPropertySelector::VisualScriptPropertySelector() {
VBoxContainer *vbc = memnew(VBoxContainer);
add_child(vbc);
//set_child_rect(vbc);
search_box = memnew(LineEdit);
vbc->add_margin_child(TTR("Search:"), search_box);
search_box->connect("text_changed", this, "_text_changed");
search_box->connect("gui_input", this, "_sbox_input");
search_options = memnew(Tree);
vbc->add_margin_child(TTR("Matches:"), search_options, true);
get_ok()->set_text(TTR("Open"));
get_ok()->set_disabled(true);
register_text_enter(search_box);
set_hide_on_ok(false);
search_options->connect("item_activated", this, "_confirmed");
search_options->connect("cell_selected", this, "_item_selected");
search_options->set_hide_root(true);
search_options->set_hide_folding(true);
virtuals_only = false;
help_bit = memnew(EditorHelpBit);
vbc->add_margin_child(TTR("Description:"), help_bit);
help_bit->connect("request_hide", this, "_closed");
search_options->set_columns(2);
search_options->set_column_expand(1, false);
}

92
modules/visual_script/visual_script_property_selector.h Normal file
View File

@ -0,0 +1,92 @@
/*************************************************************************/
/* visual_script_property_selector.h */
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* https://godotengine.org */
/*************************************************************************/
/* Copyright (c) 2007-2018 Juan Linietsky, Ariel Manzur. */
/* Copyright (c) 2014-2018 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. */
/*************************************************************************/
#ifndef VISUALSCRIPT_PROPERTYSELECTOR_H
#define VISUALSCRIPT_PROPERTYSELECTOR_H
#include "editor/property_editor.h"
#include "editor_help.h"
#include "scene/gui/rich_text_label.h"
class VisualScriptPropertySelector : public ConfirmationDialog {
GDCLASS(VisualScriptPropertySelector, ConfirmationDialog)
LineEdit *search_box;
Tree *search_options;
void _update_search();
void create_visualscript_item(const String &name, TreeItem *const root, const String &search_input, const String &text);
void get_visual_node_names(const String &root_filter, const Set<String> &filter, bool &found, TreeItem *const root, LineEdit *const search_box);
void _sbox_input(const Ref<InputEvent> &p_ie);
void _confirmed();
void _text_changed(const String &p_newtext);
EditorHelpBit *help_bit;
bool properties;
bool visual_script_generic;
String selected;
Variant::Type type;
String base_type;
ObjectID script;
Object *instance;
bool virtuals_only;
bool seq_connect = false;
void _item_selected();
Vector<Variant::Type> type_filter;
protected:
void _notification(int p_what);
static void _bind_methods();
public:
void select_method_from_base_type(const String &p_base, const String &p_current = "", bool p_virtuals_only = false);
void select_from_base_type(const String &p_base, const String &p_current = "", bool p_virtuals_only = false, bool p_seq_connect = false);
void select_from_script(const Ref<Script> &p_script, const String &p_current /*= ""*/);
void select_from_basic_type(Variant::Type p_type, const String &p_current = "");
void select_from_action(const String &p_type, const String &p_current = "");
void select_from_instance(Object *p_instance, const String &p_current = "");
void select_from_visual_script(const String &p_base);
void show_window(float p_screen_ratio);
void set_type_filter(const Vector<Variant::Type> &p_type_filter);
VisualScriptPropertySelector();
};
#endif // VISUALSCRIPT_PROPERTYSELECTOR_H

26
scene/gui/graph_edit.cpp
View File

@ -268,6 +268,10 @@ void GraphEdit::remove_child_notify(Node *p_child) {
void GraphEdit::_notification(int p_what) { void GraphEdit::_notification(int p_what) {
if (p_what == NOTIFICATION_ENTER_TREE || p_what == NOTIFICATION_THEME_CHANGED) {
port_grab_distance_horizontal = get_constant("port_grab_distance_horizontal");
port_grab_distance_vertical = get_constant("port_grab_distance_vertical");
}
if (p_what == NOTIFICATION_READY) { if (p_what == NOTIFICATION_READY) {
Size2 hmin = h_scroll->get_combined_minimum_size(); Size2 hmin = h_scroll->get_combined_minimum_size();
Size2 vmin = v_scroll->get_combined_minimum_size(); Size2 vmin = v_scroll->get_combined_minimum_size();
@ -343,8 +347,6 @@ bool GraphEdit::_filter_input(const Point2 &p_point) {
Ref<Texture> port = get_icon("port", "GraphNode"); Ref<Texture> port = get_icon("port", "GraphNode");
float grab_r_extend = 2.0;
float grab_r = port->get_width() * 0.5 * grab_r_extend;
for (int i = get_child_count() - 1; i >= 0; i--) { for (int i = get_child_count() - 1; i >= 0; i--) {
GraphNode *gn = Object::cast_to<GraphNode>(get_child(i)); GraphNode *gn = Object::cast_to<GraphNode>(get_child(i));
@ -354,14 +356,14 @@ bool GraphEdit::_filter_input(const Point2 &p_point) {
for (int j = 0; j < gn->get_connection_output_count(); j++) { for (int j = 0; j < gn->get_connection_output_count(); j++) {
Vector2 pos = gn->get_connection_output_position(j) + gn->get_position(); Vector2 pos = gn->get_connection_output_position(j) + gn->get_position();
if (pos.distance_to(p_point) < grab_r) if (create_hot_zone(pos).has_point(p_point))
return true; return true;
} }
for (int j = 0; j < gn->get_connection_input_count(); j++) { for (int j = 0; j < gn->get_connection_input_count(); j++) {
Vector2 pos = gn->get_connection_input_position(j) + gn->get_position(); Vector2 pos = gn->get_connection_input_position(j) + gn->get_position();
if (pos.distance_to(p_point) < grab_r) { if (create_hot_zone(pos).has_point(p_point)) {
return true; return true;
} }
} }
@ -372,13 +374,11 @@ bool GraphEdit::_filter_input(const Point2 &p_point) {
void GraphEdit::_top_layer_input(const Ref<InputEvent> &p_ev) { void GraphEdit::_top_layer_input(const Ref<InputEvent> &p_ev) {
float grab_r_extend = 2.0;
Ref<InputEventMouseButton> mb = p_ev; Ref<InputEventMouseButton> mb = p_ev;
if (mb.is_valid() && mb->get_button_index() == BUTTON_LEFT && mb->is_pressed()) { if (mb.is_valid() && mb->get_button_index() == BUTTON_LEFT && mb->is_pressed()) {
Ref<Texture> port = get_icon("port", "GraphNode"); Ref<Texture> port = get_icon("port", "GraphNode");
Vector2 mpos(mb->get_position().x, mb->get_position().y); Vector2 mpos(mb->get_position().x, mb->get_position().y);
float grab_r = port->get_width() * 0.5 * grab_r_extend;
for (int i = get_child_count() - 1; i >= 0; i--) { for (int i = get_child_count() - 1; i >= 0; i--) {
GraphNode *gn = Object::cast_to<GraphNode>(get_child(i)); GraphNode *gn = Object::cast_to<GraphNode>(get_child(i));
@ -388,7 +388,7 @@ void GraphEdit::_top_layer_input(const Ref<InputEvent> &p_ev) {
for (int j = 0; j < gn->get_connection_output_count(); j++) { for (int j = 0; j < gn->get_connection_output_count(); j++) {
Vector2 pos = gn->get_connection_output_position(j) + gn->get_position(); Vector2 pos = gn->get_connection_output_position(j) + gn->get_position();
if (pos.distance_to(mpos) < grab_r) { if (create_hot_zone(pos).has_point(mpos)) {
if (valid_left_disconnect_types.has(gn->get_connection_output_type(j))) { if (valid_left_disconnect_types.has(gn->get_connection_output_type(j))) {
//check disconnect //check disconnect
@ -435,8 +435,7 @@ void GraphEdit::_top_layer_input(const Ref<InputEvent> &p_ev) {
for (int j = 0; j < gn->get_connection_input_count(); j++) { for (int j = 0; j < gn->get_connection_input_count(); j++) {
Vector2 pos = gn->get_connection_input_position(j) + gn->get_position(); Vector2 pos = gn->get_connection_input_position(j) + gn->get_position();
if (create_hot_zone(pos).has_point(mpos)) {
if (pos.distance_to(mpos) < grab_r) {
if (right_disconnects || valid_right_disconnect_types.has(gn->get_connection_input_type(j))) { if (right_disconnects || valid_right_disconnect_types.has(gn->get_connection_input_type(j))) {
//check disconnect //check disconnect
@ -492,7 +491,6 @@ void GraphEdit::_top_layer_input(const Ref<InputEvent> &p_ev) {
Ref<Texture> port = get_icon("port", "GraphNode"); Ref<Texture> port = get_icon("port", "GraphNode");
Vector2 mpos = mm->get_position(); Vector2 mpos = mm->get_position();
float grab_r = port->get_width() * 0.5 * grab_r_extend;
for (int i = get_child_count() - 1; i >= 0; i--) { for (int i = get_child_count() - 1; i >= 0; i--) {
GraphNode *gn = Object::cast_to<GraphNode>(get_child(i)); GraphNode *gn = Object::cast_to<GraphNode>(get_child(i));
@ -504,7 +502,7 @@ void GraphEdit::_top_layer_input(const Ref<InputEvent> &p_ev) {
Vector2 pos = gn->get_connection_output_position(j) + gn->get_position(); Vector2 pos = gn->get_connection_output_position(j) + gn->get_position();
int type = gn->get_connection_output_type(j); int type = gn->get_connection_output_type(j);
if ((type == connecting_type || valid_connection_types.has(ConnType(type, connecting_type))) && pos.distance_to(mpos) < grab_r) { if ((type == connecting_type || valid_connection_types.has(ConnType(type, connecting_type))) && create_hot_zone(pos).has_point(mpos)) {
connecting_target = true; connecting_target = true;
connecting_to = pos; connecting_to = pos;
@ -519,7 +517,7 @@ void GraphEdit::_top_layer_input(const Ref<InputEvent> &p_ev) {
Vector2 pos = gn->get_connection_input_position(j) + gn->get_position(); Vector2 pos = gn->get_connection_input_position(j) + gn->get_position();
int type = gn->get_connection_input_type(j); int type = gn->get_connection_input_type(j);
if ((type == connecting_type || valid_connection_types.has(ConnType(type, connecting_type))) && pos.distance_to(mpos) < grab_r) { if ((type == connecting_type || valid_connection_types.has(ConnType(type, connecting_type))) && create_hot_zone(pos).has_point(mpos)) {
connecting_target = true; connecting_target = true;
connecting_to = pos; connecting_to = pos;
connecting_target_to = gn->get_name(); connecting_target_to = gn->get_name();
@ -559,6 +557,10 @@ void GraphEdit::_top_layer_input(const Ref<InputEvent> &p_ev) {
} }
} }
Rect2 GraphEdit::create_hot_zone(const Vector2 &pos) {
return Rect2(pos.x - port_grab_distance_horizontal, pos.y - port_grab_distance_vertical, port_grab_distance_horizontal * 2, port_grab_distance_vertical * 2);
}
template <class Vector2> template <class Vector2>
static _FORCE_INLINE_ Vector2 _bezier_interp(real_t t, Vector2 start, Vector2 control_1, Vector2 control_2, Vector2 end) { static _FORCE_INLINE_ Vector2 _bezier_interp(real_t t, Vector2 start, Vector2 control_1, Vector2 control_2, Vector2 end) {
/* Formula from Wikipedia article on Bezier curves. */ /* Formula from Wikipedia article on Bezier curves. */

6
scene/gui/graph_edit.h
View File

@ -81,6 +81,9 @@ private:
HScrollBar *h_scroll; HScrollBar *h_scroll;
VScrollBar *v_scroll; VScrollBar *v_scroll;
float port_grab_distance_horizontal;
float port_grab_distance_vertical;
bool connecting; bool connecting;
String connecting_from; String connecting_from;
bool connecting_out; bool connecting_out;
@ -127,6 +130,9 @@ private:
Control *connections_layer; Control *connections_layer;
GraphEditFilter *top_layer; GraphEditFilter *top_layer;
void _top_layer_input(const Ref<InputEvent> &p_ev); void _top_layer_input(const Ref<InputEvent> &p_ev);
Rect2 create_hot_zone(const Vector2 &pos);
void _top_layer_draw(); void _top_layer_draw();
void _connections_layer_draw(); void _connections_layer_draw();
void _update_scroll_offset(); void _update_scroll_offset();

4
scene/resources/default_theme/default_theme.cpp
View File

@ -883,6 +883,10 @@ void fill_default_theme(Ref<Theme> &theme, const Ref<Font> &default_font, const
theme->set_icon("logo", "Icons", make_icon(logo_png)); theme->set_icon("logo", "Icons", make_icon(logo_png));
// Visual Node Ports
theme->set_constant("port_grab_distance_horizontal", "GraphEdit", 48 * scale);
theme->set_constant("port_grab_distance_vertical", "GraphEdit", 6 * scale);
// Theme // Theme
default_icon = make_icon(error_icon_png); default_icon = make_icon(error_icon_png);