maxmustermann/godot
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
godot/core/object_type_db.cpp
Rémi Verschelde d8223ffa75 Welcome in 2017, dear changelog reader! 
That year should bring the long-awaited OpenGL ES 3.0 compatible renderer
with state-of-the-art rendering techniques tuned to work as low as middle
end handheld devices - without compromising with the possibilities given
for higher end desktop games of course. Great times ahead for the Godot
community and the gamers that will play our games!

(cherry picked from commit c7bc44d5ad)
2017-01-12 19:15:30 +01:00

1004 lines
23 KiB
C++
Raw Blame History

/*************************************************************************/
/* object_type_db.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 "object_type_db.h"
#include "os/mutex.h"
#ifdef NO_THREADS
#define OBJTYPE_LOCK
#else
#define OBJTYPE_LOCK MutexLock _mutex_lock_(lock);
#endif
#ifdef DEBUG_METHODS_ENABLED
ParamDef::ParamDef(const Variant& p_variant) { used=true; val=p_variant; }
MethodDefinition _MD(const char* p_name) {
MethodDefinition md;
md.name=StaticCString::create(p_name);
return md;
}
MethodDefinition _MD(const char* p_name,const char *p_arg1) {
MethodDefinition md;
md.name=StaticCString::create(p_name);
md.args.push_back(StaticCString::create(p_arg1));
return md;
}
MethodDefinition _MD(const char* p_name,const char *p_arg1,const char *p_arg2) {
MethodDefinition md;
md.name=StaticCString::create(p_name);
md.args.resize(2);
md.args[0]=StaticCString::create(p_arg1);
md.args[1]=StaticCString::create(p_arg2);
return md;
}
MethodDefinition _MD(const char* p_name,const char *p_arg1,const char *p_arg2,const char *p_arg3) {
MethodDefinition md;
md.name=StaticCString::create(p_name);
md.args.resize(3);
md.args[0]=StaticCString::create(p_arg1);
md.args[1]=StaticCString::create(p_arg2);
md.args[2]=StaticCString::create(p_arg3);
return md;
}
MethodDefinition _MD(const char* p_name,const char *p_arg1,const char *p_arg2,const char *p_arg3,const char *p_arg4) {
MethodDefinition md;
md.name=StaticCString::create(p_name);
md.args.resize(4);
md.args[0]=StaticCString::create(p_arg1);
md.args[1]=StaticCString::create(p_arg2);
md.args[2]=StaticCString::create(p_arg3);
md.args[3]=StaticCString::create(p_arg4);
return md;
}
MethodDefinition _MD(const char* p_name,const char *p_arg1,const char *p_arg2,const char *p_arg3,const char *p_arg4,const char *p_arg5) {
MethodDefinition md;
md.name=StaticCString::create(p_name);
md.args.resize(5);
md.args[0]=StaticCString::create(p_arg1);
md.args[1]=StaticCString::create(p_arg2);
md.args[2]=StaticCString::create(p_arg3);
md.args[3]=StaticCString::create(p_arg4);
md.args[4]=StaticCString::create(p_arg5);
return md;
}
MethodDefinition _MD(const char* p_name,const char *p_arg1,const char *p_arg2,const char *p_arg3,const char *p_arg4,const char *p_arg5,const char *p_arg6) {
MethodDefinition md;
md.name=StaticCString::create(p_name);
md.args.resize(6);
md.args[0]=StaticCString::create(p_arg1);
md.args[1]=StaticCString::create(p_arg2);
md.args[2]=StaticCString::create(p_arg3);
md.args[3]=StaticCString::create(p_arg4);
md.args[4]=StaticCString::create(p_arg5);
md.args[5]=StaticCString::create(p_arg6);
return md;
}
MethodDefinition _MD(const char* p_name,const char *p_arg1,const char *p_arg2,const char *p_arg3,const char *p_arg4,const char *p_arg5,const char *p_arg6,const char *p_arg7) {
MethodDefinition md;
md.name=StaticCString::create(p_name);
md.args.resize(7);
md.args[0]=StaticCString::create(p_arg1);
md.args[1]=StaticCString::create(p_arg2);
md.args[2]=StaticCString::create(p_arg3);
md.args[3]=StaticCString::create(p_arg4);
md.args[4]=StaticCString::create(p_arg5);
md.args[5]=StaticCString::create(p_arg6);
md.args[6]=StaticCString::create(p_arg7);
return md;
}
MethodDefinition _MD(const char* p_name,const char *p_arg1,const char *p_arg2,const char *p_arg3,const char *p_arg4,const char *p_arg5,const char *p_arg6,const char *p_arg7,const char *p_arg8) {
MethodDefinition md;
md.name=StaticCString::create(p_name);
md.args.resize(8);
md.args[0]=StaticCString::create(p_arg1);
md.args[1]=StaticCString::create(p_arg2);
md.args[2]=StaticCString::create(p_arg3);
md.args[3]=StaticCString::create(p_arg4);
md.args[4]=StaticCString::create(p_arg5);
md.args[5]=StaticCString::create(p_arg6);
md.args[6]=StaticCString::create(p_arg7);
md.args[7]=StaticCString::create(p_arg8);
return md;
}
MethodDefinition _MD(const char* p_name,const char *p_arg1,const char *p_arg2,const char *p_arg3,const char *p_arg4,const char *p_arg5,const char *p_arg6,const char *p_arg7,const char *p_arg8,const char *p_arg9) {
MethodDefinition md;
md.name=StaticCString::create(p_name);
md.args.resize(9);
md.args[0]=StaticCString::create(p_arg1);
md.args[1]=StaticCString::create(p_arg2);
md.args[2]=StaticCString::create(p_arg3);
md.args[3]=StaticCString::create(p_arg4);
md.args[4]=StaticCString::create(p_arg5);
md.args[5]=StaticCString::create(p_arg6);
md.args[6]=StaticCString::create(p_arg7);
md.args[7]=StaticCString::create(p_arg8);
md.args[8]=StaticCString::create(p_arg9);
return md;
}
MethodDefinition _MD(const char* p_name,const char *p_arg1,const char *p_arg2,const char *p_arg3,const char *p_arg4,const char *p_arg5,const char *p_arg6,const char *p_arg7,const char *p_arg8,const char *p_arg9,const char *p_arg10) {
MethodDefinition md;
md.name=StaticCString::create(p_name);
md.args.resize(10);
md.args[0]=StaticCString::create(p_arg1);
md.args[1]=StaticCString::create(p_arg2);
md.args[2]=StaticCString::create(p_arg3);
md.args[3]=StaticCString::create(p_arg4);
md.args[4]=StaticCString::create(p_arg5);
md.args[5]=StaticCString::create(p_arg6);
md.args[6]=StaticCString::create(p_arg7);
md.args[7]=StaticCString::create(p_arg8);
md.args[8]=StaticCString::create(p_arg9);
md.args[9]=StaticCString::create(p_arg10);
return md;
}
#endif
HashMap<StringName,ObjectTypeDB::TypeInfo,StringNameHasher> ObjectTypeDB::types;
HashMap<StringName,StringName,StringNameHasher> ObjectTypeDB::resource_base_extensions;
HashMap<StringName,StringName,StringNameHasher> ObjectTypeDB::compat_types;
ObjectTypeDB::TypeInfo::TypeInfo() {
creation_func=NULL;
inherits_ptr=NULL;
disabled=false;
}
ObjectTypeDB::TypeInfo::~TypeInfo() {
}
bool ObjectTypeDB::is_type(const StringName &p_type,const StringName& p_inherits) {
OBJTYPE_LOCK;
StringName inherits=p_type;
while (inherits.operator String().length()) {
if (inherits==p_inherits)
return true;
inherits=type_inherits_from(inherits);
}
return false;
}
void ObjectTypeDB::get_type_list( List<StringName> *p_types) {
OBJTYPE_LOCK;
const StringName *k=NULL;
while((k=types.next(k))) {
p_types->push_back(*k);
}
p_types->sort();
}
void ObjectTypeDB::get_inheriters_from( const StringName& p_type,List<StringName> *p_types) {
OBJTYPE_LOCK;
const StringName *k=NULL;
while((k=types.next(k))) {
if (*k!=p_type && is_type(*k,p_type))
p_types->push_back(*k);
}
}
StringName ObjectTypeDB::type_inherits_from(const StringName& p_type) {
OBJTYPE_LOCK;
TypeInfo *ti = types.getptr(p_type);
ERR_FAIL_COND_V(!ti,"");
return ti->inherits;
}
bool ObjectTypeDB::type_exists(const StringName &p_type) {
OBJTYPE_LOCK;
return types.has(p_type);
}
void ObjectTypeDB::add_compatibility_type(const StringName& p_type,const StringName& p_fallback) {
compat_types[p_type]=p_fallback;
}
Object *ObjectTypeDB::instance(const StringName &p_type) {
TypeInfo *ti;
{
OBJTYPE_LOCK;
ti=types.getptr(p_type);
if (!ti || ti->disabled || !ti->creation_func) {
if (compat_types.has(p_type)) {
ti=types.getptr(compat_types[p_type]);
}
}
ERR_FAIL_COND_V(!ti,NULL);
ERR_FAIL_COND_V(ti->disabled,NULL);
ERR_FAIL_COND_V(!ti->creation_func,NULL);
}
return ti->creation_func();
}
bool ObjectTypeDB::can_instance(const StringName &p_type) {
OBJTYPE_LOCK;
TypeInfo *ti = types.getptr(p_type);
ERR_FAIL_COND_V(!ti,false);
return (!ti->disabled && ti->creation_func!=NULL);
}
void ObjectTypeDB::_add_type2(const StringName& p_type, const StringName& p_inherits) {
OBJTYPE_LOCK;
StringName name = p_type;
ERR_FAIL_COND(types.has(name));
types[name]=TypeInfo();
TypeInfo &ti=types[name];
ti.name=name;
ti.inherits=p_inherits;
if (ti.inherits) {
ERR_FAIL_COND( !types.has(ti.inherits) ); //it MUST be registered.
ti.inherits_ptr = &types[ti.inherits];
} else {
ti.inherits_ptr=NULL;
}
}
void ObjectTypeDB::get_method_list(StringName p_type,List<MethodInfo> *p_methods,bool p_no_inheritance) {
OBJTYPE_LOCK;
TypeInfo *type=types.getptr(p_type);
while(type) {
if (type->disabled) {
if (p_no_inheritance)
break;
type=type->inherits_ptr;
continue;
}
#ifdef DEBUG_METHODS_ENABLED
for( List<MethodInfo>::Element *E=type->virtual_methods.front();E;E=E->next()) {
p_methods->push_back(E->get());
}
for( List<StringName>::Element *E=type->method_order.front();E;E=E->next()) {
MethodBind *method=type->method_map.get(E->get());
MethodInfo minfo;
minfo.name=E->get();
minfo.id=method->get_method_id();
for (int i=0;i<method->get_argument_count();i++) {
//Variant::Type t=method->get_argument_type(i);
minfo.arguments.push_back(method->get_argument_info(i));
}
if (method->get_argument_type(-1)!=Variant::NIL) {
minfo.return_val=method->get_argument_info(-1);
}
minfo.flags=method->get_hint_flags();
p_methods->push_back(minfo);
}
#else
const StringName *K=NULL;
while((K=type->method_map.next(K))) {
MethodBind*m = type->method_map[*K];
MethodInfo mi;
mi.name=m->get_name();
p_methods->push_back(mi);
}
#endif
if (p_no_inheritance)
break;
type=type->inherits_ptr;
}
}
MethodBind *ObjectTypeDB::get_method(StringName p_type, StringName p_name) {
OBJTYPE_LOCK;
TypeInfo *type=types.getptr(p_type);
while(type) {
MethodBind **method=type->method_map.getptr(p_name);
if (method && *method)
return *method;
type=type->inherits_ptr;
}
return NULL;
}
void ObjectTypeDB::bind_integer_constant(const StringName& p_type, const StringName &p_name, int p_constant) {
OBJTYPE_LOCK;
TypeInfo *type=types.getptr(p_type);
if (!type) {
ERR_FAIL_COND(!type);
}
if (type->constant_map.has(p_name)) {
ERR_FAIL();
}
type->constant_map[p_name]=p_constant;
#ifdef DEBUG_METHODS_ENABLED
type->constant_order.push_back(p_name);
#endif
}
void ObjectTypeDB::get_integer_constant_list(const StringName& p_type, List<String> *p_constants, bool p_no_inheritance) {
OBJTYPE_LOCK;
TypeInfo *type=types.getptr(p_type);
while(type) {
#ifdef DEBUG_METHODS_ENABLED
for(List<StringName>::Element *E=type->constant_order.front();E;E=E->next())
p_constants->push_back(E->get());
#else
const StringName *K=NULL;
while((K=type->constant_map.next(K))) {
p_constants->push_back(*K);
}
#endif
if (p_no_inheritance)
break;
type=type->inherits_ptr;
}
}
int ObjectTypeDB::get_integer_constant(const StringName& p_type, const StringName &p_name, bool *p_success) {
OBJTYPE_LOCK;
TypeInfo *type=types.getptr(p_type);
while(type) {
int *constant=type->constant_map.getptr(p_name);
if (constant) {
if (p_success)
*p_success=true;
return *constant;
}
type=type->inherits_ptr;
}
if (p_success)
*p_success=false;
return 0;
}
void ObjectTypeDB::add_signal(StringName p_type,const MethodInfo& p_signal) {
TypeInfo *type=types.getptr(p_type);
ERR_FAIL_COND(!type);
TypeInfo *check=type;
StringName sname = p_signal.name;
#ifdef DEBUG_METHODS_ENABLED
while(check) {
if (check->signal_map.has(sname)) {
ERR_EXPLAIN("Type "+String(p_type)+" already has signal: "+String(sname));
ERR_FAIL();
}
check=check->inherits_ptr;
}
#endif
type->signal_map[sname]=p_signal;
}
void ObjectTypeDB::get_signal_list(StringName p_type,List<MethodInfo> *p_signals,bool p_no_inheritance) {
TypeInfo *type=types.getptr(p_type);
ERR_FAIL_COND(!type);
TypeInfo *check=type;
while(check) {
const StringName *S=NULL;
while((S=check->signal_map.next(S))) {
p_signals->push_back(check->signal_map[*S]);
}
if (p_no_inheritance)
return;
check=check->inherits_ptr;
}
}
bool ObjectTypeDB::has_signal(StringName p_type,StringName p_signal) {
TypeInfo *type=types.getptr(p_type);
TypeInfo *check=type;
while(check) {
if (check->signal_map.has(p_signal))
return true;
check=check->inherits_ptr;
}
return false;
}
void ObjectTypeDB::add_property(StringName p_type,const PropertyInfo& p_pinfo, const StringName& p_setter, const StringName& p_getter, int p_index) {
TypeInfo *type=types.getptr(p_type);
ERR_FAIL_COND(!type);
MethodBind *mb_set=NULL;
if (p_setter) {
mb_set = get_method(p_type,p_setter);
#ifdef DEBUG_METHODS_ENABLED
if (!mb_set) {
ERR_EXPLAIN("Invalid Setter: "+p_type+"::"+p_setter+" for property: "+p_pinfo.name);
ERR_FAIL_COND(!mb_set);
} else {
int exp_args=1+(p_index>=0?1:0);
if (mb_set->get_argument_count()!=exp_args) {
ERR_EXPLAIN("Invalid Function for Setter: "+p_type+"::"+p_setter+" for property: "+p_pinfo.name);
ERR_FAIL();
}
}
#endif
}
MethodBind *mb_get=NULL;
if (p_getter) {
MethodBind *mb_get = get_method(p_type,p_getter);
#ifdef DEBUG_METHODS_ENABLED
if (!mb_get) {
ERR_EXPLAIN("Invalid Getter: "+p_type+"::"+p_getter+" for property: "+p_pinfo.name);
ERR_FAIL_COND(!mb_get);
} else {
int exp_args=0+(p_index>=0?1:0);
if (mb_get->get_argument_count()!=exp_args) {
ERR_EXPLAIN("Invalid Function for Getter: "+p_type+"::"+p_getter+" for property: "+p_pinfo.name);
ERR_FAIL();
}
}
#endif
}
#ifdef DEBUG_METHODS_ENABLED
if (type->property_setget.has(p_pinfo.name)) {
ERR_EXPLAIN("Object already has property: "+p_type);
ERR_FAIL();
}
#endif
type->property_list.push_back(p_pinfo);
PropertySetGet psg;
psg.setter=p_setter;
psg.getter=p_getter;
psg._setptr=mb_set;
psg._getptr=mb_get;
psg.index=p_index;
psg.type=p_pinfo.type;
type->property_setget[p_pinfo.name]=psg;
}
void ObjectTypeDB::get_property_list(StringName p_type, List<PropertyInfo> *p_list, bool p_no_inheritance,const Object *p_validator) {
TypeInfo *type=types.getptr(p_type);
TypeInfo *check=type;
while(check) {
for(List<PropertyInfo>::Element *E=type->property_list.front();E;E=E->next()) {
if (p_validator) {
PropertyInfo pi = E->get();
p_validator->_validate_property(pi);
p_list->push_back(pi);
} else {
p_list->push_back(E->get());
}
}
if (p_no_inheritance)
return ;
check=check->inherits_ptr;
}
}
bool ObjectTypeDB::set_property(Object* p_object,const StringName& p_property, const Variant& p_value,bool *r_valid) {
TypeInfo *type=types.getptr(p_object->get_type_name());
TypeInfo *check=type;
while(check) {
const PropertySetGet *psg = check->property_setget.getptr(p_property);
if (psg) {
if (!psg->setter) {
if (r_valid)
*r_valid=false;
return true; //return true but do nothing
}
Variant::CallError ce;
if (psg->index>=0) {
Variant index=psg->index;
const Variant* arg[2]={&index,&p_value};
// p_object->call(psg->setter,arg,2,ce);
if (psg->_setptr) {
psg->_setptr->call(p_object,arg,2,ce);
} else {
p_object->call(psg->setter,arg,2,ce);
}
} else {
const Variant* arg[1]={&p_value};
if (psg->_setptr) {
psg->_setptr->call(p_object,arg,1,ce);
} else {
p_object->call(psg->setter,arg,1,ce);
}
}
if (r_valid)
*r_valid=ce.error==Variant::CallError::CALL_OK;
return true;
}
check=check->inherits_ptr;
}
return false;
}
bool ObjectTypeDB::get_property(Object* p_object,const StringName& p_property, Variant& r_value) {
TypeInfo *type=types.getptr(p_object->get_type_name());
TypeInfo *check=type;
while(check) {
const PropertySetGet *psg = check->property_setget.getptr(p_property);
if (psg) {
if (!psg->getter)
return true; //return true but do nothing
if (psg->index>=0) {
Variant index=psg->index;
const Variant* arg[1]={&index};
Variant::CallError ce;
r_value = p_object->call(psg->getter,arg,1,ce);
} else {
Variant::CallError ce;
if (psg->_getptr) {
r_value = psg->_getptr->call(p_object,NULL,0,ce);
} else {
r_value = p_object->call(psg->getter,NULL,0,ce);
}
}
return true;
}
const int *c =check->constant_map.getptr(p_property);
if (c) {
r_value=*c;
return true;
}
//if (check->constant_map.fin)
check=check->inherits_ptr;
}
return false;
}
Variant::Type ObjectTypeDB::get_property_type(const StringName& p_type, const StringName& p_property,bool *r_is_valid) {
TypeInfo *type=types.getptr(p_type);
TypeInfo *check=type;
while(check) {
const PropertySetGet *psg = check->property_setget.getptr(p_property);
if (psg) {
if (r_is_valid)
*r_is_valid=true;
return psg->type;
}
check=check->inherits_ptr;
}
if (r_is_valid)
*r_is_valid=false;
return Variant::NIL;
}
void ObjectTypeDB::set_method_flags(StringName p_type,StringName p_method,int p_flags) {
TypeInfo *type=types.getptr(p_type);
TypeInfo *check=type;
ERR_FAIL_COND(!check);
ERR_FAIL_COND(!check->method_map.has(p_method));
check->method_map[p_method]->set_hint_flags(p_flags);
}
bool ObjectTypeDB::has_method(StringName p_type,StringName p_method,bool p_no_inheritance) {
TypeInfo *type=types.getptr(p_type);
TypeInfo *check=type;
while(check) {
if (check->method_map.has(p_method))
return true;
if (p_no_inheritance)
return false;
check=check->inherits_ptr;
}
return false;
}
bool ObjectTypeDB::get_setter_and_type_for_property(const StringName& p_class, const StringName& p_prop, StringName& r_class, StringName& r_setter) {
TypeInfo *type=types.getptr(p_class);
TypeInfo *check=type;
while(check) {
if (check->property_setget.has(p_prop)) {
r_class=check->name;
r_setter=check->property_setget[p_prop].setter;
return true;
}
check=check->inherits_ptr;
}
return false;
}
#ifdef DEBUG_METHODS_ENABLED
MethodBind* ObjectTypeDB::bind_methodfi(uint32_t p_flags, MethodBind *p_bind , const MethodDefinition &method_name, const Variant **p_defs, int p_defcount) {
StringName mdname=method_name.name;
#else
MethodBind* ObjectTypeDB::bind_methodfi(uint32_t p_flags, MethodBind *p_bind , const char *method_name, const Variant **p_defs, int p_defcount) {
StringName mdname=StaticCString::create(method_name);
#endif
StringName rettype;
if (mdname.operator String().find(":")!=-1) {
rettype = mdname.operator String().get_slice(":",1);
mdname = mdname.operator String().get_slice(":",0);
}
OBJTYPE_LOCK;
ERR_FAIL_COND_V(!p_bind,NULL);
p_bind->set_name(mdname);
String instance_type=p_bind->get_instance_type();
TypeInfo *type=types.getptr(instance_type);
if (!type) {
ERR_PRINTS("Couldn't bind method '"+mdname+"' for instance: "+instance_type);
memdelete(p_bind);
ERR_FAIL_COND_V(!type,NULL);
}
if (type->method_map.has(mdname)) {
memdelete(p_bind);
// overloading not supported
ERR_EXPLAIN("Method already bound: "+instance_type+"::"+mdname);
ERR_FAIL_V(NULL);
}
#ifdef DEBUG_METHODS_ENABLED
p_bind->set_argument_names(method_name.args);
p_bind->set_return_type(rettype);
type->method_order.push_back(mdname);
#endif
type->method_map[mdname]=p_bind;
Vector<Variant> defvals;
#define PARSE_DEFVAL(m_defval)\
if (d##m_defval.used) defvals.insert(0,d##m_defval.val);\
else goto set_defvals;
defvals.resize(p_defcount);
for(int i=0;i<p_defcount;i++) {
defvals[i]=*p_defs[p_defcount-i-1];
}
set_defvals:
p_bind->set_default_arguments(defvals);
p_bind->set_hint_flags(p_flags);
#undef PARSE_DEFVAL
return p_bind;
}
void ObjectTypeDB::add_virtual_method(const StringName& p_type, const MethodInfo& p_method , bool p_virtual) {
ERR_FAIL_COND(!types.has(p_type));
#ifdef DEBUG_METHODS_ENABLED
MethodInfo mi=p_method;
if (p_virtual)
mi.flags|=METHOD_FLAG_VIRTUAL;
types[p_type].virtual_methods.push_back(mi);
#endif
}
void ObjectTypeDB::get_virtual_methods(const StringName& p_type, List<MethodInfo> * p_methods , bool p_no_inheritance) {
ERR_FAIL_COND(!types.has(p_type));
#ifdef DEBUG_METHODS_ENABLED
TypeInfo *type=types.getptr(p_type);
TypeInfo *check=type;
while(check) {
for(List<MethodInfo>::Element *E=check->virtual_methods.front();E;E=E->next()) {
p_methods->push_back(E->get());
}
if (p_no_inheritance)
return;
check=check->inherits_ptr;
}
#endif
}
void ObjectTypeDB::set_type_enabled(StringName p_type,bool p_enable) {
ERR_FAIL_COND(!types.has(p_type));
types[p_type].disabled=!p_enable;
}
bool ObjectTypeDB::is_type_enabled(StringName p_type) {
TypeInfo *ti=types.getptr(p_type);
if (!ti || !ti->creation_func) {
if (compat_types.has(p_type)) {
ti=types.getptr(compat_types[p_type]);
}
}
ERR_FAIL_COND_V(!ti,false);
return !ti->disabled;
}
StringName ObjectTypeDB::get_category(const StringName& p_node) {
ERR_FAIL_COND_V(!types.has(p_node),StringName());
#ifdef DEBUG_ENABLED
return types[p_node].category;
#else
return StringName();
#endif
}
void ObjectTypeDB::add_resource_base_extension(const StringName& p_extension,const StringName& p_type) {
if (resource_base_extensions.has(p_extension))
return;
resource_base_extensions[p_extension]=p_type;
}
void ObjectTypeDB::get_resource_base_extensions(List<String> *p_extensions) {
const StringName *K=NULL;
while((K=resource_base_extensions.next(K))) {
p_extensions->push_back(*K);
}
}
void ObjectTypeDB::get_extensions_for_type(const StringName& p_type,List<String> *p_extensions) {
const StringName *K=NULL;
while((K=resource_base_extensions.next(K))) {
StringName cmp = resource_base_extensions[*K];
if (is_type(cmp,p_type))
p_extensions->push_back(*K);
}
}
Mutex *ObjectTypeDB::lock=NULL;
void ObjectTypeDB::init() {
#ifndef NO_THREADS
lock = Mutex::create();
#endif
}
void ObjectTypeDB::cleanup() {
#ifndef NO_THREADS
memdelete(lock);
#endif
//OBJTYPE_LOCK; hah not here
const StringName *k=NULL;
while((k=types.next(k))) {
TypeInfo &ti=types[*k];
const StringName *m=NULL;
while((m=ti.method_map.next(m))) {
memdelete( ti.method_map[*m] );
}
}
types.clear();
resource_base_extensions.clear();
compat_types.clear();
}
//
Reference in a new issue View git blame Copy permalink