static GDCompletionIdentifier _get_native_class(GDCompletionContext& context) {
//eeh...
GDCompletionIdentifier id;
id.type=Variant::NIL;
REF pc = _get_parent_class(context);
if (!pc.is_valid()) {
return id;
}
Ref<GDNativeClass> nc = pc;
Ref<GDScript> s = pc;
if (s.is_null() && nc.is_null()) {
return id;
}
while(!s.is_null()) {
nc=s->get_native();
s=s->get_base();
}
if (nc.is_null()) {
return id;
}
id.type=Variant::OBJECT;
if (context.base)
id.value=context.base;
id.obj_type=nc->get_name();
return id;
}
Variant::Variant(const RefPtr& p_resource) {
type=OBJECT;
memnew_placement( _data._mem, ObjData );
REF ref = p_resource;
_get_obj().obj=ref.ptr();
_get_obj().ref=p_resource;
}
Variant NativeScript::_new(const Variant **p_args, int p_argcount, Variant::CallError &r_error) {
if (lib_path.empty() || class_name.empty() || library.is_null()) {
r_error.error = Variant::CallError::CALL_ERROR_INSTANCE_IS_NULL;
return Variant();
}
NativeScriptDesc *script_data = get_script_desc();
if (!script_data) {
r_error.error = Variant::CallError::CALL_ERROR_INSTANCE_IS_NULL;
return Variant();
}
r_error.error = Variant::CallError::CALL_OK;
REF ref;
Object *owner = NULL;
if (!(script_data->base_native_type == "")) {
owner = ClassDB::instance(script_data->base_native_type);
} else {
owner = memnew(Reference);
}
if (!owner) {
r_error.error = Variant::CallError::CALL_ERROR_INSTANCE_IS_NULL;
return Variant();
}
Reference *r = Object::cast_to<Reference>(owner);
if (r) {
ref = REF(r);
}
NativeScriptInstance *instance = (NativeScriptInstance *)instance_create(owner);
owner->set_script_instance(instance);
if (!instance) {
if (ref.is_null()) {
memdelete(owner); //no owner, sorry
}
return Variant();
}
if (ref.is_valid()) {
return ref;
} else {
return owner;
}
}
void ScriptEditor::_goto_script_line(REF p_script,int p_line) {
editor->push_item(p_script.ptr());
_goto_script_line2(p_line);
}
static ObjectID safe_get_instance_id(const Variant &p_v) {
Object *o = p_v;
if (o == NULL)
return 0;
else {
REF r = p_v;
if (r.is_valid()) {
return r->get_instance_id();
} else {
_ScriptDebuggerRemote_found_id = 0;
_ScriptDebuggerRemote_find = NULL;
ObjectDB::debug_objects(_ScriptDebuggerRemote_debug_func);
return _ScriptDebuggerRemote_found_id;
}
}
}
MonoObject *godot_icall_Object_weakref(Object *p_obj) {
if (!p_obj)
return NULL;
Ref<WeakRef> wref;
Reference *ref = Object::cast_to<Reference>(p_obj);
if (ref) {
REF r = ref;
if (!r.is_valid())
return NULL;
wref.instance();
wref->set_ref(r);
} else {
wref.instance();
wref->set_obj(p_obj);
}
return GDMonoUtils::unmanaged_get_managed(wref.ptr());
}
void ini_pass(int chromatidSequenceId) {
if (first) {
first = false;
Ref.ref = new char*[26];
cRef.cref = new char*[24];
memset(main_has, 0, sizeof(main_has));
}
ref_map[chromatidSequenceId] = ref_cnt;
Ref.ref[ref_cnt] = new char[650000000];
cRef.cref[ref_cnt] = new char[650000000];
Ref.ini_table(ref_cnt);
cRef.ini_table(ref_cnt);
ref_cnt++;
}
void PacketPeerStream::_set_stream_peer(REF p_peer) {
ERR_FAIL_COND(p_peer.is_null());
set_stream_peer(p_peer);
}
void WeakRef::set_ref(const REF& p_ref) {
ref=p_ref.is_valid() ? p_ref->get_instance_ID() : 0;
}
void GDFunctions::call(Function p_func,const Variant **p_args,int p_arg_count,Variant &r_ret,Variant::CallError &r_error) {
r_error.error=Variant::CallError::CALL_OK;
#ifdef DEBUG_ENABLED
#define VALIDATE_ARG_COUNT(m_count) \
if (p_arg_count<m_count) {\
r_error.error=Variant::CallError::CALL_ERROR_TOO_FEW_ARGUMENTS;\
r_error.argument=m_count;\
r_ret=Variant();\
return;\
}\
if (p_arg_count>m_count) {\
r_error.error=Variant::CallError::CALL_ERROR_TOO_MANY_ARGUMENTS;\
r_error.argument=m_count;\
r_ret=Variant();\
return;\
}
#define VALIDATE_ARG_NUM(m_arg) \
if (!p_args[m_arg]->is_num()) {\
r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;\
r_error.argument=m_arg;\
r_error.expected=Variant::REAL;\
r_ret=Variant();\
return;\
}
#else
#define VALIDATE_ARG_COUNT(m_count)
#define VALIDATE_ARG_NUM(m_arg)
#endif
//using a switch, so the compiler generates a jumptable
switch(p_func) {
case MATH_SIN: {
VALIDATE_ARG_COUNT(1);
VALIDATE_ARG_NUM(0);
r_ret=Math::sin((double)*p_args[0]);
} break;
case MATH_COS: {
VALIDATE_ARG_COUNT(1);
VALIDATE_ARG_NUM(0);
r_ret=Math::cos((double)*p_args[0]);
} break;
case MATH_TAN: {
VALIDATE_ARG_COUNT(1);
VALIDATE_ARG_NUM(0);
r_ret=Math::tan((double)*p_args[0]);
} break;
case MATH_SINH: {
VALIDATE_ARG_COUNT(1);
VALIDATE_ARG_NUM(0);
r_ret=Math::sinh((double)*p_args[0]);
} break;
case MATH_COSH: {
VALIDATE_ARG_COUNT(1);
VALIDATE_ARG_NUM(0);
r_ret=Math::cosh((double)*p_args[0]);
} break;
case MATH_TANH: {
VALIDATE_ARG_COUNT(1);
VALIDATE_ARG_NUM(0);
r_ret=Math::tanh((double)*p_args[0]);
} break;
case MATH_ASIN: {
VALIDATE_ARG_COUNT(1);
VALIDATE_ARG_NUM(0);
r_ret=Math::asin((double)*p_args[0]);
} break;
case MATH_ACOS: {
VALIDATE_ARG_COUNT(1);
VALIDATE_ARG_NUM(0);
r_ret=Math::acos((double)*p_args[0]);
} break;
case MATH_ATAN: {
VALIDATE_ARG_COUNT(1);
VALIDATE_ARG_NUM(0);
r_ret=Math::atan((double)*p_args[0]);
} break;
case MATH_ATAN2: {
VALIDATE_ARG_COUNT(2);
VALIDATE_ARG_NUM(0);
VALIDATE_ARG_NUM(1);
r_ret=Math::atan2((double)*p_args[0],(double)*p_args[1]);
} break;
case MATH_SQRT: {
VALIDATE_ARG_COUNT(1);
VALIDATE_ARG_NUM(0);
r_ret=Math::sqrt((double)*p_args[0]);
} break;
case MATH_FMOD: {
VALIDATE_ARG_COUNT(2);
VALIDATE_ARG_NUM(0);
VALIDATE_ARG_NUM(1);
r_ret=Math::fmod((double)*p_args[0],(double)*p_args[1]);
} break;
case MATH_FPOSMOD: {
VALIDATE_ARG_COUNT(2);
VALIDATE_ARG_NUM(0);
VALIDATE_ARG_NUM(1);
r_ret=Math::fposmod((double)*p_args[0],(double)*p_args[1]);
} break;
case MATH_FLOOR: {
VALIDATE_ARG_COUNT(1);
VALIDATE_ARG_NUM(0);
r_ret=Math::floor((double)*p_args[0]);
} break;
case MATH_CEIL: {
VALIDATE_ARG_COUNT(1);
VALIDATE_ARG_NUM(0);
r_ret=Math::ceil((double)*p_args[0]);
} break;
case MATH_ROUND: {
VALIDATE_ARG_COUNT(1);
VALIDATE_ARG_NUM(0);
r_ret=Math::round((double)*p_args[0]);
} break;
case MATH_ABS: {
VALIDATE_ARG_COUNT(1);
if (p_args[0]->get_type()==Variant::INT) {
int64_t i = *p_args[0];
r_ret=ABS(i);
} else if (p_args[0]->get_type()==Variant::REAL) {
double r = *p_args[0];
r_ret=Math::abs(r);
} else {
r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
r_error.argument=0;
r_error.expected=Variant::REAL;
r_ret=Variant();
}
} break;
case MATH_SIGN: {
VALIDATE_ARG_COUNT(1);
if (p_args[0]->get_type()==Variant::INT) {
int64_t i = *p_args[0];
r_ret= i < 0 ? -1 : ( i > 0 ? +1 : 0);
} else if (p_args[0]->get_type()==Variant::REAL) {
real_t r = *p_args[0];
r_ret= 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;
r_ret=Variant();
}
} break;
case MATH_POW: {
VALIDATE_ARG_COUNT(2);
VALIDATE_ARG_NUM(0);
VALIDATE_ARG_NUM(1);
r_ret=Math::pow((double)*p_args[0],(double)*p_args[1]);
} break;
case MATH_LOG: {
VALIDATE_ARG_COUNT(1);
VALIDATE_ARG_NUM(0);
r_ret=Math::log((double)*p_args[0]);
} break;
case MATH_EXP: {
VALIDATE_ARG_COUNT(1);
VALIDATE_ARG_NUM(0);
r_ret=Math::exp((double)*p_args[0]);
} break;
case MATH_ISNAN: {
VALIDATE_ARG_COUNT(1);
VALIDATE_ARG_NUM(0);
r_ret=Math::is_nan((double)*p_args[0]);
} break;
case MATH_ISINF: {
VALIDATE_ARG_COUNT(1);
VALIDATE_ARG_NUM(0);
r_ret=Math::is_inf((double)*p_args[0]);
} break;
case MATH_EASE: {
VALIDATE_ARG_COUNT(2);
VALIDATE_ARG_NUM(0);
VALIDATE_ARG_NUM(1);
r_ret=Math::ease((double)*p_args[0],(double)*p_args[1]);
} break;
case MATH_DECIMALS: {
VALIDATE_ARG_COUNT(1);
VALIDATE_ARG_NUM(0);
r_ret=Math::step_decimals((double)*p_args[0]);
} break;
case MATH_STEPIFY: {
VALIDATE_ARG_COUNT(2);
VALIDATE_ARG_NUM(0);
VALIDATE_ARG_NUM(1);
r_ret=Math::stepify((double)*p_args[0],(double)*p_args[1]);
} break;
case MATH_LERP: {
VALIDATE_ARG_COUNT(3);
VALIDATE_ARG_NUM(0);
VALIDATE_ARG_NUM(1);
VALIDATE_ARG_NUM(2);
r_ret=Math::lerp((double)*p_args[0],(double)*p_args[1],(double)*p_args[2]);
} break;
case MATH_DECTIME: {
VALIDATE_ARG_COUNT(3);
VALIDATE_ARG_NUM(0);
VALIDATE_ARG_NUM(1);
VALIDATE_ARG_NUM(2);
r_ret=Math::dectime((double)*p_args[0],(double)*p_args[1],(double)*p_args[2]);
} break;
case MATH_RANDOMIZE: {
Math::randomize();
r_ret=Variant();
} break;
case MATH_RAND: {
r_ret=Math::rand();
} break;
case MATH_RANDF: {
r_ret=Math::randf();
} break;
case MATH_RANDOM: {
VALIDATE_ARG_COUNT(2);
VALIDATE_ARG_NUM(0);
VALIDATE_ARG_NUM(1);
r_ret=Math::random((double)*p_args[0],(double)*p_args[1]);
} break;
case MATH_SEED: {
VALIDATE_ARG_COUNT(1);
VALIDATE_ARG_NUM(0);
uint64_t seed=*p_args[0];
Math::seed(seed);
r_ret=Variant();
} break;
case MATH_RANDSEED: {
VALIDATE_ARG_COUNT(1);
VALIDATE_ARG_NUM(0);
uint64_t seed=*p_args[0];
int ret = Math::rand_from_seed(&seed);
Array reta;
reta.push_back(ret);
reta.push_back(seed);
r_ret=reta;
} break;
case MATH_DEG2RAD: {
VALIDATE_ARG_COUNT(1);
VALIDATE_ARG_NUM(0);
r_ret=Math::deg2rad((double)*p_args[0]);
} break;
case MATH_RAD2DEG: {
VALIDATE_ARG_COUNT(1);
VALIDATE_ARG_NUM(0);
r_ret=Math::rad2deg((double)*p_args[0]);
} break;
case MATH_LINEAR2DB: {
VALIDATE_ARG_COUNT(1);
VALIDATE_ARG_NUM(0);
r_ret=Math::linear2db((double)*p_args[0]);
} break;
case MATH_DB2LINEAR: {
VALIDATE_ARG_COUNT(1);
VALIDATE_ARG_NUM(0);
r_ret=Math::db2linear((double)*p_args[0]);
} break;
case LOGIC_MAX: {
VALIDATE_ARG_COUNT(2);
if (p_args[0]->get_type()==Variant::INT && p_args[1]->get_type()==Variant::INT) {
int64_t a = *p_args[0];
int64_t b = *p_args[1];
r_ret=MAX(a,b);
} else {
VALIDATE_ARG_NUM(0);
VALIDATE_ARG_NUM(1);
real_t a = *p_args[0];
real_t b = *p_args[1];
r_ret=MAX(a,b);
}
} break;
case LOGIC_MIN: {
VALIDATE_ARG_COUNT(2);
if (p_args[0]->get_type()==Variant::INT && p_args[1]->get_type()==Variant::INT) {
int64_t a = *p_args[0];
int64_t b = *p_args[1];
r_ret=MIN(a,b);
} else {
VALIDATE_ARG_NUM(0);
VALIDATE_ARG_NUM(1);
real_t a = *p_args[0];
real_t b = *p_args[1];
r_ret=MIN(a,b);
}
} break;
case LOGIC_CLAMP: {
VALIDATE_ARG_COUNT(3);
if (p_args[0]->get_type()==Variant::INT && p_args[1]->get_type()==Variant::INT && p_args[2]->get_type()==Variant::INT) {
int64_t a = *p_args[0];
int64_t b = *p_args[1];
int64_t c = *p_args[2];
r_ret=CLAMP(a,b,c);
} else {
VALIDATE_ARG_NUM(0);
VALIDATE_ARG_NUM(1);
VALIDATE_ARG_NUM(2);
real_t a = *p_args[0];
real_t b = *p_args[1];
real_t c = *p_args[2];
r_ret=CLAMP(a,b,c);
}
} break;
case LOGIC_NEAREST_PO2: {
VALIDATE_ARG_COUNT(1);
VALIDATE_ARG_NUM(0);
int64_t num = *p_args[0];
r_ret = nearest_power_of_2(num);
} break;
case OBJ_WEAKREF: {
VALIDATE_ARG_COUNT(1);
if (p_args[0]->get_type()!=Variant::OBJECT) {
r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
r_error.argument=0;
r_error.expected=Variant::OBJECT;
r_ret=Variant();
return;
}
if (p_args[0]->is_ref()) {
REF r = *p_args[0];
if (!r.is_valid()) {
r_ret=Variant();
return;
}
Ref<WeakRef> wref = memnew( WeakRef );
wref->set_ref(r);
r_ret=wref;
} else {
Object *obj = *p_args[0];
if (!obj) {
r_ret=Variant();
return;
}
Ref<WeakRef> wref = memnew( WeakRef );
wref->set_obj(obj);
r_ret=wref;
}
} break;
case FUNC_FUNCREF: {
VALIDATE_ARG_COUNT(2);
if (p_args[0]->get_type()!=Variant::OBJECT) {
r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
r_error.argument=0;
r_error.expected=Variant::OBJECT;
r_ret=Variant();
return;
}
if (p_args[1]->get_type()!=Variant::STRING && p_args[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_ret=Variant();
return;
}
Ref<FuncRef> fr = memnew( FuncRef);
fr->set_instance(*p_args[0]);
fr->set_function(*p_args[1]);
r_ret=fr;
} break;
case TYPE_CONVERT: {
VALIDATE_ARG_COUNT(2);
VALIDATE_ARG_NUM(1);
int type=*p_args[1];
if (type<0 || type>=Variant::VARIANT_MAX) {
r_ret=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_ret=Variant::construct(Variant::Type(type),p_args,1,r_error);
}
} break;
case TYPE_OF: {
VALIDATE_ARG_COUNT(1);
r_ret = p_args[0]->get_type();
} break;
case TYPE_EXISTS: {
VALIDATE_ARG_COUNT(1);
r_ret = ClassDB::class_exists(*p_args[0]);
} break;
case TEXT_CHAR: {
VALIDATE_ARG_COUNT(1);
VALIDATE_ARG_NUM(0);
CharType result[2] = {*p_args[0], 0};
r_ret=String(result);
} break;
case TEXT_STR: {
String str;
for(int i=0;i<p_arg_count;i++) {
String os = p_args[i]->operator String();
if (i==0)
str=os;
else
str+=os;
}
r_ret=str;
} break;
case TEXT_PRINT: {
String str;
for(int i=0;i<p_arg_count;i++) {
str+=p_args[i]->operator String();
}
//str+="\n";
print_line(str);
r_ret=Variant();
} break;
case TEXT_PRINT_TABBED: {
String str;
for(int i=0;i<p_arg_count;i++) {
if (i)
str+="\t";
str+=p_args[i]->operator String();
}
//str+="\n";
print_line(str);
r_ret=Variant();
} break;
case TEXT_PRINT_SPACED: {
String str;
for(int i=0;i<p_arg_count;i++) {
if (i)
str+=" ";
str+=p_args[i]->operator String();
}
//str+="\n";
print_line(str);
r_ret=Variant();
} break;
case TEXT_PRINTERR: {
String str;
for(int i=0;i<p_arg_count;i++) {
str+=p_args[i]->operator String();
}
//str+="\n";
OS::get_singleton()->printerr("%s\n",str.utf8().get_data());
r_ret=Variant();
} break;
case TEXT_PRINTRAW: {
String str;
for(int i=0;i<p_arg_count;i++) {
str+=p_args[i]->operator String();
}
//str+="\n";
OS::get_singleton()->print("%s",str.utf8().get_data());
r_ret=Variant();
} break;
case VAR_TO_STR: {
VALIDATE_ARG_COUNT(1);
String vars;
VariantWriter::write_to_string(*p_args[0],vars);
r_ret=vars;
} break;
case STR_TO_VAR: {
VALIDATE_ARG_COUNT(1);
if (p_args[0]->get_type()!=Variant::STRING) {
r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
r_error.argument=0;
r_error.expected=Variant::STRING;
r_ret=Variant();
return;
}
VariantParser::StreamString ss;
ss.s=*p_args[0];
String errs;
int line;
Error err = VariantParser::parse(&ss,r_ret,errs,line);
if (err!=OK) {
r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
r_error.argument=0;
r_error.expected=Variant::STRING;
r_ret="Parse error at line "+itos(line)+": "+errs;
return;
}
} break;
case VAR_TO_BYTES: {
VALIDATE_ARG_COUNT(1);
PoolByteArray barr;
int len;
Error err = encode_variant(*p_args[0],NULL,len);
if (err) {
r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
r_error.argument=0;
r_error.expected=Variant::NIL;
r_ret="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_args[0],w.ptr(),len);
}
r_ret=barr;
} break;
case BYTES_TO_VAR: {
VALIDATE_ARG_COUNT(1);
if (p_args[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;
r_ret=Variant();
return;
}
PoolByteArray varr=*p_args[0];
Variant ret;
{
PoolByteArray::Read r=varr.read();
Error err = decode_variant(ret,r.ptr(),varr.size(),NULL);
if (err!=OK) {
r_ret=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_ret=ret;
} break;
case GEN_RANGE: {
switch(p_arg_count) {
case 0: {
r_error.error=Variant::CallError::CALL_ERROR_TOO_FEW_ARGUMENTS;
r_error.argument=1;
r_ret=Variant();
} break;
case 1: {
VALIDATE_ARG_NUM(0);
int count=*p_args[0];
Array arr;
if (count<=0) {
r_ret=arr;
return;
}
Error err = arr.resize(count);
if (err!=OK) {
r_error.error=Variant::CallError::CALL_ERROR_INVALID_METHOD;
r_ret=Variant();
return;
}
for(int i=0;i<count;i++) {
arr[i]=i;
}
r_ret=arr;
} break;
case 2: {
VALIDATE_ARG_NUM(0);
VALIDATE_ARG_NUM(1);
int from=*p_args[0];
int to=*p_args[1];
Array arr;
if (from>=to) {
r_ret=arr;
return;
}
Error err = arr.resize(to-from);
if (err!=OK) {
r_error.error=Variant::CallError::CALL_ERROR_INVALID_METHOD;
r_ret=Variant();
return;
}
for(int i=from;i<to;i++)
arr[i-from]=i;
r_ret=arr;
} break;
case 3: {
VALIDATE_ARG_NUM(0);
VALIDATE_ARG_NUM(1);
VALIDATE_ARG_NUM(2);
int from=*p_args[0];
int to=*p_args[1];
int incr=*p_args[2];
if (incr==0) {
r_ret=RTR("step argument is zero!");
r_error.error=Variant::CallError::CALL_ERROR_INVALID_METHOD;
return;
}
Array arr;
if (from>=to && incr>0) {
r_ret=arr;
return;
}
if (from<=to && incr<0) {
r_ret=arr;
return;
}
//calculate how many
int count=0;
if (incr>0) {
count=((to-from-1)/incr)+1;
} else {
count=((from-to-1)/-incr)+1;
}
Error err = arr.resize(count);
if (err!=OK) {
r_error.error=Variant::CallError::CALL_ERROR_INVALID_METHOD;
r_ret=Variant();
return;
}
if (incr>0) {
int idx=0;
for(int i=from;i<to;i+=incr) {
arr[idx++]=i;
}
} else {
int idx=0;
for(int i=from;i>to;i+=incr) {
arr[idx++]=i;
}
}
r_ret=arr;
} break;
default: {
r_error.error=Variant::CallError::CALL_ERROR_TOO_MANY_ARGUMENTS;
r_error.argument=3;
r_ret=Variant();
} break;
}
} break;
case RESOURCE_LOAD: {
VALIDATE_ARG_COUNT(1);
if (p_args[0]->get_type()!=Variant::STRING) {
r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
r_error.argument=0;
r_error.expected=Variant::STRING;
r_ret=Variant();
} else {
r_ret=ResourceLoader::load(*p_args[0]);
}
} break;
case INST2DICT: {
VALIDATE_ARG_COUNT(1);
if (p_args[0]->get_type()==Variant::NIL) {
r_ret=Variant();
} else if (p_args[0]->get_type()!=Variant::OBJECT) {
r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
r_error.argument=0;
r_ret=Variant();
} else {
Object *obj = *p_args[0];
if (!obj) {
r_ret=Variant();
} else if (!obj->get_script_instance() || obj->get_script_instance()->get_language()!=GDScriptLanguage::get_singleton()) {
r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
r_error.argument=0;
r_error.expected=Variant::DICTIONARY;
r_ret=RTR("Not a script with an instance");
return;
} else {
GDInstance *ins = static_cast<GDInstance*>(obj->get_script_instance());
Ref<GDScript> base = ins->get_script();
if (base.is_null()) {
r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
r_error.argument=0;
r_error.expected=Variant::DICTIONARY;
r_ret=RTR("Not based on a script");
return;
}
GDScript *p = base.ptr();
Vector<StringName> sname;
while(p->_owner) {
sname.push_back(p->name);
p=p->_owner;
}
sname.invert();
if (!p->path.is_resource_file()) {
r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
r_error.argument=0;
r_error.expected=Variant::DICTIONARY;
r_ret=Variant();
r_ret=RTR("Not based on a resource file");
return;
}
NodePath cp(sname,Vector<StringName>(),false);
Dictionary d;
d["@subpath"]=cp;
d["@path"]=p->path;
p = base.ptr();
while(p) {
for(Set<StringName>::Element *E=p->members.front();E;E=E->next()) {
Variant value;
if (ins->get(E->get(),value)) {
String k = E->get();
if (!d.has(k)) {
d[k]=value;
}
}
}
p=p->_base;
}
r_ret=d;
}
}
} break;
case DICT2INST: {
VALIDATE_ARG_COUNT(1);
if (p_args[0]->get_type()!=Variant::DICTIONARY) {
r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
r_error.argument=0;
r_error.expected=Variant::DICTIONARY;
r_ret=Variant();
return;
}
Dictionary d = *p_args[0];
if (!d.has("@path")) {
r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
r_error.argument=0;
r_error.expected=Variant::OBJECT;
r_ret=RTR("Invalid instance dictionary format (missing @path)");
return;
}
Ref<Script> scr = ResourceLoader::load(d["@path"]);
if (!scr.is_valid()) {
r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
r_error.argument=0;
r_error.expected=Variant::OBJECT;
r_ret=RTR("Invalid instance dictionary format (can't load script at @path)");
return;
}
Ref<GDScript> gdscr = scr;
if (!gdscr.is_valid()) {
r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
r_error.argument=0;
r_error.expected=Variant::OBJECT;
r_ret=Variant();
r_ret=RTR("Invalid instance dictionary format (invalid script at @path)");
return;
}
NodePath sub;
if (d.has("@subpath")) {
sub=d["@subpath"];
}
for(int i=0;i<sub.get_name_count();i++) {
gdscr = gdscr->subclasses[ sub.get_name(i)];
if (!gdscr.is_valid()) {
r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
r_error.argument=0;
r_error.expected=Variant::OBJECT;
r_ret=Variant();
r_ret=RTR("Invalid instance dictionary (invalid subclasses)");
return;
}
}
r_ret = gdscr->_new(NULL,0,r_error);
GDInstance *ins = static_cast<GDInstance*>(static_cast<Object*>(r_ret)->get_script_instance());
Ref<GDScript> gd_ref = ins->get_script();
for(Map<StringName,GDScript::MemberInfo>::Element *E = gd_ref->member_indices.front(); E; E = E->next()) {
if(d.has(E->key())) {
ins->members[E->get().index] = d[E->key()];
}
}
} break;
case VALIDATE_JSON: {
VALIDATE_ARG_COUNT(1);
if (p_args[0]->get_type()!=Variant::STRING) {
r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
r_error.argument=0;
r_error.expected=Variant::STRING;
r_ret=Variant();
return;
}
String errs;
int errl;
Error err = JSON::parse(*p_args[0],r_ret,errs,errl);
if (err!=OK) {
r_ret=itos(errl)+":"+errs;
} else {
r_ret="";
}
} break;
case PARSE_JSON: {
VALIDATE_ARG_COUNT(1);
if (p_args[0]->get_type()!=Variant::STRING) {
r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
r_error.argument=0;
r_error.expected=Variant::STRING;
r_ret=Variant();
return;
}
String errs;
int errl;
Error err = JSON::parse(*p_args[0],r_ret,errs,errl);
if (err!=OK) {
r_ret=Variant();
}
} break;
case TO_JSON: {
VALIDATE_ARG_COUNT(1);
r_ret = JSON::print(*p_args[0]);
} break;
case HASH: {
VALIDATE_ARG_COUNT(1);
r_ret=p_args[0]->hash();
} break;
case COLOR8: {
if (p_arg_count<3) {
r_error.error=Variant::CallError::CALL_ERROR_TOO_FEW_ARGUMENTS;
r_error.argument=3;
r_ret=Variant();
return;
}
if (p_arg_count>4) {
r_error.error=Variant::CallError::CALL_ERROR_TOO_MANY_ARGUMENTS;
r_error.argument=4;
r_ret=Variant();
return;
}
VALIDATE_ARG_NUM(0);
VALIDATE_ARG_NUM(1);
VALIDATE_ARG_NUM(2);
Color color((float)*p_args[0]/255.0f,(float)*p_args[1]/255.0f,(float)*p_args[2]/255.0f);
if (p_arg_count==4) {
VALIDATE_ARG_NUM(3);
color.a=(float)*p_args[3]/255.0f;
}
r_ret=color;
} break;
case COLORN: {
if (p_arg_count<1) {
r_error.error=Variant::CallError::CALL_ERROR_TOO_FEW_ARGUMENTS;
r_error.argument=1;
r_ret=Variant();
return;
}
if (p_arg_count>2) {
r_error.error=Variant::CallError::CALL_ERROR_TOO_MANY_ARGUMENTS;
r_error.argument=2;
r_ret=Variant();
return;
}
if (p_args[0]->get_type()!=Variant::STRING) {
r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
r_error.argument=0;
r_ret=Variant();
} else {
Color color = Color::named(*p_args[0]);
if (p_arg_count==2) {
VALIDATE_ARG_NUM(1);
color.a=*p_args[1];
}
r_ret=color;
}
} break;
case PRINT_STACK: {
ScriptLanguage* script = GDScriptLanguage::get_singleton();
for (int i=0; i < script->debug_get_stack_level_count(); i++) {
print_line("Frame "+itos(i)+" - "+script->debug_get_stack_level_source(i)+":"+itos(script->debug_get_stack_level_line(i))+" in function '"+script->debug_get_stack_level_function(i)+"'");
};
} break;
case INSTANCE_FROM_ID: {
VALIDATE_ARG_COUNT(1);
if (p_args[0]->get_type()!=Variant::INT && p_args[0]->get_type()!=Variant::REAL) {
r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
r_error.argument=0;
r_error.expected=Variant::INT;
r_ret=Variant();
break;
}
uint32_t id=*p_args[0];
r_ret=ObjectDB::get_instance(id);
} break;
case FUNC_MAX: {
ERR_FAIL();
} break;
}
}
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) {
case VisualScriptBuiltinFunc::MATH_SIN: {
VALIDATE_ARG_NUM(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]);
} break;
case VisualScriptBuiltinFunc::MATH_TAN: {
VALIDATE_ARG_NUM(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]);
} break;
case VisualScriptBuiltinFunc::MATH_COSH: {
VALIDATE_ARG_NUM(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]);
} break;
case VisualScriptBuiltinFunc::MATH_ASIN: {
VALIDATE_ARG_NUM(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]);
} break;
case VisualScriptBuiltinFunc::MATH_ATAN: {
VALIDATE_ARG_NUM(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]);
} break;
case VisualScriptBuiltinFunc::MATH_SQRT: {
VALIDATE_ARG_NUM(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]);
} 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]);
} break;
case VisualScriptBuiltinFunc::MATH_FLOOR: {
VALIDATE_ARG_NUM(0);
*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]);
} break;
case VisualScriptBuiltinFunc::MATH_ROUND: {
VALIDATE_ARG_NUM(0);
*r_return = Math::round((double)*p_inputs[0]);
} break;
case VisualScriptBuiltinFunc::MATH_ABS: {
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) {
real_t r = *p_inputs[0];
*r_return = Math::abs(r);
} else {
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) {
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 {
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]);
} break;
case VisualScriptBuiltinFunc::MATH_LOG: {
VALIDATE_ARG_NUM(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]);
} break;
case VisualScriptBuiltinFunc::MATH_ISNAN: {
VALIDATE_ARG_NUM(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]);
} 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]);
} break;
case VisualScriptBuiltinFunc::MATH_DECIMALS: {
VALIDATE_ARG_NUM(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]);
} 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]);
} break;
case VisualScriptBuiltinFunc::MATH_INVERSE_LERP: {
VALIDATE_ARG_NUM(0);
VALIDATE_ARG_NUM(1);
VALIDATE_ARG_NUM(2);
*r_return = Math::inverse_lerp((double)*p_inputs[0], (double)*p_inputs[1], (double)*p_inputs[2]);
} break;
case VisualScriptBuiltinFunc::MATH_RANGE_LERP: {
VALIDATE_ARG_NUM(0);
VALIDATE_ARG_NUM(1);
VALIDATE_ARG_NUM(2);
VALIDATE_ARG_NUM(3);
VALIDATE_ARG_NUM(4);
*r_return = Math::range_lerp((double)*p_inputs[0], (double)*p_inputs[1], (double)*p_inputs[2], (double)*p_inputs[3], (double)*p_inputs[4]);
} break;
case VisualScriptBuiltinFunc::MATH_SMOOTHSTEP: {
VALIDATE_ARG_NUM(0);
VALIDATE_ARG_NUM(1);
VALIDATE_ARG_NUM(2);
*r_return = Math::smoothstep((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]);
} break;
case VisualScriptBuiltinFunc::MATH_RANDOMIZE: {
Math::randomize();
} break;
case VisualScriptBuiltinFunc::MATH_RAND: {
*r_return = Math::rand();
} break;
case VisualScriptBuiltinFunc::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]);
} break;
case VisualScriptBuiltinFunc::MATH_SEED: {
VALIDATE_ARG_NUM(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];
int ret = Math::rand_from_seed(&seed);
Array reta;
reta.push_back(ret);
reta.push_back(seed);
*r_return = reta;
} break;
case VisualScriptBuiltinFunc::MATH_DEG2RAD: {
VALIDATE_ARG_NUM(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]);
} break;
case VisualScriptBuiltinFunc::MATH_LINEAR2DB: {
VALIDATE_ARG_NUM(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]);
} break;
case VisualScriptBuiltinFunc::MATH_POLAR2CARTESIAN: {
VALIDATE_ARG_NUM(0);
VALIDATE_ARG_NUM(1);
double r = *p_inputs[0];
double th = *p_inputs[1];
*r_return = Vector2(r * Math::cos(th), r * Math::sin(th));
} break;
case VisualScriptBuiltinFunc::MATH_CARTESIAN2POLAR: {
VALIDATE_ARG_NUM(0);
VALIDATE_ARG_NUM(1);
double x = *p_inputs[0];
double y = *p_inputs[1];
*r_return = Vector2(Math::sqrt(x * x + y * y), Math::atan2(y, x));
} break;
case VisualScriptBuiltinFunc::MATH_WRAP: {
VALIDATE_ARG_NUM(0);
VALIDATE_ARG_NUM(1);
VALIDATE_ARG_NUM(2);
*r_return = Math::wrapi((int64_t)*p_inputs[0], (int64_t)*p_inputs[1], (int64_t)*p_inputs[2]);
} break;
case VisualScriptBuiltinFunc::MATH_WRAPF: {
VALIDATE_ARG_NUM(0);
VALIDATE_ARG_NUM(1);
VALIDATE_ARG_NUM(2);
*r_return = Math::wrapf((double)*p_inputs[0], (double)*p_inputs[1], (double)*p_inputs[2]);
} break;
case VisualScriptBuiltinFunc::LOGIC_MAX: {
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);
} else {
VALIDATE_ARG_NUM(0);
VALIDATE_ARG_NUM(1);
real_t a = *p_inputs[0];
real_t b = *p_inputs[1];
*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) {
int64_t a = *p_inputs[0];
int64_t b = *p_inputs[1];
*r_return = MIN(a, b);
} else {
VALIDATE_ARG_NUM(0);
VALIDATE_ARG_NUM(1);
real_t a = *p_inputs[0];
real_t b = *p_inputs[1];
*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) {
int64_t a = *p_inputs[0];
int64_t b = *p_inputs[1];
int64_t c = *p_inputs[2];
*r_return = CLAMP(a, b, c);
} else {
VALIDATE_ARG_NUM(0);
VALIDATE_ARG_NUM(1);
VALIDATE_ARG_NUM(2);
real_t a = *p_inputs[0];
real_t b = *p_inputs[1];
real_t c = *p_inputs[2];
*r_return = CLAMP(a, b, c);
}
} break;
case VisualScriptBuiltinFunc::LOGIC_NEAREST_PO2: {
VALIDATE_ARG_NUM(0);
int64_t num = *p_inputs[0];
*r_return = next_power_of_2(num);
} break;
case VisualScriptBuiltinFunc::OBJ_WEAKREF: {
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;
return;
}
if (p_inputs[0]->is_ref()) {
REF r = *p_inputs[0];
if (!r.is_valid()) {
return;
}
Ref<WeakRef> wref = memnew(WeakRef);
wref->set_ref(r);
*r_return = wref;
} else {
Object *obj = *p_inputs[0];
if (!obj) {
return;
}
Ref<WeakRef> wref = memnew(WeakRef);
wref->set_obj(obj);
*r_return = wref;
}
} break;
case VisualScriptBuiltinFunc::FUNC_FUNCREF: {
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;
return;
}
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;
return;
}
Ref<FuncRef> fr = memnew(FuncRef);
fr->set_instance(*p_inputs[0]);
fr->set_function(*p_inputs[1]);
*r_return = fr;
} break;
case VisualScriptBuiltinFunc::TYPE_CONVERT: {
VALIDATE_ARG_NUM(1);
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;
return;
} else {
*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);
} break;
case VisualScriptBuiltinFunc::TEXT_STR: {
String str = *p_inputs[0];
*r_return = str;
} break;
case VisualScriptBuiltinFunc::TEXT_PRINT: {
String str = *p_inputs[0];
print_line(str);
} break;
case VisualScriptBuiltinFunc::TEXT_PRINTERR: {
String str = *p_inputs[0];
print_error(str);
} break;
case VisualScriptBuiltinFunc::TEXT_PRINTRAW: {
String str = *p_inputs[0];
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;
} 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;
return;
}
VariantParser::StreamString ss;
ss.s = *p_inputs[0];
String errs;
int 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;
return;
}
} break;
case VisualScriptBuiltinFunc::VAR_TO_BYTES: {
if (p_inputs[1]->get_type() != Variant::BOOL) {
r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
r_error.argument = 1;
r_error.expected = Variant::BOOL;
return;
}
PoolByteArray barr;
int len;
bool full_objects = *p_inputs[1];
Error err = encode_variant(*p_inputs[0], NULL, len, full_objects);
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).";
return;
}
barr.resize(len);
{
PoolByteArray::Write w = barr.write();
encode_variant(*p_inputs[0], w.ptr(), len, full_objects);
}
*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;
return;
}
if (p_inputs[1]->get_type() != Variant::BOOL) {
r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
r_error.argument = 1;
r_error.expected = Variant::BOOL;
return;
}
PoolByteArray varr = *p_inputs[0];
bool allow_objects = *p_inputs[1];
Variant ret;
{
PoolByteArray::Read r = varr.read();
Error err = decode_variant(ret, r.ptr(), varr.size(), NULL, allow_objects);
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;
} break;
case VisualScriptBuiltinFunc::COLORN: {
VALIDATE_ARG_NUM(1);
Color color = Color::named(*p_inputs[0]);
color.a = *p_inputs[1];
*r_return = String(color);
} break;
default: {
}
}
}
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) {
switch(func) {
case VisualScriptBuiltinFunc::MATH_SIN: {
VALIDATE_ARG_NUM(0);
*p_outputs[0]=Math::sin(*p_inputs[0]);
}
break;
case VisualScriptBuiltinFunc::MATH_COS: {
VALIDATE_ARG_NUM(0);
*p_outputs[0]=Math::cos(*p_inputs[0]);
}
break;
case VisualScriptBuiltinFunc::MATH_TAN: {
VALIDATE_ARG_NUM(0);
*p_outputs[0]=Math::tan(*p_inputs[0]);
}
break;
case VisualScriptBuiltinFunc::MATH_SINH: {
VALIDATE_ARG_NUM(0);
*p_outputs[0]=Math::sinh(*p_inputs[0]);
}
break;
case VisualScriptBuiltinFunc::MATH_COSH: {
VALIDATE_ARG_NUM(0);
*p_outputs[0]=Math::cosh(*p_inputs[0]);
}
break;
case VisualScriptBuiltinFunc::MATH_TANH: {
VALIDATE_ARG_NUM(0);
*p_outputs[0]=Math::tanh(*p_inputs[0]);
}
break;
case VisualScriptBuiltinFunc::MATH_ASIN: {
VALIDATE_ARG_NUM(0);
*p_outputs[0]=Math::asin(*p_inputs[0]);
}
break;
case VisualScriptBuiltinFunc::MATH_ACOS: {
VALIDATE_ARG_NUM(0);
*p_outputs[0]=Math::acos(*p_inputs[0]);
}
break;
case VisualScriptBuiltinFunc::MATH_ATAN: {
VALIDATE_ARG_NUM(0);
*p_outputs[0]=Math::atan(*p_inputs[0]);
}
break;
case VisualScriptBuiltinFunc::MATH_ATAN2: {
VALIDATE_ARG_NUM(0);
VALIDATE_ARG_NUM(1);
*p_outputs[0]=Math::atan2(*p_inputs[0],*p_inputs[1]);
}
break;
case VisualScriptBuiltinFunc::MATH_SQRT: {
VALIDATE_ARG_NUM(0);
*p_outputs[0]=Math::sqrt(*p_inputs[0]);
}
break;
case VisualScriptBuiltinFunc::MATH_FMOD: {
VALIDATE_ARG_NUM(0);
VALIDATE_ARG_NUM(1);
*p_outputs[0]=Math::fmod(*p_inputs[0],*p_inputs[1]);
}
break;
case VisualScriptBuiltinFunc::MATH_FPOSMOD: {
VALIDATE_ARG_NUM(0);
VALIDATE_ARG_NUM(1);
*p_outputs[0]=Math::fposmod(*p_inputs[0],*p_inputs[1]);
}
break;
case VisualScriptBuiltinFunc::MATH_FLOOR: {
VALIDATE_ARG_NUM(0);
*p_outputs[0]=Math::floor(*p_inputs[0]);
}
break;
case VisualScriptBuiltinFunc::MATH_CEIL: {
VALIDATE_ARG_NUM(0);
*p_outputs[0]=Math::ceil(*p_inputs[0]);
}
break;
case VisualScriptBuiltinFunc::MATH_ROUND: {
VALIDATE_ARG_NUM(0);
*p_outputs[0]=Math::round(*p_inputs[0]);
}
break;
case VisualScriptBuiltinFunc::MATH_ABS: {
if (p_inputs[0]->get_type()==Variant::INT) {
int64_t i = *p_inputs[0];
*p_outputs[0]=ABS(i);
} else if (p_inputs[0]->get_type()==Variant::REAL) {
real_t r = *p_inputs[0];
*p_outputs[0]=Math::abs(r);
} else {
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) {
int64_t i = *p_inputs[0];
*p_outputs[0]= i < 0 ? -1 : ( i > 0 ? +1 : 0);
} else if (p_inputs[0]->get_type()==Variant::REAL) {
real_t r = *p_inputs[0];
*p_outputs[0]= 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);
*p_outputs[0]=Math::pow(*p_inputs[0],*p_inputs[1]);
}
break;
case VisualScriptBuiltinFunc::MATH_LOG: {
VALIDATE_ARG_NUM(0);
*p_outputs[0]=Math::log(*p_inputs[0]);
}
break;
case VisualScriptBuiltinFunc::MATH_EXP: {
VALIDATE_ARG_NUM(0);
*p_outputs[0]=Math::exp(*p_inputs[0]);
}
break;
case VisualScriptBuiltinFunc::MATH_ISNAN: {
VALIDATE_ARG_NUM(0);
*p_outputs[0]=Math::is_nan(*p_inputs[0]);
}
break;
case VisualScriptBuiltinFunc::MATH_ISINF: {
VALIDATE_ARG_NUM(0);
*p_outputs[0]=Math::is_inf(*p_inputs[0]);
}
break;
case VisualScriptBuiltinFunc::MATH_EASE: {
VALIDATE_ARG_NUM(0);
VALIDATE_ARG_NUM(1);
*p_outputs[0]=Math::ease(*p_inputs[0],*p_inputs[1]);
}
break;
case VisualScriptBuiltinFunc::MATH_DECIMALS: {
VALIDATE_ARG_NUM(0);
*p_outputs[0]=Math::step_decimals(*p_inputs[0]);
}
break;
case VisualScriptBuiltinFunc::MATH_STEPIFY: {
VALIDATE_ARG_NUM(0);
VALIDATE_ARG_NUM(1);
*p_outputs[0]=Math::stepify(*p_inputs[0],*p_inputs[1]);
}
break;
case VisualScriptBuiltinFunc::MATH_LERP: {
VALIDATE_ARG_NUM(0);
VALIDATE_ARG_NUM(1);
VALIDATE_ARG_NUM(2);
*p_outputs[0]=Math::lerp(*p_inputs[0],*p_inputs[1],*p_inputs[2]);
}
break;
case VisualScriptBuiltinFunc::MATH_DECTIME: {
VALIDATE_ARG_NUM(0);
VALIDATE_ARG_NUM(1);
VALIDATE_ARG_NUM(2);
*p_outputs[0]=Math::dectime(*p_inputs[0],*p_inputs[1],*p_inputs[2]);
}
break;
case VisualScriptBuiltinFunc::MATH_RANDOMIZE: {
Math::randomize();
}
break;
case VisualScriptBuiltinFunc::MATH_RAND: {
*p_outputs[0]=Math::rand();
}
break;
case VisualScriptBuiltinFunc::MATH_RANDF: {
*p_outputs[0]=Math::randf();
}
break;
case VisualScriptBuiltinFunc::MATH_RANDOM: {
VALIDATE_ARG_NUM(0);
VALIDATE_ARG_NUM(1);
*p_outputs[0]=Math::random(*p_inputs[0],*p_inputs[1]);
}
break;
case VisualScriptBuiltinFunc::MATH_SEED: {
VALIDATE_ARG_NUM(0);
uint32_t seed=*p_inputs[0];
Math::seed(seed);
}
break;
case VisualScriptBuiltinFunc::MATH_RANDSEED: {
VALIDATE_ARG_NUM(0);
uint32_t seed=*p_inputs[0];
int ret = Math::rand_from_seed(&seed);
Array reta;
reta.push_back(ret);
reta.push_back(seed);
*p_outputs[0]=reta;
}
break;
case VisualScriptBuiltinFunc::MATH_DEG2RAD: {
VALIDATE_ARG_NUM(0);
*p_outputs[0]=Math::deg2rad(*p_inputs[0]);
}
break;
case VisualScriptBuiltinFunc::MATH_RAD2DEG: {
VALIDATE_ARG_NUM(0);
*p_outputs[0]=Math::rad2deg(*p_inputs[0]);
}
break;
case VisualScriptBuiltinFunc::MATH_LINEAR2DB: {
VALIDATE_ARG_NUM(0);
*p_outputs[0]=Math::linear2db(*p_inputs[0]);
}
break;
case VisualScriptBuiltinFunc::MATH_DB2LINEAR: {
VALIDATE_ARG_NUM(0);
*p_outputs[0]=Math::db2linear(*p_inputs[0]);
}
break;
case VisualScriptBuiltinFunc::LOGIC_MAX: {
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];
*p_outputs[0]=MAX(a,b);
} else {
VALIDATE_ARG_NUM(0);
VALIDATE_ARG_NUM(1);
real_t a = *p_inputs[0];
real_t b = *p_inputs[1];
*p_outputs[0]=MAX(a,b);
}
}
break;
case VisualScriptBuiltinFunc::LOGIC_MIN: {
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];
*p_outputs[0]=MIN(a,b);
} else {
VALIDATE_ARG_NUM(0);
VALIDATE_ARG_NUM(1);
real_t a = *p_inputs[0];
real_t b = *p_inputs[1];
*p_outputs[0]=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) {
int64_t a = *p_inputs[0];
int64_t b = *p_inputs[1];
int64_t c = *p_inputs[2];
*p_outputs[0]=CLAMP(a,b,c);
} else {
VALIDATE_ARG_NUM(0);
VALIDATE_ARG_NUM(1);
VALIDATE_ARG_NUM(2);
real_t a = *p_inputs[0];
real_t b = *p_inputs[1];
real_t c = *p_inputs[2];
*p_outputs[0]=CLAMP(a,b,c);
}
}
break;
case VisualScriptBuiltinFunc::LOGIC_NEAREST_PO2: {
VALIDATE_ARG_NUM(0);
int64_t num = *p_inputs[0];
*p_outputs[0] = nearest_power_of_2(num);
}
break;
case VisualScriptBuiltinFunc::OBJ_WEAKREF: {
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;
return 0;
}
if (p_inputs[0]->is_ref()) {
REF r = *p_inputs[0];
if (!r.is_valid()) {
return 0;
}
Ref<WeakRef> wref = memnew( WeakRef );
wref->set_ref(r);
*p_outputs[0]=wref;
} else {
Object *obj = *p_inputs[0];
if (!obj) {
return 0;
}
Ref<WeakRef> wref = memnew( WeakRef );
wref->set_obj(obj);
*p_outputs[0]=wref;
}
}
break;
case VisualScriptBuiltinFunc::FUNC_FUNCREF: {
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;
return 0;
}
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;
return 0;
}
Ref<FuncRef> fr = memnew( FuncRef);
fr->set_instance(*p_inputs[0]);
fr->set_function(*p_inputs[1]);
*p_outputs[0]=fr;
}
break;
case VisualScriptBuiltinFunc::TYPE_CONVERT: {
VALIDATE_ARG_NUM(1);
int type=*p_inputs[1];
if (type<0 || type>=Variant::VARIANT_MAX) {
*p_outputs[0]=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 0;
} else {
*p_outputs[0]=Variant::construct(Variant::Type(type),p_inputs,1,r_error);
}
}
break;
case VisualScriptBuiltinFunc::TYPE_OF: {
*p_outputs[0] = p_inputs[0]->get_type();
}
break;
case VisualScriptBuiltinFunc::TYPE_EXISTS: {
*p_outputs[0] = ObjectTypeDB::type_exists(*p_inputs[0]);
}
break;
case VisualScriptBuiltinFunc::TEXT_STR: {
String str = *p_inputs[0];
*p_outputs[0]=str;
}
break;
case VisualScriptBuiltinFunc::TEXT_PRINT: {
String str = *p_inputs[0];
print_line(str);
}
break;
case VisualScriptBuiltinFunc::TEXT_PRINTERR: {
String str = *p_inputs[0];
//str+="\n";
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());
}
break;
case VisualScriptBuiltinFunc::VAR_TO_STR: {
String vars;
VariantWriter::write_to_string(*p_inputs[0],vars);
*p_outputs[0]=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;
return 0;
}
VariantParser::StreamString ss;
ss.s=*p_inputs[0];
String errs;
int line;
Error err = VariantParser::parse(&ss,*p_outputs[0],errs,line);
if (err!=OK) {
r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
r_error.argument=0;
r_error.expected=Variant::STRING;
*p_outputs[0]="Parse error at line "+itos(line)+": "+errs;
return 0;
}
}
break;
case VisualScriptBuiltinFunc::VAR_TO_BYTES: {
ByteArray barr;
int 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;
*p_outputs[0]="Unexpected error encoding variable to bytes, likely unserializable type found (Object or RID).";
return 0;
}
barr.resize(len);
{
ByteArray::Write w = barr.write();
encode_variant(*p_inputs[0],w.ptr(),len);
}
*p_outputs[0]=barr;
}
break;
case VisualScriptBuiltinFunc::BYTES_TO_VAR: {
if (p_inputs[0]->get_type()!=Variant::RAW_ARRAY) {
r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
r_error.argument=0;
r_error.expected=Variant::RAW_ARRAY;
return 0;
}
ByteArray varr=*p_inputs[0];
Variant ret;
{
ByteArray::Read r=varr.read();
Error err = decode_variant(ret,r.ptr(),varr.size(),NULL);
if (err!=OK) {
*p_outputs[0]=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::RAW_ARRAY;
return 0;
}
}
*p_outputs[0]=ret;
}
break;
default:
{}
}
return 0;
}
void InspectorDock::_menu_option(int p_option) {
switch (p_option) {
case RESOURCE_SAVE: {
_save_resource(false);
} break;
case RESOURCE_SAVE_AS: {
_save_resource(true);
} break;
case OBJECT_REQUEST_HELP: {
if (current) {
editor->set_visible_editor(EditorNode::EDITOR_SCRIPT);
emit_signal("request_help", current->get_class());
}
} break;
case OBJECT_COPY_PARAMS: {
editor_data->apply_changes_in_editors();
if (current)
editor_data->copy_object_params(current);
} break;
case OBJECT_PASTE_PARAMS: {
editor_data->apply_changes_in_editors();
if (current)
editor_data->paste_object_params(current);
editor_data->get_undo_redo().clear_history();
} break;
case OBJECT_UNIQUE_RESOURCES: {
editor_data->apply_changes_in_editors();
if (current) {
List<PropertyInfo> props;
current->get_property_list(&props);
Map<RES, RES> duplicates;
for (List<PropertyInfo>::Element *E = props.front(); E; E = E->next()) {
if (!(E->get().usage & PROPERTY_USAGE_STORAGE))
continue;
Variant v = current->get(E->get().name);
if (v.is_ref()) {
REF ref = v;
if (ref.is_valid()) {
RES res = ref;
if (res.is_valid()) {
if (!duplicates.has(res)) {
duplicates[res] = res->duplicate();
}
res = duplicates[res];
current->set(E->get().name, res);
}
}
}
}
}
editor_data->get_undo_redo().clear_history();
editor->get_editor_plugins_over()->edit(NULL);
editor->get_editor_plugins_over()->edit(current);
} break;
default: {
if (p_option >= OBJECT_METHOD_BASE) {
ERR_FAIL_COND(!current);
int idx = p_option - OBJECT_METHOD_BASE;
List<MethodInfo> methods;
current->get_method_list(&methods);
ERR_FAIL_INDEX(idx, methods.size());
String name = methods[idx].name;
if (current)
current->call(name);
}
}
}
}
void GDFunctions::call(Function p_func,const Variant **p_args,int p_arg_count,Variant &r_ret,Variant::CallError &r_error) {
r_error.error=Variant::CallError::CALL_OK;
#ifdef DEBUG_ENABLED
#define VALIDATE_ARG_COUNT(m_count) \
if (p_arg_count<m_count) {\
r_error.error=Variant::CallError::CALL_ERROR_TOO_FEW_ARGUMENTS;\
r_error.argument=m_count;\
return;\
}\
if (p_arg_count>m_count) {\
r_error.error=Variant::CallError::CALL_ERROR_TOO_MANY_ARGUMENTS;\
r_error.argument=m_count;\
return;\
}
#define VALIDATE_ARG_NUM(m_arg) \
if (!p_args[m_arg]->is_num()) {\
r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;\
r_error.argument=m_arg;\
r_error.expected=Variant::REAL;\
return;\
}
#else
#define VALIDATE_ARG_COUNT(m_count)
#define VALIDATE_ARG_NUM(m_arg)
#endif
//using a switch, so the compiler generates a jumptable
switch(p_func) {
case MATH_SIN: {
VALIDATE_ARG_COUNT(1);
VALIDATE_ARG_NUM(0);
r_ret=Math::sin(*p_args[0]);
} break;
case MATH_COS: {
VALIDATE_ARG_COUNT(1);
VALIDATE_ARG_NUM(0);
r_ret=Math::cos(*p_args[0]);
} break;
case MATH_TAN: {
VALIDATE_ARG_COUNT(1);
VALIDATE_ARG_NUM(0);
r_ret=Math::tan(*p_args[0]);
} break;
case MATH_SINH: {
VALIDATE_ARG_COUNT(1);
VALIDATE_ARG_NUM(0);
r_ret=Math::sinh(*p_args[0]);
} break;
case MATH_COSH: {
VALIDATE_ARG_COUNT(1);
VALIDATE_ARG_NUM(0);
r_ret=Math::cosh(*p_args[0]);
} break;
case MATH_TANH: {
VALIDATE_ARG_COUNT(1);
VALIDATE_ARG_NUM(0);
r_ret=Math::tanh(*p_args[0]);
} break;
case MATH_ASIN: {
VALIDATE_ARG_COUNT(1);
VALIDATE_ARG_NUM(0);
r_ret=Math::asin(*p_args[0]);
} break;
case MATH_ACOS: {
VALIDATE_ARG_COUNT(1);
VALIDATE_ARG_NUM(0);
r_ret=Math::acos(*p_args[0]);
} break;
case MATH_ATAN: {
VALIDATE_ARG_COUNT(1);
VALIDATE_ARG_NUM(0);
r_ret=Math::atan(*p_args[0]);
} break;
case MATH_ATAN2: {
VALIDATE_ARG_COUNT(2);
VALIDATE_ARG_NUM(0);
VALIDATE_ARG_NUM(1);
r_ret=Math::atan2(*p_args[0],*p_args[1]);
} break;
case MATH_SQRT: {
VALIDATE_ARG_COUNT(1);
VALIDATE_ARG_NUM(0);
r_ret=Math::sqrt(*p_args[0]);
} break;
case MATH_FMOD: {
VALIDATE_ARG_COUNT(2);
VALIDATE_ARG_NUM(0);
VALIDATE_ARG_NUM(1);
r_ret=Math::fmod(*p_args[0],*p_args[1]);
} break;
case MATH_FPOSMOD: {
VALIDATE_ARG_COUNT(2);
VALIDATE_ARG_NUM(0);
VALIDATE_ARG_NUM(1);
r_ret=Math::fposmod(*p_args[0],*p_args[1]);
} break;
case MATH_FLOOR: {
VALIDATE_ARG_COUNT(1);
VALIDATE_ARG_NUM(0);
r_ret=Math::floor(*p_args[0]);
} break;
case MATH_CEIL: {
VALIDATE_ARG_COUNT(1);
VALIDATE_ARG_NUM(0);
r_ret=Math::ceil(*p_args[0]);
} break;
case MATH_ROUND: {
VALIDATE_ARG_COUNT(1);
VALIDATE_ARG_NUM(0);
r_ret=Math::round(*p_args[0]);
} break;
case MATH_ABS: {
VALIDATE_ARG_COUNT(1);
if (p_args[0]->get_type()==Variant::INT) {
int64_t i = *p_args[0];
r_ret=ABS(i);
} else if (p_args[0]->get_type()==Variant::REAL) {
real_t r = *p_args[0];
r_ret=Math::abs(r);
} else {
r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
r_error.argument=0;
r_error.expected=Variant::REAL;
}
} break;
case MATH_SIGN: {
VALIDATE_ARG_COUNT(1);
if (p_args[0]->get_type()==Variant::INT) {
int64_t i = *p_args[0];
r_ret= i < 0 ? -1 : ( i > 0 ? +1 : 0);
} else if (p_args[0]->get_type()==Variant::REAL) {
real_t r = *p_args[0];
r_ret= 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 MATH_POW: {
VALIDATE_ARG_COUNT(2);
VALIDATE_ARG_NUM(0);
VALIDATE_ARG_NUM(1);
r_ret=Math::pow(*p_args[0],*p_args[1]);
} break;
case MATH_LOG: {
VALIDATE_ARG_COUNT(1);
VALIDATE_ARG_NUM(0);
r_ret=Math::log(*p_args[0]);
} break;
case MATH_EXP: {
VALIDATE_ARG_COUNT(1);
VALIDATE_ARG_NUM(0);
r_ret=Math::exp(*p_args[0]);
} break;
case MATH_ISNAN: {
VALIDATE_ARG_COUNT(1);
VALIDATE_ARG_NUM(0);
r_ret=Math::is_nan(*p_args[0]);
} break;
case MATH_ISINF: {
VALIDATE_ARG_COUNT(1);
VALIDATE_ARG_NUM(0);
r_ret=Math::is_inf(*p_args[0]);
} break;
case MATH_EASE: {
VALIDATE_ARG_COUNT(2);
VALIDATE_ARG_NUM(0);
VALIDATE_ARG_NUM(1);
r_ret=Math::ease(*p_args[0],*p_args[1]);
} break;
case MATH_DECIMALS: {
VALIDATE_ARG_COUNT(1);
VALIDATE_ARG_NUM(0);
r_ret=Math::decimals(*p_args[0]);
} break;
case MATH_STEPIFY: {
VALIDATE_ARG_COUNT(2);
VALIDATE_ARG_NUM(0);
VALIDATE_ARG_NUM(1);
r_ret=Math::stepify(*p_args[0],*p_args[1]);
} break;
case MATH_LERP: {
VALIDATE_ARG_COUNT(3);
VALIDATE_ARG_NUM(0);
VALIDATE_ARG_NUM(1);
VALIDATE_ARG_NUM(2);
r_ret=Math::lerp(*p_args[0],*p_args[1],*p_args[2]);
} break;
case MATH_DECTIME: {
VALIDATE_ARG_COUNT(3);
VALIDATE_ARG_NUM(0);
VALIDATE_ARG_NUM(1);
VALIDATE_ARG_NUM(2);
r_ret=Math::dectime(*p_args[0],*p_args[1],*p_args[2]);
} break;
case MATH_RANDOMIZE: {
Math::randomize();
r_ret=Variant();
} break;
case MATH_RAND: {
r_ret=Math::rand();
} break;
case MATH_RANDF: {
r_ret=Math::randf();
} break;
case MATH_RANDOM: {
VALIDATE_ARG_COUNT(2);
VALIDATE_ARG_NUM(0);
VALIDATE_ARG_NUM(1);
r_ret=Math::random(*p_args[0],*p_args[1]);
} break;
case MATH_RANDSEED: {
VALIDATE_ARG_COUNT(1);
VALIDATE_ARG_NUM(0);
uint32_t seed=*p_args[0];
int ret = Math::rand_from_seed(&seed);
Array reta;
reta.push_back(ret);
reta.push_back(seed);
r_ret=reta;
} break;
case MATH_DEG2RAD: {
VALIDATE_ARG_COUNT(1);
VALIDATE_ARG_NUM(0);
r_ret=Math::deg2rad(*p_args[0]);
} break;
case MATH_RAD2DEG: {
VALIDATE_ARG_COUNT(1);
VALIDATE_ARG_NUM(0);
r_ret=Math::rad2deg(*p_args[0]);
} break;
case MATH_LINEAR2DB: {
VALIDATE_ARG_COUNT(1);
VALIDATE_ARG_NUM(0);
r_ret=Math::linear2db(*p_args[0]);
} break;
case MATH_DB2LINEAR: {
VALIDATE_ARG_COUNT(1);
VALIDATE_ARG_NUM(0);
r_ret=Math::db2linear(*p_args[0]);
} break;
case LOGIC_MAX: {
VALIDATE_ARG_COUNT(2);
if (p_args[0]->get_type()==Variant::INT && p_args[1]->get_type()==Variant::INT) {
int64_t a = *p_args[0];
int64_t b = *p_args[1];
r_ret=MAX(a,b);
} else {
VALIDATE_ARG_NUM(0);
VALIDATE_ARG_NUM(1);
real_t a = *p_args[0];
real_t b = *p_args[1];
r_ret=MAX(a,b);
}
} break;
case LOGIC_MIN: {
VALIDATE_ARG_COUNT(2);
if (p_args[0]->get_type()==Variant::INT && p_args[1]->get_type()==Variant::INT) {
int64_t a = *p_args[0];
int64_t b = *p_args[1];
r_ret=MIN(a,b);
} else {
VALIDATE_ARG_NUM(0);
VALIDATE_ARG_NUM(1);
real_t a = *p_args[0];
real_t b = *p_args[1];
r_ret=MIN(a,b);
}
} break;
case LOGIC_CLAMP: {
VALIDATE_ARG_COUNT(3);
if (p_args[0]->get_type()==Variant::INT && p_args[1]->get_type()==Variant::INT && p_args[2]->get_type()==Variant::INT) {
int64_t a = *p_args[0];
int64_t b = *p_args[1];
int64_t c = *p_args[2];
r_ret=CLAMP(a,b,c);
} else {
VALIDATE_ARG_NUM(0);
VALIDATE_ARG_NUM(1);
VALIDATE_ARG_NUM(2);
real_t a = *p_args[0];
real_t b = *p_args[1];
real_t c = *p_args[2];
r_ret=CLAMP(a,b,c);
}
} break;
case LOGIC_NEAREST_PO2: {
VALIDATE_ARG_COUNT(1);
VALIDATE_ARG_NUM(0);
int64_t num = *p_args[0];
r_ret = nearest_power_of_2(num);
} break;
case OBJ_WEAKREF: {
VALIDATE_ARG_COUNT(1);
if (p_args[0]->get_type()!=Variant::OBJECT) {
r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
r_error.argument=0;
r_error.expected=Variant::OBJECT;
return;
}
if (p_args[0]->is_ref()) {
REF r = *p_args[0];
if (!r.is_valid()) {
r_ret=Variant();
return;
}
Ref<WeakRef> wref = memnew( WeakRef );
wref->set_ref(r);
r_ret=wref;
} else {
Object *obj = *p_args[0];
if (!obj) {
r_ret=Variant();
return;
}
Ref<WeakRef> wref = memnew( WeakRef );
wref->set_obj(obj);
r_ret=wref;
}
} break;
case FUNC_FUNCREF: {
VALIDATE_ARG_COUNT(2);
if (p_args[0]->get_type()!=Variant::OBJECT) {
r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
r_error.argument=0;
r_error.expected=Variant::OBJECT;
r_ret=Variant();
return;
}
if (p_args[1]->get_type()!=Variant::STRING && p_args[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_ret=Variant();
return;
}
Ref<FuncRef> fr = memnew( FuncRef);
Object *obj = *p_args[0];
fr->set_instance(*p_args[0]);
fr->set_function(*p_args[1]);
r_ret=fr;
} break;
case TYPE_CONVERT: {
VALIDATE_ARG_COUNT(2);
VALIDATE_ARG_NUM(1);
int type=*p_args[1];
if (type<0 || type>=Variant::VARIANT_MAX) {
ERR_PRINT("Invalid type argument to convert()");
r_ret=Variant::NIL;
} else {
r_ret=Variant::construct(Variant::Type(type),p_args,1,r_error);
}
} break;
case TYPE_OF: {
VALIDATE_ARG_COUNT(1);
r_ret = p_args[0]->get_type();
} break;
case TEXT_STR: {
String str;
for(int i=0;i<p_arg_count;i++) {
String os = p_args[i]->operator String();;
if (i==0)
str=os;
else
str+=os;
}
r_ret=str;
} break;
case TEXT_PRINT: {
String str;
for(int i=0;i<p_arg_count;i++) {
str+=p_args[i]->operator String();
}
//str+="\n";
print_line(str);
r_ret=Variant();
} break;
case TEXT_PRINT_TABBED: {
String str;
for(int i=0;i<p_arg_count;i++) {
if (i)
str+="\t";
str+=p_args[i]->operator String();
}
//str+="\n";
print_line(str);
r_ret=Variant();
} break;
case TEXT_PRINTERR: {
String str;
for(int i=0;i<p_arg_count;i++) {
str+=p_args[i]->operator String();
}
//str+="\n";
OS::get_singleton()->printerr("%s\n",str.utf8().get_data());
r_ret=Variant();
} break;
case TEXT_PRINTRAW: {
String str;
for(int i=0;i<p_arg_count;i++) {
str+=p_args[i]->operator String();
}
//str+="\n";
OS::get_singleton()->print("%s\n",str.utf8().get_data());
r_ret=Variant();
} break;
case GEN_RANGE: {
switch(p_arg_count) {
case 0: {
r_error.error=Variant::CallError::CALL_ERROR_TOO_FEW_ARGUMENTS;
r_error.argument=1;
} break;
case 1: {
VALIDATE_ARG_NUM(0);
int count=*p_args[0];
Array arr(true);
if (count<=0) {
r_ret=arr;
return;
}
Error err = arr.resize(count);
if (err!=OK) {
r_error.error=Variant::CallError::CALL_ERROR_INVALID_METHOD;
r_ret=Variant();
return;
}
for(int i=0;i<count;i++) {
arr[i]=i;
}
r_ret=arr;
} break;
case 2: {
VALIDATE_ARG_NUM(0);
VALIDATE_ARG_NUM(1);
int from=*p_args[0];
int to=*p_args[1];
Array arr(true);
if (from>=to) {
r_ret=arr;
return;
}
Error err = arr.resize(to-from);
if (err!=OK) {
r_error.error=Variant::CallError::CALL_ERROR_INVALID_METHOD;
r_ret=Variant();
return;
}
for(int i=from;i<to;i++)
arr[i-from]=i;
r_ret=arr;
} break;
case 3: {
VALIDATE_ARG_NUM(0);
VALIDATE_ARG_NUM(1);
VALIDATE_ARG_NUM(2);
int from=*p_args[0];
int to=*p_args[1];
int incr=*p_args[2];
if (incr==0) {
ERR_EXPLAIN("step argument is zero!");
r_error.error=Variant::CallError::CALL_ERROR_INVALID_METHOD;
ERR_FAIL();
}
Array arr(true);
if (from>=to && incr>0) {
r_ret=arr;
return;
}
if (from<=to && incr<0) {
r_ret=arr;
return;
}
//calculate how many
int count=0;
if (incr>0) {
count=((to-from-1)/incr)+1;
} else {
count=((from-to-1)/-incr)+1;
}
Error err = arr.resize(count);
if (err!=OK) {
r_error.error=Variant::CallError::CALL_ERROR_INVALID_METHOD;
r_ret=Variant();
return;
}
if (incr>0) {
int idx=0;
for(int i=from;i<to;i+=incr) {
arr[idx++]=i;
}
} else {
int idx=0;
for(int i=from;i>to;i+=incr) {
arr[idx++]=i;
}
}
r_ret=arr;
} break;
default: {
r_error.error=Variant::CallError::CALL_ERROR_TOO_MANY_ARGUMENTS;
r_error.argument=3;
} break;
}
} break;
case RESOURCE_LOAD: {
VALIDATE_ARG_COUNT(1);
if (p_args[0]->get_type()!=Variant::STRING) {
r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
r_error.argument=0;
r_ret=Variant();
}
r_ret=ResourceLoader::load(*p_args[0]);
} break;
case INST2DICT: {
VALIDATE_ARG_COUNT(1);
if (p_args[0]->get_type()==Variant::NIL) {
r_ret=Variant();
} else if (p_args[0]->get_type()!=Variant::OBJECT) {
r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
r_error.argument=0;
r_ret=Variant();
} else {
Object *obj = *p_args[0];
if (!obj) {
r_ret=Variant();
} else if (!obj->get_script_instance() || obj->get_script_instance()->get_language()!=GDScriptLanguage::get_singleton()) {
r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
r_error.argument=0;
r_error.expected=Variant::DICTIONARY;
ERR_PRINT("Not a script with an instance");
} else {
GDInstance *ins = static_cast<GDInstance*>(obj->get_script_instance());
Ref<GDScript> base = ins->get_script();
if (base.is_null()) {
r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
r_error.argument=0;
r_error.expected=Variant::DICTIONARY;
ERR_PRINT("Not based on a script");
return;
}
GDScript *p = base.ptr();
Vector<StringName> sname;
while(p->_owner) {
sname.push_back(p->name);
p=p->_owner;
}
sname.invert();
if (!p->path.is_resource_file()) {
r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
r_error.argument=0;
r_error.expected=Variant::DICTIONARY;
print_line("PATH: "+p->path);
ERR_PRINT("Not based on a resource file");
return;
}
NodePath cp(sname,Vector<StringName>(),false);
Dictionary d(true);
d["@subpath"]=cp;
d["@path"]=p->path;
p = base.ptr();
while(p) {
for(Set<StringName>::Element *E=p->members.front();E;E=E->next()) {
Variant value;
if (ins->get(E->get(),value)) {
String k = E->get();
if (!d.has(k)) {
d[k]=value;
}
}
}
p=p->_base;
}
r_ret=d;
}
}
} break;
case DICT2INST: {
VALIDATE_ARG_COUNT(1);
if (p_args[0]->get_type()!=Variant::DICTIONARY) {
r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
r_error.argument=0;
r_error.expected=Variant::DICTIONARY;
return;
}
Dictionary d = *p_args[0];
if (!d.has("@path")) {
r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
r_error.argument=0;
r_error.expected=Variant::OBJECT;
return;
}
Ref<Script> scr = ResourceLoader::load(d["@path"]);
if (!scr.is_valid()) {
r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
r_error.argument=0;
r_error.expected=Variant::OBJECT;
return;
}
Ref<GDScript> gdscr = scr;
if (!gdscr.is_valid()) {
r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
r_error.argument=0;
r_error.expected=Variant::OBJECT;
return;
}
NodePath sub;
if (d.has("@subpath")) {
sub=d["@subpath"];
}
for(int i=0;i<sub.get_name_count();i++) {
gdscr = gdscr->subclasses[ sub.get_name(i)];
if (!gdscr.is_valid()) {
r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
r_error.argument=0;
r_error.expected=Variant::OBJECT;
return;
}
}
r_ret = gdscr->_new(NULL,0,r_error);
} break;
case HASH: {
VALIDATE_ARG_COUNT(1);
r_ret=p_args[0]->hash();
} break;
case PRINT_STACK: {
ScriptLanguage* script = GDScriptLanguage::get_singleton();
for (int i=0; i < script->debug_get_stack_level_count(); i++) {
print_line("Frame "+itos(i)+" - "+script->debug_get_stack_level_source(i)+":"+itos(script->debug_get_stack_level_line(i))+" in function '"+script->debug_get_stack_level_function(i)+"'");
};
} break;
case FUNC_MAX: {
ERR_FAIL_V();
} break;
}
}
