asgardius/virtualx-engine
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
virtualx-engine/modules/gdscript/gd_functions.cpp
Juan Linietsky 118eed485e ObjectTypeDB was renamed to ClassDB. Types are meant to be more generic to Variant. 
All usages of "type" to refer to classes were renamed to "class"
ClassDB has been exposed to GDScript.
OBJ_TYPE() macro is now GDCLASS()
2017-01-02 23:03:46 -03:00

1547 lines
36 KiB
C++
Raw Blame History

/*************************************************************************/
/* gd_functions.cpp */
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* http://www.godotengine.org */
/*************************************************************************/
/* Copyright (c) 2007-2017 Juan Linietsky, Ariel Manzur. */
/* */
/* Permission is hereby granted, free of charge, to any person obtaining */
/* a copy of this software and associated documentation files (the */
/* "Software"), to deal in the Software without restriction, including */
/* without limitation the rights to use, copy, modify, merge, publish, */
/* distribute, sublicense, and/or sell copies of the Software, and to */
/* permit persons to whom the Software is furnished to do so, subject to */
/* the following conditions: */
/* */
/* The above copyright notice and this permission notice shall be */
/* included in all copies or substantial portions of the Software. */
/* */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/*************************************************************************/
#include "gd_functions.h"
#include "math_funcs.h"
#include "object_type_db.h"
#include "reference.h"
#include "gd_script.h"
#include "func_ref.h"
#include "os/os.h"
#include "variant_parser.h"
#include "io/marshalls.h"
const char *GDFunctions::get_func_name(Function p_func) {
ERR_FAIL_INDEX_V(p_func,FUNC_MAX,"");
static const char *_names[FUNC_MAX]={
"sin",
"cos",
"tan",
"sinh",
"cosh",
"tanh",
"asin",
"acos",
"atan",
"atan2",
"sqrt",
"fmod",
"fposmod",
"floor",
"ceil",
"round",
"abs",
"sign",
"pow",
"log",
"exp",
"is_nan",
"is_inf",
"ease",
"decimals",
"stepify",
"lerp",
"dectime",
"randomize",
"randi",
"randf",
"rand_range",
"seed",
"rand_seed",
"deg2rad",
"rad2deg",
"linear2db",
"db2linear",
"max",
"min",
"clamp",
"nearest_po2",
"weakref",
"funcref",
"convert",
"typeof",
"type_exists",
"char",
"str",
"print",
"printt",
"prints",
"printerr",
"printraw",
"var2str",
"str2var",
"var2bytes",
"bytes2var",
"range",
"load",
"inst2dict",
"dict2inst",
"hash",
"Color8",
"print_stack",
"instance_from_id",
};
return _names[p_func];
}
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(*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;
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(*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::step_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_SEED: {
VALIDATE_ARG_COUNT(1);
VALIDATE_ARG_NUM(0);
uint32_t seed=*p_args[0];
Math::seed(seed);
r_ret=Variant();
} 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;
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);
ByteArray 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);
{
ByteArray::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::RAW_ARRAY) {
r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
r_error.argument=0;
r_error.expected=Variant::RAW_ARRAY;
r_ret=Variant();
return;
}
ByteArray varr=*p_args[0];
Variant ret;
{
ByteArray::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::RAW_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(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) {
r_ret=RTR("step argument is zero!");
r_error.error=Variant::CallError::CALL_ERROR_INVALID_METHOD;
return;
}
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;
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_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(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;
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 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 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;
}
}
bool GDFunctions::is_deterministic(Function p_func) {
//man i couldn't have chosen a worse function name,
//way too controversial..
switch(p_func) {
case MATH_SIN:
case MATH_COS:
case MATH_TAN:
case MATH_SINH:
case MATH_COSH:
case MATH_TANH:
case MATH_ASIN:
case MATH_ACOS:
case MATH_ATAN:
case MATH_ATAN2:
case MATH_SQRT:
case MATH_FMOD:
case MATH_FPOSMOD:
case MATH_FLOOR:
case MATH_CEIL:
case MATH_ROUND:
case MATH_ABS:
case MATH_SIGN:
case MATH_POW:
case MATH_LOG:
case MATH_EXP:
case MATH_ISNAN:
case MATH_ISINF:
case MATH_EASE:
case MATH_DECIMALS:
case MATH_STEPIFY:
case MATH_LERP:
case MATH_DECTIME:
case MATH_DEG2RAD:
case MATH_RAD2DEG:
case MATH_LINEAR2DB:
case MATH_DB2LINEAR:
case LOGIC_MAX:
case LOGIC_MIN:
case LOGIC_CLAMP:
case LOGIC_NEAREST_PO2:
case TYPE_CONVERT:
case TYPE_OF:
case TYPE_EXISTS:
case TEXT_CHAR:
case TEXT_STR:
case COLOR8:
// enable for debug only, otherwise not desirable - case GEN_RANGE:
return true;
default:
return false;
}
return false;
}
MethodInfo GDFunctions::get_info(Function p_func) {
#ifdef TOOLS_ENABLED
//using a switch, so the compiler generates a jumptable
switch(p_func) {
case MATH_SIN: {
MethodInfo mi("sin",PropertyInfo(Variant::REAL,"s"));
mi.return_val.type=Variant::REAL;
return mi;
} break;
case MATH_COS: {
MethodInfo mi("cos",PropertyInfo(Variant::REAL,"s"));
mi.return_val.type=Variant::REAL;
return mi;
} break;
case MATH_TAN: {
MethodInfo mi("tan",PropertyInfo(Variant::REAL,"s"));
mi.return_val.type=Variant::REAL;
return mi;
} break;
case MATH_SINH: {
MethodInfo mi("sinh",PropertyInfo(Variant::REAL,"s"));
mi.return_val.type=Variant::REAL;
return mi;
} break;
case MATH_COSH: {
MethodInfo mi("cosh",PropertyInfo(Variant::REAL,"s"));
mi.return_val.type=Variant::REAL;
return mi;
} break;
case MATH_TANH: {
MethodInfo mi("tanh",PropertyInfo(Variant::REAL,"s"));
mi.return_val.type=Variant::REAL;
return mi;
} break;
case MATH_ASIN: {
MethodInfo mi("asin",PropertyInfo(Variant::REAL,"s"));
mi.return_val.type=Variant::REAL;
return mi;
} break;
case MATH_ACOS: {
MethodInfo mi("acos",PropertyInfo(Variant::REAL,"s"));
mi.return_val.type=Variant::REAL;
return mi;
} break;
case MATH_ATAN: {
MethodInfo mi("atan",PropertyInfo(Variant::REAL,"s"));
mi.return_val.type=Variant::REAL;
return mi;
} break;
case MATH_ATAN2: {
MethodInfo mi("atan2",PropertyInfo(Variant::REAL,"x"),PropertyInfo(Variant::REAL,"y"));
mi.return_val.type=Variant::REAL;
return mi;
} break;
case MATH_SQRT: {
MethodInfo mi("sqrt",PropertyInfo(Variant::REAL,"s"));
mi.return_val.type=Variant::REAL;
return mi;
} break;
case MATH_FMOD: {
MethodInfo mi("fmod",PropertyInfo(Variant::REAL,"x"),PropertyInfo(Variant::REAL,"y"));
mi.return_val.type=Variant::REAL;
return mi;
} break;
case MATH_FPOSMOD: {
MethodInfo mi("fposmod",PropertyInfo(Variant::REAL,"x"),PropertyInfo(Variant::REAL,"y"));
mi.return_val.type=Variant::REAL;
return mi;
} break;
case MATH_FLOOR: {
MethodInfo mi("floor",PropertyInfo(Variant::REAL,"s"));
mi.return_val.type=Variant::REAL;
return mi;
} break;
case MATH_CEIL: {
MethodInfo mi("ceil",PropertyInfo(Variant::REAL,"s"));
mi.return_val.type=Variant::REAL;
return mi;
} break;
case MATH_ROUND: {
MethodInfo mi("round",PropertyInfo(Variant::REAL,"s"));
mi.return_val.type=Variant::REAL;
return mi;
} break;
case MATH_ABS: {
MethodInfo mi("abs",PropertyInfo(Variant::REAL,"s"));
mi.return_val.type=Variant::REAL;
return mi;
} break;
case MATH_SIGN: {
MethodInfo mi("sign",PropertyInfo(Variant::REAL,"s"));
mi.return_val.type=Variant::REAL;
return mi;
} break;
case MATH_POW: {
MethodInfo mi("pow",PropertyInfo(Variant::REAL,"x"),PropertyInfo(Variant::REAL,"y"));
mi.return_val.type=Variant::REAL;
return mi;
} break;
case MATH_LOG: {
MethodInfo mi("log",PropertyInfo(Variant::REAL,"s"));
mi.return_val.type=Variant::REAL;
return mi;
} break;
case MATH_EXP: {
MethodInfo mi("exp",PropertyInfo(Variant::REAL,"s"));
mi.return_val.type=Variant::REAL;
return mi;
} break;
case MATH_ISNAN: {
MethodInfo mi("is_nan",PropertyInfo(Variant::REAL,"s"));
mi.return_val.type=Variant::REAL;
return mi;
} break;
case MATH_ISINF: {
MethodInfo mi("is_inf",PropertyInfo(Variant::REAL,"s"));
mi.return_val.type=Variant::REAL;
return mi;
} break;
case MATH_EASE: {
MethodInfo mi("ease",PropertyInfo(Variant::REAL,"s"),PropertyInfo(Variant::REAL,"curve"));
mi.return_val.type=Variant::REAL;
return mi;
} break;
case MATH_DECIMALS: {
MethodInfo mi("decimals",PropertyInfo(Variant::REAL,"step"));
mi.return_val.type=Variant::REAL;
return mi;
} break;
case MATH_STEPIFY: {
MethodInfo mi("stepify",PropertyInfo(Variant::REAL,"s"),PropertyInfo(Variant::REAL,"step"));
mi.return_val.type=Variant::REAL;
return mi;
} break;
case MATH_LERP: {
MethodInfo mi("lerp",PropertyInfo(Variant::REAL,"from"),PropertyInfo(Variant::REAL,"to"), PropertyInfo(Variant::REAL,"weight"));
mi.return_val.type=Variant::REAL;
return mi;
} break;
case MATH_DECTIME: {
MethodInfo mi("dectime",PropertyInfo(Variant::REAL,"value"),PropertyInfo(Variant::REAL,"amount"),PropertyInfo(Variant::REAL,"step"));
mi.return_val.type=Variant::REAL;
return mi;
} break;
case MATH_RANDOMIZE: {
MethodInfo mi("randomize");
mi.return_val.type=Variant::NIL;
return mi;
} break;
case MATH_RAND: {
MethodInfo mi("randi");
mi.return_val.type=Variant::INT;
return mi;
} break;
case MATH_RANDF: {
MethodInfo mi("randf");
mi.return_val.type=Variant::REAL;
return mi;
} break;
case MATH_RANDOM: {
MethodInfo mi("rand_range",PropertyInfo(Variant::REAL,"from"),PropertyInfo(Variant::REAL,"to"));
mi.return_val.type=Variant::REAL;
return mi;
} break;
case MATH_SEED: {
MethodInfo mi("seed",PropertyInfo(Variant::INT,"seed"));
mi.return_val.type=Variant::NIL;
return mi;
} break;
case MATH_RANDSEED: {
MethodInfo mi("rand_seed",PropertyInfo(Variant::INT,"seed"));
mi.return_val.type=Variant::ARRAY;
return mi;
} break;
case MATH_DEG2RAD: {
MethodInfo mi("deg2rad",PropertyInfo(Variant::REAL,"deg"));
mi.return_val.type=Variant::REAL;
return mi;
} break;
case MATH_RAD2DEG: {
MethodInfo mi("rad2deg",PropertyInfo(Variant::REAL,"rad"));
mi.return_val.type=Variant::REAL;
return mi;
} break;
case MATH_LINEAR2DB: {
MethodInfo mi("linear2db",PropertyInfo(Variant::REAL,"nrg"));
mi.return_val.type=Variant::REAL;
return mi;
} break;
case MATH_DB2LINEAR: {
MethodInfo mi("db2linear",PropertyInfo(Variant::REAL,"db"));
mi.return_val.type=Variant::REAL;
return mi;
} break;
case LOGIC_MAX: {
MethodInfo mi("max",PropertyInfo(Variant::REAL,"a"),PropertyInfo(Variant::REAL,"b"));
mi.return_val.type=Variant::REAL;
return mi;
} break;
case LOGIC_MIN: {
MethodInfo mi("min",PropertyInfo(Variant::REAL,"a"),PropertyInfo(Variant::REAL,"b"));
mi.return_val.type=Variant::REAL;
return mi;
} break;
case LOGIC_CLAMP: {
MethodInfo mi("clamp",PropertyInfo(Variant::REAL,"val"),PropertyInfo(Variant::REAL,"min"),PropertyInfo(Variant::REAL,"max"));
mi.return_val.type=Variant::REAL;
return mi;
} break;
case LOGIC_NEAREST_PO2: {
MethodInfo mi("nearest_po2",PropertyInfo(Variant::INT,"val"));
mi.return_val.type=Variant::INT;
return mi;
} break;
case OBJ_WEAKREF: {
MethodInfo mi("weakref",PropertyInfo(Variant::OBJECT,"obj"));
mi.return_val.type=Variant::OBJECT;
mi.return_val.name="WeakRef";
return mi;
} break;
case FUNC_FUNCREF: {
MethodInfo mi("funcref",PropertyInfo(Variant::OBJECT,"instance"),PropertyInfo(Variant::STRING,"funcname"));
mi.return_val.type=Variant::OBJECT;
mi.return_val.name="FuncRef";
return mi;
} break;
case TYPE_CONVERT: {
MethodInfo mi("convert",PropertyInfo(Variant::NIL,"what"),PropertyInfo(Variant::INT,"type"));
mi.return_val.type=Variant::OBJECT;
return mi;
} break;
case TYPE_OF: {
MethodInfo mi("typeof",PropertyInfo(Variant::NIL,"what"));
mi.return_val.type=Variant::INT;
return mi;
} break;
case TYPE_EXISTS: {
MethodInfo mi("type_exists",PropertyInfo(Variant::STRING,"type"));
mi.return_val.type=Variant::BOOL;
return mi;
} break;
case TEXT_CHAR: {
MethodInfo mi("char",PropertyInfo(Variant::INT,"ascii"));
mi.return_val.type=Variant::STRING;
return mi;
} break;
case TEXT_STR: {
MethodInfo mi("str",PropertyInfo(Variant::NIL,"what"),PropertyInfo(Variant::NIL,"..."));
mi.return_val.type=Variant::STRING;
return mi;
} break;
case TEXT_PRINT: {
MethodInfo mi("print",PropertyInfo(Variant::NIL,"what"),PropertyInfo(Variant::NIL,"..."));
mi.return_val.type=Variant::NIL;
return mi;
} break;
case TEXT_PRINT_TABBED: {
MethodInfo mi("printt",PropertyInfo(Variant::NIL,"what"),PropertyInfo(Variant::NIL,"..."));
mi.return_val.type=Variant::NIL;
return mi;
} break;
case TEXT_PRINT_SPACED: {
MethodInfo mi("prints",PropertyInfo(Variant::NIL,"what"),PropertyInfo(Variant::NIL,"..."));
mi.return_val.type=Variant::NIL;
return mi;
} break;
case TEXT_PRINTERR: {
MethodInfo mi("printerr",PropertyInfo(Variant::NIL,"what"),PropertyInfo(Variant::NIL,"..."));
mi.return_val.type=Variant::NIL;
return mi;
} break;
case TEXT_PRINTRAW: {
MethodInfo mi("printraw",PropertyInfo(Variant::NIL,"what"),PropertyInfo(Variant::NIL,"..."));
mi.return_val.type=Variant::NIL;
return mi;
} break;
case VAR_TO_STR: {
MethodInfo mi("var2str",PropertyInfo(Variant::NIL,"var"));
mi.return_val.type=Variant::STRING;
return mi;
} break;
case STR_TO_VAR: {
MethodInfo mi("str2var:Variant",PropertyInfo(Variant::STRING,"string"));
mi.return_val.type=Variant::NIL;
return mi;
} break;
case VAR_TO_BYTES: {
MethodInfo mi("var2bytes",PropertyInfo(Variant::NIL,"var"));
mi.return_val.type=Variant::RAW_ARRAY;
return mi;
} break;
case BYTES_TO_VAR: {
MethodInfo mi("bytes2var:Variant",PropertyInfo(Variant::RAW_ARRAY,"bytes"));
mi.return_val.type=Variant::NIL;
return mi;
} break;
case GEN_RANGE: {
MethodInfo mi("range",PropertyInfo(Variant::NIL,"..."));
mi.return_val.type=Variant::ARRAY;
return mi;
} break;
case RESOURCE_LOAD: {
MethodInfo mi("load",PropertyInfo(Variant::STRING,"path"));
mi.return_val.type=Variant::OBJECT;
mi.return_val.name="Resource";
return mi;
} break;
case INST2DICT: {
MethodInfo mi("inst2dict",PropertyInfo(Variant::OBJECT,"inst"));
mi.return_val.type=Variant::DICTIONARY;
return mi;
} break;
case DICT2INST: {
MethodInfo mi("dict2inst",PropertyInfo(Variant::DICTIONARY,"dict"));
mi.return_val.type=Variant::OBJECT;
return mi;
} break;
case HASH: {
MethodInfo mi("hash",PropertyInfo(Variant::NIL,"var:Variant"));
mi.return_val.type=Variant::INT;
return mi;
} break;
case COLOR8: {
MethodInfo mi("Color8",PropertyInfo(Variant::INT,"r8"),PropertyInfo(Variant::INT,"g8"),PropertyInfo(Variant::INT,"b8"),PropertyInfo(Variant::INT,"a8"));
mi.return_val.type=Variant::COLOR;
return mi;
} break;
case PRINT_STACK: {
MethodInfo mi("print_stack");
mi.return_val.type=Variant::NIL;
return mi;
} break;
case INSTANCE_FROM_ID: {
MethodInfo mi("instance_from_id",PropertyInfo(Variant::INT,"instance_id"));
mi.return_val.type=Variant::OBJECT;
return mi;
} break;
case FUNC_MAX: {
ERR_FAIL_V(MethodInfo());
} break;
}
#endif
return MethodInfo();
}
Reference in a new issue View git blame Copy permalink