2760 lines
51 KiB
C++
2760 lines
51 KiB
C++
/*************************************************************************/
|
|
/* variant.cpp */
|
|
/*************************************************************************/
|
|
/* This file is part of: */
|
|
/* GODOT ENGINE */
|
|
/* http://www.godotengine.org */
|
|
/*************************************************************************/
|
|
/* Copyright (c) 2007-2014 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 "variant.h"
|
|
#include "resource.h"
|
|
#include "print_string.h"
|
|
#include "scene/main/node.h"
|
|
#include "scene/gui/control.h"
|
|
#include "io/marshalls.h"
|
|
|
|
|
|
|
|
|
|
String Variant::get_type_name(Variant::Type p_type) {
|
|
|
|
switch( p_type ) {
|
|
case NIL: {
|
|
|
|
return "Nil";
|
|
} break;
|
|
|
|
// atomic types
|
|
case BOOL: {
|
|
|
|
return "bool";
|
|
} break;
|
|
case INT: {
|
|
|
|
return "int";
|
|
|
|
} break;
|
|
case REAL: {
|
|
|
|
return "float";
|
|
|
|
} break;
|
|
case STRING: {
|
|
|
|
return "String";
|
|
} break;
|
|
|
|
// math types
|
|
|
|
case VECTOR2: {
|
|
|
|
return "Vector2";
|
|
} break;
|
|
case RECT2: {
|
|
|
|
return "Rect2";
|
|
} break;
|
|
case MATRIX32: {
|
|
|
|
return "Matrix32";
|
|
} break;
|
|
case VECTOR3: {
|
|
|
|
return "Vector3";
|
|
} break;
|
|
case PLANE: {
|
|
|
|
return "Plane";
|
|
|
|
} break;
|
|
/*
|
|
case QUAT: {
|
|
|
|
|
|
} break;*/
|
|
case _AABB: {
|
|
|
|
return "AABB";
|
|
} break;
|
|
case QUAT: {
|
|
|
|
return "Quat";
|
|
|
|
} break;
|
|
case MATRIX3: {
|
|
|
|
return "Matrix3";
|
|
|
|
} break;
|
|
case TRANSFORM: {
|
|
|
|
return "Transform";
|
|
|
|
} break;
|
|
|
|
// misc types
|
|
case COLOR: {
|
|
|
|
return "Color";
|
|
|
|
} break;
|
|
case IMAGE: {
|
|
|
|
return "Image";
|
|
|
|
} break;
|
|
case _RID: {
|
|
|
|
return "RID";
|
|
} break;
|
|
case OBJECT: {
|
|
|
|
return "Object";
|
|
} break;
|
|
case NODE_PATH: {
|
|
|
|
return "NodePath";
|
|
|
|
} break;
|
|
case INPUT_EVENT: {
|
|
|
|
return "InputEvent";
|
|
|
|
} break;
|
|
case DICTIONARY: {
|
|
|
|
return "Dictionary";
|
|
|
|
} break;
|
|
case ARRAY: {
|
|
|
|
return "Array";
|
|
|
|
} break;
|
|
|
|
// arrays
|
|
case RAW_ARRAY: {
|
|
|
|
return "RawArray";
|
|
|
|
} break;
|
|
case INT_ARRAY: {
|
|
|
|
return "IntArray";
|
|
|
|
} break;
|
|
case REAL_ARRAY: {
|
|
|
|
return "RealArray";
|
|
|
|
} break;
|
|
case STRING_ARRAY: {
|
|
|
|
return "StringArray";
|
|
} break;
|
|
case VECTOR2_ARRAY: {
|
|
|
|
return "Vector2Array";
|
|
|
|
} break;
|
|
case VECTOR3_ARRAY: {
|
|
|
|
return "Vector3Array";
|
|
|
|
} break;
|
|
case COLOR_ARRAY: {
|
|
|
|
return "ColorArray";
|
|
|
|
} break;
|
|
default: {}
|
|
}
|
|
|
|
return "";
|
|
}
|
|
|
|
|
|
bool Variant::can_convert(Variant::Type p_type_from,Variant::Type p_type_to) {
|
|
|
|
if (p_type_from==p_type_to)
|
|
return true;
|
|
if (p_type_to==NIL && p_type_from!=NIL) //nil can convert to anything
|
|
return true;
|
|
|
|
if (p_type_from == NIL) {
|
|
return (p_type_to == OBJECT);
|
|
};
|
|
|
|
const Type *valid_types=NULL;
|
|
const Type *invalid_types=NULL;
|
|
|
|
switch(p_type_to) {
|
|
case BOOL: {
|
|
|
|
static const Type valid[]={
|
|
INT,
|
|
REAL,
|
|
STRING,
|
|
NIL,
|
|
};
|
|
|
|
valid_types=valid;
|
|
} break;
|
|
case INT: {
|
|
|
|
static const Type valid[]={
|
|
BOOL,
|
|
REAL,
|
|
STRING,
|
|
NIL,
|
|
};
|
|
|
|
valid_types=valid;
|
|
|
|
} break;
|
|
case REAL: {
|
|
|
|
static const Type valid[]={
|
|
BOOL,
|
|
INT,
|
|
STRING,
|
|
NIL,
|
|
};
|
|
|
|
valid_types=valid;
|
|
|
|
} break;
|
|
case STRING: {
|
|
|
|
|
|
static const Type invalid[]={
|
|
OBJECT,
|
|
IMAGE,
|
|
NIL
|
|
};
|
|
|
|
invalid_types=invalid;
|
|
} break;
|
|
case MATRIX32: {
|
|
|
|
|
|
static const Type invalid[]={
|
|
TRANSFORM,
|
|
NIL
|
|
};
|
|
|
|
invalid_types=invalid;
|
|
} break;
|
|
case QUAT: {
|
|
|
|
static const Type valid[]={
|
|
MATRIX3,
|
|
NIL
|
|
};
|
|
|
|
valid_types=valid;
|
|
|
|
} break;
|
|
case MATRIX3: {
|
|
|
|
static const Type valid[]={
|
|
QUAT,
|
|
NIL
|
|
};
|
|
|
|
valid_types=valid;
|
|
|
|
|
|
} break;
|
|
case TRANSFORM: {
|
|
|
|
static const Type valid[]={
|
|
MATRIX32,
|
|
QUAT,
|
|
MATRIX3,
|
|
NIL
|
|
};
|
|
|
|
valid_types=valid;
|
|
|
|
} break;
|
|
|
|
case COLOR: {
|
|
|
|
static const Type valid[] = {
|
|
STRING,
|
|
INT,
|
|
NIL,
|
|
};
|
|
|
|
valid_types = valid;
|
|
|
|
} break;
|
|
|
|
case _RID: {
|
|
|
|
static const Type valid[]={
|
|
OBJECT,
|
|
NIL
|
|
};
|
|
|
|
valid_types=valid;
|
|
} break;
|
|
case OBJECT: {
|
|
|
|
static const Type valid[]={
|
|
NIL
|
|
};
|
|
|
|
valid_types=valid;
|
|
} break;
|
|
case NODE_PATH: {
|
|
|
|
static const Type valid[]={
|
|
STRING,
|
|
NIL
|
|
};
|
|
|
|
valid_types=valid;
|
|
} break;
|
|
case ARRAY: {
|
|
|
|
|
|
static const Type valid[]={
|
|
RAW_ARRAY,
|
|
INT_ARRAY,
|
|
STRING_ARRAY,
|
|
REAL_ARRAY,
|
|
COLOR_ARRAY,
|
|
VECTOR2_ARRAY,
|
|
VECTOR3_ARRAY,
|
|
NIL
|
|
};
|
|
|
|
valid_types=valid;
|
|
} break;
|
|
// arrays
|
|
case RAW_ARRAY: {
|
|
|
|
static const Type valid[]={
|
|
ARRAY,
|
|
NIL
|
|
};
|
|
|
|
valid_types=valid;
|
|
} break;
|
|
case INT_ARRAY: {
|
|
|
|
static const Type valid[]={
|
|
ARRAY,
|
|
NIL
|
|
};
|
|
valid_types=valid;
|
|
} break;
|
|
case REAL_ARRAY: {
|
|
|
|
static const Type valid[]={
|
|
ARRAY,
|
|
NIL
|
|
};
|
|
|
|
valid_types=valid;
|
|
} break;
|
|
case STRING_ARRAY: {
|
|
|
|
static const Type valid[]={
|
|
ARRAY,
|
|
NIL
|
|
};
|
|
valid_types=valid;
|
|
} break;
|
|
case VECTOR2_ARRAY: {
|
|
|
|
static const Type valid[]={
|
|
ARRAY,
|
|
NIL
|
|
};
|
|
valid_types=valid;
|
|
|
|
} break;
|
|
case VECTOR3_ARRAY: {
|
|
|
|
static const Type valid[]={
|
|
ARRAY,
|
|
NIL
|
|
};
|
|
valid_types=valid;
|
|
|
|
} break;
|
|
case COLOR_ARRAY: {
|
|
|
|
static const Type valid[]={
|
|
ARRAY,
|
|
NIL
|
|
};
|
|
|
|
valid_types=valid;
|
|
|
|
} break;
|
|
default: {}
|
|
}
|
|
|
|
|
|
if (valid_types) {
|
|
|
|
int i=0;
|
|
while(valid_types[i]!=NIL) {
|
|
|
|
if (p_type_from==valid_types[i])
|
|
return true;
|
|
i++;
|
|
}
|
|
} else if (invalid_types) {
|
|
|
|
|
|
int i=0;
|
|
while(invalid_types[i]!=NIL) {
|
|
|
|
if (p_type_from==invalid_types[i])
|
|
return false;
|
|
i++;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
bool Variant::operator==(const Variant& p_variant) const {
|
|
|
|
if (type!=p_variant.type) //evaluation of operator== needs to be more strict
|
|
return false;
|
|
bool v;
|
|
Variant r;
|
|
evaluate(OP_EQUAL,*this,p_variant,r,v);
|
|
return r;
|
|
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
void Variant::reference(const Variant& p_variant) {
|
|
|
|
|
|
if (this == &p_variant)
|
|
return;
|
|
|
|
clear();
|
|
|
|
type=p_variant.type;
|
|
|
|
switch( p_variant.type ) {
|
|
case NIL: {
|
|
|
|
// none
|
|
} break;
|
|
|
|
// atomic types
|
|
case BOOL: {
|
|
|
|
_data._bool=p_variant._data._bool;
|
|
} break;
|
|
case INT: {
|
|
|
|
_data._int=p_variant._data._int;
|
|
|
|
} break;
|
|
case REAL: {
|
|
|
|
_data._real=p_variant._data._real;
|
|
|
|
} break;
|
|
case STRING: {
|
|
|
|
memnew_placement( _data._mem, String( *reinterpret_cast<const String*>(p_variant._data._mem) ) );
|
|
|
|
} break;
|
|
|
|
// math types
|
|
|
|
case VECTOR2: {
|
|
|
|
memnew_placement( _data._mem, Vector2( *reinterpret_cast<const Vector2*>(p_variant._data._mem) ) );
|
|
|
|
} break;
|
|
case RECT2: {
|
|
|
|
memnew_placement( _data._mem, Rect2( *reinterpret_cast<const Rect2*>(p_variant._data._mem) ) );
|
|
|
|
} break;
|
|
case MATRIX32: {
|
|
|
|
_data._matrix32 = memnew( Matrix32( *p_variant._data._matrix32 ) );
|
|
|
|
} break;
|
|
case VECTOR3: {
|
|
|
|
memnew_placement( _data._mem, Vector3( *reinterpret_cast<const Vector3*>(p_variant._data._mem) ) );
|
|
|
|
} break;
|
|
case PLANE: {
|
|
|
|
memnew_placement( _data._mem, Plane( *reinterpret_cast<const Plane*>(p_variant._data._mem) ) );
|
|
|
|
} break;
|
|
/*
|
|
case QUAT: {
|
|
|
|
|
|
} break;*/
|
|
case _AABB: {
|
|
|
|
_data._aabb = memnew( AABB( *p_variant._data._aabb ) );
|
|
} break;
|
|
case QUAT: {
|
|
|
|
memnew_placement( _data._mem, Quat( *reinterpret_cast<const Quat*>(p_variant._data._mem) ) );
|
|
|
|
} break;
|
|
case MATRIX3: {
|
|
|
|
_data._matrix3 = memnew( Matrix3( *p_variant._data._matrix3 ) );
|
|
|
|
} break;
|
|
case TRANSFORM: {
|
|
|
|
_data._transform = memnew( Transform( *p_variant._data._transform ) );
|
|
|
|
} break;
|
|
|
|
// misc types
|
|
case COLOR: {
|
|
|
|
memnew_placement( _data._mem, Color( *reinterpret_cast<const Color*>(p_variant._data._mem) ) );
|
|
|
|
} break;
|
|
case IMAGE: {
|
|
|
|
_data._image = memnew( Image( *p_variant._data._image ) );
|
|
|
|
} break;
|
|
case _RID: {
|
|
|
|
memnew_placement( _data._mem, RID( *reinterpret_cast<const RID*>(p_variant._data._mem) ) );
|
|
} break;
|
|
case OBJECT: {
|
|
|
|
memnew_placement( _data._mem, ObjData( p_variant._get_obj() ) );
|
|
} break;
|
|
case NODE_PATH: {
|
|
|
|
memnew_placement( _data._mem, NodePath( *reinterpret_cast<const NodePath*>(p_variant._data._mem) ) );
|
|
|
|
} break;
|
|
case INPUT_EVENT: {
|
|
|
|
_data._input_event= memnew( InputEvent( *p_variant._data._input_event ) );
|
|
|
|
} break;
|
|
case DICTIONARY: {
|
|
|
|
memnew_placement( _data._mem, Dictionary( *reinterpret_cast<const Dictionary*>(p_variant._data._mem) ) );
|
|
|
|
} break;
|
|
case ARRAY: {
|
|
|
|
memnew_placement( _data._mem, Array ( *reinterpret_cast<const Array*>(p_variant._data._mem) ) );
|
|
|
|
} break;
|
|
|
|
// arrays
|
|
case RAW_ARRAY: {
|
|
|
|
memnew_placement( _data._mem, DVector<uint8_t> ( *reinterpret_cast<const DVector<uint8_t>*>(p_variant._data._mem) ) );
|
|
|
|
} break;
|
|
case INT_ARRAY: {
|
|
|
|
memnew_placement( _data._mem, DVector<int> ( *reinterpret_cast<const DVector<int>*>(p_variant._data._mem) ) );
|
|
|
|
} break;
|
|
case REAL_ARRAY: {
|
|
|
|
memnew_placement( _data._mem, DVector<real_t> ( *reinterpret_cast<const DVector<real_t>*>(p_variant._data._mem) ) );
|
|
|
|
} break;
|
|
case STRING_ARRAY: {
|
|
|
|
memnew_placement( _data._mem, DVector<String> ( *reinterpret_cast<const DVector<String>*>(p_variant._data._mem) ) );
|
|
|
|
} break;
|
|
case VECTOR2_ARRAY: {
|
|
|
|
memnew_placement( _data._mem, DVector<Vector2> ( *reinterpret_cast<const DVector<Vector2>*>(p_variant._data._mem) ) );
|
|
|
|
} break;
|
|
case VECTOR3_ARRAY: {
|
|
|
|
memnew_placement( _data._mem, DVector<Vector3> ( *reinterpret_cast<const DVector<Vector3>*>(p_variant._data._mem) ) );
|
|
|
|
} break;
|
|
case COLOR_ARRAY: {
|
|
|
|
memnew_placement( _data._mem, DVector<Color> ( *reinterpret_cast<const DVector<Color>*>(p_variant._data._mem) ) );
|
|
|
|
} break;
|
|
default: {}
|
|
}
|
|
|
|
|
|
}
|
|
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;
|
|
|
|
}
|
|
|
|
|
|
Variant::operator signed int() const {
|
|
|
|
switch( type ) {
|
|
|
|
case NIL: return 0;
|
|
case BOOL: return _data._bool ? 1 : 0;
|
|
case INT: return _data._int;
|
|
case REAL: return _data._real;
|
|
case STRING: return operator String().to_int();
|
|
default: {
|
|
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
Variant::operator unsigned int() const {
|
|
|
|
switch( type ) {
|
|
|
|
case NIL: return 0;
|
|
case BOOL: return _data._bool ? 1 : 0;
|
|
case INT: return _data._int;
|
|
case REAL: return _data._real;
|
|
case STRING: return operator String().to_int();
|
|
default: {
|
|
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
Variant::operator int64_t() const {
|
|
|
|
switch( type ) {
|
|
|
|
case NIL: return 0;
|
|
case BOOL: return _data._bool ? 1 : 0;
|
|
case INT: return _data._int;
|
|
case REAL: return _data._real;
|
|
case STRING: return operator String().to_int();
|
|
default: {
|
|
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
Variant::operator long unsigned int() const {
|
|
|
|
switch( type ) {
|
|
|
|
case NIL: return 0;
|
|
case BOOL: return _data._bool ? 1 : 0;
|
|
case INT: return _data._int;
|
|
case REAL: return _data._real;
|
|
case STRING: return operator String().to_int();
|
|
default: {
|
|
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
};
|
|
*/
|
|
|
|
Variant::operator uint64_t() const {
|
|
|
|
switch( type ) {
|
|
|
|
case NIL: return 0;
|
|
case BOOL: return _data._bool ? 1 : 0;
|
|
case INT: return _data._int;
|
|
case REAL: return _data._real;
|
|
case STRING: return operator String().to_int();
|
|
default: {
|
|
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
#ifdef NEED_LONG_INT
|
|
Variant::operator signed long() const {
|
|
|
|
switch( type ) {
|
|
|
|
case NIL: return 0;
|
|
case BOOL: return _data._bool ? 1 : 0;
|
|
case INT: return _data._int;
|
|
case REAL: return _data._real;
|
|
case STRING: return operator String().to_int();
|
|
default: {
|
|
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
};
|
|
|
|
Variant::operator unsigned long() const {
|
|
|
|
switch( type ) {
|
|
|
|
case NIL: return 0;
|
|
case BOOL: return _data._bool ? 1 : 0;
|
|
case INT: return _data._int;
|
|
case REAL: return _data._real;
|
|
case STRING: return operator String().to_int();
|
|
default: {
|
|
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
};
|
|
#endif
|
|
|
|
|
|
Variant::operator signed short() const {
|
|
|
|
switch( type ) {
|
|
|
|
case NIL: return 0;
|
|
case BOOL: return _data._bool ? 1 : 0;
|
|
case INT: return _data._int;
|
|
case REAL: return _data._real;
|
|
case STRING: return operator String().to_int();
|
|
default: {
|
|
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
Variant::operator unsigned short() const {
|
|
|
|
switch( type ) {
|
|
|
|
case NIL: return 0;
|
|
case BOOL: return _data._bool ? 1 : 0;
|
|
case INT: return _data._int;
|
|
case REAL: return _data._real;
|
|
case STRING: return operator String().to_int();
|
|
default: {
|
|
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
Variant::operator signed char() const {
|
|
|
|
switch( type ) {
|
|
|
|
case NIL: return 0;
|
|
case BOOL: return _data._bool ? 1 : 0;
|
|
case INT: return _data._int;
|
|
case REAL: return _data._real;
|
|
case STRING: return operator String().to_int();
|
|
default: {
|
|
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
Variant::operator unsigned char() const {
|
|
|
|
switch( type ) {
|
|
|
|
case NIL: return 0;
|
|
case BOOL: return _data._bool ? 1 : 0;
|
|
case INT: return _data._int;
|
|
case REAL: return _data._real;
|
|
case STRING: return operator String().to_int();
|
|
default: {
|
|
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
#ifndef CHARTYPE_16BITS
|
|
Variant::operator CharType() const {
|
|
|
|
return operator unsigned int();
|
|
}
|
|
#endif
|
|
|
|
Variant::operator float() const {
|
|
|
|
switch( type ) {
|
|
|
|
case NIL: return 0;
|
|
case BOOL: return _data._bool ? 1.0 : 0.0;
|
|
case INT: return (float)_data._int;
|
|
case REAL: return _data._real;
|
|
case STRING: return operator String().to_double();
|
|
default: {
|
|
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
Variant::operator double() const {
|
|
|
|
switch( type ) {
|
|
|
|
case NIL: return 0;
|
|
case BOOL: return _data._bool ? 1.0 : 0.0;
|
|
case INT: return (float)_data._int;
|
|
case REAL: return _data._real;
|
|
case STRING: return operator String().to_double();
|
|
default: {
|
|
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
Variant::operator StringName() const {
|
|
|
|
if (type==NODE_PATH) {
|
|
return reinterpret_cast<const NodePath*>(_data._mem)->get_sname();
|
|
}
|
|
return StringName(operator String());
|
|
}
|
|
|
|
struct _VariantStrPair {
|
|
|
|
String key;
|
|
String value;
|
|
|
|
bool operator<(const _VariantStrPair& p) const {
|
|
|
|
return key < p.key;
|
|
}
|
|
};
|
|
|
|
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 "";
|
|
}
|
|
|
|
Variant::operator Vector2() const {
|
|
|
|
if (type==VECTOR2)
|
|
return *reinterpret_cast<const Vector2*>(_data._mem);
|
|
else if (type==VECTOR3)
|
|
return Vector2(reinterpret_cast<const Vector3*>(_data._mem)->x,reinterpret_cast<const Vector3*>(_data._mem)->y);
|
|
else
|
|
return Vector2();
|
|
|
|
}
|
|
Variant::operator Rect2() const {
|
|
|
|
if (type==RECT2)
|
|
return *reinterpret_cast<const Rect2*>(_data._mem);
|
|
else
|
|
return Rect2();
|
|
|
|
}
|
|
|
|
Variant::operator Vector3() const {
|
|
|
|
if (type==VECTOR3)
|
|
return *reinterpret_cast<const Vector3*>(_data._mem);
|
|
else
|
|
return Vector3();
|
|
|
|
}
|
|
Variant::operator Plane() const {
|
|
|
|
if (type==PLANE)
|
|
return *reinterpret_cast<const Plane*>(_data._mem);
|
|
else
|
|
return Plane();
|
|
|
|
}
|
|
Variant::operator AABB() const {
|
|
|
|
if (type==_AABB)
|
|
return *_data._aabb;
|
|
else
|
|
return AABB();
|
|
}
|
|
|
|
Variant::operator Matrix3() const {
|
|
|
|
if (type==MATRIX3)
|
|
return *_data._matrix3;
|
|
else if (type==QUAT)
|
|
return *reinterpret_cast<const Quat*>(_data._mem);
|
|
else if (type==TRANSFORM)
|
|
return _data._transform->basis;
|
|
else
|
|
return Matrix3();
|
|
}
|
|
|
|
Variant::operator Quat() const {
|
|
|
|
if (type==QUAT)
|
|
return *reinterpret_cast<const Quat*>(_data._mem);
|
|
else if (type==MATRIX3)
|
|
return *_data._matrix3;
|
|
else if (type==TRANSFORM)
|
|
return _data._transform->basis;
|
|
else
|
|
return Quat();
|
|
}
|
|
|
|
|
|
|
|
Variant::operator Transform() const {
|
|
|
|
if (type==TRANSFORM)
|
|
return *_data._transform;
|
|
else if (type==MATRIX3)
|
|
return Transform(*_data._matrix3,Vector3());
|
|
else if (type==QUAT)
|
|
return Transform(Matrix3(*reinterpret_cast<const Quat*>(_data._mem)),Vector3());
|
|
else
|
|
return Transform();
|
|
}
|
|
|
|
Variant::operator Matrix32() const {
|
|
|
|
if (type==MATRIX32) {
|
|
return *_data._matrix32;
|
|
} else if (type==TRANSFORM) {
|
|
const Transform& t = *_data._transform;;
|
|
Matrix32 m;
|
|
m.elements[0][0]=t.basis.elements[0][0];
|
|
m.elements[0][1]=t.basis.elements[1][0];
|
|
m.elements[1][0]=t.basis.elements[0][1];
|
|
m.elements[1][1]=t.basis.elements[1][1];
|
|
m.elements[2][0]=t.origin[0];
|
|
m.elements[2][1]=t.origin[1];
|
|
return m;
|
|
} else
|
|
return Matrix32();
|
|
}
|
|
|
|
|
|
Variant::operator Color() const {
|
|
|
|
if (type==COLOR)
|
|
return *reinterpret_cast<const Color*>(_data._mem);
|
|
else
|
|
return Color();
|
|
}
|
|
Variant::operator Image() const {
|
|
|
|
if (type==IMAGE)
|
|
return *_data._image;
|
|
else
|
|
return Image();
|
|
}
|
|
|
|
Variant::operator NodePath() const {
|
|
|
|
if (type==NODE_PATH)
|
|
return *reinterpret_cast<const NodePath*>(_data._mem);
|
|
else if (type==STRING)
|
|
return NodePath(operator String());
|
|
else
|
|
return NodePath();
|
|
}
|
|
|
|
|
|
Variant::operator RefPtr() const {
|
|
|
|
if (type==OBJECT)
|
|
return _get_obj().ref;
|
|
else
|
|
return RefPtr();
|
|
}
|
|
|
|
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 Object*() const {
|
|
|
|
if (type==OBJECT)
|
|
return _get_obj().obj;
|
|
else
|
|
return NULL;
|
|
}
|
|
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::operator InputEvent() const {
|
|
|
|
if (type==INPUT_EVENT)
|
|
return *reinterpret_cast<const InputEvent*>(_data._input_event);
|
|
else
|
|
return InputEvent();
|
|
}
|
|
|
|
Variant::operator Dictionary() const {
|
|
|
|
if (type==DICTIONARY)
|
|
return *reinterpret_cast<const Dictionary*>(_data._mem);
|
|
else
|
|
return Dictionary();
|
|
}
|
|
|
|
template<class DA,class SA>
|
|
inline DA _convert_array(const SA& p_array) {
|
|
|
|
DA da;
|
|
da.resize(p_array.size());
|
|
|
|
for(int i=0;i<p_array.size();i++) {
|
|
|
|
da.set( i, Variant(p_array.get(i)) );
|
|
}
|
|
|
|
return da;
|
|
}
|
|
|
|
template<class DA>
|
|
inline DA _convert_array_from_variant(const Variant& p_variant) {
|
|
|
|
switch(p_variant.get_type()) {
|
|
|
|
|
|
case Variant::ARRAY: { return _convert_array<DA,Array >( p_variant.operator Array () ); }
|
|
case Variant::RAW_ARRAY: { return _convert_array<DA,DVector<uint8_t> >( p_variant.operator DVector<uint8_t> () ); }
|
|
case Variant::INT_ARRAY: { return _convert_array<DA,DVector<int> >( p_variant.operator DVector<int> () ); }
|
|
case Variant::REAL_ARRAY: { return _convert_array<DA,DVector<real_t> >( p_variant.operator DVector<real_t> () ); }
|
|
case Variant::STRING_ARRAY: { return _convert_array<DA,DVector<String> >( p_variant.operator DVector<String> () ); }
|
|
case Variant::VECTOR2_ARRAY: { return _convert_array<DA,DVector<Vector2> >( p_variant.operator DVector<Vector2> () ); }
|
|
case Variant::VECTOR3_ARRAY: { return _convert_array<DA,DVector<Vector3> >( p_variant.operator DVector<Vector3> () ); }
|
|
case Variant::COLOR_ARRAY: { return _convert_array<DA,DVector<Color> >( p_variant.operator DVector<Color>() ); }
|
|
default: { return DA(); }
|
|
}
|
|
|
|
return DA();
|
|
}
|
|
|
|
Variant::operator Array() const {
|
|
|
|
if (type==ARRAY)
|
|
return *reinterpret_cast<const Array*>(_data._mem);
|
|
else
|
|
return _convert_array_from_variant<Array >(*this);
|
|
}
|
|
|
|
Variant::operator DVector<uint8_t>() const {
|
|
|
|
if (type==RAW_ARRAY)
|
|
return *reinterpret_cast<const DVector<uint8_t>* >(_data._mem);
|
|
else
|
|
return _convert_array_from_variant<DVector<uint8_t> >(*this);
|
|
}
|
|
Variant::operator DVector<int>() const {
|
|
|
|
if (type==INT_ARRAY)
|
|
return *reinterpret_cast<const DVector<int>* >(_data._mem);
|
|
else
|
|
return _convert_array_from_variant<DVector<int> >(*this);
|
|
|
|
}
|
|
Variant::operator DVector<real_t>() const {
|
|
|
|
if (type==REAL_ARRAY)
|
|
return *reinterpret_cast<const DVector<real_t>* >(_data._mem);
|
|
else
|
|
return _convert_array_from_variant<DVector<real_t> >(*this);
|
|
|
|
}
|
|
|
|
Variant::operator DVector<String>() const {
|
|
|
|
if (type==STRING_ARRAY)
|
|
return *reinterpret_cast<const DVector<String>* >(_data._mem);
|
|
else
|
|
return _convert_array_from_variant<DVector<String> >(*this);
|
|
|
|
|
|
}
|
|
Variant::operator DVector<Vector3>() const {
|
|
|
|
if (type==VECTOR3_ARRAY)
|
|
return *reinterpret_cast<const DVector<Vector3>* >(_data._mem);
|
|
else
|
|
return _convert_array_from_variant<DVector<Vector3> >(*this);
|
|
|
|
|
|
}
|
|
Variant::operator DVector<Vector2>() const {
|
|
|
|
if (type==VECTOR2_ARRAY)
|
|
return *reinterpret_cast<const DVector<Vector2>* >(_data._mem);
|
|
else
|
|
return _convert_array_from_variant<DVector<Vector2> >(*this);
|
|
|
|
|
|
}
|
|
|
|
Variant::operator DVector<Color>() const {
|
|
|
|
if (type==COLOR_ARRAY)
|
|
return *reinterpret_cast<const DVector<Color>* >(_data._mem);
|
|
else
|
|
return _convert_array_from_variant<DVector<Color> >(*this);
|
|
|
|
}
|
|
|
|
/* helpers */
|
|
|
|
|
|
Variant::operator Vector<RID>() const {
|
|
|
|
Array va= operator Array();
|
|
Vector<RID> rids;
|
|
rids.resize(va.size());
|
|
for(int i=0;i<rids.size();i++)
|
|
rids[i]=va[i];
|
|
return rids;
|
|
}
|
|
|
|
Variant::operator Vector<Vector2>() const {
|
|
|
|
DVector<Vector2> from=operator DVector<Vector2>();
|
|
Vector<Vector2> to;
|
|
int len=from.size();
|
|
if (len==0)
|
|
return Vector<Vector2>();
|
|
to.resize(len);
|
|
DVector<Vector2>::Read r = from.read();
|
|
Vector2 *w = &to[0];
|
|
for (int i=0;i<len;i++) {
|
|
|
|
w[i]=r[i];
|
|
}
|
|
return to;
|
|
}
|
|
|
|
Variant::operator DVector<Plane>() const {
|
|
|
|
Array va= operator Array();
|
|
DVector<Plane> planes;
|
|
int va_size=va.size();
|
|
if (va_size==0)
|
|
return planes;
|
|
|
|
planes.resize(va_size);
|
|
DVector<Plane>::Write w = planes.write();
|
|
|
|
for(int i=0;i<va_size;i++)
|
|
w[i]=va[i];
|
|
|
|
return planes;
|
|
}
|
|
|
|
Variant::operator DVector<Face3>() const {
|
|
|
|
DVector<Vector3> va= operator DVector<Vector3>();
|
|
DVector<Face3> faces;
|
|
int va_size=va.size();
|
|
if (va_size==0)
|
|
return faces;
|
|
|
|
faces.resize(va_size/3);
|
|
DVector<Face3>::Write w = faces.write();
|
|
DVector<Vector3>::Read r = va.read();
|
|
|
|
for(int i=0;i<va_size;i++)
|
|
w[i/3].vertex[i%3]=r[i];
|
|
|
|
return faces;
|
|
}
|
|
|
|
Variant::operator Vector<Plane>() const {
|
|
|
|
Array va= operator Array();
|
|
Vector<Plane> planes;
|
|
int va_size=va.size();
|
|
if (va_size==0)
|
|
return planes;
|
|
|
|
planes.resize(va_size);
|
|
|
|
for(int i=0;i<va_size;i++)
|
|
planes[i]=va[i];
|
|
|
|
return planes;
|
|
}
|
|
|
|
Variant::operator Vector<Variant>() const {
|
|
|
|
Array from=operator Array();
|
|
Vector<Variant> to;
|
|
int len=from.size();
|
|
to.resize(len);
|
|
for (int i=0;i<len;i++) {
|
|
|
|
to[i]=from[i];
|
|
}
|
|
return to;
|
|
|
|
}
|
|
|
|
Variant::operator Vector<uint8_t>() const {
|
|
|
|
DVector<uint8_t> from=operator DVector<uint8_t>();
|
|
Vector<uint8_t> to;
|
|
int len=from.size();
|
|
to.resize(len);
|
|
for (int i=0;i<len;i++) {
|
|
|
|
to[i]=from[i];
|
|
}
|
|
return to;
|
|
}
|
|
Variant::operator Vector<int>() const {
|
|
|
|
DVector<int> from=operator DVector<int>();
|
|
Vector<int> to;
|
|
int len=from.size();
|
|
to.resize(len);
|
|
for (int i=0;i<len;i++) {
|
|
|
|
to[i]=from[i];
|
|
}
|
|
return to;
|
|
}
|
|
Variant::operator Vector<real_t>() const {
|
|
|
|
DVector<real_t> from=operator DVector<real_t>();
|
|
Vector<real_t> to;
|
|
int len=from.size();
|
|
to.resize(len);
|
|
for (int i=0;i<len;i++) {
|
|
|
|
to[i]=from[i];
|
|
}
|
|
return to;
|
|
}
|
|
|
|
Variant::operator Vector<String>() const {
|
|
|
|
DVector<String> from=operator DVector<String>();
|
|
Vector<String> to;
|
|
int len=from.size();
|
|
to.resize(len);
|
|
for (int i=0;i<len;i++) {
|
|
|
|
to[i]=from[i];
|
|
}
|
|
return to;
|
|
|
|
}
|
|
Variant::operator Vector<Vector3>() const {
|
|
|
|
DVector<Vector3> from=operator DVector<Vector3>();
|
|
Vector<Vector3> to;
|
|
int len=from.size();
|
|
if (len==0)
|
|
return Vector<Vector3>();
|
|
to.resize(len);
|
|
DVector<Vector3>::Read r = from.read();
|
|
Vector3 *w = &to[0];
|
|
for (int i=0;i<len;i++) {
|
|
|
|
w[i]=r[i];
|
|
}
|
|
return to;
|
|
|
|
}
|
|
Variant::operator Vector<Color>() const {
|
|
|
|
DVector<Color> from=operator DVector<Color>();
|
|
Vector<Color> to;
|
|
int len=from.size();
|
|
if (len==0)
|
|
return Vector<Color>();
|
|
to.resize(len);
|
|
DVector<Color>::Read r = from.read();
|
|
Color *w = &to[0];
|
|
for (int i=0;i<len;i++) {
|
|
|
|
w[i]=r[i];
|
|
}
|
|
return to;
|
|
}
|
|
|
|
Variant::operator Margin() const {
|
|
|
|
return (Margin)operator int();
|
|
}
|
|
Variant::operator Orientation() const {
|
|
|
|
return (Orientation)operator int();
|
|
}
|
|
|
|
Variant::operator IP_Address() const {
|
|
|
|
if (type==REAL_ARRAY || type==INT_ARRAY || type==RAW_ARRAY) {
|
|
|
|
DVector<int> addr=operator DVector<int>();
|
|
if (addr.size()==4) {
|
|
return IP_Address(addr.get(0),addr.get(1),addr.get(2),addr.get(3));
|
|
}
|
|
}
|
|
|
|
return IP_Address( operator String() );
|
|
}
|
|
|
|
Variant::Variant(bool p_bool) {
|
|
|
|
type=BOOL;
|
|
_data._bool=p_bool;
|
|
}
|
|
|
|
/*
|
|
Variant::Variant(long unsigned int p_long) {
|
|
|
|
type=INT;
|
|
_data._int=p_long;
|
|
};
|
|
*/
|
|
|
|
Variant::Variant(signed int p_int) {
|
|
|
|
type=INT;
|
|
_data._int=p_int;
|
|
|
|
}
|
|
Variant::Variant(unsigned int p_int) {
|
|
|
|
type=INT;
|
|
_data._int=p_int;
|
|
|
|
}
|
|
|
|
#ifdef NEED_LONG_INT
|
|
|
|
Variant::Variant(signed long p_int) {
|
|
|
|
type=INT;
|
|
_data._int=p_int;
|
|
|
|
}
|
|
Variant::Variant(unsigned long p_int) {
|
|
|
|
type=INT;
|
|
_data._int=p_int;
|
|
|
|
}
|
|
#endif
|
|
|
|
Variant::Variant(int64_t p_int) {
|
|
|
|
type=INT;
|
|
_data._int=p_int;
|
|
|
|
}
|
|
|
|
Variant::Variant(uint64_t p_int) {
|
|
|
|
type=INT;
|
|
_data._int=p_int;
|
|
|
|
}
|
|
|
|
Variant::Variant(signed short p_short) {
|
|
|
|
type=INT;
|
|
_data._int=p_short;
|
|
|
|
}
|
|
Variant::Variant(unsigned short p_short) {
|
|
|
|
type=INT;
|
|
_data._int=p_short;
|
|
|
|
}
|
|
Variant::Variant(signed char p_char) {
|
|
|
|
type=INT;
|
|
_data._int=p_char;
|
|
|
|
}
|
|
Variant::Variant(unsigned char p_char) {
|
|
|
|
type=INT;
|
|
_data._int=p_char;
|
|
|
|
}
|
|
Variant::Variant(float p_float) {
|
|
|
|
type=REAL;
|
|
_data._real=p_float;
|
|
|
|
}
|
|
Variant::Variant(double p_double) {
|
|
|
|
type=REAL;
|
|
_data._real=p_double;
|
|
}
|
|
|
|
Variant::Variant(const StringName& p_string) {
|
|
|
|
type=STRING;
|
|
memnew_placement( _data._mem, String( p_string.operator String() ) );
|
|
|
|
}
|
|
Variant::Variant(const String& p_string) {
|
|
|
|
type=STRING;
|
|
memnew_placement( _data._mem, String( p_string ) );
|
|
|
|
}
|
|
|
|
Variant::Variant(const char * const p_cstring) {
|
|
|
|
type=STRING;
|
|
memnew_placement( _data._mem, String( (const char*)p_cstring ) );
|
|
|
|
}
|
|
|
|
Variant::Variant(const CharType * p_wstring) {
|
|
|
|
type=STRING;
|
|
memnew_placement( _data._mem, String( p_wstring ) );
|
|
|
|
}
|
|
Variant::Variant(const Vector3& p_vector3) {
|
|
|
|
type=VECTOR3;
|
|
memnew_placement( _data._mem, Vector3( p_vector3 ) );
|
|
|
|
}
|
|
Variant::Variant(const Vector2& p_vector2) {
|
|
|
|
type=VECTOR2;
|
|
memnew_placement( _data._mem, Vector2( p_vector2 ) );
|
|
|
|
}
|
|
Variant::Variant(const Rect2& p_rect2) {
|
|
|
|
type=RECT2;
|
|
memnew_placement( _data._mem, Rect2( p_rect2 ) );
|
|
|
|
}
|
|
|
|
Variant::Variant(const Plane& p_plane) {
|
|
|
|
type=PLANE;
|
|
memnew_placement( _data._mem, Plane( p_plane ) );
|
|
|
|
}
|
|
Variant::Variant(const AABB& p_aabb) {
|
|
|
|
type=_AABB;
|
|
_data._aabb = memnew( AABB( p_aabb ) );
|
|
}
|
|
|
|
Variant::Variant(const Matrix3& p_matrix) {
|
|
|
|
type=MATRIX3;
|
|
_data._matrix3= memnew( Matrix3( p_matrix ) );
|
|
|
|
}
|
|
|
|
Variant::Variant(const Quat& p_quat) {
|
|
|
|
type=QUAT;
|
|
memnew_placement( _data._mem, Quat( p_quat ) );
|
|
|
|
}
|
|
Variant::Variant(const Transform& p_transform) {
|
|
|
|
type=TRANSFORM;
|
|
_data._transform = memnew( Transform( p_transform ) );
|
|
|
|
}
|
|
|
|
Variant::Variant(const Matrix32& p_transform) {
|
|
|
|
type=MATRIX32;
|
|
_data._matrix32 = memnew( Matrix32( p_transform ) );
|
|
|
|
}
|
|
Variant::Variant(const Color& p_color) {
|
|
|
|
type=COLOR;
|
|
memnew_placement( _data._mem, Color(p_color) );
|
|
|
|
}
|
|
Variant::Variant(const Image& p_image) {
|
|
|
|
type=IMAGE;
|
|
_data._image=memnew( Image(p_image) );
|
|
|
|
}
|
|
|
|
Variant::Variant(const NodePath& p_node_path) {
|
|
|
|
type=NODE_PATH;
|
|
memnew_placement( _data._mem, NodePath(p_node_path) );
|
|
|
|
}
|
|
|
|
Variant::Variant(const InputEvent& p_input_event) {
|
|
|
|
type=INPUT_EVENT;
|
|
_data._input_event = memnew( InputEvent(p_input_event) );
|
|
|
|
}
|
|
|
|
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::Variant(const RID& p_rid) {
|
|
|
|
type=_RID;
|
|
memnew_placement( _data._mem, RID(p_rid) );
|
|
|
|
}
|
|
|
|
Variant::Variant(const Object* p_object) {
|
|
|
|
type=OBJECT;
|
|
|
|
memnew_placement( _data._mem, ObjData );
|
|
_get_obj().obj=const_cast<Object*>(p_object);
|
|
}
|
|
|
|
Variant::Variant(const Dictionary& p_dictionary) {
|
|
|
|
type=DICTIONARY;
|
|
memnew_placement( _data._mem, (Dictionary)( p_dictionary) );
|
|
|
|
}
|
|
|
|
Variant::Variant(const Array& p_array) {
|
|
|
|
type=ARRAY;
|
|
memnew_placement( _data._mem, Array(p_array) );
|
|
|
|
}
|
|
|
|
Variant::Variant(const DVector<Plane>& p_array) {
|
|
|
|
|
|
type=ARRAY;
|
|
|
|
Array *plane_array=memnew_placement( _data._mem, Array );
|
|
|
|
plane_array->resize( p_array.size() );
|
|
|
|
for (int i=0;i<p_array.size();i++) {
|
|
|
|
plane_array->operator [](i)=Variant(p_array[i]);
|
|
}
|
|
}
|
|
|
|
Variant::Variant(const Vector<Plane>& p_array) {
|
|
|
|
|
|
type=ARRAY;
|
|
|
|
Array *plane_array=memnew_placement( _data._mem, Array );
|
|
|
|
plane_array->resize( p_array.size() );
|
|
|
|
for (int i=0;i<p_array.size();i++) {
|
|
|
|
plane_array->operator [](i)=Variant(p_array[i]);
|
|
}
|
|
}
|
|
|
|
Variant::Variant(const Vector<RID>& p_array) {
|
|
|
|
|
|
type=ARRAY;
|
|
|
|
Array *rid_array=memnew_placement( _data._mem, Array );
|
|
|
|
rid_array->resize( p_array.size() );
|
|
|
|
for (int i=0;i<p_array.size();i++) {
|
|
|
|
rid_array->set(i,Variant(p_array[i]));
|
|
}
|
|
}
|
|
|
|
Variant::Variant(const Vector<Vector2>& p_array) {
|
|
|
|
|
|
type=NIL;
|
|
DVector<Vector2> v;
|
|
int len=p_array.size();
|
|
if (len>0) {
|
|
v.resize(len);
|
|
DVector<Vector2>::Write w = v.write();
|
|
const Vector2 *r = p_array.ptr();
|
|
|
|
for (int i=0;i<len;i++)
|
|
w[i]=r[i];
|
|
}
|
|
*this=v;
|
|
}
|
|
|
|
|
|
Variant::Variant(const DVector<uint8_t>& p_raw_array) {
|
|
|
|
type=RAW_ARRAY;
|
|
memnew_placement( _data._mem, DVector<uint8_t>(p_raw_array) );
|
|
|
|
}
|
|
Variant::Variant(const DVector<int>& p_int_array) {
|
|
|
|
type=INT_ARRAY;
|
|
memnew_placement( _data._mem, DVector<int>(p_int_array) );
|
|
|
|
}
|
|
Variant::Variant(const DVector<real_t>& p_real_array) {
|
|
|
|
type=REAL_ARRAY;
|
|
memnew_placement( _data._mem, DVector<real_t>(p_real_array) );
|
|
|
|
}
|
|
Variant::Variant(const DVector<String>& p_string_array) {
|
|
|
|
type=STRING_ARRAY;
|
|
memnew_placement( _data._mem, DVector<String>(p_string_array) );
|
|
|
|
}
|
|
Variant::Variant(const DVector<Vector3>& p_vector3_array) {
|
|
|
|
type=VECTOR3_ARRAY;
|
|
memnew_placement( _data._mem, DVector<Vector3>(p_vector3_array) );
|
|
|
|
}
|
|
|
|
Variant::Variant(const DVector<Vector2>& p_vector2_array) {
|
|
|
|
type=VECTOR2_ARRAY;
|
|
memnew_placement( _data._mem, DVector<Vector2>(p_vector2_array) );
|
|
|
|
}
|
|
Variant::Variant(const DVector<Color>& p_color_array) {
|
|
|
|
type=COLOR_ARRAY;
|
|
memnew_placement( _data._mem, DVector<Color>(p_color_array) );
|
|
}
|
|
|
|
Variant::Variant(const DVector<Face3>& p_face_array) {
|
|
|
|
|
|
DVector<Vector3> vertices;
|
|
int face_count=p_face_array.size();
|
|
vertices.resize(face_count*3);
|
|
|
|
if (face_count) {
|
|
DVector<Face3>::Read r = p_face_array.read();
|
|
DVector<Vector3>::Write w = vertices.write();
|
|
|
|
for(int i=0;i<face_count;i++) {
|
|
|
|
for(int j=0;j<3;j++)
|
|
w[i*3+j]=r[i].vertex[j];
|
|
}
|
|
|
|
r=DVector<Face3>::Read();
|
|
w=DVector<Vector3>::Write();
|
|
|
|
}
|
|
|
|
type = NIL;
|
|
|
|
*this = vertices;
|
|
}
|
|
|
|
/* helpers */
|
|
|
|
Variant::Variant(const Vector<Variant>& p_array) {
|
|
|
|
type=NIL;
|
|
Array v;
|
|
int len=p_array.size();
|
|
v.resize(len);
|
|
for (int i=0;i<len;i++)
|
|
v.set(i,p_array[i]);
|
|
*this=v;
|
|
}
|
|
|
|
Variant::Variant(const Vector<uint8_t>& p_array) {
|
|
|
|
type=NIL;
|
|
DVector<uint8_t> v;
|
|
int len=p_array.size();
|
|
v.resize(len);
|
|
for (int i=0;i<len;i++)
|
|
v.set(i,p_array[i]);
|
|
*this=v;
|
|
}
|
|
|
|
Variant::Variant(const Vector<int>& p_array) {
|
|
|
|
type=NIL;
|
|
DVector<int> v;
|
|
int len=p_array.size();
|
|
v.resize(len);
|
|
for (int i=0;i<len;i++)
|
|
v.set(i,p_array[i]);
|
|
*this=v;
|
|
}
|
|
|
|
Variant::Variant(const Vector<real_t>& p_array) {
|
|
|
|
type=NIL;
|
|
DVector<real_t> v;
|
|
int len=p_array.size();
|
|
v.resize(len);
|
|
for (int i=0;i<len;i++)
|
|
v.set(i,p_array[i]);
|
|
*this=v;
|
|
}
|
|
|
|
Variant::Variant(const Vector<String>& p_array) {
|
|
|
|
type=NIL;
|
|
DVector<String> v;
|
|
int len=p_array.size();
|
|
v.resize(len);
|
|
for (int i=0;i<len;i++)
|
|
v.set(i,p_array[i]);
|
|
*this=v;
|
|
}
|
|
|
|
Variant::Variant(const Vector<Vector3>& p_array) {
|
|
|
|
type=NIL;
|
|
DVector<Vector3> v;
|
|
int len=p_array.size();
|
|
if (len>0) {
|
|
v.resize(len);
|
|
DVector<Vector3>::Write w = v.write();
|
|
const Vector3 *r = p_array.ptr();
|
|
|
|
for (int i=0;i<len;i++)
|
|
w[i]=r[i];
|
|
}
|
|
*this=v;
|
|
}
|
|
|
|
Variant::Variant(const Vector<Color>& p_array) {
|
|
|
|
type=NIL;
|
|
DVector<Color> v;
|
|
int len=p_array.size();
|
|
v.resize(len);
|
|
for (int i=0;i<len;i++)
|
|
v.set(i,p_array[i]);
|
|
*this=v;
|
|
}
|
|
|
|
void Variant::operator=(const Variant& p_variant) {
|
|
|
|
reference(p_variant);
|
|
}
|
|
|
|
Variant::Variant(const IP_Address& p_address) {
|
|
|
|
type=STRING;
|
|
memnew_placement( _data._mem, String( p_address ) );
|
|
}
|
|
|
|
Variant::Variant(const Variant& p_variant) {
|
|
|
|
type=NIL;
|
|
reference(p_variant);
|
|
}
|
|
|
|
|
|
/*
|
|
Variant::~Variant() {
|
|
|
|
clear();
|
|
}*/
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
|
bool Variant::is_ref() const {
|
|
|
|
return type==OBJECT && !_get_obj().ref.is_null();
|
|
}
|
|
|
|
|
|
Vector<Variant> varray() {
|
|
|
|
return Vector<Variant>();
|
|
}
|
|
|
|
Vector<Variant> varray(const Variant& p_arg1) {
|
|
|
|
Vector<Variant> v;
|
|
v.push_back(p_arg1);
|
|
return v;
|
|
}
|
|
Vector<Variant> varray(const Variant& p_arg1,const Variant& p_arg2) {
|
|
|
|
Vector<Variant> v;
|
|
v.push_back(p_arg1);
|
|
v.push_back(p_arg2);
|
|
return v;
|
|
}
|
|
Vector<Variant> varray(const Variant& p_arg1,const Variant& p_arg2,const Variant& p_arg3) {
|
|
|
|
Vector<Variant> v;
|
|
v.push_back(p_arg1);
|
|
v.push_back(p_arg2);
|
|
v.push_back(p_arg3);
|
|
return v;
|
|
}
|
|
Vector<Variant> varray(const Variant& p_arg1,const Variant& p_arg2,const Variant& p_arg3,const Variant& p_arg4) {
|
|
|
|
Vector<Variant> v;
|
|
v.push_back(p_arg1);
|
|
v.push_back(p_arg2);
|
|
v.push_back(p_arg3);
|
|
v.push_back(p_arg4);
|
|
return v;
|
|
}
|
|
|
|
Vector<Variant> varray(const Variant& p_arg1,const Variant& p_arg2,const Variant& p_arg3,const Variant& p_arg4,const Variant& p_arg5) {
|
|
|
|
Vector<Variant> v;
|
|
v.push_back(p_arg1);
|
|
v.push_back(p_arg2);
|
|
v.push_back(p_arg3);
|
|
v.push_back(p_arg4);
|
|
v.push_back(p_arg5);
|
|
return v;
|
|
|
|
}
|
|
|
|
void Variant::static_assign(const Variant& p_variant) {
|
|
|
|
|
|
}
|
|
|
|
bool Variant::is_shared() const {
|
|
|
|
switch(type) {
|
|
|
|
case OBJECT: return true;
|
|
case ARRAY: return reinterpret_cast<const Array*>(_data._mem)->is_shared();
|
|
case DICTIONARY: return reinterpret_cast<const Dictionary*>(_data._mem)->is_shared();
|
|
default: {}
|
|
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
Variant Variant::call(const StringName& p_method,VARIANT_ARG_DECLARE) {
|
|
VARIANT_ARGPTRS;
|
|
int argc=0;
|
|
for(int i=0;i<VARIANT_ARG_MAX;i++) {
|
|
if (argptr[i]->get_type()==Variant::NIL)
|
|
break;
|
|
argc++;
|
|
}
|
|
|
|
CallError error;
|
|
|
|
Variant ret = call(p_method,argptr,argc,error);
|
|
|
|
switch(error.error) {
|
|
|
|
case CallError::CALL_ERROR_INVALID_ARGUMENT: {
|
|
|
|
String err = "Invalid type for argument #"+itos(error.argument)+", expected '"+Variant::get_type_name(error.expected)+"'.";
|
|
ERR_PRINT(err.utf8().get_data());
|
|
|
|
} break;
|
|
case CallError::CALL_ERROR_INVALID_METHOD: {
|
|
|
|
String err = "Invalid method '"+p_method+"' for type '"+Variant::get_type_name(type)+"'.";
|
|
ERR_PRINT(err.utf8().get_data());
|
|
} break;
|
|
case CallError::CALL_ERROR_TOO_MANY_ARGUMENTS: {
|
|
|
|
String err = "Too many arguments for method '"+p_method+"'";
|
|
ERR_PRINT(err.utf8().get_data());
|
|
} break;
|
|
default: {}
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
|
|
String Variant::get_construct_string() const {
|
|
|
|
switch( type ) {
|
|
|
|
case NIL: return "null";
|
|
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 "Vector2("+operator Vector2()+")";
|
|
case RECT2: return "Rect2("+operator Rect2()+")";
|
|
case MATRIX32: return "Matrix32("+operator Matrix32()+")";
|
|
case VECTOR3: return "Vector3("+operator Vector3()+")";
|
|
case PLANE: return "Plane("+operator Plane()+")";
|
|
//case QUAT:
|
|
case _AABB: return "AABB("+operator AABB()+")";
|
|
case QUAT: return "Quat("+operator Quat()+")";
|
|
case MATRIX3: return "Matrix3("+operator Matrix3()+")";
|
|
case TRANSFORM: return "Transform("+operator Transform()+")";
|
|
case NODE_PATH: return "@\""+operator NodePath()+"\"";
|
|
case INPUT_EVENT: return "InputEvent()";
|
|
case COLOR: return "Color("+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=E->get().get_construct_string();
|
|
sp.value=d[E->get()].get_construct_string();
|
|
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+")";
|
|
}
|
|
str+="}";
|
|
|
|
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+=Variant( vec[i] ).get_construct_string();
|
|
}
|
|
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+=Variant( vec[i] ).get_construct_string();
|
|
}
|
|
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 += arr[i].get_construct_string();
|
|
};
|
|
return str+"]";
|
|
|
|
} break;
|
|
case OBJECT: {
|
|
|
|
if (_get_obj().obj)
|
|
return _get_obj().obj->get_type()+".new()";
|
|
else
|
|
return "null";
|
|
|
|
} break;
|
|
default: {
|
|
return "["+get_type_name(type)+"]";
|
|
}
|
|
}
|
|
|
|
}
|