From 5dbf1809c6e3e905b94b8764e99491e608122261 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?R=C3=A9mi=20Verschelde?= <rverschelde@gmail.com>
Date: Sun, 5 Mar 2017 16:44:50 +0100
Subject: A Whole New World (clang-format edition)

I can show you the code
Pretty, with proper whitespace
Tell me, coder, now when did
You last write readable code?

I can open your eyes
Make you see your bad indent
Force you to respect the style
The core devs agreed upon

A whole new world
A new fantastic code format
A de facto standard
With some sugar
Enforced with clang-format

A whole new world
A dazzling style we all dreamed of
And when we read it through
It's crystal clear
That now we're in a whole new world of code
---
 .../visual_script/visual_script_builtin_funcs.cpp  | 713 ++++++++++-----------
 1 file changed, 339 insertions(+), 374 deletions(-)

(limited to 'modules/visual_script/visual_script_builtin_funcs.cpp')

diff --git a/modules/visual_script/visual_script_builtin_funcs.cpp b/modules/visual_script/visual_script_builtin_funcs.cpp
index e83cd3e614..378ca06f90 100644
--- a/modules/visual_script/visual_script_builtin_funcs.cpp
+++ b/modules/visual_script/visual_script_builtin_funcs.cpp
@@ -28,15 +28,15 @@
 /*************************************************************************/
 #include "visual_script_builtin_funcs.h"
 
-#include "math_funcs.h"
 #include "class_db.h"
-#include "reference.h"
 #include "func_ref.h"
+#include "io/marshalls.h"
+#include "math_funcs.h"
 #include "os/os.h"
+#include "reference.h"
 #include "variant_parser.h"
-#include "io/marshalls.h"
 
-const char* VisualScriptBuiltinFunc::func_name[VisualScriptBuiltinFunc::FUNC_MAX]={
+const char *VisualScriptBuiltinFunc::func_name[VisualScriptBuiltinFunc::FUNC_MAX] = {
 	"sin",
 	"cos",
 	"tan",
@@ -96,10 +96,10 @@ const char* VisualScriptBuiltinFunc::func_name[VisualScriptBuiltinFunc::FUNC_MAX
 	"color_named",
 };
 
-VisualScriptBuiltinFunc::BuiltinFunc VisualScriptBuiltinFunc::find_function(const String& p_string) {
+VisualScriptBuiltinFunc::BuiltinFunc VisualScriptBuiltinFunc::find_function(const String &p_string) {
 
-	for(int i=0;i<FUNC_MAX;i++) {
-		if (p_string==func_name[i])
+	for (int i = 0; i < FUNC_MAX; i++) {
+		if (p_string == func_name[i])
 			return BuiltinFunc(i);
 	}
 
@@ -108,19 +108,18 @@ VisualScriptBuiltinFunc::BuiltinFunc VisualScriptBuiltinFunc::find_function(cons
 
 String VisualScriptBuiltinFunc::get_func_name(BuiltinFunc p_func) {
 
-	ERR_FAIL_INDEX_V(p_func,FUNC_MAX,String());
+	ERR_FAIL_INDEX_V(p_func, FUNC_MAX, String());
 	return func_name[p_func];
 }
 
-
 int VisualScriptBuiltinFunc::get_output_sequence_port_count() const {
 
 	return has_input_sequence_port() ? 1 : 0;
 }
 
-bool VisualScriptBuiltinFunc::has_input_sequence_port() const{
+bool VisualScriptBuiltinFunc::has_input_sequence_port() const {
 
-	switch(func) {
+	switch (func) {
 
 		case MATH_RANDOMIZE:
 		case TEXT_PRINT:
@@ -129,15 +128,12 @@ bool VisualScriptBuiltinFunc::has_input_sequence_port() const{
 			return true;
 		default:
 			return false;
-
 	}
-
 }
 
 int VisualScriptBuiltinFunc::get_func_argument_count(BuiltinFunc p_func) {
 
-
-	switch(p_func) {
+	switch (p_func) {
 
 		case MATH_RANDOMIZE:
 		case MATH_RAND:
@@ -200,19 +196,19 @@ int VisualScriptBuiltinFunc::get_func_argument_count(BuiltinFunc p_func) {
 		case MATH_DECTIME:
 		case LOGIC_CLAMP:
 			return 3;
-		case FUNC_MAX:{}
-
+		case FUNC_MAX: {
+		}
 	}
 	return 0;
 }
 
-int VisualScriptBuiltinFunc::get_input_value_port_count() const{
+int VisualScriptBuiltinFunc::get_input_value_port_count() const {
 
 	return get_func_argument_count(func);
 }
-int VisualScriptBuiltinFunc::get_output_value_port_count() const{
+int VisualScriptBuiltinFunc::get_output_value_port_count() const {
 
-	switch(func) {
+	switch (func) {
 		case MATH_RANDOMIZE:
 		case TEXT_PRINT:
 		case TEXT_PRINTERR:
@@ -233,9 +229,9 @@ String VisualScriptBuiltinFunc::get_output_sequence_port_text(int p_port) const
 	return String();
 }
 
-PropertyInfo VisualScriptBuiltinFunc::get_input_value_port_info(int p_idx) const{
+PropertyInfo VisualScriptBuiltinFunc::get_input_value_port_info(int p_idx) const {
 
-	switch(func) {
+	switch (func) {
 
 		case MATH_SIN:
 		case MATH_COS:
@@ -248,67 +244,67 @@ PropertyInfo VisualScriptBuiltinFunc::get_input_value_port_info(int p_idx) const
 		case MATH_ATAN:
 		case MATH_ATAN2:
 		case MATH_SQRT: {
-			return PropertyInfo(Variant::REAL,"num");
+			return PropertyInfo(Variant::REAL, "num");
 		} break;
 		case MATH_FMOD:
 		case MATH_FPOSMOD: {
-			if (p_idx==0)
-				return PropertyInfo(Variant::REAL,"x");
+			if (p_idx == 0)
+				return PropertyInfo(Variant::REAL, "x");
 			else
-				return PropertyInfo(Variant::REAL,"y");
+				return PropertyInfo(Variant::REAL, "y");
 		} break;
 		case MATH_FLOOR:
 		case MATH_CEIL:
 		case MATH_ROUND:
 		case MATH_ABS:
 		case MATH_SIGN: {
-			return PropertyInfo(Variant::REAL,"num");
+			return PropertyInfo(Variant::REAL, "num");
 
 		} break;
 
 		case MATH_POW: {
-			if (p_idx==0)
-				return PropertyInfo(Variant::REAL,"x");
+			if (p_idx == 0)
+				return PropertyInfo(Variant::REAL, "x");
 			else
-				return PropertyInfo(Variant::REAL,"y");
+				return PropertyInfo(Variant::REAL, "y");
 		} break;
 		case MATH_LOG:
 		case MATH_EXP:
 		case MATH_ISNAN:
 		case MATH_ISINF: {
-			return PropertyInfo(Variant::REAL,"num");
+			return PropertyInfo(Variant::REAL, "num");
 		} break;
 		case MATH_EASE: {
-			if (p_idx==0)
-				return PropertyInfo(Variant::REAL,"s");
+			if (p_idx == 0)
+				return PropertyInfo(Variant::REAL, "s");
 			else
-				return PropertyInfo(Variant::REAL,"curve");
+				return PropertyInfo(Variant::REAL, "curve");
 		} break;
 		case MATH_DECIMALS: {
-			return PropertyInfo(Variant::REAL,"step");
+			return PropertyInfo(Variant::REAL, "step");
 		} break;
 		case MATH_STEPIFY: {
-			if (p_idx==0)
-				return PropertyInfo(Variant::REAL,"s");
+			if (p_idx == 0)
+				return PropertyInfo(Variant::REAL, "s");
 			else
-				return PropertyInfo(Variant::REAL,"steps");
+				return PropertyInfo(Variant::REAL, "steps");
 		} break;
 		case MATH_LERP: {
-			if (p_idx==0)
-				return PropertyInfo(Variant::REAL,"from");
-			else if (p_idx==1)
-				return PropertyInfo(Variant::REAL,"to");
+			if (p_idx == 0)
+				return PropertyInfo(Variant::REAL, "from");
+			else if (p_idx == 1)
+				return PropertyInfo(Variant::REAL, "to");
 			else
-				return PropertyInfo(Variant::REAL,"weight");
+				return PropertyInfo(Variant::REAL, "weight");
 
 		} break;
 		case MATH_DECTIME: {
-			if (p_idx==0)
-				return PropertyInfo(Variant::REAL,"value");
-			else if (p_idx==1)
-				return PropertyInfo(Variant::REAL,"amount");
+			if (p_idx == 0)
+				return PropertyInfo(Variant::REAL, "value");
+			else if (p_idx == 1)
+				return PropertyInfo(Variant::REAL, "amount");
 			else
-				return PropertyInfo(Variant::REAL,"step");
+				return PropertyInfo(Variant::REAL, "step");
 		} break;
 		case MATH_RANDOMIZE: {
 
@@ -320,139 +316,140 @@ PropertyInfo VisualScriptBuiltinFunc::get_input_value_port_info(int p_idx) const
 
 		} break;
 		case MATH_RANDOM: {
-			if (p_idx==0)
-				return PropertyInfo(Variant::REAL,"from");
+			if (p_idx == 0)
+				return PropertyInfo(Variant::REAL, "from");
 			else
-				return PropertyInfo(Variant::REAL,"to");
+				return PropertyInfo(Variant::REAL, "to");
 		} break;
 		case MATH_SEED: {
-			return PropertyInfo(Variant::INT,"seed");
+			return PropertyInfo(Variant::INT, "seed");
 		} break;
 		case MATH_RANDSEED: {
-			return PropertyInfo(Variant::INT,"seed");
+			return PropertyInfo(Variant::INT, "seed");
 		} break;
 		case MATH_DEG2RAD: {
-			return PropertyInfo(Variant::REAL,"deg");
+			return PropertyInfo(Variant::REAL, "deg");
 		} break;
 		case MATH_RAD2DEG: {
-			return PropertyInfo(Variant::REAL,"rad");
+			return PropertyInfo(Variant::REAL, "rad");
 		} break;
 		case MATH_LINEAR2DB: {
-			return PropertyInfo(Variant::REAL,"nrg");
+			return PropertyInfo(Variant::REAL, "nrg");
 		} break;
 		case MATH_DB2LINEAR: {
-			return PropertyInfo(Variant::REAL,"db");
+			return PropertyInfo(Variant::REAL, "db");
 		} break;
 		case LOGIC_MAX: {
-			if (p_idx==0)
-				return PropertyInfo(Variant::REAL,"a");
+			if (p_idx == 0)
+				return PropertyInfo(Variant::REAL, "a");
 			else
-				return PropertyInfo(Variant::REAL,"b");
+				return PropertyInfo(Variant::REAL, "b");
 		} break;
 		case LOGIC_MIN: {
-			if (p_idx==0)
-				return PropertyInfo(Variant::REAL,"a");
+			if (p_idx == 0)
+				return PropertyInfo(Variant::REAL, "a");
 			else
-				return PropertyInfo(Variant::REAL,"b");
+				return PropertyInfo(Variant::REAL, "b");
 		} break;
 		case LOGIC_CLAMP: {
-			if (p_idx==0)
-				return PropertyInfo(Variant::REAL,"a");
-			else if (p_idx==0)	// FIXME: is it ok to test p_idx == 0 twice?
-				return PropertyInfo(Variant::REAL,"min");
+			if (p_idx == 0)
+				return PropertyInfo(Variant::REAL, "a");
+			else if (p_idx == 0) // FIXME: is it ok to test p_idx == 0 twice?
+				return PropertyInfo(Variant::REAL, "min");
 			else
-				return PropertyInfo(Variant::REAL,"max");
+				return PropertyInfo(Variant::REAL, "max");
 		} break;
 		case LOGIC_NEAREST_PO2: {
-			return PropertyInfo(Variant::INT,"num");
+			return PropertyInfo(Variant::INT, "num");
 		} break;
 		case OBJ_WEAKREF: {
 
-			return PropertyInfo(Variant::OBJECT,"source");
+			return PropertyInfo(Variant::OBJECT, "source");
 
 		} break;
 		case FUNC_FUNCREF: {
 
-			if (p_idx==0)
-				return PropertyInfo(Variant::OBJECT,"instance");
+			if (p_idx == 0)
+				return PropertyInfo(Variant::OBJECT, "instance");
 			else
-				return PropertyInfo(Variant::STRING,"funcname");
+				return PropertyInfo(Variant::STRING, "funcname");
 
 		} break;
 		case TYPE_CONVERT: {
 
-			if (p_idx==0)
-				return PropertyInfo(Variant::NIL,"what");
+			if (p_idx == 0)
+				return PropertyInfo(Variant::NIL, "what");
 			else
-				return PropertyInfo(Variant::STRING,"type");
+				return PropertyInfo(Variant::STRING, "type");
 		} break;
 		case TYPE_OF: {
-			return PropertyInfo(Variant::NIL,"what");
+			return PropertyInfo(Variant::NIL, "what");
 
 		} break;
 		case TYPE_EXISTS: {
 
-			return PropertyInfo(Variant::STRING,"type");
+			return PropertyInfo(Variant::STRING, "type");
 
 		} break;
 		case TEXT_CHAR: {
 
-			return PropertyInfo(Variant::INT,"ascii");
+			return PropertyInfo(Variant::INT, "ascii");
 
 		} break;
 		case TEXT_STR: {
 
-			return PropertyInfo(Variant::NIL,"value");
+			return PropertyInfo(Variant::NIL, "value");
 
 		} break;
 		case TEXT_PRINT: {
 
-			return PropertyInfo(Variant::NIL,"value");
+			return PropertyInfo(Variant::NIL, "value");
 
 		} break;
 		case TEXT_PRINTERR: {
-			return PropertyInfo(Variant::NIL,"value");
+			return PropertyInfo(Variant::NIL, "value");
 
 		} break;
 		case TEXT_PRINTRAW: {
 
-			return PropertyInfo(Variant::NIL,"value");
+			return PropertyInfo(Variant::NIL, "value");
 
 		} break;
 		case VAR_TO_STR: {
-			return PropertyInfo(Variant::NIL,"var");
+			return PropertyInfo(Variant::NIL, "var");
 
 		} break;
 		case STR_TO_VAR: {
 
-			return PropertyInfo(Variant::STRING,"string");
+			return PropertyInfo(Variant::STRING, "string");
 		} break;
 		case VAR_TO_BYTES: {
-			return PropertyInfo(Variant::NIL,"var");
+			return PropertyInfo(Variant::NIL, "var");
 
 		} break;
 		case BYTES_TO_VAR: {
 
-			return PropertyInfo(Variant::POOL_BYTE_ARRAY,"bytes");
+			return PropertyInfo(Variant::POOL_BYTE_ARRAY, "bytes");
 		} break;
 		case COLORN: {
 
-			if (p_idx==0)
-				return PropertyInfo(Variant::STRING,"name");
+			if (p_idx == 0)
+				return PropertyInfo(Variant::STRING, "name");
 			else
-				return PropertyInfo(Variant::REAL,"alpha");
+				return PropertyInfo(Variant::REAL, "alpha");
 
 		} break;
-		case FUNC_MAX:{}
+		case FUNC_MAX: {
+		}
 	}
 
 	return PropertyInfo();
 }
 
-PropertyInfo VisualScriptBuiltinFunc::get_output_value_port_info(int p_idx) const{
+PropertyInfo VisualScriptBuiltinFunc::get_output_value_port_info(int p_idx) const {
 
-	Variant::Type t=Variant::NIL;
-	switch(func) {
+	Variant::Type t = Variant::NIL;
+	switch (func) {
 
 		case MATH_SIN:
 		case MATH_COS:
@@ -469,36 +466,36 @@ PropertyInfo VisualScriptBuiltinFunc::get_output_value_port_info(int p_idx) cons
 		case MATH_FPOSMOD:
 		case MATH_FLOOR:
 		case MATH_CEIL: {
-			t=Variant::REAL;
+			t = Variant::REAL;
 		} break;
 		case MATH_ROUND: {
-			t=Variant::INT;
+			t = Variant::INT;
 		} break;
 		case MATH_ABS: {
-			t=Variant::NIL;
+			t = Variant::NIL;
 		} break;
 		case MATH_SIGN: {
-			t=Variant::NIL;
+			t = Variant::NIL;
 		} break;
 		case MATH_POW:
 		case MATH_LOG:
 		case MATH_EXP: {
-			t=Variant::REAL;
+			t = Variant::REAL;
 		} break;
 		case MATH_ISNAN:
 		case MATH_ISINF: {
-			t=Variant::BOOL;
+			t = Variant::BOOL;
 		} break;
 		case MATH_EASE: {
-			t=Variant::REAL;
+			t = Variant::REAL;
 		} break;
 		case MATH_DECIMALS: {
-			t=Variant::INT;
+			t = Variant::INT;
 		} break;
 		case MATH_STEPIFY:
 		case MATH_LERP:
 		case MATH_DECTIME: {
-			t=Variant::REAL;
+			t = Variant::REAL;
 
 		} break;
 		case MATH_RANDOMIZE: {
@@ -506,71 +503,67 @@ PropertyInfo VisualScriptBuiltinFunc::get_output_value_port_info(int p_idx) cons
 		} break;
 		case MATH_RAND: {
 
-			t=Variant::INT;
+			t = Variant::INT;
 		} break;
 		case MATH_RANDF:
 		case MATH_RANDOM: {
-			t=Variant::REAL;
+			t = Variant::REAL;
 		} break;
 		case MATH_SEED: {
 
 		} break;
 		case MATH_RANDSEED: {
 
-			if (p_idx==0)
-				return PropertyInfo(Variant::INT,"rnd");
+			if (p_idx == 0)
+				return PropertyInfo(Variant::INT, "rnd");
 			else
-				return PropertyInfo(Variant::INT,"seed");
+				return PropertyInfo(Variant::INT, "seed");
 		} break;
 		case MATH_DEG2RAD:
 		case MATH_RAD2DEG:
 		case MATH_LINEAR2DB:
 		case MATH_DB2LINEAR: {
-			t=Variant::REAL;
+			t = Variant::REAL;
 		} break;
 		case LOGIC_MAX:
 		case LOGIC_MIN:
 		case LOGIC_CLAMP: {
 
-
 		} break;
 
 		case LOGIC_NEAREST_PO2: {
-			t=Variant::NIL;
+			t = Variant::NIL;
 		} break;
 		case OBJ_WEAKREF: {
 
-			t=Variant::OBJECT;
+			t = Variant::OBJECT;
 
 		} break;
 		case FUNC_FUNCREF: {
 
-			t=Variant::OBJECT;
+			t = Variant::OBJECT;
 
 		} break;
 		case TYPE_CONVERT: {
 
-
-
 		} break;
 		case TYPE_OF: {
-			t=Variant::INT;
+			t = Variant::INT;
 
 		} break;
 		case TYPE_EXISTS: {
 
-			t=Variant::BOOL;
+			t = Variant::BOOL;
 
 		} break;
 		case TEXT_CHAR:
 		case TEXT_STR: {
 
-			t=Variant::STRING;
+			t = Variant::STRING;
 
 		} break;
 		case TEXT_PRINT: {
 
-
 		} break;
 		case TEXT_PRINTERR: {
 
@@ -579,26 +572,26 @@ PropertyInfo VisualScriptBuiltinFunc::get_output_value_port_info(int p_idx) cons
 
 		} break;
 		case VAR_TO_STR: {
-			t=Variant::STRING;
+			t = Variant::STRING;
 		} break;
 		case STR_TO_VAR: {
 
 		} break;
 		case VAR_TO_BYTES: {
-			t=Variant::POOL_BYTE_ARRAY;
+			t = Variant::POOL_BYTE_ARRAY;
 
 		} break;
 		case BYTES_TO_VAR: {
 
-
 		} break;
 		case COLORN: {
-			t=Variant::COLOR;
+			t = Variant::COLOR;
 		} break;
-		case FUNC_MAX:{}
+		case FUNC_MAX: {
+		}
 	}
 
-	return PropertyInfo(t,"");
+	return PropertyInfo(t, "");
 }
 
 String VisualScriptBuiltinFunc::get_caption() const {
@@ -613,8 +606,8 @@ String VisualScriptBuiltinFunc::get_text() const {
 
 void VisualScriptBuiltinFunc::set_func(BuiltinFunc p_which) {
 
-	ERR_FAIL_INDEX(p_which,FUNC_MAX);
-	func=p_which;
+	ERR_FAIL_INDEX(p_which, FUNC_MAX);
+	func = p_which;
 	_change_notify();
 	ports_changed_notify();
 }
@@ -623,256 +616,252 @@ VisualScriptBuiltinFunc::BuiltinFunc VisualScriptBuiltinFunc::get_func() {
 	return func;
 }
 
-
-#define VALIDATE_ARG_NUM(m_arg) \
-	if (!p_inputs[m_arg]->is_num()) {\
-		r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;\
-		r_error.argument=m_arg;\
-		r_error.expected=Variant::REAL;\
-		return;\
+#define VALIDATE_ARG_NUM(m_arg)                                          \
+	if (!p_inputs[m_arg]->is_num()) {                                    \
+		r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT; \
+		r_error.argument = m_arg;                                        \
+		r_error.expected = Variant::REAL;                                \
+		return;                                                          \
 	}
 
+void VisualScriptBuiltinFunc::exec_func(BuiltinFunc p_func, const Variant **p_inputs, Variant *r_return, Variant::CallError &r_error, String &r_error_str) {
 
-void VisualScriptBuiltinFunc::exec_func(BuiltinFunc p_func,const Variant** p_inputs,Variant* r_return,Variant::CallError& r_error,String& r_error_str) {
-
-	switch(p_func) {
+	switch (p_func) {
 		case VisualScriptBuiltinFunc::MATH_SIN: {
 
 			VALIDATE_ARG_NUM(0);
-			*r_return=Math::sin((double)*p_inputs[0]);
+			*r_return = Math::sin((double)*p_inputs[0]);
 		} break;
 		case VisualScriptBuiltinFunc::MATH_COS: {
 
 			VALIDATE_ARG_NUM(0);
-			*r_return=Math::cos((double)*p_inputs[0]);
+			*r_return = Math::cos((double)*p_inputs[0]);
 		} break;
 		case VisualScriptBuiltinFunc::MATH_TAN: {
 
 			VALIDATE_ARG_NUM(0);
-			*r_return=Math::tan((double)*p_inputs[0]);
+			*r_return = Math::tan((double)*p_inputs[0]);
 		} break;
 		case VisualScriptBuiltinFunc::MATH_SINH: {
 
 			VALIDATE_ARG_NUM(0);
-			*r_return=Math::sinh((double)*p_inputs[0]);
+			*r_return = Math::sinh((double)*p_inputs[0]);
 		} break;
 		case VisualScriptBuiltinFunc::MATH_COSH: {
 
 			VALIDATE_ARG_NUM(0);
-			*r_return=Math::cosh((double)*p_inputs[0]);
+			*r_return = Math::cosh((double)*p_inputs[0]);
 		} break;
 		case VisualScriptBuiltinFunc::MATH_TANH: {
 
 			VALIDATE_ARG_NUM(0);
-			*r_return=Math::tanh((double)*p_inputs[0]);
+			*r_return = Math::tanh((double)*p_inputs[0]);
 		} break;
 		case VisualScriptBuiltinFunc::MATH_ASIN: {
 
 			VALIDATE_ARG_NUM(0);
-			*r_return=Math::asin((double)*p_inputs[0]);
+			*r_return = Math::asin((double)*p_inputs[0]);
 		} break;
 		case VisualScriptBuiltinFunc::MATH_ACOS: {
 
 			VALIDATE_ARG_NUM(0);
-			*r_return=Math::acos((double)*p_inputs[0]);
+			*r_return = Math::acos((double)*p_inputs[0]);
 		} break;
 		case VisualScriptBuiltinFunc::MATH_ATAN: {
 
 			VALIDATE_ARG_NUM(0);
-			*r_return=Math::atan((double)*p_inputs[0]);
+			*r_return = Math::atan((double)*p_inputs[0]);
 		} break;
 		case VisualScriptBuiltinFunc::MATH_ATAN2: {
 
 			VALIDATE_ARG_NUM(0);
 			VALIDATE_ARG_NUM(1);
-			*r_return=Math::atan2((double)*p_inputs[0],(double)*p_inputs[1]);
+			*r_return = Math::atan2((double)*p_inputs[0], (double)*p_inputs[1]);
 		} break;
 		case VisualScriptBuiltinFunc::MATH_SQRT: {
 
 			VALIDATE_ARG_NUM(0);
-			*r_return=Math::sqrt((double)*p_inputs[0]);
+			*r_return = Math::sqrt((double)*p_inputs[0]);
 		} break;
 		case VisualScriptBuiltinFunc::MATH_FMOD: {
 
 			VALIDATE_ARG_NUM(0);
 			VALIDATE_ARG_NUM(1);
-			*r_return=Math::fmod((double)*p_inputs[0],(double)*p_inputs[1]);
+			*r_return = Math::fmod((double)*p_inputs[0], (double)*p_inputs[1]);
 		} break;
 		case VisualScriptBuiltinFunc::MATH_FPOSMOD: {
 
 			VALIDATE_ARG_NUM(0);
 			VALIDATE_ARG_NUM(1);
-			*r_return=Math::fposmod((double)*p_inputs[0],(double)*p_inputs[1]);
+			*r_return = Math::fposmod((double)*p_inputs[0], (double)*p_inputs[1]);
 		} break;
 		case VisualScriptBuiltinFunc::MATH_FLOOR: {
 
 			VALIDATE_ARG_NUM(0);
-			*r_return=Math::floor((double)*p_inputs[0]);
-		  } break;
+			*r_return = Math::floor((double)*p_inputs[0]);
+		} break;
 		case VisualScriptBuiltinFunc::MATH_CEIL: {
 
 			VALIDATE_ARG_NUM(0);
-			*r_return=Math::ceil((double)*p_inputs[0]);
+			*r_return = Math::ceil((double)*p_inputs[0]);
 		} break;
 		case VisualScriptBuiltinFunc::MATH_ROUND: {
 
 			VALIDATE_ARG_NUM(0);
-			*r_return=Math::round((double)*p_inputs[0]);
+			*r_return = Math::round((double)*p_inputs[0]);
 		} break;
 		case VisualScriptBuiltinFunc::MATH_ABS: {
 
-			if (p_inputs[0]->get_type()==Variant::INT) {
+			if (p_inputs[0]->get_type() == Variant::INT) {
 
 				int64_t i = *p_inputs[0];
-				*r_return=ABS(i);
-			} else if (p_inputs[0]->get_type()==Variant::REAL) {
+				*r_return = ABS(i);
+			} else if (p_inputs[0]->get_type() == Variant::REAL) {
 
 				real_t r = *p_inputs[0];
-				*r_return=Math::abs(r);
+				*r_return = Math::abs(r);
 			} else {
 
-				r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
-				r_error.argument=0;
-				r_error.expected=Variant::REAL;
-
+				r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
+				r_error.argument = 0;
+				r_error.expected = Variant::REAL;
 			}
 		} break;
 		case VisualScriptBuiltinFunc::MATH_SIGN: {
 
-				if (p_inputs[0]->get_type()==Variant::INT) {
+			if (p_inputs[0]->get_type() == Variant::INT) {
 
-					int64_t i = *p_inputs[0];
-					*r_return= i < 0 ? -1 : ( i > 0 ? +1 : 0);
-				} else if (p_inputs[0]->get_type()==Variant::REAL) {
-
-					real_t r = *p_inputs[0];
-					*r_return= r < 0.0 ? -1.0 : ( r > 0.0 ? +1.0 : 0.0);
-				} else {
+				int64_t i = *p_inputs[0];
+				*r_return = i < 0 ? -1 : (i > 0 ? +1 : 0);
+			} else if (p_inputs[0]->get_type() == Variant::REAL) {
 
-					r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
-					r_error.argument=0;
-					r_error.expected=Variant::REAL;
+				real_t r = *p_inputs[0];
+				*r_return = r < 0.0 ? -1.0 : (r > 0.0 ? +1.0 : 0.0);
+			} else {
 
-				}
+				r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
+				r_error.argument = 0;
+				r_error.expected = Variant::REAL;
+			}
 		} break;
 		case VisualScriptBuiltinFunc::MATH_POW: {
 
 			VALIDATE_ARG_NUM(0);
 			VALIDATE_ARG_NUM(1);
-			*r_return=Math::pow((double)*p_inputs[0],(double)*p_inputs[1]);
+			*r_return = Math::pow((double)*p_inputs[0], (double)*p_inputs[1]);
 		} break;
 		case VisualScriptBuiltinFunc::MATH_LOG: {
 
 			VALIDATE_ARG_NUM(0);
-			*r_return=Math::log((double)*p_inputs[0]);
+			*r_return = Math::log((double)*p_inputs[0]);
 		} break;
 		case VisualScriptBuiltinFunc::MATH_EXP: {
 
 			VALIDATE_ARG_NUM(0);
-			*r_return=Math::exp((double)*p_inputs[0]);
+			*r_return = Math::exp((double)*p_inputs[0]);
 		} break;
 		case VisualScriptBuiltinFunc::MATH_ISNAN: {
 
 			VALIDATE_ARG_NUM(0);
-			*r_return=Math::is_nan((double)*p_inputs[0]);
+			*r_return = Math::is_nan((double)*p_inputs[0]);
 		} break;
 		case VisualScriptBuiltinFunc::MATH_ISINF: {
 
 			VALIDATE_ARG_NUM(0);
-			*r_return=Math::is_inf((double)*p_inputs[0]);
+			*r_return = Math::is_inf((double)*p_inputs[0]);
 		} break;
 		case VisualScriptBuiltinFunc::MATH_EASE: {
 
 			VALIDATE_ARG_NUM(0);
 			VALIDATE_ARG_NUM(1);
-			*r_return=Math::ease((double)*p_inputs[0],(double)*p_inputs[1]);
+			*r_return = Math::ease((double)*p_inputs[0], (double)*p_inputs[1]);
 		} break;
 		case VisualScriptBuiltinFunc::MATH_DECIMALS: {
 
 			VALIDATE_ARG_NUM(0);
-			*r_return=Math::step_decimals((double)*p_inputs[0]);
+			*r_return = Math::step_decimals((double)*p_inputs[0]);
 		} break;
 		case VisualScriptBuiltinFunc::MATH_STEPIFY: {
 
 			VALIDATE_ARG_NUM(0);
 			VALIDATE_ARG_NUM(1);
-			*r_return=Math::stepify((double)*p_inputs[0],(double)*p_inputs[1]);
+			*r_return = Math::stepify((double)*p_inputs[0], (double)*p_inputs[1]);
 		} break;
 		case VisualScriptBuiltinFunc::MATH_LERP: {
 
 			VALIDATE_ARG_NUM(0);
 			VALIDATE_ARG_NUM(1);
 			VALIDATE_ARG_NUM(2);
-			*r_return=Math::lerp((double)*p_inputs[0],(double)*p_inputs[1],(double)*p_inputs[2]);
+			*r_return = Math::lerp((double)*p_inputs[0], (double)*p_inputs[1], (double)*p_inputs[2]);
 		} break;
 		case VisualScriptBuiltinFunc::MATH_DECTIME: {
 
 			VALIDATE_ARG_NUM(0);
 			VALIDATE_ARG_NUM(1);
 			VALIDATE_ARG_NUM(2);
-			*r_return=Math::dectime((double)*p_inputs[0],(double)*p_inputs[1],(double)*p_inputs[2]);
+			*r_return = Math::dectime((double)*p_inputs[0], (double)*p_inputs[1], (double)*p_inputs[2]);
 		} break;
 		case VisualScriptBuiltinFunc::MATH_RANDOMIZE: {
 			Math::randomize();
 
 		} break;
 		case VisualScriptBuiltinFunc::MATH_RAND: {
-			*r_return=Math::rand();
+			*r_return = Math::rand();
 		} break;
 		case VisualScriptBuiltinFunc::MATH_RANDF: {
-			*r_return=Math::randf();
+			*r_return = Math::randf();
 		} break;
 		case VisualScriptBuiltinFunc::MATH_RANDOM: {
 
 			VALIDATE_ARG_NUM(0);
 			VALIDATE_ARG_NUM(1);
-			*r_return=Math::random((double)*p_inputs[0],(double)*p_inputs[1]);
+			*r_return = Math::random((double)*p_inputs[0], (double)*p_inputs[1]);
 		} break;
 		case VisualScriptBuiltinFunc::MATH_SEED: {
 
 			VALIDATE_ARG_NUM(0);
-			uint64_t seed=*p_inputs[0];
+			uint64_t seed = *p_inputs[0];
 			Math::seed(seed);
 
 		} break;
 		case VisualScriptBuiltinFunc::MATH_RANDSEED: {
 
 			VALIDATE_ARG_NUM(0);
-			uint64_t seed=*p_inputs[0];
+			uint64_t seed = *p_inputs[0];
 			int ret = Math::rand_from_seed(&seed);
 			Array reta;
 			reta.push_back(ret);
 			reta.push_back(seed);
-			*r_return=reta;
+			*r_return = reta;
 
 		} break;
 		case VisualScriptBuiltinFunc::MATH_DEG2RAD: {
 
 			VALIDATE_ARG_NUM(0);
-			*r_return=Math::deg2rad((double)*p_inputs[0]);
+			*r_return = Math::deg2rad((double)*p_inputs[0]);
 		} break;
 		case VisualScriptBuiltinFunc::MATH_RAD2DEG: {
 
 			VALIDATE_ARG_NUM(0);
-			*r_return=Math::rad2deg((double)*p_inputs[0]);
+			*r_return = Math::rad2deg((double)*p_inputs[0]);
 		} break;
 		case VisualScriptBuiltinFunc::MATH_LINEAR2DB: {
 
 			VALIDATE_ARG_NUM(0);
-			*r_return=Math::linear2db((double)*p_inputs[0]);
+			*r_return = Math::linear2db((double)*p_inputs[0]);
 		} break;
 		case VisualScriptBuiltinFunc::MATH_DB2LINEAR: {
 
 			VALIDATE_ARG_NUM(0);
-			*r_return=Math::db2linear((double)*p_inputs[0]);
+			*r_return = Math::db2linear((double)*p_inputs[0]);
 		} break;
 		case VisualScriptBuiltinFunc::LOGIC_MAX: {
 
-			if (p_inputs[0]->get_type()==Variant::INT && p_inputs[1]->get_type()==Variant::INT) {
+			if (p_inputs[0]->get_type() == Variant::INT && p_inputs[1]->get_type() == Variant::INT) {
 
 				int64_t a = *p_inputs[0];
 				int64_t b = *p_inputs[1];
-				*r_return=MAX(a,b);
+				*r_return = MAX(a, b);
 			} else {
 				VALIDATE_ARG_NUM(0);
 				VALIDATE_ARG_NUM(1);
@@ -880,17 +869,17 @@ void VisualScriptBuiltinFunc::exec_func(BuiltinFunc p_func,const Variant** p_inp
 				real_t a = *p_inputs[0];
 				real_t b = *p_inputs[1];
 
-				*r_return=MAX(a,b);
+				*r_return = MAX(a, b);
 			}
 
 		} break;
 		case VisualScriptBuiltinFunc::LOGIC_MIN: {
 
-			if (p_inputs[0]->get_type()==Variant::INT && p_inputs[1]->get_type()==Variant::INT) {
+			if (p_inputs[0]->get_type() == Variant::INT && p_inputs[1]->get_type() == Variant::INT) {
 
 				int64_t a = *p_inputs[0];
 				int64_t b = *p_inputs[1];
-				*r_return=MIN(a,b);
+				*r_return = MIN(a, b);
 			} else {
 				VALIDATE_ARG_NUM(0);
 				VALIDATE_ARG_NUM(1);
@@ -898,17 +887,17 @@ void VisualScriptBuiltinFunc::exec_func(BuiltinFunc p_func,const Variant** p_inp
 				real_t a = *p_inputs[0];
 				real_t b = *p_inputs[1];
 
-				*r_return=MIN(a,b);
+				*r_return = MIN(a, b);
 			}
 		} break;
 		case VisualScriptBuiltinFunc::LOGIC_CLAMP: {
 
-			if (p_inputs[0]->get_type()==Variant::INT && p_inputs[1]->get_type()==Variant::INT && p_inputs[2]->get_type()==Variant::INT) {
+			if (p_inputs[0]->get_type() == Variant::INT && p_inputs[1]->get_type() == Variant::INT && p_inputs[2]->get_type() == Variant::INT) {
 
 				int64_t a = *p_inputs[0];
 				int64_t b = *p_inputs[1];
 				int64_t c = *p_inputs[2];
-				*r_return=CLAMP(a,b,c);
+				*r_return = CLAMP(a, b, c);
 			} else {
 				VALIDATE_ARG_NUM(0);
 				VALIDATE_ARG_NUM(1);
@@ -918,7 +907,7 @@ void VisualScriptBuiltinFunc::exec_func(BuiltinFunc p_func,const Variant** p_inp
 				real_t b = *p_inputs[1];
 				real_t c = *p_inputs[2];
 
-				*r_return=CLAMP(a,b,c);
+				*r_return = CLAMP(a, b, c);
 			}
 		} break;
 		case VisualScriptBuiltinFunc::LOGIC_NEAREST_PO2: {
@@ -929,14 +918,13 @@ void VisualScriptBuiltinFunc::exec_func(BuiltinFunc p_func,const Variant** p_inp
 		} break;
 		case VisualScriptBuiltinFunc::OBJ_WEAKREF: {
 
-			if (p_inputs[0]->get_type()!=Variant::OBJECT) {
+			if (p_inputs[0]->get_type() != Variant::OBJECT) {
 
-				r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
-				r_error.argument=0;
-				r_error.expected=Variant::OBJECT;
+				r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
+				r_error.argument = 0;
+				r_error.expected = Variant::OBJECT;
 
 				return;
-
 			}
 
 			if (p_inputs[0]->is_ref()) {
@@ -947,95 +935,87 @@ void VisualScriptBuiltinFunc::exec_func(BuiltinFunc p_func,const Variant** p_inp
 					return;
 				}
 
-				Ref<WeakRef> wref = memnew( WeakRef );
+				Ref<WeakRef> wref = memnew(WeakRef);
 				wref->set_ref(r);
-				*r_return=wref;
+				*r_return = wref;
 			} else {
 				Object *obj = *p_inputs[0];
 				if (!obj) {
 
 					return;
 				}
-				Ref<WeakRef> wref = memnew( WeakRef );
+				Ref<WeakRef> wref = memnew(WeakRef);
 				wref->set_obj(obj);
-				*r_return=wref;
+				*r_return = wref;
 			}
 
-
-
-
 		} break;
 		case VisualScriptBuiltinFunc::FUNC_FUNCREF: {
 
-			if (p_inputs[0]->get_type()!=Variant::OBJECT) {
+			if (p_inputs[0]->get_type() != Variant::OBJECT) {
 
-				r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
-				r_error.argument=0;
-				r_error.expected=Variant::OBJECT;
+				r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
+				r_error.argument = 0;
+				r_error.expected = Variant::OBJECT;
 
 				return;
-
 			}
-			if (p_inputs[1]->get_type()!=Variant::STRING && p_inputs[1]->get_type()!=Variant::NODE_PATH) {
+			if (p_inputs[1]->get_type() != Variant::STRING && p_inputs[1]->get_type() != Variant::NODE_PATH) {
 
-				r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
-				r_error.argument=1;
-				r_error.expected=Variant::STRING;
+				r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
+				r_error.argument = 1;
+				r_error.expected = Variant::STRING;
 
 				return;
-
 			}
 
-			Ref<FuncRef> fr = memnew( FuncRef);
+			Ref<FuncRef> fr = memnew(FuncRef);
 
 			fr->set_instance(*p_inputs[0]);
 			fr->set_function(*p_inputs[1]);
 
-			*r_return=fr;
+			*r_return = fr;
 
 		} break;
 		case VisualScriptBuiltinFunc::TYPE_CONVERT: {
 
 			VALIDATE_ARG_NUM(1);
-			int type=*p_inputs[1];
-			if (type<0 || type>=Variant::VARIANT_MAX) {
+			int type = *p_inputs[1];
+			if (type < 0 || type >= Variant::VARIANT_MAX) {
 
-				r_error_str=RTR("Invalid type argument to convert(), use TYPE_* constants.");
-				r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
-				r_error.argument=0;
-				r_error.expected=Variant::INT;
+				r_error_str = RTR("Invalid type argument to convert(), use TYPE_* constants.");
+				r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
+				r_error.argument = 0;
+				r_error.expected = Variant::INT;
 				return;
 
 			} else {
 
-
-				*r_return=Variant::construct(Variant::Type(type),p_inputs,1,r_error);
+				*r_return = Variant::construct(Variant::Type(type), p_inputs, 1, r_error);
 			}
 		} break;
 		case VisualScriptBuiltinFunc::TYPE_OF: {
 
-
 			*r_return = p_inputs[0]->get_type();
 
 		} break;
 		case VisualScriptBuiltinFunc::TYPE_EXISTS: {
 
-
 			*r_return = ClassDB::class_exists(*p_inputs[0]);
 
 		} break;
 		case VisualScriptBuiltinFunc::TEXT_CHAR: {
 
-			CharType result[2] = {*p_inputs[0], 0};
-			
-			*r_return=String(result);
+			CharType result[2] = { *p_inputs[0], 0 };
+
+			*r_return = String(result);
 
 		} break;
 		case VisualScriptBuiltinFunc::TEXT_STR: {
 
 			String str = *p_inputs[0];
 
-			*r_return=str;
+			*r_return = str;
 
 		} break;
 		case VisualScriptBuiltinFunc::TEXT_PRINT: {
@@ -1043,7 +1023,6 @@ void VisualScriptBuiltinFunc::exec_func(BuiltinFunc p_func,const Variant** p_inp
 			String str = *p_inputs[0];
 			print_line(str);
 
-
 		} break;
 
 		case VisualScriptBuiltinFunc::TEXT_PRINTERR: {
@@ -1051,98 +1030,93 @@ void VisualScriptBuiltinFunc::exec_func(BuiltinFunc p_func,const Variant** p_inp
 			String str = *p_inputs[0];
 
 			//str+="\n";
-			OS::get_singleton()->printerr("%s\n",str.utf8().get_data());
-
+			OS::get_singleton()->printerr("%s\n", str.utf8().get_data());
 
 		} break;
 		case VisualScriptBuiltinFunc::TEXT_PRINTRAW: {
 			String str = *p_inputs[0];
 
 			//str+="\n";
-			OS::get_singleton()->print("%s",str.utf8().get_data());
-
+			OS::get_singleton()->print("%s", str.utf8().get_data());
 
 		} break;
 		case VisualScriptBuiltinFunc::VAR_TO_STR: {
 
 			String vars;
-			VariantWriter::write_to_string(*p_inputs[0],vars);
-			*r_return=vars;
+			VariantWriter::write_to_string(*p_inputs[0], vars);
+			*r_return = vars;
 		} break;
 		case VisualScriptBuiltinFunc::STR_TO_VAR: {
 
-			if (p_inputs[0]->get_type()!=Variant::STRING) {
-				r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
-				r_error.argument=0;
-				r_error.expected=Variant::STRING;
+			if (p_inputs[0]->get_type() != Variant::STRING) {
+				r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
+				r_error.argument = 0;
+				r_error.expected = Variant::STRING;
 
 				return;
 			}
 
 			VariantParser::StreamString ss;
-			ss.s=*p_inputs[0];
+			ss.s = *p_inputs[0];
 
 			String errs;
 			int line;
-			Error err = VariantParser::parse(&ss,*r_return,errs,line);
+			Error err = VariantParser::parse(&ss, *r_return, errs, line);
 
-			if (err!=OK) {
-				r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
-				r_error.argument=0;
-				r_error.expected=Variant::STRING;
-				*r_return="Parse error at line "+itos(line)+": "+errs;
+			if (err != OK) {
+				r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
+				r_error.argument = 0;
+				r_error.expected = Variant::STRING;
+				*r_return = "Parse error at line " + itos(line) + ": " + errs;
 				return;
 			}
 
 		} break;
 		case VisualScriptBuiltinFunc::VAR_TO_BYTES: {
 
-
 			PoolByteArray barr;
 			int len;
-			Error err = encode_variant(*p_inputs[0],NULL,len);
+			Error err = encode_variant(*p_inputs[0], NULL, len);
 			if (err) {
-				r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
-				r_error.argument=0;
-				r_error.expected=Variant::NIL;
-				r_error_str="Unexpected error encoding variable to bytes, likely unserializable type found (Object or RID).";
+				r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
+				r_error.argument = 0;
+				r_error.expected = Variant::NIL;
+				r_error_str = "Unexpected error encoding variable to bytes, likely unserializable type found (Object or RID).";
 				return;
 			}
 
 			barr.resize(len);
 			{
 				PoolByteArray::Write w = barr.write();
-				encode_variant(*p_inputs[0],w.ptr(),len);
-
+				encode_variant(*p_inputs[0], w.ptr(), len);
 			}
-			*r_return=barr;
+			*r_return = barr;
 		} break;
 		case VisualScriptBuiltinFunc::BYTES_TO_VAR: {
 
-			if (p_inputs[0]->get_type()!=Variant::POOL_BYTE_ARRAY) {
-				r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
-				r_error.argument=0;
-				r_error.expected=Variant::POOL_BYTE_ARRAY;
+			if (p_inputs[0]->get_type() != Variant::POOL_BYTE_ARRAY) {
+				r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
+				r_error.argument = 0;
+				r_error.expected = Variant::POOL_BYTE_ARRAY;
 
 				return;
 			}
 
-			PoolByteArray varr=*p_inputs[0];
+			PoolByteArray varr = *p_inputs[0];
 			Variant ret;
 			{
-				PoolByteArray::Read r=varr.read();
-				Error err = decode_variant(ret,r.ptr(),varr.size(),NULL);
-				if (err!=OK) {
-					r_error_str=RTR("Not enough bytes for decoding bytes, or invalid format.");
-					r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
-					r_error.argument=0;
-					r_error.expected=Variant::POOL_BYTE_ARRAY;
+				PoolByteArray::Read r = varr.read();
+				Error err = decode_variant(ret, r.ptr(), varr.size(), NULL);
+				if (err != OK) {
+					r_error_str = RTR("Not enough bytes for decoding bytes, or invalid format.");
+					r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
+					r_error.argument = 0;
+					r_error.expected = Variant::POOL_BYTE_ARRAY;
 					return;
 				}
-
 			}
 
-			*r_return=ret;
+			*r_return = ret;
 
 		} break;
 		case VisualScriptBuiltinFunc::COLORN: {
@@ -1150,72 +1124,65 @@ void VisualScriptBuiltinFunc::exec_func(BuiltinFunc p_func,const Variant** p_inp
 			VALIDATE_ARG_NUM(1);
 
 			Color color = Color::named(*p_inputs[0]);
-			color.a=*p_inputs[1];
-			
-			*r_return=String(color);
+			color.a = *p_inputs[1];
+
+			*r_return = String(color);
 
 		} break;
 		default: {}
 	}
-
 }
 
-
 class VisualScriptNodeInstanceBuiltinFunc : public VisualScriptNodeInstance {
 public:
-
 	VisualScriptBuiltinFunc *node;
 	VisualScriptInstance *instance;
 
 	VisualScriptBuiltinFunc::BuiltinFunc func;
 
-
 	//virtual int get_working_memory_size() const { 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 true; }
 
-	virtual int step(const Variant** p_inputs,Variant** p_outputs,StartMode p_start_mode,Variant* p_working_mem,Variant::CallError& r_error,String& r_error_str) {
+	virtual int step(const Variant **p_inputs, Variant **p_outputs, StartMode p_start_mode, Variant *p_working_mem, Variant::CallError &r_error, String &r_error_str) {
 
-		VisualScriptBuiltinFunc::exec_func(func,p_inputs,p_outputs[0],r_error,r_error_str);
+		VisualScriptBuiltinFunc::exec_func(func, p_inputs, p_outputs[0], r_error, r_error_str);
 		return 0;
 	}
-
-
 };
 
-VisualScriptNodeInstance* VisualScriptBuiltinFunc::instance(VisualScriptInstance* p_instance) {
+VisualScriptNodeInstance *VisualScriptBuiltinFunc::instance(VisualScriptInstance *p_instance) {
 
-	VisualScriptNodeInstanceBuiltinFunc * instance = memnew(VisualScriptNodeInstanceBuiltinFunc );
-	instance->node=this;
-	instance->instance=p_instance;
-	instance->func=func;
+	VisualScriptNodeInstanceBuiltinFunc *instance = memnew(VisualScriptNodeInstanceBuiltinFunc);
+	instance->node = this;
+	instance->instance = p_instance;
+	instance->func = func;
 	return instance;
 }
 
-
 void VisualScriptBuiltinFunc::_bind_methods() {
 
-	ClassDB::bind_method(D_METHOD("set_func","which"),&VisualScriptBuiltinFunc::set_func);
-	ClassDB::bind_method(D_METHOD("get_func"),&VisualScriptBuiltinFunc::get_func);
+	ClassDB::bind_method(D_METHOD("set_func", "which"), &VisualScriptBuiltinFunc::set_func);
+	ClassDB::bind_method(D_METHOD("get_func"), &VisualScriptBuiltinFunc::get_func);
 
 	String cc;
 
-	for(int i=0;i<FUNC_MAX;i++) {
+	for (int i = 0; i < FUNC_MAX; i++) {
 
-		if (i>0)
-			cc+=",";
-		cc+=func_name[i];
+		if (i > 0)
+			cc += ",";
+		cc += func_name[i];
 	}
-	ADD_PROPERTY(PropertyInfo(Variant::INT,"function",PROPERTY_HINT_ENUM,cc),"set_func","get_func");
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "function", PROPERTY_HINT_ENUM, cc), "set_func", "get_func");
 }
 
 VisualScriptBuiltinFunc::VisualScriptBuiltinFunc() {
 
-	func=MATH_SIN;
+	func = MATH_SIN;
 }
 
-template<VisualScriptBuiltinFunc::BuiltinFunc func>
-static Ref<VisualScriptNode> create_builtin_func_node(const String& p_name) {
+template <VisualScriptBuiltinFunc::BuiltinFunc func>
+static Ref<VisualScriptNode> create_builtin_func_node(const String &p_name) {
 
 	Ref<VisualScriptBuiltinFunc> node;
 	node.instance();
@@ -1225,69 +1192,67 @@ static Ref<VisualScriptNode> create_builtin_func_node(const String& p_name) {
 
 void register_visual_script_builtin_func_node() {
 
-
-	VisualScriptLanguage::singleton->add_register_func("functions/built_in/sin",create_builtin_func_node<VisualScriptBuiltinFunc::MATH_SIN>);
-	VisualScriptLanguage::singleton->add_register_func("functions/built_in/cos",create_builtin_func_node<VisualScriptBuiltinFunc::MATH_COS>);
-	VisualScriptLanguage::singleton->add_register_func("functions/built_in/tan",create_builtin_func_node<VisualScriptBuiltinFunc::MATH_TAN>);
-	VisualScriptLanguage::singleton->add_register_func("functions/built_in/sinh",create_builtin_func_node<VisualScriptBuiltinFunc::MATH_SINH>);
-	VisualScriptLanguage::singleton->add_register_func("functions/built_in/cosh",create_builtin_func_node<VisualScriptBuiltinFunc::MATH_COSH>);
-	VisualScriptLanguage::singleton->add_register_func("functions/built_in/tanh",create_builtin_func_node<VisualScriptBuiltinFunc::MATH_TANH>);
-
-	VisualScriptLanguage::singleton->add_register_func("functions/built_in/asin",create_builtin_func_node<VisualScriptBuiltinFunc::MATH_ASIN>);
-	VisualScriptLanguage::singleton->add_register_func("functions/built_in/acos",create_builtin_func_node<VisualScriptBuiltinFunc::MATH_ACOS>);
-	VisualScriptLanguage::singleton->add_register_func("functions/built_in/atan",create_builtin_func_node<VisualScriptBuiltinFunc::MATH_ATAN>);
-	VisualScriptLanguage::singleton->add_register_func("functions/built_in/atan2",create_builtin_func_node<VisualScriptBuiltinFunc::MATH_ATAN2>);
-
-	VisualScriptLanguage::singleton->add_register_func("functions/built_in/sqrt",create_builtin_func_node<VisualScriptBuiltinFunc::MATH_SQRT>);
-	VisualScriptLanguage::singleton->add_register_func("functions/built_in/fmod",create_builtin_func_node<VisualScriptBuiltinFunc::MATH_FMOD>);
-	VisualScriptLanguage::singleton->add_register_func("functions/built_in/fposmod",create_builtin_func_node<VisualScriptBuiltinFunc::MATH_FPOSMOD>);
-	VisualScriptLanguage::singleton->add_register_func("functions/built_in/floor",create_builtin_func_node<VisualScriptBuiltinFunc::MATH_FLOOR>);
-	VisualScriptLanguage::singleton->add_register_func("functions/built_in/ceil",create_builtin_func_node<VisualScriptBuiltinFunc::MATH_CEIL>);
-	VisualScriptLanguage::singleton->add_register_func("functions/built_in/round",create_builtin_func_node<VisualScriptBuiltinFunc::MATH_ROUND>);
-	VisualScriptLanguage::singleton->add_register_func("functions/built_in/abs",create_builtin_func_node<VisualScriptBuiltinFunc::MATH_ABS>);
-	VisualScriptLanguage::singleton->add_register_func("functions/built_in/sign",create_builtin_func_node<VisualScriptBuiltinFunc::MATH_SIGN>);
-	VisualScriptLanguage::singleton->add_register_func("functions/built_in/pow",create_builtin_func_node<VisualScriptBuiltinFunc::MATH_POW>);
-	VisualScriptLanguage::singleton->add_register_func("functions/built_in/log",create_builtin_func_node<VisualScriptBuiltinFunc::MATH_LOG>);
-	VisualScriptLanguage::singleton->add_register_func("functions/built_in/exp",create_builtin_func_node<VisualScriptBuiltinFunc::MATH_EXP>);
-	VisualScriptLanguage::singleton->add_register_func("functions/built_in/isnan",create_builtin_func_node<VisualScriptBuiltinFunc::MATH_ISNAN>);
-	VisualScriptLanguage::singleton->add_register_func("functions/built_in/isinf",create_builtin_func_node<VisualScriptBuiltinFunc::MATH_ISINF>);
-
-	VisualScriptLanguage::singleton->add_register_func("functions/built_in/ease",create_builtin_func_node<VisualScriptBuiltinFunc::MATH_EASE>);
-	VisualScriptLanguage::singleton->add_register_func("functions/built_in/decimals",create_builtin_func_node<VisualScriptBuiltinFunc::MATH_DECIMALS>);
-	VisualScriptLanguage::singleton->add_register_func("functions/built_in/stepify",create_builtin_func_node<VisualScriptBuiltinFunc::MATH_STEPIFY>);
-	VisualScriptLanguage::singleton->add_register_func("functions/built_in/lerp",create_builtin_func_node<VisualScriptBuiltinFunc::MATH_LERP>);
-	VisualScriptLanguage::singleton->add_register_func("functions/built_in/dectime",create_builtin_func_node<VisualScriptBuiltinFunc::MATH_DECTIME>);
-	VisualScriptLanguage::singleton->add_register_func("functions/built_in/randomize",create_builtin_func_node<VisualScriptBuiltinFunc::MATH_RANDOMIZE>);
-	VisualScriptLanguage::singleton->add_register_func("functions/built_in/rand",create_builtin_func_node<VisualScriptBuiltinFunc::MATH_RAND>);
-	VisualScriptLanguage::singleton->add_register_func("functions/built_in/randf",create_builtin_func_node<VisualScriptBuiltinFunc::MATH_RANDF>);
-	VisualScriptLanguage::singleton->add_register_func("functions/built_in/random",create_builtin_func_node<VisualScriptBuiltinFunc::MATH_RANDOM>);
-
-	VisualScriptLanguage::singleton->add_register_func("functions/built_in/seed",create_builtin_func_node<VisualScriptBuiltinFunc::MATH_SEED>);
-	VisualScriptLanguage::singleton->add_register_func("functions/built_in/randseed",create_builtin_func_node<VisualScriptBuiltinFunc::MATH_RANDSEED>);
-	VisualScriptLanguage::singleton->add_register_func("functions/built_in/deg2rad",create_builtin_func_node<VisualScriptBuiltinFunc::MATH_DEG2RAD>);
-	VisualScriptLanguage::singleton->add_register_func("functions/built_in/rad2deg",create_builtin_func_node<VisualScriptBuiltinFunc::MATH_RAD2DEG>);
-	VisualScriptLanguage::singleton->add_register_func("functions/built_in/linear2db",create_builtin_func_node<VisualScriptBuiltinFunc::MATH_LINEAR2DB>);
-	VisualScriptLanguage::singleton->add_register_func("functions/built_in/db2linear",create_builtin_func_node<VisualScriptBuiltinFunc::MATH_DB2LINEAR>);
-
-	VisualScriptLanguage::singleton->add_register_func("functions/built_in/max",create_builtin_func_node<VisualScriptBuiltinFunc::LOGIC_MAX>);
-	VisualScriptLanguage::singleton->add_register_func("functions/built_in/min",create_builtin_func_node<VisualScriptBuiltinFunc::LOGIC_MIN>);
-	VisualScriptLanguage::singleton->add_register_func("functions/built_in/clamp",create_builtin_func_node<VisualScriptBuiltinFunc::LOGIC_CLAMP>);
-	VisualScriptLanguage::singleton->add_register_func("functions/built_in/nearest_po2",create_builtin_func_node<VisualScriptBuiltinFunc::LOGIC_NEAREST_PO2>);
-
-	VisualScriptLanguage::singleton->add_register_func("functions/built_in/weakref",create_builtin_func_node<VisualScriptBuiltinFunc::OBJ_WEAKREF>);
-	VisualScriptLanguage::singleton->add_register_func("functions/built_in/funcref",create_builtin_func_node<VisualScriptBuiltinFunc::FUNC_FUNCREF>);
-	VisualScriptLanguage::singleton->add_register_func("functions/built_in/convert",create_builtin_func_node<VisualScriptBuiltinFunc::TYPE_CONVERT>);
-	VisualScriptLanguage::singleton->add_register_func("functions/built_in/typeof",create_builtin_func_node<VisualScriptBuiltinFunc::TYPE_OF>);
-	VisualScriptLanguage::singleton->add_register_func("functions/built_in/type_exists",create_builtin_func_node<VisualScriptBuiltinFunc::TYPE_EXISTS>);
-	VisualScriptLanguage::singleton->add_register_func("functions/built_in/char",create_builtin_func_node<VisualScriptBuiltinFunc::TEXT_CHAR>);
-	VisualScriptLanguage::singleton->add_register_func("functions/built_in/str",create_builtin_func_node<VisualScriptBuiltinFunc::TEXT_STR>);
-	VisualScriptLanguage::singleton->add_register_func("functions/built_in/print",create_builtin_func_node<VisualScriptBuiltinFunc::TEXT_PRINT>);
-	VisualScriptLanguage::singleton->add_register_func("functions/built_in/printerr",create_builtin_func_node<VisualScriptBuiltinFunc::TEXT_PRINTERR>);
-	VisualScriptLanguage::singleton->add_register_func("functions/built_in/printraw",create_builtin_func_node<VisualScriptBuiltinFunc::TEXT_PRINTRAW>);
-	VisualScriptLanguage::singleton->add_register_func("functions/built_in/var2str",create_builtin_func_node<VisualScriptBuiltinFunc::VAR_TO_STR>);
-	VisualScriptLanguage::singleton->add_register_func("functions/built_in/str2var",create_builtin_func_node<VisualScriptBuiltinFunc::STR_TO_VAR>);
-	VisualScriptLanguage::singleton->add_register_func("functions/built_in/var2bytes",create_builtin_func_node<VisualScriptBuiltinFunc::VAR_TO_BYTES>);
-	VisualScriptLanguage::singleton->add_register_func("functions/built_in/bytes2var",create_builtin_func_node<VisualScriptBuiltinFunc::BYTES_TO_VAR>);
-	VisualScriptLanguage::singleton->add_register_func("functions/built_in/color_named",create_builtin_func_node<VisualScriptBuiltinFunc::COLORN>);
-
+	VisualScriptLanguage::singleton->add_register_func("functions/built_in/sin", create_builtin_func_node<VisualScriptBuiltinFunc::MATH_SIN>);
+	VisualScriptLanguage::singleton->add_register_func("functions/built_in/cos", create_builtin_func_node<VisualScriptBuiltinFunc::MATH_COS>);
+	VisualScriptLanguage::singleton->add_register_func("functions/built_in/tan", create_builtin_func_node<VisualScriptBuiltinFunc::MATH_TAN>);
+	VisualScriptLanguage::singleton->add_register_func("functions/built_in/sinh", create_builtin_func_node<VisualScriptBuiltinFunc::MATH_SINH>);
+	VisualScriptLanguage::singleton->add_register_func("functions/built_in/cosh", create_builtin_func_node<VisualScriptBuiltinFunc::MATH_COSH>);
+	VisualScriptLanguage::singleton->add_register_func("functions/built_in/tanh", create_builtin_func_node<VisualScriptBuiltinFunc::MATH_TANH>);
+
+	VisualScriptLanguage::singleton->add_register_func("functions/built_in/asin", create_builtin_func_node<VisualScriptBuiltinFunc::MATH_ASIN>);
+	VisualScriptLanguage::singleton->add_register_func("functions/built_in/acos", create_builtin_func_node<VisualScriptBuiltinFunc::MATH_ACOS>);
+	VisualScriptLanguage::singleton->add_register_func("functions/built_in/atan", create_builtin_func_node<VisualScriptBuiltinFunc::MATH_ATAN>);
+	VisualScriptLanguage::singleton->add_register_func("functions/built_in/atan2", create_builtin_func_node<VisualScriptBuiltinFunc::MATH_ATAN2>);
+
+	VisualScriptLanguage::singleton->add_register_func("functions/built_in/sqrt", create_builtin_func_node<VisualScriptBuiltinFunc::MATH_SQRT>);
+	VisualScriptLanguage::singleton->add_register_func("functions/built_in/fmod", create_builtin_func_node<VisualScriptBuiltinFunc::MATH_FMOD>);
+	VisualScriptLanguage::singleton->add_register_func("functions/built_in/fposmod", create_builtin_func_node<VisualScriptBuiltinFunc::MATH_FPOSMOD>);
+	VisualScriptLanguage::singleton->add_register_func("functions/built_in/floor", create_builtin_func_node<VisualScriptBuiltinFunc::MATH_FLOOR>);
+	VisualScriptLanguage::singleton->add_register_func("functions/built_in/ceil", create_builtin_func_node<VisualScriptBuiltinFunc::MATH_CEIL>);
+	VisualScriptLanguage::singleton->add_register_func("functions/built_in/round", create_builtin_func_node<VisualScriptBuiltinFunc::MATH_ROUND>);
+	VisualScriptLanguage::singleton->add_register_func("functions/built_in/abs", create_builtin_func_node<VisualScriptBuiltinFunc::MATH_ABS>);
+	VisualScriptLanguage::singleton->add_register_func("functions/built_in/sign", create_builtin_func_node<VisualScriptBuiltinFunc::MATH_SIGN>);
+	VisualScriptLanguage::singleton->add_register_func("functions/built_in/pow", create_builtin_func_node<VisualScriptBuiltinFunc::MATH_POW>);
+	VisualScriptLanguage::singleton->add_register_func("functions/built_in/log", create_builtin_func_node<VisualScriptBuiltinFunc::MATH_LOG>);
+	VisualScriptLanguage::singleton->add_register_func("functions/built_in/exp", create_builtin_func_node<VisualScriptBuiltinFunc::MATH_EXP>);
+	VisualScriptLanguage::singleton->add_register_func("functions/built_in/isnan", create_builtin_func_node<VisualScriptBuiltinFunc::MATH_ISNAN>);
+	VisualScriptLanguage::singleton->add_register_func("functions/built_in/isinf", create_builtin_func_node<VisualScriptBuiltinFunc::MATH_ISINF>);
+
+	VisualScriptLanguage::singleton->add_register_func("functions/built_in/ease", create_builtin_func_node<VisualScriptBuiltinFunc::MATH_EASE>);
+	VisualScriptLanguage::singleton->add_register_func("functions/built_in/decimals", create_builtin_func_node<VisualScriptBuiltinFunc::MATH_DECIMALS>);
+	VisualScriptLanguage::singleton->add_register_func("functions/built_in/stepify", create_builtin_func_node<VisualScriptBuiltinFunc::MATH_STEPIFY>);
+	VisualScriptLanguage::singleton->add_register_func("functions/built_in/lerp", create_builtin_func_node<VisualScriptBuiltinFunc::MATH_LERP>);
+	VisualScriptLanguage::singleton->add_register_func("functions/built_in/dectime", create_builtin_func_node<VisualScriptBuiltinFunc::MATH_DECTIME>);
+	VisualScriptLanguage::singleton->add_register_func("functions/built_in/randomize", create_builtin_func_node<VisualScriptBuiltinFunc::MATH_RANDOMIZE>);
+	VisualScriptLanguage::singleton->add_register_func("functions/built_in/rand", create_builtin_func_node<VisualScriptBuiltinFunc::MATH_RAND>);
+	VisualScriptLanguage::singleton->add_register_func("functions/built_in/randf", create_builtin_func_node<VisualScriptBuiltinFunc::MATH_RANDF>);
+	VisualScriptLanguage::singleton->add_register_func("functions/built_in/random", create_builtin_func_node<VisualScriptBuiltinFunc::MATH_RANDOM>);
+
+	VisualScriptLanguage::singleton->add_register_func("functions/built_in/seed", create_builtin_func_node<VisualScriptBuiltinFunc::MATH_SEED>);
+	VisualScriptLanguage::singleton->add_register_func("functions/built_in/randseed", create_builtin_func_node<VisualScriptBuiltinFunc::MATH_RANDSEED>);
+	VisualScriptLanguage::singleton->add_register_func("functions/built_in/deg2rad", create_builtin_func_node<VisualScriptBuiltinFunc::MATH_DEG2RAD>);
+	VisualScriptLanguage::singleton->add_register_func("functions/built_in/rad2deg", create_builtin_func_node<VisualScriptBuiltinFunc::MATH_RAD2DEG>);
+	VisualScriptLanguage::singleton->add_register_func("functions/built_in/linear2db", create_builtin_func_node<VisualScriptBuiltinFunc::MATH_LINEAR2DB>);
+	VisualScriptLanguage::singleton->add_register_func("functions/built_in/db2linear", create_builtin_func_node<VisualScriptBuiltinFunc::MATH_DB2LINEAR>);
+
+	VisualScriptLanguage::singleton->add_register_func("functions/built_in/max", create_builtin_func_node<VisualScriptBuiltinFunc::LOGIC_MAX>);
+	VisualScriptLanguage::singleton->add_register_func("functions/built_in/min", create_builtin_func_node<VisualScriptBuiltinFunc::LOGIC_MIN>);
+	VisualScriptLanguage::singleton->add_register_func("functions/built_in/clamp", create_builtin_func_node<VisualScriptBuiltinFunc::LOGIC_CLAMP>);
+	VisualScriptLanguage::singleton->add_register_func("functions/built_in/nearest_po2", create_builtin_func_node<VisualScriptBuiltinFunc::LOGIC_NEAREST_PO2>);
+
+	VisualScriptLanguage::singleton->add_register_func("functions/built_in/weakref", create_builtin_func_node<VisualScriptBuiltinFunc::OBJ_WEAKREF>);
+	VisualScriptLanguage::singleton->add_register_func("functions/built_in/funcref", create_builtin_func_node<VisualScriptBuiltinFunc::FUNC_FUNCREF>);
+	VisualScriptLanguage::singleton->add_register_func("functions/built_in/convert", create_builtin_func_node<VisualScriptBuiltinFunc::TYPE_CONVERT>);
+	VisualScriptLanguage::singleton->add_register_func("functions/built_in/typeof", create_builtin_func_node<VisualScriptBuiltinFunc::TYPE_OF>);
+	VisualScriptLanguage::singleton->add_register_func("functions/built_in/type_exists", create_builtin_func_node<VisualScriptBuiltinFunc::TYPE_EXISTS>);
+	VisualScriptLanguage::singleton->add_register_func("functions/built_in/char", create_builtin_func_node<VisualScriptBuiltinFunc::TEXT_CHAR>);
+	VisualScriptLanguage::singleton->add_register_func("functions/built_in/str", create_builtin_func_node<VisualScriptBuiltinFunc::TEXT_STR>);
+	VisualScriptLanguage::singleton->add_register_func("functions/built_in/print", create_builtin_func_node<VisualScriptBuiltinFunc::TEXT_PRINT>);
+	VisualScriptLanguage::singleton->add_register_func("functions/built_in/printerr", create_builtin_func_node<VisualScriptBuiltinFunc::TEXT_PRINTERR>);
+	VisualScriptLanguage::singleton->add_register_func("functions/built_in/printraw", create_builtin_func_node<VisualScriptBuiltinFunc::TEXT_PRINTRAW>);
+	VisualScriptLanguage::singleton->add_register_func("functions/built_in/var2str", create_builtin_func_node<VisualScriptBuiltinFunc::VAR_TO_STR>);
+	VisualScriptLanguage::singleton->add_register_func("functions/built_in/str2var", create_builtin_func_node<VisualScriptBuiltinFunc::STR_TO_VAR>);
+	VisualScriptLanguage::singleton->add_register_func("functions/built_in/var2bytes", create_builtin_func_node<VisualScriptBuiltinFunc::VAR_TO_BYTES>);
+	VisualScriptLanguage::singleton->add_register_func("functions/built_in/bytes2var", create_builtin_func_node<VisualScriptBuiltinFunc::BYTES_TO_VAR>);
+	VisualScriptLanguage::singleton->add_register_func("functions/built_in/color_named", create_builtin_func_node<VisualScriptBuiltinFunc::COLORN>);
 }
-- 
cgit v1.2.3