Variant::operator Node*() const {
if (type==OBJECT)
return _get_obj().obj?_get_obj().obj->cast_to<Node>():NULL;
else
return NULL;
}
Variant::operator Control*() const {
if (type==OBJECT)
return _get_obj().obj?_get_obj().obj->cast_to<Control>():NULL;
else
return NULL;
}
Variant::Variant(const RefPtr& p_resource) {
type=OBJECT;
memnew_placement( _data._mem, ObjData );
REF ref = p_resource;
_get_obj().obj=ref.ptr();
_get_obj().ref=p_resource;
}
Variant::operator RID() const {
if (type==_RID)
return *reinterpret_cast<const RID*>(_data._mem);
else if (type==OBJECT && !_get_obj().ref.is_null()) {
return _get_obj().ref.get_rid();
} else
return RID();
}
Variant::operator RefPtr() const {
if (type==OBJECT)
return _get_obj().ref;
else
return RefPtr();
}
static void configure_bind_button()
{
guiObject_t *obj = _get_obj(ITEM_PROTO, 1);
if(obj)
GUI_Redraw(obj);
//GUI_SetHidden(mp->obj, PROTOCOL_AutoBindEnabled());
}
Variant::Variant(const Object* p_object) {
type=OBJECT;
memnew_placement( _data._mem, ObjData );
_get_obj().obj=const_cast<Object*>(p_object);
}
const char *set_source_cb(guiObject_t *obj, int dir, void *data)
{
(void) obj;
u8 *source = (u8 *)data;
if (!GUI_IsTextSelectEnabled(obj) ) {
strcpy(mp->tmpstr, _tr("None"));
return mp->tmpstr;
}
u8 is_neg = MIXER_SRC_IS_INV(*source);
u8 changed;
*source = GUI_TextSelectHelper(MIXER_SRC(*source), 1, NUM_SOURCES, dir, 1, 1, &changed);
MIXER_SET_SRC_INV(*source, is_neg);
if (changed) {
if(mp->cur_template == MIXERTEMPLATE_COMPLEX) {
guiObject_t *trim = _get_obj(COMPLEX_TRIM, 0);
if(trim) {
if (MIXER_SourceHasTrim(MIXER_SRC(mp->mixer[0].src)))
GUI_SetHidden(trim, 0);
else
GUI_SetHidden(trim, 1);
}
}
sync_mixers();
MIXPAGE_RedrawGraphs();
}
GUI_TextSelectEnablePress((guiTextSelect_t *)obj, MIXER_SRC(*source));
return INPUT_SourceName(mp->tmpstr, *source);
}
Variant::operator Object*() const {
if (type==OBJECT)
return _get_obj().obj;
else
return NULL;
}
static const char *protoselect_cb(guiObject_t *obj, int dir, void *data)
{
(void)data;
(void)obj;
u8 changed;
enum Protocols new_protocol;
new_protocol = GUI_TextSelectHelper(Model.protocol, PROTOCOL_NONE, PROTOCOL_COUNT-1, dir, 1, 1, &changed);
if (changed) {
const u8 *oldmap = ProtocolChannelMap[Model.protocol];
// DeInit() the old protocol (Model.protocol unchanged)
PROTOCOL_DeInit();
// Load() the new protocol
Model.protocol = new_protocol;
PROTOCOL_Load(1);
TELEMETRY_SetTypeByProtocol(Model.protocol);
Model.num_channels = PROTOCOL_DefaultNumChannels();
if (! PROTOCOL_HasPowerAmp(Model.protocol))
Model.tx_power = TXPOWER_150mW;
else
Model.tx_power = mp->last_txpower;
memset(Model.proto_opts, 0, sizeof(Model.proto_opts));
guiObject_t *obj = _get_obj(ITEM_NUMCHAN, 0);
if (obj)
GUI_Redraw(obj);
obj = _get_obj(ITEM_TXPOWER, 0);
if (obj)
GUI_Redraw(obj);
if (Model.mixer_mode == MIXER_STANDARD)
STDMIXER_SetChannelOrderByProtocol();
else
RemapChannelsForProtocol(oldmap);
configure_bind_button();
}
GUI_TextSelectEnablePress((guiTextSelect_t *)obj, PROTOCOL_GetOptions() ? 1 : 0);
if (Model.protocol == 0)
return _tr("None");
if(PROTOCOL_HasModule(Model.protocol))
return ProtocolNames[Model.protocol];
sprintf(tempstring, "*%s", ProtocolNames[Model.protocol]);
return tempstring;
}
void PAGE_ChantestEvent()
{
int i;
if(cp->type == MONITOR_BUTTONTEST) {
_handle_button_test();
return;
}
volatile s16 *raw = MIXER_GetInputs();
for(i = 0; i < cp->num_bars; i++) {
int j = _get_input_idx(i);
int v = RANGE_TO_PCT(cp->type ? raw[j+1] : Channels[j]);
if (v != cp->pctvalue[i]) {
guiObject_t *obj = _get_obj(i, ITEM_GRAPH);
if (obj) {
GUI_Redraw(obj);
GUI_Redraw(_get_obj(i, ITEM_VALUE));
}
cp->pctvalue[i] = v;
}
}
}
void PAGE_ChantestEvent()
{
if(cp->type == MONITOR_BUTTONTEST) {
_handle_button_test();
return;
}
volatile s32 *raw = MIXER_GetInputs();
for(int i = 0; i < cp->num_bars; i++) {
int ch = get_channel_idx(cur_row * NUM_BARS_PER_ROW + i);
int v = RANGE_TO_PCT((ch >= NUM_INPUTS && ch < NUM_INPUTS + NUM_OUT_CHANNELS)
? Channels[ch - NUM_INPUTS]
: raw[ch + 1]);
if (v != cp->pctvalue[i]) {
guiObject_t *obj = _get_obj(i, ITEM_VALUE);
if (obj) {
GUI_Redraw(obj);
GUI_Redraw(_get_obj(i, ITEM_GRAPH));
}
cp->pctvalue[i] = v;
}
}
}
static const char *set_trimstep_cb(guiObject_t *obj, int dir, void *data)
{
(void)obj;
int i = (long)data;
u8 *value = &Model.trims[i].step;
//place switches before 0.1 on the spinbox
u8 v = ((int)*value + TRIM_SWITCH_TYPES - 1) % (190 + TRIM_SWITCH_TYPES);
v = GUI_TextSelectHelper(v, 0, 190 + TRIM_SWITCH_TYPES - 1, dir, 1, 5, NULL);
*value = ((int)v + 190) % (190 + TRIM_SWITCH_TYPES) + 1;
guiObject_t *negtrimObj = _get_obj(i, TRIM_MINUS);
guiObject_t *switchObj = _get_obj(i, TRIM_SWITCH);
int hide_trim = 0;
int hide_switch = 0;
if (*value == TRIM_MOMENTARY) {
strcpy(tp->tmpstr, _tr("Momentary"));
hide_trim = 1; hide_switch = 1;
} else if (*value == TRIM_TOGGLE) {
strcpy(tp->tmpstr, _tr("Toggle"));
hide_trim = 1; hide_switch = 1;
} else if (*value == TRIM_ONOFF) {
strcpy(tp->tmpstr, _tr("On/Off"));
hide_switch = 1;
} else if (*value < 100) {
sprintf(tp->tmpstr, "%d.%d", *value / 10, *value % 10);
} else {
sprintf(tp->tmpstr, "%d", *value - 90);
}
if (negtrimObj) {
if (negtrimObj->Type == TextSelect)
GUI_TextSelectEnable((guiTextSelect_t *)negtrimObj, ! hide_trim);
else
GUI_Redraw(negtrimObj);
}
if (switchObj)
GUI_TextSelectEnable((guiTextSelect_t *)switchObj, ! hide_switch);
return tp->tmpstr;
}
static void set_src_enable(int curve_type)
{
int state;
if(curve_type != CURVE_FIXED) {
state = 1;
} else if(mp->cur_template != MIXERTEMPLATE_EXPO_DR) {
state = 0;
} else if(CURVE_TYPE(&mp->mixer[0].curve) == CURVE_FIXED &&
(! mp->mixer[1].src || CURVE_TYPE(&mp->mixer[1].curve) == CURVE_FIXED) &&
(! mp->mixer[2].src || CURVE_TYPE(&mp->mixer[2].curve) == CURVE_FIXED))
{
state = 0;
} else {
state = 1;
}
guiObject_t *src = _get_obj(COMMON_SRC, 0);
if (src) {
GUI_TextSelectEnable((guiTextSelect_t *)src, state);
GUI_TextSelectEnablePress((guiTextSelect_t *)src, state);
}
}
static const char *auto_dimmer_time_cb(guiObject_t *obj, int dir, void *data)
{
(void)obj;
(void)data;
u8 changed;
u16 dimmer_timmer = Transmitter.auto_dimmer.timer/1000;
dimmer_timmer = GUI_TextSelectHelper(dimmer_timmer,
MIN_BACKLIGHT_DIMTIME, MAX_BACKLIGHT_DIMTIME, dir, 5, 10, &changed);
if (changed)
Transmitter.auto_dimmer.timer = dimmer_timmer * 1000;
guiObject_t *dimobj = _get_obj(ITEM_DIMVAL, 0);
if (dimmer_timmer == 0) {
if(dimobj)
GUI_TextSelectEnable((guiTextSelect_t *)dimobj, 0);
return _tr("Off");
}
if (dimobj)
GUI_TextSelectEnable((guiTextSelect_t *)dimobj, 1);
TIMER_SetString(tempstring, Transmitter.auto_dimmer.timer);
return tempstring;
}
static const char *set_source_helper(guiObject_t *obj, void *data, int changed) {
(void) obj;
u8 *source = (u8 *)data;
if (!GUI_IsTextSelectEnabled(obj) ) {
tempstring_cpy(_tr("None"));
return tempstring;
}
if (changed) {
if(mp->cur_template == MIXERTEMPLATE_COMPLEX) {
guiObject_t *trim = _get_obj(COMPLEX_TRIM, 0);
if(trim) {
if (MIXER_SourceHasTrim(MIXER_SRC(mp->mixer[0].src)))
GUI_SetHidden(trim, 0);
else
GUI_SetHidden(trim, 1);
}
}
sync_mixers();
MIXPAGE_RedrawGraphs();
}
GUI_TextSelectEnablePress((guiTextSelect_t *)obj, MIXER_SRC(*source));
return INPUT_SourceName(tempstring, *source);
}
/* Text Select Callback */
static const char *type_val_cb(guiObject_t *obj, int dir, void *data)
{
(void)data;
(void)obj;
u8 changed = 0;
Model.type = GUI_TextSelectHelper(Model.type, 0, MODELTYPE_LAST-1, dir, 1, 1, &changed);
GUI_TextSelectEnablePress((guiTextSelect_t *)obj, Model.type == 0);
if (changed && Model.type != 0) {
//Standard GUI is not supported
Model.mixer_mode = MIXER_ADVANCED;
#if HAS_STANDARD_GUI
guiObject_t *obj = _get_obj(ITEM_GUI, 0);
if(obj)
GUI_Redraw(obj);
#endif
}
switch (Model.type) {
case MODELTYPE_HELI: return _tr(HELI_LABEL);
case MODELTYPE_PLANE: return _tr(PLANE_LABEL);
case MODELTYPE_MULTI: return _tr(MULTI_LABEL);
default: return 0; // supress warning.
}
}
static const char *telem_name_cb(guiObject_t *obj, int dir, void *data)
{
(void)obj;
int val = (long)data;
struct TelemetryAlarm *alarm = &Model.alarms[val];
int telem_src = alarm->src;
int last = TELEMETRY_GetNumTelemSrc();
u8 changed;
//skip over (don't allow selection of) telemetry src's with max=0 (eg. JETCAT_STATUS, JETCAT_OFFCOND)
while (1) {
telem_src = GUI_TextSelectHelper(telem_src, 0, last, dir, 1, 1, &changed);
if (telem_src == 0 || TELEMETRY_GetMaxValue(telem_src))
break;
if (telem_src == last)
dir = -1;
}
alarm->src = telem_src;
if (changed) {
guiObject_t *valObj = _get_obj(val, 2);
if (valObj)
GUI_Redraw(valObj);
}
return TELEMETRY_ShortName(tempstring, alarm->src);
}
void Variant::clear() {
switch(type) {
case STRING: {
reinterpret_cast<String*>(_data._mem)->~String();
} break;
/*
// no point, they don't allocate memory
VECTOR3,
PLANE,
QUAT,
COLOR,
VECTOR2,
RECT2
*/
case MATRIX32: {
memdelete( _data._matrix32 );
} break;
case _AABB: {
memdelete( _data._aabb );
} break;
case MATRIX3: {
memdelete( _data._matrix3 );
} break;
case TRANSFORM: {
memdelete( _data._transform );
} break;
// misc types
case IMAGE: {
memdelete( _data._image );
} break;
case NODE_PATH: {
reinterpret_cast<NodePath*>(_data._mem)->~NodePath();
} break;
case OBJECT: {
_get_obj().obj=NULL;
_get_obj().ref.unref();
} break;
case _RID: {
// not much need probably
reinterpret_cast<RID*>(_data._mem)->~RID();
} break;
case DICTIONARY: {
reinterpret_cast<Dictionary*>(_data._mem)->~Dictionary();
} break;
case ARRAY: {
reinterpret_cast<Array*>(_data._mem)->~Array();
} break;
case INPUT_EVENT: {
memdelete( _data._input_event );
} break;
// arrays
case RAW_ARRAY: {
reinterpret_cast< DVector<uint8_t>* >(_data._mem)->~DVector<uint8_t>();
} break;
case INT_ARRAY: {
reinterpret_cast< DVector<int>* >(_data._mem)->~DVector<int>();
} break;
case REAL_ARRAY: {
reinterpret_cast< DVector<real_t>* >(_data._mem)->~DVector<real_t>();
} break;
case STRING_ARRAY: {
reinterpret_cast< DVector<String>* >(_data._mem)->~DVector<String>();
} break;
case VECTOR2_ARRAY: {
reinterpret_cast< DVector<Vector2>* >(_data._mem)->~DVector<Vector2>();
} break;
case VECTOR3_ARRAY: {
reinterpret_cast< DVector<Vector3>* >(_data._mem)->~DVector<Vector3>();
} break;
case COLOR_ARRAY: {
reinterpret_cast< DVector<Color>* >(_data._mem)->~DVector<Color>();
} break;
default: {} /* not needed */
}
type=NIL;
}
bool Variant::is_zero() const {
switch( type ) {
case NIL: {
return true;
} break;
// atomic types
case BOOL: {
return _data._bool==false;
} break;
case INT: {
return _data._int==0;
} break;
case REAL: {
return _data._real==0;
} break;
case STRING: {
return *reinterpret_cast<const String*>(_data._mem)==String();
} break;
// math types
case VECTOR2: {
return *reinterpret_cast<const Vector2*>(_data._mem)==Vector2();
} break;
case RECT2: {
return *reinterpret_cast<const Rect2*>(_data._mem)==Rect2();
} break;
case MATRIX32: {
return *_data._matrix32==Matrix32();
} break;
case VECTOR3: {
return *reinterpret_cast<const Vector3*>(_data._mem)==Vector3();
} break;
case PLANE: {
return *reinterpret_cast<const Plane*>(_data._mem)==Plane();
} break;
/*
case QUAT: {
} break;*/
case _AABB: {
return *_data._aabb==AABB();
} break;
case QUAT: {
*reinterpret_cast<const Quat*>(_data._mem)==Quat();
} break;
case MATRIX3: {
return *_data._matrix3==Matrix3();
} break;
case TRANSFORM: {
return *_data._transform == Transform();
} break;
// misc types
case COLOR: {
return *reinterpret_cast<const Color*>(_data._mem)==Color();
} break;
case IMAGE: {
return _data._image->empty();
} break;
case _RID: {
return *reinterpret_cast<const RID*>(_data._mem)==RID();
} break;
case OBJECT: {
return _get_obj().obj==NULL;
} break;
case NODE_PATH: {
return reinterpret_cast<const NodePath*>(_data._mem)->is_empty();
} break;
case INPUT_EVENT: {
return _data._input_event->type==InputEvent::NONE;
} break;
case DICTIONARY: {
return reinterpret_cast<const Dictionary*>(_data._mem)->empty();
} break;
case ARRAY: {
return reinterpret_cast<const Array*>(_data._mem)->empty();
} break;
// arrays
case RAW_ARRAY: {
return reinterpret_cast<const DVector<uint8_t>*>(_data._mem)->size()==0;
} break;
case INT_ARRAY: {
return reinterpret_cast<const DVector<int>*>(_data._mem)->size()==0;
} break;
case REAL_ARRAY: {
return reinterpret_cast<const DVector<real_t>*>(_data._mem)->size()==0;
} break;
case STRING_ARRAY: {
return reinterpret_cast<const DVector<String>*>(_data._mem)->size()==0;
} break;
case VECTOR2_ARRAY: {
return reinterpret_cast<const DVector<Vector2>*>(_data._mem)->size()==0;
} break;
case VECTOR3_ARRAY: {
return reinterpret_cast<const DVector<Vector3>*>(_data._mem)->size()==0;
} break;
case COLOR_ARRAY: {
return reinterpret_cast<const DVector<Color>*>(_data._mem)->size()==0;
} break;
default: {}
}
return false;
}
bool Variant::is_ref() const {
return type==OBJECT && !_get_obj().ref.is_null();
}
uint32_t Variant::hash() const {
switch( type ) {
case NIL: {
return 0;
} break;
case BOOL: {
return _data._bool?1:0;
} break;
case INT: {
return _data._int;
} break;
case REAL: {
MarshallFloat mf;
mf.f=_data._real;
return mf.i;
} break;
case STRING: {
return reinterpret_cast<const String*>(_data._mem)->hash();
} break;
// math types
case VECTOR2: {
uint32_t hash = hash_djb2_one_float(reinterpret_cast<const Vector2*>(_data._mem)->x);
return hash_djb2_one_float(reinterpret_cast<const Vector2*>(_data._mem)->y,hash);
} break;
case RECT2: {
uint32_t hash = hash_djb2_one_float(reinterpret_cast<const Rect2*>(_data._mem)->pos.x);
hash = hash_djb2_one_float(reinterpret_cast<const Rect2*>(_data._mem)->pos.y,hash);
hash = hash_djb2_one_float(reinterpret_cast<const Rect2*>(_data._mem)->size.x,hash);
return hash_djb2_one_float(reinterpret_cast<const Rect2*>(_data._mem)->size.y,hash);
} break;
case MATRIX32: {
uint32_t hash = 5831;
for(int i=0;i<3;i++) {
for(int j=0;j<2;j++) {
hash = hash_djb2_one_float(_data._matrix32->elements[i][j],hash);
}
}
return hash;
} break;
case VECTOR3: {
uint32_t hash = hash_djb2_one_float(reinterpret_cast<const Vector3*>(_data._mem)->x);
hash = hash_djb2_one_float(reinterpret_cast<const Vector3*>(_data._mem)->y,hash);
return hash_djb2_one_float(reinterpret_cast<const Vector3*>(_data._mem)->z,hash);
} break;
case PLANE: {
uint32_t hash = hash_djb2_one_float(reinterpret_cast<const Plane*>(_data._mem)->normal.x);
hash = hash_djb2_one_float(reinterpret_cast<const Plane*>(_data._mem)->normal.y,hash);
hash = hash_djb2_one_float(reinterpret_cast<const Plane*>(_data._mem)->normal.z,hash);
return hash_djb2_one_float(reinterpret_cast<const Plane*>(_data._mem)->d,hash);
} break;
/*
case QUAT: {
} break;*/
case _AABB: {
uint32_t hash = 5831;
for(int i=0;i<3;i++) {
hash = hash_djb2_one_float(_data._aabb->pos[i],hash);
hash = hash_djb2_one_float(_data._aabb->size[i],hash);
}
return hash;
} break;
case QUAT: {
uint32_t hash = hash_djb2_one_float(reinterpret_cast<const Quat*>(_data._mem)->x);
hash = hash_djb2_one_float(reinterpret_cast<const Quat*>(_data._mem)->y,hash);
hash = hash_djb2_one_float(reinterpret_cast<const Quat*>(_data._mem)->z,hash);
return hash_djb2_one_float(reinterpret_cast<const Quat*>(_data._mem)->w,hash);
} break;
case MATRIX3: {
uint32_t hash = 5831;
for(int i=0;i<3;i++) {
for(int j=0;j<3;j++) {
hash = hash_djb2_one_float(_data._matrix3->elements[i][j],hash);
}
}
return hash;
} break;
case TRANSFORM: {
uint32_t hash = 5831;
for(int i=0;i<3;i++) {
for(int j=0;j<3;j++) {
hash = hash_djb2_one_float(_data._transform->basis.elements[i][j],hash);
}
hash = hash_djb2_one_float(_data._transform->origin[i],hash);
}
return hash;
} break;
// misc types
case COLOR: {
uint32_t hash = hash_djb2_one_float(reinterpret_cast<const Color*>(_data._mem)->r);
hash = hash_djb2_one_float(reinterpret_cast<const Color*>(_data._mem)->g,hash);
hash = hash_djb2_one_float(reinterpret_cast<const Color*>(_data._mem)->b,hash);
return hash_djb2_one_float(reinterpret_cast<const Color*>(_data._mem)->a,hash);
} break;
case IMAGE: {
return 0;
} break;
case _RID: {
return hash_djb2_one_64(reinterpret_cast<const RID*>(_data._mem)->get_id());
} break;
case OBJECT: {
return hash_djb2_one_64(make_uint64_t(_get_obj().obj));
} break;
case NODE_PATH: {
return reinterpret_cast<const NodePath*>(_data._mem)->hash();
} break;
case INPUT_EVENT: {
return hash_djb2_buffer((uint8_t*)_data._input_event,sizeof(InputEvent));
} break;
case DICTIONARY: {
return reinterpret_cast<const Dictionary*>(_data._mem)->hash();
} break;
case ARRAY: {
const Array& arr = *reinterpret_cast<const Array* >(_data._mem);
return arr.hash();
} break;
case RAW_ARRAY: {
const DVector<uint8_t>& arr = *reinterpret_cast<const DVector<uint8_t>* >(_data._mem);
int len = arr.size();
DVector<uint8_t>::Read r = arr.read();
return hash_djb2_buffer((uint8_t*)&r[0],len);
} break;
case INT_ARRAY: {
const DVector<int>& arr = *reinterpret_cast<const DVector<int>* >(_data._mem);
int len = arr.size();
DVector<int>::Read r = arr.read();
return hash_djb2_buffer((uint8_t*)&r[0],len*sizeof(int));
} break;
case REAL_ARRAY: {
const DVector<real_t>& arr = *reinterpret_cast<const DVector<real_t>* >(_data._mem);
int len = arr.size();
DVector<real_t>::Read r = arr.read();
return hash_djb2_buffer((uint8_t*)&r[0],len*sizeof(real_t));
} break;
case STRING_ARRAY: {
uint32_t hash=5831;
const DVector<String>& arr = *reinterpret_cast<const DVector<String>* >(_data._mem);
int len = arr.size();
DVector<String>::Read r = arr.read();
for(int i=0;i<len;i++) {
hash = hash_djb2_one_32(r[i].hash(),hash);
}
return hash;
} break;
case VECTOR2_ARRAY: {
uint32_t hash=5831;
const DVector<Vector2>& arr = *reinterpret_cast<const DVector<Vector2>* >(_data._mem);
int len = arr.size();
DVector<Vector2>::Read r = arr.read();
for(int i=0;i<len;i++) {
hash = hash_djb2_one_float(r[i].x,hash);
hash = hash_djb2_one_float(r[i].y,hash);
}
return hash;
} break;
case VECTOR3_ARRAY: {
uint32_t hash=5831;
const DVector<Vector3>& arr = *reinterpret_cast<const DVector<Vector3>* >(_data._mem);
int len = arr.size();
DVector<Vector3>::Read r = arr.read();
for(int i=0;i<len;i++) {
hash = hash_djb2_one_float(r[i].x,hash);
hash = hash_djb2_one_float(r[i].y,hash);
hash = hash_djb2_one_float(r[i].z,hash);
}
return hash;
} break;
case COLOR_ARRAY: {
uint32_t hash=5831;
const DVector<Color>& arr = *reinterpret_cast<const DVector<Color>* >(_data._mem);
int len = arr.size();
DVector<Color>::Read r = arr.read();
for(int i=0;i<len;i++) {
hash = hash_djb2_one_float(r[i].r,hash);
hash = hash_djb2_one_float(r[i].g,hash);
hash = hash_djb2_one_float(r[i].b,hash);
hash = hash_djb2_one_float(r[i].a,hash);
}
return hash;
} break;
default: {}
}
return 0;
}
Variant::operator String() const {
switch( type ) {
case NIL: return "";
case BOOL: return _data._bool ? "True" : "False";
case INT: return String::num(_data._int);
case REAL: return String::num(_data._real);
case STRING: return *reinterpret_cast<const String*>(_data._mem);
case VECTOR2: return operator Vector2();
case RECT2: return operator Rect2();
case MATRIX32: return operator Matrix32();
case VECTOR3: return operator Vector3();
case PLANE: return operator Plane();
//case QUAT:
case _AABB: return operator AABB();
case QUAT: return operator Quat();
case MATRIX3: return operator Matrix3();
case TRANSFORM: return operator Transform();
case NODE_PATH: return operator NodePath();
case INPUT_EVENT: return operator InputEvent();
case COLOR: return String::num( operator Color().r)+","+String::num( operator Color().g)+","+String::num( operator Color().b)+","+String::num( operator Color().a) ;
case DICTIONARY: {
const Dictionary &d =*reinterpret_cast<const Dictionary*>(_data._mem);
//const String *K=NULL;
String str;
List<Variant> keys;
d.get_key_list(&keys);
Vector<_VariantStrPair> pairs;
for(List<Variant>::Element *E=keys.front();E;E=E->next()) {
_VariantStrPair sp;
sp.key=String(E->get());
sp.value=d[E->get()];
pairs.push_back(sp);
}
pairs.sort();
for(int i=0;i<pairs.size();i++) {
if (i>0)
str+=", ";
str+="("+pairs[i].key+":"+pairs[i].value+")";
}
return str;
} break;
case VECTOR3_ARRAY: {
DVector<Vector3> vec = operator DVector<Vector3>();
String str;
for(int i=0;i<vec.size();i++) {
if (i>0)
str+=", ";
str=str+Variant( vec[i] );
}
return str;
} break;
case STRING_ARRAY: {
DVector<String> vec = operator DVector<String>();
String str;
for(int i=0;i<vec.size();i++) {
if (i>0)
str+=", ";
str=str+vec[i];
}
return str;
} break;
case INT_ARRAY: {
DVector<int> vec = operator DVector<int>();
String str;
for(int i=0;i<vec.size();i++) {
if (i>0)
str+=", ";
str=str+itos(vec[i]);
}
return str;
} break;
case REAL_ARRAY: {
DVector<real_t> vec = operator DVector<real_t>();
String str;
for(int i=0;i<vec.size();i++) {
if (i>0)
str+=", ";
str=str+rtos(vec[i]);
}
return str;
} break;
case ARRAY: {
Array arr = operator Array();
String str;
for (int i=0; i<arr.size(); i++) {
if (i)
str+=", ";
str += String(arr[i]);
};
return str;
} break;
case OBJECT: {
if (_get_obj().obj)
return "["+_get_obj().obj->get_type()+":"+itos(_get_obj().obj->get_instance_ID())+"]";
else
return "[Object:null]";
} break;
default: {
return "["+get_type_name(type)+"]";
}
}
return "";
}
