godotengine
/
godot
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
godot/modules/gdscript/gd_functions.cpp

1421 lines
33 KiB
C++
Raw Normal View History

GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
/*************************************************************************/
/* gd_functions.cpp */
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* http://www.godotengine.org */
/*************************************************************************/
Updated copyright year in all headers
2015-04-18 17:38:54 +00:00
/* Copyright (c) 2007-2015 Juan Linietsky, Ariel Manzur. */
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
/* */
/* 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"
-fix bug in cache for atlas import/export -fix some menus -fixed bug in out transition curves -detect and remove file:/// in collada -remove multiscript for now -remove dependencies on mouse in OS, moved to Input -avoid fscache from screwing up (fix might make it slower, but it works) -funcref was missing, it's there now
2014-03-14 01:57:24 +00:00
#include "func_ref.h"
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
#include "os/os.h"
-Changed var2str and str2var in GDScript to use VariantWriter and VariantParser -It is now finally possible to parse back a variant from text!
2015-12-31 03:54:00 +00:00
#include "variant_parser.h"
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
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",
Add seed/get_inst function for GDScript seed -> Math::seed get_inst -> ObjectDB::get_instance
2015-03-25 03:01:12 +00:00
"seed",
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
"rand_seed",
"deg2rad",
"rad2deg",
"linear2db",
"db2linear",
"max",
"min",
"clamp",
"nearest_po2",
"weakref",
-fix bug in cache for atlas import/export -fix some menus -fixed bug in out transition curves -detect and remove file:/// in collada -remove multiscript for now -remove dependencies on mouse in OS, moved to Input -avoid fscache from screwing up (fix might make it slower, but it works) -funcref was missing, it's there now
2014-03-14 01:57:24 +00:00
"funcref",
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
"convert",
"typeof",
"str",
"print",
"printt",
-Added prints() function, fixes #1132, #1859 -Tabs work inside built-in log window, fixes #1867
2015-05-09 21:09:58 +00:00
"prints",
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
"printerr",
"printraw",
begin new serialization framework also got rid of STL dependency on triangulator
2015-02-15 04:19:46 +00:00
"var2str",
"str2var",
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
"range",
-project settings are saved when changed -load() was in the GDScript docs but missing in the scripting-different music for platformer 2D and 3D -fix how documentation is generated, built in doc browser should be always up to date -copypaste, scrolling, etc in builtin doc -built-in scripts get saved now (though debugger may not always work on them) -Theme can be set to controls as a property
2014-02-16 00:16:33 +00:00
"load",
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
"inst2dict",
"dict2inst",
-Added Color8(r8,g8,b8,a8) function as well as .r8,.g8,.b8,.a8 members to Color, to deal with colors in the 0-255 range. Closes #2345
2015-12-31 21:26:49 +00:00
"Color8",
More 3D Work -=-=-=-=-=- -ESM Shadow Mapping for softer and less glitchy shadows -HDR Pipeline (convert to Linear on texture import, convert to SRGB at the end) -Fix to xml parse bug
2014-06-16 13:22:26 +00:00
"hash",
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
"print_stack",
-renamed function to get object from instance id -added function to get list of tiles used
2015-04-18 17:00:15 +00:00
"instance_from_id",
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
};
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;\
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;
Add seed/get_inst function for GDScript seed -> Math::seed get_inst -> ObjectDB::get_instance
2015-03-25 03:01:12 +00:00
case MATH_SEED: {
VALIDATE_ARG_COUNT(1);
VALIDATE_ARG_NUM(0);
uint32_t seed=*p_args[0];
Math::seed(seed);
r_ret=Variant();
} break;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
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;
}
-fix bug in cache for atlas import/export -fix some menus -fixed bug in out transition curves -detect and remove file:/// in collada -remove multiscript for now -remove dependencies on mouse in OS, moved to Input -avoid fscache from screwing up (fix might make it slower, but it works) -funcref was missing, it's there now
2014-03-14 01:57:24 +00:00
} 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;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
} 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();;
force thread model to single-safe when running editor, fixes #2387
2015-12-31 19:24:27 +00:00
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
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();
-Added prints() function, fixes #1132, #1859 -Tabs work inside built-in log window, fixes #1867
2015-05-09 21:09:58 +00:00
} 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();
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
} 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";
fix printraw to make it actually print raw
2015-04-06 11:57:31 +00:00
OS::get_singleton()->print("%s",str.utf8().get_data());
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
r_ret=Variant();
} break;
begin new serialization framework also got rid of STL dependency on triangulator
2015-02-15 04:19:46 +00:00
case VAR_TO_STR: {
VALIDATE_ARG_COUNT(1);
-Changed var2str and str2var in GDScript to use VariantWriter and VariantParser -It is now finally possible to parse back a variant from text!
2015-12-31 03:54:00 +00:00
String vars;
VariantWriter::write_to_string(*p_args[0],vars);
r_ret=vars;
begin new serialization framework also got rid of STL dependency on triangulator
2015-02-15 04:19:46 +00:00
} 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;
}
-Changed var2str and str2var in GDScript to use VariantWriter and VariantParser -It is now finally possible to parse back a variant from text!
2015-12-31 03:54:00 +00:00
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=Variant();
}
begin new serialization framework also got rid of STL dependency on triangulator
2015-02-15 04:19:46 +00:00
} break;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
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;
-project settings are saved when changed -load() was in the GDScript docs but missing in the scripting-different music for platformer 2D and 3D -fix how documentation is generated, built in doc browser should be always up to date -copypaste, scrolling, etc in builtin doc -built-in scripts get saved now (though debugger may not always work on them) -Theme can be set to controls as a property
2014-02-16 00:16:33 +00:00
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]);
-fix bug in cache for atlas import/export -fix some menus -fixed bug in out transition curves -detect and remove file:/// in collada -remove multiscript for now -remove dependencies on mouse in OS, moved to Input -avoid fscache from screwing up (fix might make it slower, but it works) -funcref was missing, it's there now
2014-03-14 01:57:24 +00:00
} break;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
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);
Make dict2inst set internal members of instance Fix #2490
2015-09-20 19:17:30 +00:00
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()];
}
}
More 3D Work -=-=-=-=-=- -ESM Shadow Mapping for softer and less glitchy shadows -HDR Pipeline (convert to Linear on texture import, convert to SRGB at the end) -Fix to xml parse bug
2014-06-16 13:22:26 +00:00
} break;
case HASH: {
VALIDATE_ARG_COUNT(1);
r_ret=p_args[0]->hash();
-Added Color8(r8,g8,b8,a8) function as well as .r8,.g8,.b8,.a8 members to Color, to deal with colors in the 0-255 range. Closes #2345
2015-12-31 21:26:49 +00:00
} break;
case COLOR8: {
if (p_arg_count<3) {
r_error.error=Variant::CallError::CALL_ERROR_TOO_FEW_ARGUMENTS;
r_error.argument=3;
return;
}
if (p_arg_count>4) {
r_error.error=Variant::CallError::CALL_ERROR_TOO_MANY_ARGUMENTS;
r_error.argument=4;
return;
}
VALIDATE_ARG_NUM(0);
VALIDATE_ARG_NUM(1);
VALIDATE_ARG_NUM(2);
Color color(*p_args[0],*p_args[1],*p_args[2]);
if (p_arg_count==4) {
VALIDATE_ARG_NUM(3);
color.a=*p_args[3];
}
r_ret=color;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
} 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;
-renamed function to get object from instance id -added function to get list of tiles used
2015-04-18 17:00:15 +00:00
case INSTANCE_FROM_ID: {
Add seed/get_inst function for GDScript seed -> Math::seed get_inst -> ObjectDB::get_instance
2015-03-25 03:01:12 +00:00
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_ret=Variant();
break;
}
uint32_t id=*p_args[0];
r_ret=ObjectDB::get_instance(id);
} break;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
case FUNC_MAX: {
ERR_FAIL_V();
} 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 TEXT_STR:
-Added Color8(r8,g8,b8,a8) function as well as .r8,.g8,.b8,.a8 members to Color, to deal with colors in the 0-255 range. Closes #2345
2015-12-31 21:26:49 +00:00
case COLOR8:
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
// 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("isnan",PropertyInfo(Variant::REAL,"s"));
mi.return_val.type=Variant::REAL;
return mi;
} break;
case MATH_ISINF: {
MethodInfo mi("isinf",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: {
Updated the variable in the lerp function to be weight instead of percent.
2015-02-20 21:28:48 +00:00
MethodInfo mi("lerp",PropertyInfo(Variant::REAL,"from"),PropertyInfo(Variant::REAL,"to"), PropertyInfo(Variant::REAL,"weight"));
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
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: {
-Support for changing fonts -Detect when free() might crash the project and throw error -fixed 2D Bounce in physics (3d still broken) -renamed “on_top” property to “behind_parent”, which makes more sense, old on_top remains there for compatibility but is invisible. -large amount of fixes
2014-04-05 15:39:30 +00:00
MethodInfo mi("randi");
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
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;
Add seed/get_inst function for GDScript seed -> Math::seed get_inst -> ObjectDB::get_instance
2015-03-25 03:01:12 +00:00
case MATH_SEED: {
MethodInfo mi("seed",PropertyInfo(Variant::REAL,"seed"));
mi.return_val.type=Variant::NIL;
return mi;
} break;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
case MATH_RANDSEED: {
MethodInfo mi("rand_seed",PropertyInfo(Variant::REAL,"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;
-Work in progress visual shader editor *DOES NOT WORK YET*
2015-01-03 19:52:37 +00:00
mi.return_val.name="WeakRef";
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return mi;
} break;
-fix bug in cache for atlas import/export -fix some menus -fixed bug in out transition curves -detect and remove file:/// in collada -remove multiscript for now -remove dependencies on mouse in OS, moved to Input -avoid fscache from screwing up (fix might make it slower, but it works) -funcref was missing, it's there now
2014-03-14 01:57:24 +00:00
case FUNC_FUNCREF: {
MethodInfo mi("funcref",PropertyInfo(Variant::OBJECT,"instance"),PropertyInfo(Variant::STRING,"funcname"));
mi.return_val.type=Variant::OBJECT;
-Work in progress visual shader editor *DOES NOT WORK YET*
2015-01-03 19:52:37 +00:00
mi.return_val.name="FuncRef";
-fix bug in cache for atlas import/export -fix some menus -fixed bug in out transition curves -detect and remove file:/// in collada -remove multiscript for now -remove dependencies on mouse in OS, moved to Input -avoid fscache from screwing up (fix might make it slower, but it works) -funcref was missing, it's there now
2014-03-14 01:57:24 +00:00
return mi;
} break;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
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;
};
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;
-Added prints() function, fixes #1132, #1859 -Tabs work inside built-in log window, fixes #1867
2015-05-09 21:09:58 +00:00
} break;
case TEXT_PRINT_SPACED: {
MethodInfo mi("prints",PropertyInfo(Variant::NIL,"what"),PropertyInfo(Variant::NIL,"..."));
mi.return_val.type=Variant::NIL;
return mi;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
} 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;
begin new serialization framework also got rid of STL dependency on triangulator
2015-02-15 04:19:46 +00:00
case VAR_TO_STR: {
MethodInfo mi("var2str",PropertyInfo(Variant::NIL,"var"));
mi.return_val.type=Variant::STRING;
return mi;
} break;
case STR_TO_VAR: {
replaced :var by :Variant in documentation, fixes #2897
2015-12-14 11:28:01 +00:00
MethodInfo mi("str2var:Variant",PropertyInfo(Variant::STRING,"string"));
begin new serialization framework also got rid of STL dependency on triangulator
2015-02-15 04:19:46 +00:00
mi.return_val.type=Variant::NIL;
return mi;
} break;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
case GEN_RANGE: {
MethodInfo mi("range",PropertyInfo(Variant::NIL,"..."));
mi.return_val.type=Variant::ARRAY;
return mi;
} break;
-project settings are saved when changed -load() was in the GDScript docs but missing in the scripting-different music for platformer 2D and 3D -fix how documentation is generated, built in doc browser should be always up to date -copypaste, scrolling, etc in builtin doc -built-in scripts get saved now (though debugger may not always work on them) -Theme can be set to controls as a property
2014-02-16 00:16:33 +00:00
case RESOURCE_LOAD: {
MethodInfo mi("load",PropertyInfo(Variant::STRING,"path"));
mi.return_val.type=Variant::OBJECT;
-Work in progress visual shader editor *DOES NOT WORK YET*
2015-01-03 19:52:37 +00:00
mi.return_val.name="Resource";
-project settings are saved when changed -load() was in the GDScript docs but missing in the scripting-different music for platformer 2D and 3D -fix how documentation is generated, built in doc browser should be always up to date -copypaste, scrolling, etc in builtin doc -built-in scripts get saved now (though debugger may not always work on them) -Theme can be set to controls as a property
2014-02-16 00:16:33 +00:00
return mi;
} break;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
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;
More 3D Work -=-=-=-=-=- -ESM Shadow Mapping for softer and less glitchy shadows -HDR Pipeline (convert to Linear on texture import, convert to SRGB at the end) -Fix to xml parse bug
2014-06-16 13:22:26 +00:00
case HASH: {
replaced :var by :Variant in documentation, fixes #2897
2015-12-14 11:28:01 +00:00
MethodInfo mi("hash",PropertyInfo(Variant::NIL,"var:Variant"));
More 3D Work -=-=-=-=-=- -ESM Shadow Mapping for softer and less glitchy shadows -HDR Pipeline (convert to Linear on texture import, convert to SRGB at the end) -Fix to xml parse bug
2014-06-16 13:22:26 +00:00
mi.return_val.type=Variant::INT;
return mi;
} break;
-Added Color8(r8,g8,b8,a8) function as well as .r8,.g8,.b8,.a8 members to Color, to deal with colors in the 0-255 range. Closes #2345
2015-12-31 21:26:49 +00:00
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;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
case PRINT_STACK: {
MethodInfo mi("print_stack");
mi.return_val.type=Variant::NIL;
return mi;
} break;
-renamed function to get object from instance id -added function to get list of tiles used
2015-04-18 17:00:15 +00:00
case INSTANCE_FROM_ID: {
MethodInfo mi("instance_from_id",PropertyInfo(Variant::INT,"instance_id"));
Add seed/get_inst function for GDScript seed -> Math::seed get_inst -> ObjectDB::get_instance
2015-03-25 03:01:12 +00:00
mi.return_val.type=Variant::OBJECT;
return mi;
} break;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
case FUNC_MAX: {
ERR_FAIL_V(MethodInfo());
} break;
}
#endif
return MethodInfo();
}