godotengine/godot-visual-script
1
0
Fork 0
mirror of https://github.com/godotengine/godot-visual-script.git synced 2026-01-05 22:10:23 +03:00
Code Issues Packages Projects Releases Wiki Activity

Codebase Enhancements and Performance Improvements

Browse Source 
We've made several updates to improve our codebase and application performance.

- Clang format was applied for better readability and consistency, aiding other developers in understanding and contributing to the code.
- We resolved issues that were causing visual script compilation failure. The visual script now compiles successfully, ensuring application functionality.
- Broken sections within the codebase were fixed, improving overall stability.
- Built-in functions from the visual script were removed to simplify the code and enhance readability.
- Generic search performance was improved to provide faster results, enhancing user experience.
- Missing flow nodes were added to the Visual Script, ensuring all necessary components are present for correct functioning.

In an effort to streamline the codebase:

- `VisualScriptComment` class and related code were removed, reducing complexity and improving maintainability.
- Error messages were optimized for quicker feedback when errors occur.
- Licenses were updated to reflect recent changes, ensuring legal compliance and project transparency.
- The `get_global_name()` override in `visual_script.h` was fixed, and `TYPE_BUILTIN_FUNC` in `visual_script_expression.h` was removed, improving code functionality.
- Search logic was refactored to avoid double searching, enhancing performance.
- Documentation was updated to reflect recent changes, providing accurate information to users and developers.
- Property selection logic in `VisualScriptPropertySelector` was refactored for easier understanding and modification.
- Code was refactored to avoid variable shadowing, improving readability and reducing potential errors.
- `.clang-format` and `.clang-tidy` configuration files were added to ensure consistent code styling.

To make the code more robust and easier to understand:

- Variable names were corrected for clarity, and error handling in `visual_script_expression.cpp` was improved.
- Function and variable names were refactored for better readability and maintainability.
- Member editing logic in `VisualScriptEditor` was simplified.
- Name variables were updated to be unique, avoiding potential conflicts and errors.
- The `VisualScriptSubCall` class was refactored for simplicity and ease of understanding.

For macOS workflow:

- It was updated to use the latest version and correct path for installing Vulkan SDK, enabling the application to leverage the latest features and improvements from the Vulkan SDK.
- Mac Vulkan SDK was installed to support Vulkan-based functionalities.

Lastly, we made necessary changes to pass CI/CD tests, ensuring the code quality and stability of the application.
This commit is contained in:
K. S. Ernest (iFire) Lee
2023-08-15 09:34:34 -07:00
parent 40bdeebc80
commit 9a4df15d3e
78 changed files with 5752 additions and 6218 deletions
Download Patch File Download Diff File Expand all files Collapse all files

498
visual_script_flow_control.cpp
View File

@@ -1,32 +1,32 @@
/*************************************************************************/
/* visual_script_flow_control.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. */
/*************************************************************************/
/**************************************************************************/
/* visual_script_flow_control.cpp */
/**************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* https://godotengine.org */
/**************************************************************************/
/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */
/* */
/* 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_flow_control.h"
@@ -38,21 +38,15 @@
////////////////RETURN////////////////////
//////////////////////////////////////////
int VisualScriptReturn::get_output_sequence_port_count() const {
return 0;
}
int VisualScriptReturn::get_output_sequence_port_count() const { return 0; }
bool VisualScriptReturn::has_input_sequence_port() const {
return true;
}
bool VisualScriptReturn::has_input_sequence_port() const { return true; }
int VisualScriptReturn::get_input_value_port_count() const {
return with_value ? 1 : 0;
}
int VisualScriptReturn::get_output_value_port_count() const {
return 0;
}
int VisualScriptReturn::get_output_value_port_count() const { return 0; }
String VisualScriptReturn::get_output_sequence_port_text(int p_port) const {
return String();
@@ -69,13 +63,9 @@ PropertyInfo VisualScriptReturn::get_output_value_port_info(int p_idx) const {
return PropertyInfo();
}
String VisualScriptReturn::get_caption() const {
return RTR("Return");
}
String VisualScriptReturn::get_caption() const { return RTR("Return"); }
String VisualScriptReturn::get_text() const {
return get_name();
}
String VisualScriptReturn::get_text() const { return get_name(); }
void VisualScriptReturn::set_return_type(Variant::Type p_type) {
if (type == p_type) {
@@ -85,9 +75,7 @@ void VisualScriptReturn::set_return_type(Variant::Type p_type) {
ports_changed_notify();
}
Variant::Type VisualScriptReturn::get_return_type() const {
return type;
}
Variant::Type VisualScriptReturn::get_return_type() const { return type; }
void VisualScriptReturn::set_enable_return_value(bool p_enable) {
if (with_value == p_enable) {
@@ -98,23 +86,28 @@ void VisualScriptReturn::set_enable_return_value(bool p_enable) {
ports_changed_notify();
}
bool VisualScriptReturn::is_return_value_enabled() const {
return with_value;
}
bool VisualScriptReturn::is_return_value_enabled() const { return with_value; }
void VisualScriptReturn::_bind_methods() {
ClassDB::bind_method(D_METHOD("set_return_type", "type"), &VisualScriptReturn::set_return_type);
ClassDB::bind_method(D_METHOD("get_return_type"), &VisualScriptReturn::get_return_type);
ClassDB::bind_method(D_METHOD("set_enable_return_value", "enable"), &VisualScriptReturn::set_enable_return_value);
ClassDB::bind_method(D_METHOD("is_return_value_enabled"), &VisualScriptReturn::is_return_value_enabled);
ClassDB::bind_method(D_METHOD("set_return_type", "type"),
&VisualScriptReturn::set_return_type);
ClassDB::bind_method(D_METHOD("get_return_type"),
&VisualScriptReturn::get_return_type);
ClassDB::bind_method(D_METHOD("set_enable_return_value", "enable"),
&VisualScriptReturn::set_enable_return_value);
ClassDB::bind_method(D_METHOD("is_return_value_enabled"),
&VisualScriptReturn::is_return_value_enabled);
String argt = "Any";
for (int i = 1; i < Variant::VARIANT_MAX; i++) {
argt += "," + Variant::get_type_name(Variant::Type(i));
}
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "return_enabled"), "set_enable_return_value", "is_return_value_enabled");
ADD_PROPERTY(PropertyInfo(Variant::INT, "return_type", PROPERTY_HINT_ENUM, argt), "set_return_type", "get_return_type");
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "return_enabled"),
"set_enable_return_value", "is_return_value_enabled");
ADD_PROPERTY(
PropertyInfo(Variant::INT, "return_type", PROPERTY_HINT_ENUM, argt),
"set_return_type", "get_return_type");
}
class VisualScriptNodeInstanceReturn : public VisualScriptNodeInstance {
@@ -124,10 +117,13 @@ public:
bool with_value = false;
virtual int get_working_memory_size() const override { return 1; }
//virtual bool is_output_port_unsequenced(int p_idx) const { return false; }
//virtual bool get_output_port_unsequenced(int p_idx,Variant* r_value,Variant* p_working_mem,String &r_error) const { return true; }
// virtual bool is_output_port_unsequenced(int p_idx) const { return false; }
// virtual bool get_output_port_unsequenced(int p_idx,Variant*
// r_value,Variant* p_working_mem,String &r_error) const { return true; }
virtual int step(const Variant **p_inputs, Variant **p_outputs, StartMode p_start_mode, Variant *p_working_mem, Callable::CallError &r_error, String &r_error_str) override {
virtual int step(const Variant **p_inputs, Variant **p_outputs,
StartMode p_start_mode, Variant *p_working_mem,
Callable::CallError &r_error, String &r_error_str) override {
if (with_value) {
*p_working_mem = *p_inputs[0];
return STEP_EXIT_FUNCTION_BIT;
@@ -138,8 +134,10 @@ public:
}
};
VisualScriptNodeInstance *VisualScriptReturn::instantiate(VisualScriptInstance *p_instance) {
VisualScriptNodeInstanceReturn *instance = memnew(VisualScriptNodeInstanceReturn);
VisualScriptNodeInstance *
VisualScriptReturn::instantiate(VisualScriptInstance *p_instance) {
VisualScriptNodeInstanceReturn *instance =
memnew(VisualScriptNodeInstanceReturn);
instance->node = this;
instance->instance = p_instance;
instance->with_value = with_value;
@@ -163,21 +161,13 @@ static Ref<VisualScriptNode> create_return_node(const String &p_name) {
////////////////CONDITION/////////////////
//////////////////////////////////////////
int VisualScriptCondition::get_output_sequence_port_count() const {
return 3;
}
int VisualScriptCondition::get_output_sequence_port_count() const { return 3; }
bool VisualScriptCondition::has_input_sequence_port() const {
return true;
}
bool VisualScriptCondition::has_input_sequence_port() const { return true; }
int VisualScriptCondition::get_input_value_port_count() const {
return 1;
}
int VisualScriptCondition::get_input_value_port_count() const { return 1; }
int VisualScriptCondition::get_output_value_port_count() const {
return 0;
}
int VisualScriptCondition::get_output_value_port_count() const { return 0; }
String VisualScriptCondition::get_output_sequence_port_text(int p_port) const {
if (p_port == 0) {
@@ -196,31 +186,30 @@ PropertyInfo VisualScriptCondition::get_input_value_port_info(int p_idx) const {
return pinfo;
}
PropertyInfo VisualScriptCondition::get_output_value_port_info(int p_idx) const {
PropertyInfo
VisualScriptCondition::get_output_value_port_info(int p_idx) const {
return PropertyInfo();
}
String VisualScriptCondition::get_caption() const {
return RTR("Condition");
}
String VisualScriptCondition::get_caption() const { return RTR("Condition"); }
String VisualScriptCondition::get_text() const {
return RTR("if (cond) is:");
}
String VisualScriptCondition::get_text() const { return RTR("if (cond) is:"); }
void VisualScriptCondition::_bind_methods() {
}
void VisualScriptCondition::_bind_methods() {}
class VisualScriptNodeInstanceCondition : public VisualScriptNodeInstance {
public:
VisualScriptCondition *node = nullptr;
VisualScriptInstance *instance = nullptr;
//virtual int get_working_memory_size() const override { return 1; }
//virtual bool is_output_port_unsequenced(int p_idx) const { return false; }
//virtual bool get_output_port_unsequenced(int p_idx,Variant* r_value,Variant* p_working_mem,String &r_error) const { return true; }
// virtual int get_working_memory_size() const override { return 1; }
// virtual bool is_output_port_unsequenced(int p_idx) const { return false; }
// virtual bool get_output_port_unsequenced(int p_idx,Variant*
// r_value,Variant* p_working_mem,String &r_error) const { return true; }
virtual int step(const Variant **p_inputs, Variant **p_outputs, StartMode p_start_mode, Variant *p_working_mem, Callable::CallError &r_error, String &r_error_str) override {
virtual int step(const Variant **p_inputs, Variant **p_outputs,
StartMode p_start_mode, Variant *p_working_mem,
Callable::CallError &r_error, String &r_error_str) override {
if (p_start_mode == START_MODE_CONTINUE_SEQUENCE) {
return 2;
} else if (p_inputs[0]->operator bool()) {
@@ -231,35 +220,28 @@ public:
}
};
VisualScriptNodeInstance *VisualScriptCondition::instantiate(VisualScriptInstance *p_instance) {
VisualScriptNodeInstanceCondition *instance = memnew(VisualScriptNodeInstanceCondition);
VisualScriptNodeInstance *
VisualScriptCondition::instantiate(VisualScriptInstance *p_instance) {
VisualScriptNodeInstanceCondition *instance =
memnew(VisualScriptNodeInstanceCondition);
instance->node = this;
instance->instance = p_instance;
return instance;
}
VisualScriptCondition::VisualScriptCondition() {
}
VisualScriptCondition::VisualScriptCondition() {}
//////////////////////////////////////////
////////////////WHILE/////////////////
//////////////////////////////////////////
int VisualScriptWhile::get_output_sequence_port_count() const {
return 2;
}
int VisualScriptWhile::get_output_sequence_port_count() const { return 2; }
bool VisualScriptWhile::has_input_sequence_port() const {
return true;
}
bool VisualScriptWhile::has_input_sequence_port() const { return true; }
int VisualScriptWhile::get_input_value_port_count() const {
return 1;
}
int VisualScriptWhile::get_input_value_port_count() const { return 1; }
int VisualScriptWhile::get_output_value_port_count() const {
return 0;
}
int VisualScriptWhile::get_output_value_port_count() const { return 0; }
String VisualScriptWhile::get_output_sequence_port_text(int p_port) const {
if (p_port == 0) {
@@ -280,27 +262,25 @@ PropertyInfo VisualScriptWhile::get_output_value_port_info(int p_idx) const {
return PropertyInfo();
}
String VisualScriptWhile::get_caption() const {
return RTR("While");
}
String VisualScriptWhile::get_caption() const { return RTR("While"); }
String VisualScriptWhile::get_text() const {
return RTR("while (cond):");
}
String VisualScriptWhile::get_text() const { return RTR("while (cond):"); }
void VisualScriptWhile::_bind_methods() {
}
void VisualScriptWhile::_bind_methods() {}
class VisualScriptNodeInstanceWhile : public VisualScriptNodeInstance {
public:
VisualScriptWhile *node = nullptr;
VisualScriptInstance *instance = nullptr;
//virtual int get_working_memory_size() const override { return 1; }
//virtual bool is_output_port_unsequenced(int p_idx) const { return false; }
//virtual bool get_output_port_unsequenced(int p_idx,Variant* r_value,Variant* p_working_mem,String &r_error) const { return true; }
// virtual int get_working_memory_size() const override { return 1; }
// virtual bool is_output_port_unsequenced(int p_idx) const { return false; }
// virtual bool get_output_port_unsequenced(int p_idx,Variant*
// r_value,Variant* p_working_mem,String &r_error) const { return true; }
virtual int step(const Variant **p_inputs, Variant **p_outputs, StartMode p_start_mode, Variant *p_working_mem, Callable::CallError &r_error, String &r_error_str) override {
virtual int step(const Variant **p_inputs, Variant **p_outputs,
StartMode p_start_mode, Variant *p_working_mem,
Callable::CallError &r_error, String &r_error_str) override {
bool keep_going = p_inputs[0]->operator bool();
if (keep_going) {
@@ -311,35 +291,28 @@ public:
}
};
VisualScriptNodeInstance *VisualScriptWhile::instantiate(VisualScriptInstance *p_instance) {
VisualScriptNodeInstanceWhile *instance = memnew(VisualScriptNodeInstanceWhile);
VisualScriptNodeInstance *
VisualScriptWhile::instantiate(VisualScriptInstance *p_instance) {
VisualScriptNodeInstanceWhile *instance =
memnew(VisualScriptNodeInstanceWhile);
instance->node = this;
instance->instance = p_instance;
return instance;
}
VisualScriptWhile::VisualScriptWhile() {
}
VisualScriptWhile::VisualScriptWhile() {}
//////////////////////////////////////////
////////////////ITERATOR/////////////////
//////////////////////////////////////////
int VisualScriptIterator::get_output_sequence_port_count() const {
return 2;
}
int VisualScriptIterator::get_output_sequence_port_count() const { return 2; }
bool VisualScriptIterator::has_input_sequence_port() const {
return true;
}
bool VisualScriptIterator::has_input_sequence_port() const { return true; }
int VisualScriptIterator::get_input_value_port_count() const {
return 1;
}
int VisualScriptIterator::get_input_value_port_count() const { return 1; }
int VisualScriptIterator::get_output_value_port_count() const {
return 1;
}
int VisualScriptIterator::get_output_value_port_count() const { return 1; }
String VisualScriptIterator::get_output_sequence_port_text(int p_port) const {
if (p_port == 0) {
@@ -363,16 +336,13 @@ PropertyInfo VisualScriptIterator::get_output_value_port_info(int p_idx) const {
return pinfo;
}
String VisualScriptIterator::get_caption() const {
return RTR("Iterator");
}
String VisualScriptIterator::get_caption() const { return RTR("Iterator"); }
String VisualScriptIterator::get_text() const {
return RTR("for (elem) in (input):");
}
void VisualScriptIterator::_bind_methods() {
}
void VisualScriptIterator::_bind_methods() {}
class VisualScriptNodeInstanceIterator : public VisualScriptNodeInstance {
public:
@@ -380,10 +350,13 @@ public:
VisualScriptInstance *instance = nullptr;
virtual int get_working_memory_size() const override { return 2; }
//virtual bool is_output_port_unsequenced(int p_idx) const { return false; }
//virtual bool get_output_port_unsequenced(int p_idx,Variant* r_value,Variant* p_working_mem,String &r_error) const { return true; }
// virtual bool is_output_port_unsequenced(int p_idx) const { return false; }
// virtual bool get_output_port_unsequenced(int p_idx,Variant*
// r_value,Variant* p_working_mem,String &r_error) const { return true; }
virtual int step(const Variant **p_inputs, Variant **p_outputs, StartMode p_start_mode, Variant *p_working_mem, Callable::CallError &r_error, String &r_error_str) override {
virtual int step(const Variant **p_inputs, Variant **p_outputs,
StartMode p_start_mode, Variant *p_working_mem,
Callable::CallError &r_error, String &r_error_str) override {
if (p_start_mode == START_MODE_BEGIN_SEQUENCE) {
p_working_mem[0] = *p_inputs[0];
bool valid;
@@ -391,12 +364,13 @@ public:
if (!valid) {
r_error.error = Callable::CallError::CALL_ERROR_INVALID_METHOD;
r_error_str = RTR("Input type not iterable:") + " " + Variant::get_type_name(p_inputs[0]->get_type());
r_error_str = RTR("Input type not iterable:") + " " +
Variant::get_type_name(p_inputs[0]->get_type());
return 0;
}
if (!can_iter) {
return 1; //nothing to iterate
return 1; // nothing to iterate
}
*p_outputs[0] = p_working_mem[0].iter_get(p_working_mem[1], valid);
@@ -407,19 +381,20 @@ public:
return 0;
}
} else { //continue sequence
} else { // continue sequence
bool valid;
bool can_iter = p_working_mem[0].iter_next(p_working_mem[1], valid);
if (!valid) {
r_error.error = Callable::CallError::CALL_ERROR_INVALID_METHOD;
r_error_str = RTR("Iterator became invalid:") + " " + Variant::get_type_name(p_inputs[0]->get_type());
r_error_str = RTR("Iterator became invalid:") + " " +
Variant::get_type_name(p_inputs[0]->get_type());
return 0;
}
if (!can_iter) {
return 1; //nothing to iterate
return 1; // nothing to iterate
}
*p_outputs[0] = p_working_mem[0].iter_get(p_working_mem[1], valid);
@@ -431,19 +406,20 @@ public:
}
}
return 0 | STEP_FLAG_PUSH_STACK_BIT; //go around
return 0 | STEP_FLAG_PUSH_STACK_BIT; // go around
}
};
VisualScriptNodeInstance *VisualScriptIterator::instantiate(VisualScriptInstance *p_instance) {
VisualScriptNodeInstanceIterator *instance = memnew(VisualScriptNodeInstanceIterator);
VisualScriptNodeInstance *
VisualScriptIterator::instantiate(VisualScriptInstance *p_instance) {
VisualScriptNodeInstanceIterator *instance =
memnew(VisualScriptNodeInstanceIterator);
instance->node = this;
instance->instance = p_instance;
return instance;
}
VisualScriptIterator::VisualScriptIterator() {
}
VisualScriptIterator::VisualScriptIterator() {}
//////////////////////////////////////////
////////////////SEQUENCE/////////////////
@@ -453,17 +429,11 @@ int VisualScriptSequence::get_output_sequence_port_count() const {
return steps;
}
bool VisualScriptSequence::has_input_sequence_port() const {
return true;
}
bool VisualScriptSequence::has_input_sequence_port() const { return true; }
int VisualScriptSequence::get_input_value_port_count() const {
return 0;
}
int VisualScriptSequence::get_input_value_port_count() const { return 0; }
int VisualScriptSequence::get_output_value_port_count() const {
return 1;
}
int VisualScriptSequence::get_output_value_port_count() const { return 1; }
String VisualScriptSequence::get_output_sequence_port_text(int p_port) const {
return itos(p_port + 1);
@@ -477,13 +447,9 @@ PropertyInfo VisualScriptSequence::get_output_value_port_info(int p_idx) const {
return PropertyInfo(Variant::INT, "current");
}
String VisualScriptSequence::get_caption() const {
return RTR("Sequence");
}
String VisualScriptSequence::get_caption() const { return RTR("Sequence"); }
String VisualScriptSequence::get_text() const {
return RTR("in order:");
}
String VisualScriptSequence::get_text() const { return RTR("in order:"); }
void VisualScriptSequence::set_steps(int p_steps) {
ERR_FAIL_COND(p_steps < 1);
@@ -495,15 +461,16 @@ void VisualScriptSequence::set_steps(int p_steps) {
ports_changed_notify();
}
int VisualScriptSequence::get_steps() const {
return steps;
}
int VisualScriptSequence::get_steps() const { return steps; }
void VisualScriptSequence::_bind_methods() {
ClassDB::bind_method(D_METHOD("set_steps", "steps"), &VisualScriptSequence::set_steps);
ClassDB::bind_method(D_METHOD("set_steps", "steps"),
&VisualScriptSequence::set_steps);
ClassDB::bind_method(D_METHOD("get_steps"), &VisualScriptSequence::get_steps);
ADD_PROPERTY(PropertyInfo(Variant::INT, "steps", PROPERTY_HINT_RANGE, "1,64,1"), "set_steps", "get_steps");
ADD_PROPERTY(
PropertyInfo(Variant::INT, "steps", PROPERTY_HINT_RANGE, "1,64,1"),
"set_steps", "get_steps");
}
class VisualScriptNodeInstanceSequence : public VisualScriptNodeInstance {
@@ -513,10 +480,13 @@ public:
int steps = 0;
virtual int get_working_memory_size() const override { return 1; }
//virtual bool is_output_port_unsequenced(int p_idx) const { return false; }
//virtual bool get_output_port_unsequenced(int p_idx,Variant* r_value,Variant* p_working_mem,String &r_error) const { return true; }
// virtual bool is_output_port_unsequenced(int p_idx) const { return false; }
// virtual bool get_output_port_unsequenced(int p_idx,Variant*
// r_value,Variant* p_working_mem,String &r_error) const { return true; }
virtual int step(const Variant **p_inputs, Variant **p_outputs, StartMode p_start_mode, Variant *p_working_mem, Callable::CallError &r_error, String &r_error_str) override {
virtual int step(const Variant **p_inputs, Variant **p_outputs,
StartMode p_start_mode, Variant *p_working_mem,
Callable::CallError &r_error, String &r_error_str) override {
if (p_start_mode == START_MODE_BEGIN_SEQUENCE) {
p_working_mem[0] = 0;
}
@@ -534,17 +504,17 @@ public:
}
};
VisualScriptNodeInstance *VisualScriptSequence::instantiate(VisualScriptInstance *p_instance) {
VisualScriptNodeInstanceSequence *instance = memnew(VisualScriptNodeInstanceSequence);
VisualScriptNodeInstance *
VisualScriptSequence::instantiate(VisualScriptInstance *p_instance) {
VisualScriptNodeInstanceSequence *instance =
memnew(VisualScriptNodeInstanceSequence);
instance->node = this;
instance->instance = p_instance;
instance->steps = steps;
return instance;
}
VisualScriptSequence::VisualScriptSequence() {
steps = 1;
}
VisualScriptSequence::VisualScriptSequence() { steps = 1; }
//////////////////////////////////////////
////////////////EVENT TYPE FILTER///////////
@@ -554,17 +524,13 @@ int VisualScriptSwitch::get_output_sequence_port_count() const {
return case_values.size() + 1;
}
bool VisualScriptSwitch::has_input_sequence_port() const {
return true;
}
bool VisualScriptSwitch::has_input_sequence_port() const { return true; }
int VisualScriptSwitch::get_input_value_port_count() const {
return case_values.size() + 1;
}
int VisualScriptSwitch::get_output_value_port_count() const {
return 0;
}
int VisualScriptSwitch::get_output_value_port_count() const { return 0; }
String VisualScriptSwitch::get_output_sequence_port_text(int p_port) const {
if (p_port == case_values.size()) {
@@ -586,26 +552,25 @@ PropertyInfo VisualScriptSwitch::get_output_value_port_info(int p_idx) const {
return PropertyInfo();
}
String VisualScriptSwitch::get_caption() const {
return RTR("Switch");
}
String VisualScriptSwitch::get_caption() const { return RTR("Switch"); }
String VisualScriptSwitch::get_text() const {
return RTR("'input' is:");
}
String VisualScriptSwitch::get_text() const { return RTR("'input' is:"); }
class VisualScriptNodeInstanceSwitch : public VisualScriptNodeInstance {
public:
VisualScriptInstance *instance = nullptr;
int case_count = 0;
//virtual int get_working_memory_size() const override { return 0; }
//virtual bool is_output_port_unsequenced(int p_idx) const { return false; }
//virtual bool get_output_port_unsequenced(int p_idx,Variant* r_value,Variant* p_working_mem,String &r_error) const { return false; }
// virtual int get_working_memory_size() const override { return 0; }
// virtual bool is_output_port_unsequenced(int p_idx) const { return false; }
// virtual bool get_output_port_unsequenced(int p_idx,Variant*
// r_value,Variant* p_working_mem,String &r_error) const { return false; }
virtual int step(const Variant **p_inputs, Variant **p_outputs, StartMode p_start_mode, Variant *p_working_mem, Callable::CallError &r_error, String &r_error_str) override {
virtual int step(const Variant **p_inputs, Variant **p_outputs,
StartMode p_start_mode, Variant *p_working_mem,
Callable::CallError &r_error, String &r_error_str) override {
if (p_start_mode == START_MODE_CONTINUE_SEQUENCE) {
return case_count; //exit
return case_count; // exit
}
for (int i = 0; i < case_count; i++) {
@@ -618,14 +583,17 @@ public:
}
};
VisualScriptNodeInstance *VisualScriptSwitch::instantiate(VisualScriptInstance *p_instance) {
VisualScriptNodeInstanceSwitch *instance = memnew(VisualScriptNodeInstanceSwitch);
VisualScriptNodeInstance *
VisualScriptSwitch::instantiate(VisualScriptInstance *p_instance) {
VisualScriptNodeInstanceSwitch *instance =
memnew(VisualScriptNodeInstanceSwitch);
instance->instance = p_instance;
instance->case_count = case_values.size();
return instance;
}
bool VisualScriptSwitch::_set(const StringName &p_name, const Variant &p_value) {
bool VisualScriptSwitch::_set(const StringName &p_name,
const Variant &p_value) {
if (String(p_name) == "case_count") {
case_values.resize(p_value);
notify_property_list_changed();
@@ -665,7 +633,8 @@ bool VisualScriptSwitch::_get(const StringName &p_name, Variant &r_ret) const {
}
void VisualScriptSwitch::_get_property_list(List<PropertyInfo> *p_list) const {
p_list->push_back(PropertyInfo(Variant::INT, "case_count", PROPERTY_HINT_RANGE, "0,128"));
p_list->push_back(
PropertyInfo(Variant::INT, "case_count", PROPERTY_HINT_RANGE, "0,128"));
String argt = "Any";
for (int i = 1; i < Variant::VARIANT_MAX; i++) {
@@ -673,39 +642,28 @@ void VisualScriptSwitch::_get_property_list(List<PropertyInfo> *p_list) const {
}
for (int i = 0; i < case_values.size(); i++) {
p_list->push_back(PropertyInfo(Variant::INT, "case/" + itos(i), PROPERTY_HINT_ENUM, argt));
p_list->push_back(PropertyInfo(Variant::INT, "case/" + itos(i),
PROPERTY_HINT_ENUM, argt));
}
}
void VisualScriptSwitch::reset_state() {
case_values.clear();
}
void VisualScriptSwitch::reset_state() { case_values.clear(); }
void VisualScriptSwitch::_bind_methods() {
}
void VisualScriptSwitch::_bind_methods() {}
VisualScriptSwitch::VisualScriptSwitch() {
}
VisualScriptSwitch::VisualScriptSwitch() {}
//////////////////////////////////////////
////////////////TYPE CAST///////////
//////////////////////////////////////////
int VisualScriptTypeCast::get_output_sequence_port_count() const {
return 2;
}
int VisualScriptTypeCast::get_output_sequence_port_count() const { return 2; }
bool VisualScriptTypeCast::has_input_sequence_port() const {
return true;
}
bool VisualScriptTypeCast::has_input_sequence_port() const { return true; }
int VisualScriptTypeCast::get_input_value_port_count() const {
return 1;
}
int VisualScriptTypeCast::get_input_value_port_count() const { return 1; }
int VisualScriptTypeCast::get_output_value_port_count() const {
return 1;
}
int VisualScriptTypeCast::get_output_value_port_count() const { return 1; }
String VisualScriptTypeCast::get_output_sequence_port_text(int p_port) const {
return p_port == 0 ? "yes" : "no";
@@ -716,12 +674,11 @@ PropertyInfo VisualScriptTypeCast::get_input_value_port_info(int p_idx) const {
}
PropertyInfo VisualScriptTypeCast::get_output_value_port_info(int p_idx) const {
return PropertyInfo(Variant::OBJECT, "", PROPERTY_HINT_TYPE_STRING, get_base_type());
return PropertyInfo(Variant::OBJECT, "", PROPERTY_HINT_TYPE_STRING,
get_base_type());
}
String VisualScriptTypeCast::get_caption() const {
return RTR("Type Cast");
}
String VisualScriptTypeCast::get_caption() const { return RTR("Type Cast"); }
String VisualScriptTypeCast::get_text() const {
if (!script.is_empty()) {
@@ -741,9 +698,7 @@ void VisualScriptTypeCast::set_base_type(const StringName &p_type) {
ports_changed_notify();
}
StringName VisualScriptTypeCast::get_base_type() const {
return base_type;
}
StringName VisualScriptTypeCast::get_base_type() const { return base_type; }
void VisualScriptTypeCast::set_base_script(const String &p_path) {
if (script == p_path) {
@@ -755,19 +710,19 @@ void VisualScriptTypeCast::set_base_script(const String &p_path) {
ports_changed_notify();
}
String VisualScriptTypeCast::get_base_script() const {
return script;
}
String VisualScriptTypeCast::get_base_script() const { return script; }
VisualScriptTypeCast::TypeGuess VisualScriptTypeCast::guess_output_type(TypeGuess *p_inputs, int p_output) const {
VisualScriptTypeCast::TypeGuess
VisualScriptTypeCast::guess_output_type(TypeGuess *p_inputs,
int p_output) const {
TypeGuess tg;
tg.type = Variant::OBJECT;
if (!script.is_empty()) {
tg.script = ResourceLoader::load(script);
}
//if (!tg.script.is_valid()) {
// if (!tg.script.is_valid()) {
// tg.gdclass = base_type;
//}
// }
return tg;
}
@@ -778,11 +733,14 @@ public:
StringName base_type;
String script;
//virtual int get_working_memory_size() const override { return 0; }
//virtual bool is_output_port_unsequenced(int p_idx) const { return false; }
//virtual bool get_output_port_unsequenced(int p_idx,Variant* r_value,Variant* p_working_mem,String &r_error) const { return false; }
// virtual int get_working_memory_size() const override { return 0; }
// virtual bool is_output_port_unsequenced(int p_idx) const { return false; }
// virtual bool get_output_port_unsequenced(int p_idx,Variant*
// r_value,Variant* p_working_mem,String &r_error) const { return false; }
virtual int step(const Variant **p_inputs, Variant **p_outputs, StartMode p_start_mode, Variant *p_working_mem, Callable::CallError &r_error, String &r_error_str) override {
virtual int step(const Variant **p_inputs, Variant **p_outputs,
StartMode p_start_mode, Variant *p_working_mem,
Callable::CallError &r_error, String &r_error_str) override {
Object *obj = *p_inputs[0];
*p_outputs[0] = Variant();
@@ -796,11 +754,13 @@ public:
if (!script.is_empty()) {
Ref<Script> obj_script = obj->get_script();
if (!obj_script.is_valid()) {
return 1; //well, definitely not the script because object we got has no script.
return 1; // well, definitely not the script because object we got has
// no script.
}
if (!ResourceCache::has(script)) {
//if the script is not in use by anyone, we can safely assume whatever we got is not casting to it.
// if the script is not in use by anyone, we can safely assume whatever
// we got is not casting to it.
return 1;
}
Ref<Script> cast_script = ResourceCache::get_ref(script);
@@ -812,18 +772,18 @@ public:
while (obj_script.is_valid()) {
if (cast_script == obj_script) {
*p_outputs[0] = *p_inputs[0]; //copy
*p_outputs[0] = *p_inputs[0]; // copy
return 0; // it is the script, yey
}
obj_script = obj_script->get_base_script();
}
return 1; //not found sorry
return 1; // not found sorry
}
if (ClassDB::is_parent_class(obj->get_class_name(), base_type)) {
*p_outputs[0] = *p_inputs[0]; //copy
*p_outputs[0] = *p_inputs[0]; // copy
return 0;
} else {
return 1;
@@ -831,8 +791,10 @@ public:
}
};
VisualScriptNodeInstance *VisualScriptTypeCast::instantiate(VisualScriptInstance *p_instance) {
VisualScriptNodeInstanceTypeCast *instance = memnew(VisualScriptNodeInstanceTypeCast);
VisualScriptNodeInstance *
VisualScriptTypeCast::instantiate(VisualScriptInstance *p_instance) {
VisualScriptNodeInstanceTypeCast *instance =
memnew(VisualScriptNodeInstanceTypeCast);
instance->instance = p_instance;
instance->base_type = base_type;
instance->script = script;
@@ -840,15 +802,20 @@ VisualScriptNodeInstance *VisualScriptTypeCast::instantiate(VisualScriptInstance
}
void VisualScriptTypeCast::_bind_methods() {
ClassDB::bind_method(D_METHOD("set_base_type", "type"), &VisualScriptTypeCast::set_base_type);
ClassDB::bind_method(D_METHOD("get_base_type"), &VisualScriptTypeCast::get_base_type);
ClassDB::bind_method(D_METHOD("set_base_type", "type"),
&VisualScriptTypeCast::set_base_type);
ClassDB::bind_method(D_METHOD("get_base_type"),
&VisualScriptTypeCast::get_base_type);
ClassDB::bind_method(D_METHOD("set_base_script", "path"), &VisualScriptTypeCast::set_base_script);
ClassDB::bind_method(D_METHOD("get_base_script"), &VisualScriptTypeCast::get_base_script);
ClassDB::bind_method(D_METHOD("set_base_script", "path"),
&VisualScriptTypeCast::set_base_script);
ClassDB::bind_method(D_METHOD("get_base_script"),
&VisualScriptTypeCast::get_base_script);
List<String> script_extensions;
for (int i = 0; i > ScriptServer::get_language_count(); i++) {
ScriptServer::get_language(i)->get_recognized_extensions(&script_extensions);
ScriptServer::get_language(i)->get_recognized_extensions(
&script_extensions);
}
String script_ext_hint;
@@ -859,22 +826,33 @@ void VisualScriptTypeCast::_bind_methods() {
script_ext_hint += "*." + E;
}
ADD_PROPERTY(PropertyInfo(Variant::STRING, "base_type", PROPERTY_HINT_TYPE_STRING, "Object"), "set_base_type", "get_base_type");
ADD_PROPERTY(PropertyInfo(Variant::STRING, "base_script", PROPERTY_HINT_FILE, script_ext_hint), "set_base_script", "get_base_script");
ADD_PROPERTY(PropertyInfo(Variant::STRING, "base_type",
PROPERTY_HINT_TYPE_STRING, "Object"),
"set_base_type", "get_base_type");
ADD_PROPERTY(PropertyInfo(Variant::STRING, "base_script", PROPERTY_HINT_FILE,
script_ext_hint),
"set_base_script", "get_base_script");
}
VisualScriptTypeCast::VisualScriptTypeCast() {
base_type = "Object";
}
VisualScriptTypeCast::VisualScriptTypeCast() { base_type = "Object"; }
void register_visual_script_flow_control_nodes() {
VisualScriptLanguage::singleton->add_register_func("flow_control/return", create_return_node<false>);
VisualScriptLanguage::singleton->add_register_func("flow_control/return_with_value", create_return_node<true>);
VisualScriptLanguage::singleton->add_register_func("flow_control/condition", create_node_generic<VisualScriptCondition>);
VisualScriptLanguage::singleton->add_register_func("flow_control/while", create_node_generic<VisualScriptWhile>);
VisualScriptLanguage::singleton->add_register_func("flow_control/iterator", create_node_generic<VisualScriptIterator>);
VisualScriptLanguage::singleton->add_register_func("flow_control/sequence", create_node_generic<VisualScriptSequence>);
VisualScriptLanguage::singleton->add_register_func("flow_control/switch", create_node_generic<VisualScriptSwitch>);
//VisualScriptLanguage::singleton->add_register_func("flow_control/input", create_node_generic<VisualScriptInputFilter>);
VisualScriptLanguage::singleton->add_register_func("flow_control/type_cast", create_node_generic<VisualScriptTypeCast>);
VisualScriptLanguage::singleton->add_register_func("flow_control/return",
create_return_node<false>);
VisualScriptLanguage::singleton->add_register_func(
"flow_control/return_with_value", create_return_node<true>);
VisualScriptLanguage::singleton->add_register_func(
"flow_control/condition", create_node_generic<VisualScriptCondition>);
VisualScriptLanguage::singleton->add_register_func(
"flow_control/while", create_node_generic<VisualScriptWhile>);
VisualScriptLanguage::singleton->add_register_func(
"flow_control/iterator", create_node_generic<VisualScriptIterator>);
VisualScriptLanguage::singleton->add_register_func(
"flow_control/sequence", create_node_generic<VisualScriptSequence>);
VisualScriptLanguage::singleton->add_register_func(
"flow_control/switch", create_node_generic<VisualScriptSwitch>);
// VisualScriptLanguage::singleton->add_register_func("flow_control/input",
// create_node_generic<VisualScriptInputFilter>);
VisualScriptLanguage::singleton->add_register_func(
"flow_control/type_cast", create_node_generic<VisualScriptTypeCast>);
}