From 5dbf1809c6e3e905b94b8764e99491e608122261 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?R=C3=A9mi=20Verschelde?= Date: Sun, 5 Mar 2017 16:44:50 +0100 Subject: A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code --- core/variant.cpp | 1833 ++++++++++++++++++++++++++---------------------------- 1 file changed, 867 insertions(+), 966 deletions(-) (limited to 'core/variant.cpp') diff --git a/core/variant.cpp b/core/variant.cpp index 6fd0618250..771d97a4eb 100644 --- a/core/variant.cpp +++ b/core/variant.cpp @@ -28,25 +28,24 @@ /*************************************************************************/ #include "variant.h" +#include "core_string_names.h" +#include "io/marshalls.h" #include "math_funcs.h" -#include "resource.h" #include "print_string.h" -#include "scene/main/node.h" +#include "resource.h" #include "scene/gui/control.h" -#include "io/marshalls.h" -#include "core_string_names.h" +#include "scene/main/node.h" #include "variant_parser.h" - String Variant::get_type_name(Variant::Type p_type) { - switch( p_type ) { + switch (p_type) { case NIL: { return "Nil"; } break; - // atomic types + // atomic types case BOOL: { return "bool"; @@ -66,7 +65,7 @@ String Variant::get_type_name(Variant::Type p_type) { return "String"; } break; - // math types + // math types case VECTOR2: { @@ -89,7 +88,7 @@ String Variant::get_type_name(Variant::Type p_type) { return "Plane"; } break; - /* + /* case QUAT: { @@ -114,7 +113,7 @@ String Variant::get_type_name(Variant::Type p_type) { } break; - // misc types + // misc types case COLOR: { return "Color"; @@ -154,7 +153,7 @@ String Variant::get_type_name(Variant::Type p_type) { } break; - // arrays + // arrays case POOL_BYTE_ARRAY: { return "PoolByteArray"; @@ -190,114 +189,110 @@ String Variant::get_type_name(Variant::Type p_type) { } break; default: {} - } + } return ""; } +bool Variant::can_convert(Variant::Type p_type_from, Variant::Type p_type_to) { -bool Variant::can_convert(Variant::Type p_type_from,Variant::Type p_type_to) { - - if (p_type_from==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 + 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; + const Type *valid_types = NULL; + const Type *invalid_types = NULL; - switch(p_type_to) { + switch (p_type_to) { case BOOL: { - static const Type valid[]={ + static const Type valid[] = { INT, REAL, STRING, NIL, }; - valid_types=valid; + valid_types = valid; } break; case INT: { - static const Type valid[]={ + static const Type valid[] = { BOOL, REAL, STRING, NIL, }; - valid_types=valid; + valid_types = valid; } break; case REAL: { - static const Type valid[]={ + static const Type valid[] = { BOOL, INT, STRING, NIL, }; - valid_types=valid; + valid_types = valid; } break; case STRING: { - - static const Type invalid[]={ + static const Type invalid[] = { OBJECT, IMAGE, NIL }; - invalid_types=invalid; + invalid_types = invalid; } break; case TRANSFORM2D: { - - static const Type valid[]={ + static const Type valid[] = { TRANSFORM, NIL }; - valid_types=valid; + valid_types = valid; } break; case QUAT: { - static const Type valid[]={ + static const Type valid[] = { BASIS, NIL }; - valid_types=valid; + valid_types = valid; } break; case BASIS: { - static const Type valid[]={ + static const Type valid[] = { QUAT, NIL }; - valid_types=valid; - + valid_types = valid; } break; case TRANSFORM: { - static const Type valid[]={ + static const Type valid[] = { TRANSFORM2D, QUAT, BASIS, NIL }; - valid_types=valid; + valid_types = valid; } break; @@ -315,34 +310,33 @@ bool Variant::can_convert(Variant::Type p_type_from,Variant::Type p_type_to) { case _RID: { - static const Type valid[]={ + static const Type valid[] = { OBJECT, NIL }; - valid_types=valid; + valid_types = valid; } break; case OBJECT: { - static const Type valid[]={ + static const Type valid[] = { NIL }; - valid_types=valid; + valid_types = valid; } break; case NODE_PATH: { - static const Type valid[]={ + static const Type valid[] = { STRING, NIL }; - valid_types=valid; + valid_types = valid; } break; case ARRAY: { - - static const Type valid[]={ + static const Type valid[] = { POOL_BYTE_ARRAY, POOL_INT_ARRAY, POOL_STRING_ARRAY, @@ -353,92 +347,90 @@ bool Variant::can_convert(Variant::Type p_type_from,Variant::Type p_type_to) { NIL }; - valid_types=valid; + valid_types = valid; } break; - // arrays + // arrays case POOL_BYTE_ARRAY: { - static const Type valid[]={ + static const Type valid[] = { ARRAY, NIL }; - valid_types=valid; + valid_types = valid; } break; case POOL_INT_ARRAY: { - static const Type valid[]={ + static const Type valid[] = { ARRAY, NIL }; - valid_types=valid; + valid_types = valid; } break; case POOL_REAL_ARRAY: { - static const Type valid[]={ + static const Type valid[] = { ARRAY, NIL }; - valid_types=valid; + valid_types = valid; } break; case POOL_STRING_ARRAY: { - static const Type valid[]={ + static const Type valid[] = { ARRAY, NIL }; - valid_types=valid; + valid_types = valid; } break; case POOL_VECTOR2_ARRAY: { - static const Type valid[]={ + static const Type valid[] = { ARRAY, NIL }; - valid_types=valid; + valid_types = valid; } break; case POOL_VECTOR3_ARRAY: { - static const Type valid[]={ + static const Type valid[] = { ARRAY, NIL }; - valid_types=valid; + valid_types = valid; } break; case POOL_COLOR_ARRAY: { - static const Type valid[]={ + static const Type valid[] = { ARRAY, NIL }; - valid_types=valid; + valid_types = valid; } break; default: {} } - if (valid_types) { - int i=0; - while(valid_types[i]!=NIL) { + int i = 0; + while (valid_types[i] != NIL) { - if (p_type_from==valid_types[i]) + if (p_type_from == valid_types[i]) return true; i++; } } else if (invalid_types) { + int i = 0; + while (invalid_types[i] != NIL) { - int i=0; - while(invalid_types[i]!=NIL) { - - if (p_type_from==invalid_types[i]) + if (p_type_from == invalid_types[i]) return false; i++; } @@ -447,109 +439,105 @@ bool Variant::can_convert(Variant::Type p_type_from,Variant::Type p_type_to) { } return false; - } -bool Variant::can_convert_strict(Variant::Type p_type_from,Variant::Type p_type_to) { +bool Variant::can_convert_strict(Variant::Type p_type_from, Variant::Type p_type_to) { - if (p_type_from==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 + 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 *valid_types = NULL; - switch(p_type_to) { + switch (p_type_to) { case BOOL: { - static const Type valid[]={ + static const Type valid[] = { INT, REAL, //STRING, NIL, }; - valid_types=valid; + valid_types = valid; } break; case INT: { - static const Type valid[]={ + static const Type valid[] = { BOOL, REAL, //STRING, NIL, }; - valid_types=valid; + valid_types = valid; } break; case REAL: { - static const Type valid[]={ + static const Type valid[] = { BOOL, INT, //STRING, NIL, }; - valid_types=valid; + valid_types = valid; } break; case STRING: { - - static const Type valid[]={ + static const Type valid[] = { NODE_PATH, NIL }; - valid_types=valid; + valid_types = valid; } break; case TRANSFORM2D: { - - static const Type valid[]={ + static const Type valid[] = { TRANSFORM, NIL }; - valid_types=valid; + valid_types = valid; } break; case QUAT: { - static const Type valid[]={ + static const Type valid[] = { BASIS, NIL }; - valid_types=valid; + valid_types = valid; } break; case BASIS: { - static const Type valid[]={ + static const Type valid[] = { QUAT, NIL }; - valid_types=valid; - + valid_types = valid; } break; case TRANSFORM: { - static const Type valid[]={ + static const Type valid[] = { TRANSFORM2D, QUAT, BASIS, NIL }; - valid_types=valid; + valid_types = valid; } break; @@ -567,34 +555,33 @@ bool Variant::can_convert_strict(Variant::Type p_type_from,Variant::Type p_type_ case _RID: { - static const Type valid[]={ + static const Type valid[] = { OBJECT, NIL }; - valid_types=valid; + valid_types = valid; } break; case OBJECT: { - static const Type valid[]={ + static const Type valid[] = { NIL }; - valid_types=valid; + valid_types = valid; } break; case NODE_PATH: { - static const Type valid[]={ + static const Type valid[] = { STRING, NIL }; - valid_types=valid; + valid_types = valid; } break; case ARRAY: { - - static const Type valid[]={ + static const Type valid[] = { POOL_BYTE_ARRAY, POOL_INT_ARRAY, POOL_STRING_ARRAY, @@ -605,124 +592,120 @@ bool Variant::can_convert_strict(Variant::Type p_type_from,Variant::Type p_type_ NIL }; - valid_types=valid; + valid_types = valid; } break; - // arrays + // arrays case POOL_BYTE_ARRAY: { - static const Type valid[]={ + static const Type valid[] = { ARRAY, NIL }; - valid_types=valid; + valid_types = valid; } break; case POOL_INT_ARRAY: { - static const Type valid[]={ + static const Type valid[] = { ARRAY, NIL }; - valid_types=valid; + valid_types = valid; } break; case POOL_REAL_ARRAY: { - static const Type valid[]={ + static const Type valid[] = { ARRAY, NIL }; - valid_types=valid; + valid_types = valid; } break; case POOL_STRING_ARRAY: { - static const Type valid[]={ + static const Type valid[] = { ARRAY, NIL }; - valid_types=valid; + valid_types = valid; } break; case POOL_VECTOR2_ARRAY: { - static const Type valid[]={ + static const Type valid[] = { ARRAY, NIL }; - valid_types=valid; + valid_types = valid; } break; case POOL_VECTOR3_ARRAY: { - static const Type valid[]={ + static const Type valid[] = { ARRAY, NIL }; - valid_types=valid; + valid_types = valid; } break; case POOL_COLOR_ARRAY: { - static const Type valid[]={ + static const Type valid[] = { ARRAY, NIL }; - valid_types=valid; + valid_types = valid; } break; default: {} } - if (valid_types) { - int i=0; - while(valid_types[i]!=NIL) { + int i = 0; + while (valid_types[i] != NIL) { - if (p_type_from==valid_types[i]) + if (p_type_from == valid_types[i]) return true; i++; } } return false; - } -bool Variant::operator==(const Variant& p_variant) const { +bool Variant::operator==(const Variant &p_variant) const { - if (type!=p_variant.type) //evaluation of operator== needs to be more strict + 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); + evaluate(OP_EQUAL, *this, p_variant, r, v); return r; - } -bool Variant::operator!=(const Variant& p_variant) const { +bool Variant::operator!=(const Variant &p_variant) const { - if (type!=p_variant.type) //evaluation of operator== needs to be more strict + if (type != p_variant.type) //evaluation of operator== needs to be more strict return true; bool v; Variant r; - evaluate(OP_NOT_EQUAL,*this,p_variant,r,v); + evaluate(OP_NOT_EQUAL, *this, p_variant, r, v); return r; - } -bool Variant::operator<(const Variant& p_variant) const { - if (type!=p_variant.type) //if types differ, then order by type first - return type(_data._mem)==String(); + return *reinterpret_cast(_data._mem) == String(); } break; @@ -753,46 +736,46 @@ bool Variant::is_zero() const { case VECTOR2: { - return *reinterpret_cast(_data._mem)==Vector2(); + return *reinterpret_cast(_data._mem) == Vector2(); } break; case RECT2: { - return *reinterpret_cast(_data._mem)==Rect2(); + return *reinterpret_cast(_data._mem) == Rect2(); } break; case TRANSFORM2D: { - return *_data._transform2d==Transform2D(); + return *_data._transform2d == Transform2D(); } break; case VECTOR3: { - return *reinterpret_cast(_data._mem)==Vector3(); + return *reinterpret_cast(_data._mem) == Vector3(); } break; case PLANE: { - return *reinterpret_cast(_data._mem)==Plane(); + return *reinterpret_cast(_data._mem) == Plane(); } break; -/* + /* case QUAT: { } break;*/ case RECT3: { - return *_data._rect3==Rect3(); + return *_data._rect3 == Rect3(); } break; case QUAT: { - return *reinterpret_cast(_data._mem)==Quat(); + return *reinterpret_cast(_data._mem) == Quat(); } break; case BASIS: { - return *_data._basis==Basis(); + return *_data._basis == Basis(); } break; case TRANSFORM: { @@ -804,7 +787,7 @@ bool Variant::is_zero() const { // misc types case COLOR: { - return *reinterpret_cast(_data._mem)==Color(); + return *reinterpret_cast(_data._mem) == Color(); } break; case IMAGE: { @@ -814,67 +797,67 @@ bool Variant::is_zero() const { } break; case _RID: { - return *reinterpret_cast(_data._mem)==RID(); + return *reinterpret_cast(_data._mem) == RID(); } break; case OBJECT: { - return _get_obj().obj==NULL; + return _get_obj().obj == NULL; } break; case NODE_PATH: { - return reinterpret_cast(_data._mem)->is_empty(); + return reinterpret_cast(_data._mem)->is_empty(); } break; case INPUT_EVENT: { - return _data._input_event->type==InputEvent::NONE; + return _data._input_event->type == InputEvent::NONE; } break; case DICTIONARY: { - return reinterpret_cast(_data._mem)->empty(); + return reinterpret_cast(_data._mem)->empty(); } break; case ARRAY: { - return reinterpret_cast(_data._mem)->empty(); + return reinterpret_cast(_data._mem)->empty(); } break; // arrays case POOL_BYTE_ARRAY: { - return reinterpret_cast*>(_data._mem)->size()==0; + return reinterpret_cast *>(_data._mem)->size() == 0; } break; case POOL_INT_ARRAY: { - return reinterpret_cast*>(_data._mem)->size()==0; + return reinterpret_cast *>(_data._mem)->size() == 0; } break; case POOL_REAL_ARRAY: { - return reinterpret_cast*>(_data._mem)->size()==0; + return reinterpret_cast *>(_data._mem)->size() == 0; } break; case POOL_STRING_ARRAY: { - return reinterpret_cast*>(_data._mem)->size()==0; + return reinterpret_cast *>(_data._mem)->size() == 0; } break; case POOL_VECTOR2_ARRAY: { - return reinterpret_cast*>(_data._mem)->size()==0; + return reinterpret_cast *>(_data._mem)->size() == 0; } break; case POOL_VECTOR3_ARRAY: { - return reinterpret_cast*>(_data._mem)->size()==0; + return reinterpret_cast *>(_data._mem)->size() == 0; } break; case POOL_COLOR_ARRAY: { - return reinterpret_cast*>(_data._mem)->size()==0; + return reinterpret_cast *>(_data._mem)->size() == 0; } break; default: {} @@ -883,10 +866,9 @@ bool Variant::is_zero() const { return false; } - bool Variant::is_one() const { - switch( type ) { + switch (type) { case NIL: { return true; @@ -895,41 +877,41 @@ bool Variant::is_one() const { // atomic types case BOOL: { - return _data._bool==true; + return _data._bool == true; } break; case INT: { - return _data._int==1; + return _data._int == 1; } break; case REAL: { - return _data._real==1; + return _data._real == 1; } break; case VECTOR2: { - return *reinterpret_cast(_data._mem)==Vector2(1,1); + return *reinterpret_cast(_data._mem) == Vector2(1, 1); } break; case RECT2: { - return *reinterpret_cast(_data._mem)==Rect2(1,1,1,1); + return *reinterpret_cast(_data._mem) == Rect2(1, 1, 1, 1); } break; case VECTOR3: { - return *reinterpret_cast(_data._mem)==Vector3(1,1,1); + return *reinterpret_cast(_data._mem) == Vector3(1, 1, 1); } break; case PLANE: { - return *reinterpret_cast(_data._mem)==Plane(1,1,1,1); + return *reinterpret_cast(_data._mem) == Plane(1, 1, 1, 1); } break; case COLOR: { - return *reinterpret_cast(_data._mem)==Color(1,1,1,1); + return *reinterpret_cast(_data._mem) == Color(1, 1, 1, 1); } break; @@ -939,18 +921,16 @@ bool Variant::is_one() const { return false; } - -void Variant::reference(const Variant& p_variant) { - +void Variant::reference(const Variant &p_variant) { if (this == &p_variant) return; clear(); - type=p_variant.type; + type = p_variant.type; - switch( p_variant.type ) { + switch (p_variant.type) { case NIL: { // none @@ -959,21 +939,21 @@ void Variant::reference(const Variant& p_variant) { // atomic types case BOOL: { - _data._bool=p_variant._data._bool; + _data._bool = p_variant._data._bool; } break; case INT: { - _data._int=p_variant._data._int; + _data._int = p_variant._data._int; } break; case REAL: { - _data._real=p_variant._data._real; + _data._real = p_variant._data._real; } break; case STRING: { - memnew_placement( _data._mem, String( *reinterpret_cast(p_variant._data._mem) ) ); + memnew_placement(_data._mem, String(*reinterpret_cast(p_variant._data._mem))); } break; @@ -981,158 +961,156 @@ void Variant::reference(const Variant& p_variant) { case VECTOR2: { - memnew_placement( _data._mem, Vector2( *reinterpret_cast(p_variant._data._mem) ) ); + memnew_placement(_data._mem, Vector2(*reinterpret_cast(p_variant._data._mem))); } break; case RECT2: { - memnew_placement( _data._mem, Rect2( *reinterpret_cast(p_variant._data._mem) ) ); + memnew_placement(_data._mem, Rect2(*reinterpret_cast(p_variant._data._mem))); } break; case TRANSFORM2D: { - _data._transform2d = memnew( Transform2D( *p_variant._data._transform2d ) ); + _data._transform2d = memnew(Transform2D(*p_variant._data._transform2d)); } break; case VECTOR3: { - memnew_placement( _data._mem, Vector3( *reinterpret_cast(p_variant._data._mem) ) ); + memnew_placement(_data._mem, Vector3(*reinterpret_cast(p_variant._data._mem))); } break; case PLANE: { - memnew_placement( _data._mem, Plane( *reinterpret_cast(p_variant._data._mem) ) ); + memnew_placement(_data._mem, Plane(*reinterpret_cast(p_variant._data._mem))); } break; -/* + /* case QUAT: { } break;*/ case RECT3: { - _data._rect3 = memnew( Rect3( *p_variant._data._rect3 ) ); + _data._rect3 = memnew(Rect3(*p_variant._data._rect3)); } break; case QUAT: { - memnew_placement( _data._mem, Quat( *reinterpret_cast(p_variant._data._mem) ) ); + memnew_placement(_data._mem, Quat(*reinterpret_cast(p_variant._data._mem))); } break; case BASIS: { - _data._basis = memnew( Basis( *p_variant._data._basis ) ); + _data._basis = memnew(Basis(*p_variant._data._basis)); } break; case TRANSFORM: { - _data._transform = memnew( Transform( *p_variant._data._transform ) ); + _data._transform = memnew(Transform(*p_variant._data._transform)); } break; // misc types case COLOR: { - memnew_placement( _data._mem, Color( *reinterpret_cast(p_variant._data._mem) ) ); + memnew_placement(_data._mem, Color(*reinterpret_cast(p_variant._data._mem))); } break; case IMAGE: { - _data._image = memnew( Image( *p_variant._data._image ) ); + _data._image = memnew(Image(*p_variant._data._image)); } break; case _RID: { - memnew_placement( _data._mem, RID( *reinterpret_cast(p_variant._data._mem) ) ); + memnew_placement(_data._mem, RID(*reinterpret_cast(p_variant._data._mem))); } break; case OBJECT: { - memnew_placement( _data._mem, ObjData( p_variant._get_obj() ) ); + memnew_placement(_data._mem, ObjData(p_variant._get_obj())); } break; case NODE_PATH: { - memnew_placement( _data._mem, NodePath( *reinterpret_cast(p_variant._data._mem) ) ); + memnew_placement(_data._mem, NodePath(*reinterpret_cast(p_variant._data._mem))); } break; case INPUT_EVENT: { - _data._input_event= memnew( InputEvent( *p_variant._data._input_event ) ); + _data._input_event = memnew(InputEvent(*p_variant._data._input_event)); } break; case DICTIONARY: { - memnew_placement( _data._mem, Dictionary( *reinterpret_cast(p_variant._data._mem) ) ); + memnew_placement(_data._mem, Dictionary(*reinterpret_cast(p_variant._data._mem))); } break; case ARRAY: { - memnew_placement( _data._mem, Array ( *reinterpret_cast(p_variant._data._mem) ) ); + memnew_placement(_data._mem, Array(*reinterpret_cast(p_variant._data._mem))); } break; // arrays case POOL_BYTE_ARRAY: { - memnew_placement( _data._mem, PoolVector ( *reinterpret_cast*>(p_variant._data._mem) ) ); + memnew_placement(_data._mem, PoolVector(*reinterpret_cast *>(p_variant._data._mem))); } break; case POOL_INT_ARRAY: { - memnew_placement( _data._mem, PoolVector ( *reinterpret_cast*>(p_variant._data._mem) ) ); + memnew_placement(_data._mem, PoolVector(*reinterpret_cast *>(p_variant._data._mem))); } break; case POOL_REAL_ARRAY: { - memnew_placement( _data._mem, PoolVector ( *reinterpret_cast*>(p_variant._data._mem) ) ); + memnew_placement(_data._mem, PoolVector(*reinterpret_cast *>(p_variant._data._mem))); } break; case POOL_STRING_ARRAY: { - memnew_placement( _data._mem, PoolVector ( *reinterpret_cast*>(p_variant._data._mem) ) ); + memnew_placement(_data._mem, PoolVector(*reinterpret_cast *>(p_variant._data._mem))); } break; case POOL_VECTOR2_ARRAY: { - memnew_placement( _data._mem, PoolVector ( *reinterpret_cast*>(p_variant._data._mem) ) ); + memnew_placement(_data._mem, PoolVector(*reinterpret_cast *>(p_variant._data._mem))); } break; case POOL_VECTOR3_ARRAY: { - memnew_placement( _data._mem, PoolVector ( *reinterpret_cast*>(p_variant._data._mem) ) ); + memnew_placement(_data._mem, PoolVector(*reinterpret_cast *>(p_variant._data._mem))); } break; case POOL_COLOR_ARRAY: { - memnew_placement( _data._mem, PoolVector ( *reinterpret_cast*>(p_variant._data._mem) ) ); + memnew_placement(_data._mem, PoolVector(*reinterpret_cast *>(p_variant._data._mem))); } break; default: {} } - - } void Variant::zero() { - switch(type) { + switch (type) { case NIL: break; case BOOL: this->_data._bool = false; break; case INT: this->_data._int = 0; break; case REAL: this->_data._real = 0; break; - case VECTOR2: *reinterpret_cast(this->_data._mem) = Vector2(); break; - case RECT2: *reinterpret_cast(this->_data._mem) = Rect2(); break; - case VECTOR3: *reinterpret_cast(this->_data._mem) = Vector3(); break; - case PLANE: *reinterpret_cast(this->_data._mem) = Plane(); break; - case QUAT: *reinterpret_cast(this->_data._mem) = Quat(); break; - case COLOR: *reinterpret_cast(this->_data._mem) = Color(); break; + case VECTOR2: *reinterpret_cast(this->_data._mem) = Vector2(); break; + case RECT2: *reinterpret_cast(this->_data._mem) = Rect2(); break; + case VECTOR3: *reinterpret_cast(this->_data._mem) = Vector3(); break; + case PLANE: *reinterpret_cast(this->_data._mem) = Plane(); break; + case QUAT: *reinterpret_cast(this->_data._mem) = Quat(); break; + case COLOR: *reinterpret_cast(this->_data._mem) = Color(); break; default: this->clear(); break; } } void Variant::clear() { - switch(type) { + switch (type) { case STRING: { - reinterpret_cast(_data._mem)->~String(); + reinterpret_cast(_data._mem)->~String(); } break; - /* + /* // no point, they don't allocate memory VECTOR3, PLANE, @@ -1143,107 +1121,105 @@ void Variant::clear() { */ case TRANSFORM2D: { - memdelete( _data._transform2d ); + memdelete(_data._transform2d); } break; case RECT3: { - memdelete( _data._rect3 ); + memdelete(_data._rect3); } break; case BASIS: { - memdelete( _data._basis ); + memdelete(_data._basis); } break; case TRANSFORM: { - memdelete( _data._transform ); + memdelete(_data._transform); } break; // misc types case IMAGE: { - memdelete( _data._image ); + memdelete(_data._image); } break; case NODE_PATH: { - reinterpret_cast(_data._mem)->~NodePath(); + reinterpret_cast(_data._mem)->~NodePath(); } break; case OBJECT: { - _get_obj().obj=NULL; + _get_obj().obj = NULL; _get_obj().ref.unref(); } break; case _RID: { // not much need probably - reinterpret_cast(_data._mem)->~RID(); + reinterpret_cast(_data._mem)->~RID(); } break; case DICTIONARY: { - reinterpret_cast(_data._mem)->~Dictionary(); + reinterpret_cast(_data._mem)->~Dictionary(); } break; case ARRAY: { - reinterpret_cast(_data._mem)->~Array(); + reinterpret_cast(_data._mem)->~Array(); } break; case INPUT_EVENT: { - memdelete( _data._input_event ); + memdelete(_data._input_event); } break; // arrays case POOL_BYTE_ARRAY: { - reinterpret_cast< PoolVector* >(_data._mem)->~PoolVector(); + reinterpret_cast *>(_data._mem)->~PoolVector(); } break; case POOL_INT_ARRAY: { - reinterpret_cast< PoolVector* >(_data._mem)->~PoolVector(); + reinterpret_cast *>(_data._mem)->~PoolVector(); } break; case POOL_REAL_ARRAY: { - reinterpret_cast< PoolVector* >(_data._mem)->~PoolVector(); + reinterpret_cast *>(_data._mem)->~PoolVector(); } break; case POOL_STRING_ARRAY: { - reinterpret_cast< PoolVector* >(_data._mem)->~PoolVector(); + reinterpret_cast *>(_data._mem)->~PoolVector(); } break; case POOL_VECTOR2_ARRAY: { - reinterpret_cast< PoolVector* >(_data._mem)->~PoolVector(); + reinterpret_cast *>(_data._mem)->~PoolVector(); } break; case POOL_VECTOR3_ARRAY: { - reinterpret_cast< PoolVector* >(_data._mem)->~PoolVector(); + reinterpret_cast *>(_data._mem)->~PoolVector(); } break; case POOL_COLOR_ARRAY: { - reinterpret_cast< PoolVector* >(_data._mem)->~PoolVector(); + reinterpret_cast *>(_data._mem)->~PoolVector(); } break; default: {} /* not needed */ } - type=NIL; - + type = NIL; } - Variant::operator signed int() const { - switch( type ) { + switch (type) { case NIL: return 0; case BOOL: return _data._bool ? 1 : 0; @@ -1260,7 +1236,7 @@ Variant::operator signed int() const { } Variant::operator unsigned int() const { - switch( type ) { + switch (type) { case NIL: return 0; case BOOL: return _data._bool ? 1 : 0; @@ -1278,7 +1254,7 @@ Variant::operator unsigned int() const { Variant::operator int64_t() const { - switch( type ) { + switch (type) { case NIL: return 0; case BOOL: return _data._bool ? 1 : 0; @@ -1316,7 +1292,7 @@ Variant::operator long unsigned int() const { Variant::operator uint64_t() const { - switch( type ) { + switch (type) { case NIL: return 0; case BOOL: return _data._bool ? 1 : 0; @@ -1335,7 +1311,7 @@ Variant::operator uint64_t() const { #ifdef NEED_LONG_INT Variant::operator signed long() const { - switch( type ) { + switch (type) { case NIL: return 0; case BOOL: return _data._bool ? 1 : 0; @@ -1353,7 +1329,7 @@ Variant::operator signed long() const { Variant::operator unsigned long() const { - switch( type ) { + switch (type) { case NIL: return 0; case BOOL: return _data._bool ? 1 : 0; @@ -1370,10 +1346,9 @@ Variant::operator unsigned long() const { }; #endif - Variant::operator signed short() const { - switch( type ) { + switch (type) { case NIL: return 0; case BOOL: return _data._bool ? 1 : 0; @@ -1390,7 +1365,7 @@ Variant::operator signed short() const { } Variant::operator unsigned short() const { - switch( type ) { + switch (type) { case NIL: return 0; case BOOL: return _data._bool ? 1 : 0; @@ -1407,7 +1382,7 @@ Variant::operator unsigned short() const { } Variant::operator signed char() const { - switch( type ) { + switch (type) { case NIL: return 0; case BOOL: return _data._bool ? 1 : 0; @@ -1424,7 +1399,7 @@ Variant::operator signed char() const { } Variant::operator unsigned char() const { - switch( type ) { + switch (type) { case NIL: return 0; case BOOL: return _data._bool ? 1 : 0; @@ -1445,10 +1420,9 @@ Variant::operator CharType() const { return operator unsigned int(); } - Variant::operator float() const { - switch( type ) { + switch (type) { case NIL: return 0; case BOOL: return _data._bool ? 1.0 : 0.0; @@ -1465,7 +1439,7 @@ Variant::operator float() const { } Variant::operator double() const { - switch( type ) { + switch (type) { case NIL: return 0; case BOOL: return _data._bool ? 1.0 : 0.0; @@ -1483,8 +1457,8 @@ Variant::operator double() const { Variant::operator StringName() const { - if (type==NODE_PATH) { - return reinterpret_cast(_data._mem)->get_sname(); + if (type == NODE_PATH) { + return reinterpret_cast(_data._mem)->get_sname(); } return StringName(operator String()); } @@ -1494,7 +1468,7 @@ struct _VariantStrPair { String key; String value; - bool operator<(const _VariantStrPair& p) const { + bool operator<(const _VariantStrPair &p) const { return key < p.key; } @@ -1502,57 +1476,58 @@ struct _VariantStrPair { Variant::operator String() const { - switch( type ) { + switch (type) { case NIL: return "Null"; case BOOL: return _data._bool ? "True" : "False"; case INT: return itos(_data._int); case REAL: return rtos(_data._real); - case STRING: return *reinterpret_cast(_data._mem); - case VECTOR2: return "("+operator Vector2()+")"; - case RECT2: return "("+operator Rect2()+")"; + case STRING: return *reinterpret_cast(_data._mem); + case VECTOR2: return "(" + operator Vector2() + ")"; + case RECT2: return "(" + operator Rect2() + ")"; case TRANSFORM2D: { Transform2D mat32 = operator Transform2D(); - return "("+Variant(mat32.elements[0]).operator String()+", "+Variant(mat32.elements[1]).operator String()+", "+Variant(mat32.elements[2]).operator String()+")"; + return "(" + Variant(mat32.elements[0]).operator String() + ", " + Variant(mat32.elements[1]).operator String() + ", " + Variant(mat32.elements[2]).operator String() + ")"; } break; - case VECTOR3: return "("+operator Vector3()+")"; - case PLANE: return operator Plane(); + case VECTOR3: return "(" + operator Vector3() + ")"; + case PLANE: + return operator Plane(); //case QUAT: case RECT3: return operator Rect3(); - case QUAT: return "("+operator Quat()+")"; + case QUAT: return "(" + operator Quat() + ")"; case BASIS: { Basis mat3 = operator Basis(); String mtx("("); - for (int i=0;i<3;i++) { + for (int i = 0; i < 3; i++) { - if (i!=0) - mtx+=", "; + if (i != 0) + mtx += ", "; - mtx+="("; + mtx += "("; - for (int j=0;j<3;j++) { + for (int j = 0; j < 3; j++) { - if (j!=0) - mtx+=", "; + if (j != 0) + mtx += ", "; - mtx+=Variant( mat3.elements[i][j] ).operator String(); + mtx += Variant(mat3.elements[i][j]).operator String(); } - mtx+=")"; + mtx += ")"; } - return mtx+")"; + return mtx + ")"; } break; 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 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(_data._mem); + const Dictionary &d = *reinterpret_cast(_data._mem); //const String *K=NULL; String str; List keys; @@ -1560,20 +1535,20 @@ Variant::operator String() const { Vector<_VariantStrPair> pairs; - for(List::Element *E=keys.front();E;E=E->next()) { + for (List::Element *E = keys.front(); E; E = E->next()) { _VariantStrPair sp; - sp.key=String(E->get()); - sp.value=d[E->get()]; + sp.key = String(E->get()); + sp.value = d[E->get()]; pairs.push_back(sp); } pairs.sort(); - for(int i=0;i0) - str+=", "; - str+="("+pairs[i].key+":"+pairs[i].value+")"; + for (int i = 0; i < pairs.size(); i++) { + if (i > 0) + str += ", "; + str += "(" + pairs[i].key + ":" + pairs[i].value + ")"; } return str; @@ -1582,11 +1557,11 @@ Variant::operator String() const { PoolVector vec = operator PoolVector(); String str("["); - for(int i=0;i0) - str+=", "; - str=str+Variant( vec[i] ); + if (i > 0) + str += ", "; + str = str + Variant(vec[i]); } str += "]"; return str; @@ -1595,11 +1570,11 @@ Variant::operator String() const { PoolVector vec = operator PoolVector(); String str("["); - for(int i=0;i0) - str+=", "; - str=str+Variant( vec[i] ); + if (i > 0) + str += ", "; + str = str + Variant(vec[i]); } str += "]"; return str; @@ -1608,11 +1583,11 @@ Variant::operator String() const { PoolVector vec = operator PoolVector(); String str("["); - for(int i=0;i0) - str+=", "; - str=str+vec[i]; + if (i > 0) + str += ", "; + str = str + vec[i]; } str += "]"; return str; @@ -1621,11 +1596,11 @@ Variant::operator String() const { PoolVector vec = operator PoolVector(); String str("["); - for(int i=0;i0) - str+=", "; - str=str+itos(vec[i]); + if (i > 0) + str += ", "; + str = str + itos(vec[i]); } str += "]"; return str; @@ -1634,11 +1609,11 @@ Variant::operator String() const { PoolVector vec = operator PoolVector(); String str("["); - for(int i=0;i0) - str+=", "; - str=str+rtos(vec[i]); + if (i > 0) + str += ", "; + str = str + rtos(vec[i]); } str += "]"; return str; @@ -1647,9 +1622,9 @@ Variant::operator String() const { Array arr = operator Array(); String str("["); - for (int i=0; iget_class()+":"+itos(_get_obj().obj->get_instance_ID())+"]"; + }; +#endif + return "[" + _get_obj().obj->get_class() + ":" + itos(_get_obj().obj->get_instance_ID()) + "]"; } else return "[Object:null]"; } break; default: { - return "["+get_type_name(type)+"]"; + return "[" + get_type_name(type) + "]"; } } @@ -1682,42 +1657,38 @@ Variant::operator String() const { Variant::operator Vector2() const { - if (type==VECTOR2) - return *reinterpret_cast(_data._mem); - else if (type==VECTOR3) - return Vector2(reinterpret_cast(_data._mem)->x,reinterpret_cast(_data._mem)->y); + if (type == VECTOR2) + return *reinterpret_cast(_data._mem); + else if (type == VECTOR3) + return Vector2(reinterpret_cast(_data._mem)->x, reinterpret_cast(_data._mem)->y); else return Vector2(); - } Variant::operator Rect2() const { - if (type==RECT2) - return *reinterpret_cast(_data._mem); + if (type == RECT2) + return *reinterpret_cast(_data._mem); else return Rect2(); - } Variant::operator Vector3() const { - if (type==VECTOR3) - return *reinterpret_cast(_data._mem); + if (type == VECTOR3) + return *reinterpret_cast(_data._mem); else return Vector3(); - } Variant::operator Plane() const { - if (type==PLANE) - return *reinterpret_cast(_data._mem); + if (type == PLANE) + return *reinterpret_cast(_data._mem); else return Plane(); - } Variant::operator Rect3() const { - if (type==RECT3) + if (type == RECT3) return *_data._rect3; else return Rect3(); @@ -1725,11 +1696,11 @@ Variant::operator Rect3() const { Variant::operator Basis() const { - if (type==BASIS) + if (type == BASIS) return *_data._basis; - else if (type==QUAT) - return *reinterpret_cast(_data._mem); - else if (type==TRANSFORM) + else if (type == QUAT) + return *reinterpret_cast(_data._mem); + else if (type == TRANSFORM) return _data._transform->basis; else return Basis(); @@ -1737,63 +1708,60 @@ Variant::operator Basis() const { Variant::operator Quat() const { - if (type==QUAT) - return *reinterpret_cast(_data._mem); - else if (type==BASIS) - return *_data._basis; - else if (type==TRANSFORM) - return _data._transform->basis; + if (type == QUAT) + return *reinterpret_cast(_data._mem); + else if (type == BASIS) + return *_data._basis; + else if (type == TRANSFORM) + return _data._transform->basis; else return Quat(); } - - Variant::operator Transform() const { - if (type==TRANSFORM) + if (type == TRANSFORM) return *_data._transform; - else if (type==BASIS) - return Transform(*_data._basis,Vector3()); - else if (type==QUAT) - return Transform(Basis(*reinterpret_cast(_data._mem)),Vector3()); + else if (type == BASIS) + return Transform(*_data._basis, Vector3()); + else if (type == QUAT) + return Transform(Basis(*reinterpret_cast(_data._mem)), Vector3()); else return Transform(); } - Variant::operator Transform2D() const { +Variant::operator Transform2D() const { - if (type==TRANSFORM2D) { - return *_data._transform2d; - } else if (type==TRANSFORM) { - const Transform& t = *_data._transform; - Transform2D 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 Transform2D(); + if (type == TRANSFORM2D) { + return *_data._transform2d; + } else if (type == TRANSFORM) { + const Transform &t = *_data._transform; + Transform2D 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 Transform2D(); } - Variant::operator Color() const { - if (type==COLOR) - return *reinterpret_cast(_data._mem); - else if (type==STRING) - return Color::html( operator String() ); - else if (type==INT) - return Color::hex( operator int() ); + if (type == COLOR) + return *reinterpret_cast(_data._mem); + else if (type == STRING) + return Color::html(operator String()); + else if (type == INT) + return Color::hex(operator int()); else return Color(); } Variant::operator Image() const { - if (type==IMAGE) + if (type == IMAGE) return *_data._image; else return Image(); @@ -1801,18 +1769,17 @@ Variant::operator Image() const { Variant::operator NodePath() const { - if (type==NODE_PATH) - return *reinterpret_cast(_data._mem); - else if (type==STRING) + if (type == NODE_PATH) + return *reinterpret_cast(_data._mem); + else if (type == STRING) return NodePath(operator String()); else return NodePath(); } - Variant::operator RefPtr() const { - if (type==OBJECT) + if (type == OBJECT) return _get_obj().ref; else return RefPtr(); @@ -1820,14 +1787,14 @@ Variant::operator RefPtr() const { Variant::operator RID() const { - if (type==_RID) - return *reinterpret_cast(_data._mem); - else if (type==OBJECT && !_get_obj().ref.is_null()) { + if (type == _RID) + return *reinterpret_cast(_data._mem); + else if (type == OBJECT && !_get_obj().ref.is_null()) { return _get_obj().ref.get_rid(); - } else if (type==OBJECT && _get_obj().obj) { + } else if (type == OBJECT && _get_obj().obj) { Variant::CallError ce; - Variant ret = _get_obj().obj->call(CoreStringNames::get_singleton()->get_rid,NULL,0,ce); - if (ce.error==Variant::CallError::CALL_OK && ret.get_type()==Variant::_RID) { + Variant ret = _get_obj().obj->call(CoreStringNames::get_singleton()->get_rid, NULL, 0, ce); + if (ce.error == Variant::CallError::CALL_OK && ret.get_type() == Variant::_RID) { return ret; } return RID(); @@ -1836,72 +1803,87 @@ Variant::operator RID() const { } } -Variant::operator Object*() const { +Variant::operator Object *() const { - if (type==OBJECT) + if (type == OBJECT) return _get_obj().obj; else return NULL; } -Variant::operator Node*() const { +Variant::operator Node *() const { - if (type==OBJECT) - return _get_obj().obj?_get_obj().obj->cast_to():NULL; + if (type == OBJECT) + return _get_obj().obj ? _get_obj().obj->cast_to() : NULL; else return NULL; } -Variant::operator Control*() const { +Variant::operator Control *() const { - if (type==OBJECT) - return _get_obj().obj?_get_obj().obj->cast_to():NULL; + if (type == OBJECT) + return _get_obj().obj ? _get_obj().obj->cast_to() : NULL; else return NULL; } Variant::operator InputEvent() const { - if (type==INPUT_EVENT) - return *reinterpret_cast(_data._input_event); + if (type == INPUT_EVENT) + return *reinterpret_cast(_data._input_event); else return InputEvent(); } Variant::operator Dictionary() const { - if (type==DICTIONARY) - return *reinterpret_cast(_data._mem); + if (type == DICTIONARY) + return *reinterpret_cast(_data._mem); else return Dictionary(); } -template -inline DA _convert_array(const SA& p_array) { +template +inline DA _convert_array(const SA &p_array) { DA da; da.resize(p_array.size()); - for(int i=0;i -inline DA _convert_array_from_variant(const Variant& p_variant) { - - switch(p_variant.get_type()) { +template +inline DA _convert_array_from_variant(const Variant &p_variant) { + switch (p_variant.get_type()) { - case Variant::ARRAY: { return _convert_array( p_variant.operator Array () ); } - case Variant::POOL_BYTE_ARRAY: { return _convert_array >( p_variant.operator PoolVector () ); } - case Variant::POOL_INT_ARRAY: { return _convert_array >( p_variant.operator PoolVector () ); } - case Variant::POOL_REAL_ARRAY: { return _convert_array >( p_variant.operator PoolVector () ); } - case Variant::POOL_STRING_ARRAY: { return _convert_array >( p_variant.operator PoolVector () ); } - case Variant::POOL_VECTOR2_ARRAY: { return _convert_array >( p_variant.operator PoolVector () ); } - case Variant::POOL_VECTOR3_ARRAY: { return _convert_array >( p_variant.operator PoolVector () ); } - case Variant::POOL_COLOR_ARRAY: { return _convert_array >( p_variant.operator PoolVector() ); } + case Variant::ARRAY: { + return _convert_array(p_variant.operator Array()); + } + case Variant::POOL_BYTE_ARRAY: { + return _convert_array >(p_variant.operator PoolVector()); + } + case Variant::POOL_INT_ARRAY: { + return _convert_array >(p_variant.operator PoolVector()); + } + case Variant::POOL_REAL_ARRAY: { + return _convert_array >(p_variant.operator PoolVector()); + } + case Variant::POOL_STRING_ARRAY: { + return _convert_array >(p_variant.operator PoolVector()); + } + case Variant::POOL_VECTOR2_ARRAY: { + return _convert_array >(p_variant.operator PoolVector()); + } + case Variant::POOL_VECTOR3_ARRAY: { + return _convert_array >(p_variant.operator PoolVector()); + } + case Variant::POOL_COLOR_ARRAY: { + return _convert_array >(p_variant.operator PoolVector()); + } default: { return DA(); } } @@ -1910,278 +1892,265 @@ inline DA _convert_array_from_variant(const Variant& p_variant) { Variant::operator Array() const { - if (type==ARRAY) - return *reinterpret_cast(_data._mem); + if (type == ARRAY) + return *reinterpret_cast(_data._mem); else - return _convert_array_from_variant(*this); + return _convert_array_from_variant(*this); } Variant::operator PoolVector() const { - if (type==POOL_BYTE_ARRAY) - return *reinterpret_cast* >(_data._mem); + if (type == POOL_BYTE_ARRAY) + return *reinterpret_cast *>(_data._mem); else return _convert_array_from_variant >(*this); } Variant::operator PoolVector() const { - if (type==POOL_INT_ARRAY) - return *reinterpret_cast* >(_data._mem); + if (type == POOL_INT_ARRAY) + return *reinterpret_cast *>(_data._mem); else return _convert_array_from_variant >(*this); - } Variant::operator PoolVector() const { - if (type==POOL_REAL_ARRAY) - return *reinterpret_cast* >(_data._mem); + if (type == POOL_REAL_ARRAY) + return *reinterpret_cast *>(_data._mem); else return _convert_array_from_variant >(*this); - } Variant::operator PoolVector() const { - if (type==POOL_STRING_ARRAY) - return *reinterpret_cast* >(_data._mem); + if (type == POOL_STRING_ARRAY) + return *reinterpret_cast *>(_data._mem); else return _convert_array_from_variant >(*this); - - } Variant::operator PoolVector() const { - if (type==POOL_VECTOR3_ARRAY) - return *reinterpret_cast* >(_data._mem); + if (type == POOL_VECTOR3_ARRAY) + return *reinterpret_cast *>(_data._mem); else return _convert_array_from_variant >(*this); - - } Variant::operator PoolVector() const { - if (type==POOL_VECTOR2_ARRAY) - return *reinterpret_cast* >(_data._mem); + if (type == POOL_VECTOR2_ARRAY) + return *reinterpret_cast *>(_data._mem); else return _convert_array_from_variant >(*this); - - } Variant::operator PoolVector() const { - if (type==POOL_COLOR_ARRAY) - return *reinterpret_cast* >(_data._mem); + if (type == POOL_COLOR_ARRAY) + return *reinterpret_cast *>(_data._mem); else return _convert_array_from_variant >(*this); - } /* helpers */ - Variant::operator Vector() const { - Array va= operator Array(); + Array va = operator Array(); Vector rids; rids.resize(va.size()); - for(int i=0;i() const { - PoolVector from=operator PoolVector(); + PoolVector from = operator PoolVector(); Vector to; - int len=from.size(); - if (len==0) + int len = from.size(); + if (len == 0) return Vector(); to.resize(len); PoolVector::Read r = from.read(); Vector2 *w = &to[0]; - for (int i=0;i() const { - Array va= operator Array(); + Array va = operator Array(); PoolVector planes; - int va_size=va.size(); - if (va_size==0) + int va_size = va.size(); + if (va_size == 0) return planes; planes.resize(va_size); PoolVector::Write w = planes.write(); - for(int i=0;i() const { - PoolVector va= operator PoolVector(); + PoolVector va = operator PoolVector(); PoolVector faces; - int va_size=va.size(); - if (va_size==0) + int va_size = va.size(); + if (va_size == 0) return faces; - faces.resize(va_size/3); + faces.resize(va_size / 3); PoolVector::Write w = faces.write(); PoolVector::Read r = va.read(); - for(int i=0;i() const { - Array va= operator Array(); + Array va = operator Array(); Vector planes; - int va_size=va.size(); - if (va_size==0) + int va_size = va.size(); + if (va_size == 0) return planes; planes.resize(va_size); - for(int i=0;i() const { - Array from=operator Array(); + Array from = operator Array(); Vector to; - int len=from.size(); + int len = from.size(); to.resize(len); - for (int i=0;i() const { - PoolVector from=operator PoolVector(); + PoolVector from = operator PoolVector(); Vector to; - int len=from.size(); + int len = from.size(); to.resize(len); - for (int i=0;i() const { - PoolVector from=operator PoolVector(); + PoolVector from = operator PoolVector(); Vector to; - int len=from.size(); + int len = from.size(); to.resize(len); - for (int i=0;i() const { - PoolVector from=operator PoolVector(); + PoolVector from = operator PoolVector(); Vector to; - int len=from.size(); + int len = from.size(); to.resize(len); - for (int i=0;i() const { - PoolVector from=operator PoolVector(); + PoolVector from = operator PoolVector(); Vector to; - int len=from.size(); + int len = from.size(); to.resize(len); - for (int i=0;i() const { - PoolVector from=operator PoolVector(); + PoolVector from = operator PoolVector(); Vector to; - int len=from.size(); - if (len==0) + int len = from.size(); + if (len == 0) return Vector(); to.resize(len); PoolVector::Read r = from.read(); Vector3 *w = &to[0]; - for (int i=0;i() const { - PoolVector from=operator PoolVector(); + PoolVector from = operator PoolVector(); Vector to; - int len=from.size(); - if (len==0) + int len = from.size(); + if (len == 0) return Vector(); to.resize(len); PoolVector::Read r = from.read(); Color *w = &to[0]; - for (int i=0;i addr=operator PoolVector(); - if (addr.size()==4) { - return IP_Address(addr.get(0),addr.get(1),addr.get(2),addr.get(3)); + PoolVector addr = operator PoolVector(); + if (addr.size() == 4) { + return IP_Address(addr.get(0), addr.get(1), addr.get(2), addr.get(3)); } } - return IP_Address( operator String() ); + return IP_Address(operator String()); } Variant::Variant(bool p_bool) { - type=BOOL; - _data._bool=p_bool; + type = BOOL; + _data._bool = p_bool; } /* @@ -2194,358 +2163,314 @@ Variant::Variant(long unsigned int p_long) { Variant::Variant(signed int p_int) { - type=INT; - _data._int=p_int; - + type = INT; + _data._int = p_int; } Variant::Variant(unsigned int p_int) { - type=INT; - _data._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; - + type = INT; + _data._int = p_int; } Variant::Variant(unsigned long p_int) { - type=INT; - _data._int=p_int; - + type = INT; + _data._int = p_int; } #endif Variant::Variant(int64_t p_int) { - type=INT; - _data._int=p_int; - + type = INT; + _data._int = p_int; } Variant::Variant(uint64_t p_int) { - type=INT; - _data._int=p_int; - + type = INT; + _data._int = p_int; } Variant::Variant(signed short p_short) { - type=INT; - _data._int=p_short; - + type = INT; + _data._int = p_short; } Variant::Variant(unsigned short p_short) { - type=INT; - _data._int=p_short; - + type = INT; + _data._int = p_short; } Variant::Variant(signed char p_char) { - type=INT; - _data._int=p_char; - + type = INT; + _data._int = p_char; } Variant::Variant(unsigned char p_char) { - type=INT; - _data._int=p_char; - + type = INT; + _data._int = p_char; } Variant::Variant(float p_float) { - type=REAL; - _data._real=p_float; - + type = REAL; + _data._real = p_float; } Variant::Variant(double p_double) { - type=REAL; - _data._real=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 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 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 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 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 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 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 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 Plane &p_plane) { + type = PLANE; + memnew_placement(_data._mem, Plane(p_plane)); } -Variant::Variant(const Rect3& p_aabb) { +Variant::Variant(const Rect3 &p_aabb) { - type=RECT3; - _data._rect3 = memnew( Rect3( p_aabb ) ); + type = RECT3; + _data._rect3 = memnew(Rect3(p_aabb)); } -Variant::Variant(const Basis& p_matrix) { - - type=BASIS; - _data._basis= memnew( Basis( p_matrix ) ); +Variant::Variant(const Basis &p_matrix) { + type = BASIS; + _data._basis = memnew(Basis(p_matrix)); } -Variant::Variant(const Quat& p_quat) { - - type=QUAT; - memnew_placement( _data._mem, Quat( p_quat ) ); +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 Transform &p_transform) { + type = TRANSFORM; + _data._transform = memnew(Transform(p_transform)); } -Variant::Variant(const Transform2D& p_transform) { - - type=TRANSFORM2D; - _data._transform2d = memnew( Transform2D( p_transform ) ); +Variant::Variant(const Transform2D &p_transform) { + type = TRANSFORM2D; + _data._transform2d = memnew(Transform2D(p_transform)); } -Variant::Variant(const Color& p_color) { - - type=COLOR; - memnew_placement( _data._mem, Color(p_color) ); +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 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 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 InputEvent &p_input_event) { + type = INPUT_EVENT; + _data._input_event = memnew(InputEvent(p_input_event)); } -Variant::Variant(const RefPtr& p_resource) { +Variant::Variant(const RefPtr &p_resource) { - type=OBJECT; - memnew_placement( _data._mem, ObjData ); + type = OBJECT; + memnew_placement(_data._mem, ObjData); REF ref = p_resource; - _get_obj().obj=ref.ptr(); - _get_obj().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 RID &p_rid) { + type = _RID; + memnew_placement(_data._mem, RID(p_rid)); } -Variant::Variant(const Object* p_object) { +Variant::Variant(const Object *p_object) { - type=OBJECT; + type = OBJECT; - memnew_placement( _data._mem, ObjData ); - _get_obj().obj=const_cast(p_object); + memnew_placement(_data._mem, ObjData); + _get_obj().obj = const_cast(p_object); } -Variant::Variant(const Dictionary& p_dictionary) { - - type=DICTIONARY; - memnew_placement( _data._mem, (Dictionary)( p_dictionary) ); +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 Array &p_array) { + type = ARRAY; + memnew_placement(_data._mem, Array(p_array)); } -Variant::Variant(const PoolVector& p_array) { +Variant::Variant(const PoolVector &p_array) { + type = ARRAY; - type=ARRAY; + Array *plane_array = memnew_placement(_data._mem, Array); - Array *plane_array=memnew_placement( _data._mem, Array ); + plane_array->resize(p_array.size()); - plane_array->resize( p_array.size() ); + for (int i = 0; i < p_array.size(); i++) { - for (int i=0;ioperator [](i)=Variant(p_array[i]); + plane_array->operator[](i) = Variant(p_array[i]); } } -Variant::Variant(const Vector& p_array) { - +Variant::Variant(const Vector &p_array) { - type=ARRAY; + type = ARRAY; - Array *plane_array=memnew_placement( _data._mem, Array ); + Array *plane_array = memnew_placement(_data._mem, Array); - plane_array->resize( p_array.size() ); + plane_array->resize(p_array.size()); - for (int i=0;ioperator [](i)=Variant(p_array[i]); + plane_array->operator[](i) = Variant(p_array[i]); } } -Variant::Variant(const Vector& p_array) { +Variant::Variant(const Vector &p_array) { + type = ARRAY; - type=ARRAY; + Array *rid_array = memnew_placement(_data._mem, Array); - Array *rid_array=memnew_placement( _data._mem, Array ); + rid_array->resize(p_array.size()); - rid_array->resize( p_array.size() ); + for (int i = 0; i < p_array.size(); i++) { - for (int i=0;iset(i,Variant(p_array[i])); + rid_array->set(i, Variant(p_array[i])); } } -Variant::Variant(const Vector& p_array) { - +Variant::Variant(const Vector &p_array) { - type=NIL; + type = NIL; PoolVector v; - int len=p_array.size(); - if (len>0) { + int len = p_array.size(); + if (len > 0) { v.resize(len); PoolVector::Write w = v.write(); const Vector2 *r = p_array.ptr(); - for (int i=0;i &p_raw_array) { -Variant::Variant(const PoolVector& p_raw_array) { - - type=POOL_BYTE_ARRAY; - memnew_placement( _data._mem, PoolVector(p_raw_array) ); - + type = POOL_BYTE_ARRAY; + memnew_placement(_data._mem, PoolVector(p_raw_array)); } -Variant::Variant(const PoolVector& p_int_array) { - - type=POOL_INT_ARRAY; - memnew_placement( _data._mem, PoolVector(p_int_array) ); +Variant::Variant(const PoolVector &p_int_array) { + type = POOL_INT_ARRAY; + memnew_placement(_data._mem, PoolVector(p_int_array)); } -Variant::Variant(const PoolVector& p_real_array) { - - type=POOL_REAL_ARRAY; - memnew_placement( _data._mem, PoolVector(p_real_array) ); +Variant::Variant(const PoolVector &p_real_array) { + type = POOL_REAL_ARRAY; + memnew_placement(_data._mem, PoolVector(p_real_array)); } -Variant::Variant(const PoolVector& p_string_array) { - - type=POOL_STRING_ARRAY; - memnew_placement( _data._mem, PoolVector(p_string_array) ); +Variant::Variant(const PoolVector &p_string_array) { + type = POOL_STRING_ARRAY; + memnew_placement(_data._mem, PoolVector(p_string_array)); } -Variant::Variant(const PoolVector& p_vector3_array) { - - type=POOL_VECTOR3_ARRAY; - memnew_placement( _data._mem, PoolVector(p_vector3_array) ); +Variant::Variant(const PoolVector &p_vector3_array) { + type = POOL_VECTOR3_ARRAY; + memnew_placement(_data._mem, PoolVector(p_vector3_array)); } -Variant::Variant(const PoolVector& p_vector2_array) { - - type=POOL_VECTOR2_ARRAY; - memnew_placement( _data._mem, PoolVector(p_vector2_array) ); +Variant::Variant(const PoolVector &p_vector2_array) { + type = POOL_VECTOR2_ARRAY; + memnew_placement(_data._mem, PoolVector(p_vector2_array)); } -Variant::Variant(const PoolVector& p_color_array) { +Variant::Variant(const PoolVector &p_color_array) { - type=POOL_COLOR_ARRAY; - memnew_placement( _data._mem, PoolVector(p_color_array) ); + type = POOL_COLOR_ARRAY; + memnew_placement(_data._mem, PoolVector(p_color_array)); } -Variant::Variant(const PoolVector& p_face_array) { - +Variant::Variant(const PoolVector &p_face_array) { PoolVector vertices; - int face_count=p_face_array.size(); - vertices.resize(face_count*3); + int face_count = p_face_array.size(); + vertices.resize(face_count * 3); if (face_count) { PoolVector::Read r = p_face_array.read(); PoolVector::Write w = vertices.write(); - for(int i=0;i::Read(); - w=PoolVector::Write(); - + r = PoolVector::Read(); + w = PoolVector::Write(); } type = NIL; @@ -2555,107 +2480,105 @@ Variant::Variant(const PoolVector& p_face_array) { /* helpers */ -Variant::Variant(const Vector& p_array) { +Variant::Variant(const Vector &p_array) { - type=NIL; + type = NIL; Array v; - int len=p_array.size(); + int len = p_array.size(); v.resize(len); - for (int i=0;i& p_array) { +Variant::Variant(const Vector &p_array) { - type=NIL; + type = NIL; PoolVector v; - int len=p_array.size(); + int len = p_array.size(); v.resize(len); - for (int i=0;i& p_array) { +Variant::Variant(const Vector &p_array) { - type=NIL; + type = NIL; PoolVector v; - int len=p_array.size(); + int len = p_array.size(); v.resize(len); - for (int i=0;i& p_array) { +Variant::Variant(const Vector &p_array) { - type=NIL; + type = NIL; PoolVector v; - int len=p_array.size(); + int len = p_array.size(); v.resize(len); - for (int i=0;i& p_array) { +Variant::Variant(const Vector &p_array) { - type=NIL; + type = NIL; PoolVector v; - int len=p_array.size(); + int len = p_array.size(); v.resize(len); - for (int i=0;i& p_array) { +Variant::Variant(const Vector &p_array) { - type=NIL; + type = NIL; PoolVector v; - int len=p_array.size(); - if (len>0) { + int len = p_array.size(); + if (len > 0) { v.resize(len); PoolVector::Write w = v.write(); const Vector3 *r = p_array.ptr(); - for (int i=0;i& p_array) { +Variant::Variant(const Vector &p_array) { - type=NIL; + type = NIL; PoolVector v; - int len=p_array.size(); + int len = p_array.size(); v.resize(len); - for (int i=0;i(_data._mem)->hash(); + return reinterpret_cast(_data._mem)->hash(); } break; - // math types + // math types case VECTOR2: { - uint32_t hash = hash_djb2_one_float(reinterpret_cast(_data._mem)->x); - return hash_djb2_one_float(reinterpret_cast(_data._mem)->y,hash); + uint32_t hash = hash_djb2_one_float(reinterpret_cast(_data._mem)->x); + return hash_djb2_one_float(reinterpret_cast(_data._mem)->y, hash); } break; case RECT2: { - uint32_t hash = hash_djb2_one_float(reinterpret_cast(_data._mem)->pos.x); - hash = hash_djb2_one_float(reinterpret_cast(_data._mem)->pos.y,hash); - hash = hash_djb2_one_float(reinterpret_cast(_data._mem)->size.x,hash); - return hash_djb2_one_float(reinterpret_cast(_data._mem)->size.y,hash); + uint32_t hash = hash_djb2_one_float(reinterpret_cast(_data._mem)->pos.x); + hash = hash_djb2_one_float(reinterpret_cast(_data._mem)->pos.y, hash); + hash = hash_djb2_one_float(reinterpret_cast(_data._mem)->size.x, hash); + return hash_djb2_one_float(reinterpret_cast(_data._mem)->size.y, hash); } break; case TRANSFORM2D: { uint32_t hash = 5831; - for(int i=0;i<3;i++) { + for (int i = 0; i < 3; i++) { - for(int j=0;j<2;j++) { - hash = hash_djb2_one_float(_data._transform2d->elements[i][j],hash); + for (int j = 0; j < 2; j++) { + hash = hash_djb2_one_float(_data._transform2d->elements[i][j], hash); } } @@ -2713,19 +2636,19 @@ uint32_t Variant::hash() const { } break; case VECTOR3: { - uint32_t hash = hash_djb2_one_float(reinterpret_cast(_data._mem)->x); - hash = hash_djb2_one_float(reinterpret_cast(_data._mem)->y,hash); - return hash_djb2_one_float(reinterpret_cast(_data._mem)->z,hash); + uint32_t hash = hash_djb2_one_float(reinterpret_cast(_data._mem)->x); + hash = hash_djb2_one_float(reinterpret_cast(_data._mem)->y, hash); + return hash_djb2_one_float(reinterpret_cast(_data._mem)->z, hash); } break; case PLANE: { - uint32_t hash = hash_djb2_one_float(reinterpret_cast(_data._mem)->normal.x); - hash = hash_djb2_one_float(reinterpret_cast(_data._mem)->normal.y,hash); - hash = hash_djb2_one_float(reinterpret_cast(_data._mem)->normal.z,hash); - return hash_djb2_one_float(reinterpret_cast(_data._mem)->d,hash); + uint32_t hash = hash_djb2_one_float(reinterpret_cast(_data._mem)->normal.x); + hash = hash_djb2_one_float(reinterpret_cast(_data._mem)->normal.y, hash); + hash = hash_djb2_one_float(reinterpret_cast(_data._mem)->normal.z, hash); + return hash_djb2_one_float(reinterpret_cast(_data._mem)->d, hash); } break; - /* + /* case QUAT: { @@ -2733,31 +2656,30 @@ uint32_t Variant::hash() const { case RECT3: { uint32_t hash = 5831; - for(int i=0;i<3;i++) { + for (int i = 0; i < 3; i++) { - hash = hash_djb2_one_float(_data._rect3->pos[i],hash); - hash = hash_djb2_one_float(_data._rect3->size[i],hash); + hash = hash_djb2_one_float(_data._rect3->pos[i], hash); + hash = hash_djb2_one_float(_data._rect3->size[i], hash); } - return hash; } break; case QUAT: { - uint32_t hash = hash_djb2_one_float(reinterpret_cast(_data._mem)->x); - hash = hash_djb2_one_float(reinterpret_cast(_data._mem)->y,hash); - hash = hash_djb2_one_float(reinterpret_cast(_data._mem)->z,hash); - return hash_djb2_one_float(reinterpret_cast(_data._mem)->w,hash); + uint32_t hash = hash_djb2_one_float(reinterpret_cast(_data._mem)->x); + hash = hash_djb2_one_float(reinterpret_cast(_data._mem)->y, hash); + hash = hash_djb2_one_float(reinterpret_cast(_data._mem)->z, hash); + return hash_djb2_one_float(reinterpret_cast(_data._mem)->w, hash); } break; case BASIS: { uint32_t hash = 5831; - for(int i=0;i<3;i++) { + for (int i = 0; i < 3; i++) { - for(int j=0;j<3;j++) { - hash = hash_djb2_one_float(_data._basis->elements[i][j],hash); + for (int j = 0; j < 3; j++) { + hash = hash_djb2_one_float(_data._basis->elements[i][j], hash); } } @@ -2767,26 +2689,25 @@ uint32_t Variant::hash() const { case TRANSFORM: { uint32_t hash = 5831; - for(int i=0;i<3;i++) { + 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); + 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); + hash = hash_djb2_one_float(_data._transform->origin[i], hash); } - return hash; } break; - // misc types + // misc types case COLOR: { - uint32_t hash = hash_djb2_one_float(reinterpret_cast(_data._mem)->r); - hash = hash_djb2_one_float(reinterpret_cast(_data._mem)->g,hash); - hash = hash_djb2_one_float(reinterpret_cast(_data._mem)->b,hash); - return hash_djb2_one_float(reinterpret_cast(_data._mem)->a,hash); + uint32_t hash = hash_djb2_one_float(reinterpret_cast(_data._mem)->r); + hash = hash_djb2_one_float(reinterpret_cast(_data._mem)->g, hash); + hash = hash_djb2_one_float(reinterpret_cast(_data._mem)->b, hash); + return hash_djb2_one_float(reinterpret_cast(_data._mem)->a, hash); } break; case IMAGE: { @@ -2796,7 +2717,7 @@ uint32_t Variant::hash() const { } break; case _RID: { - return hash_djb2_one_64(reinterpret_cast(_data._mem)->get_id()); + return hash_djb2_one_64(reinterpret_cast(_data._mem)->get_id()); } break; case OBJECT: { @@ -2804,75 +2725,74 @@ uint32_t Variant::hash() const { } break; case NODE_PATH: { - return reinterpret_cast(_data._mem)->hash(); + return reinterpret_cast(_data._mem)->hash(); } break; case INPUT_EVENT: { - return hash_djb2_buffer((uint8_t*)_data._input_event,sizeof(InputEvent)); + return hash_djb2_buffer((uint8_t *)_data._input_event, sizeof(InputEvent)); } break; case DICTIONARY: { - return reinterpret_cast(_data._mem)->hash(); - + return reinterpret_cast(_data._mem)->hash(); } break; case ARRAY: { - const Array& arr = *reinterpret_cast(_data._mem); + const Array &arr = *reinterpret_cast(_data._mem); return arr.hash(); } break; case POOL_BYTE_ARRAY: { - const PoolVector& arr = *reinterpret_cast* >(_data._mem); + const PoolVector &arr = *reinterpret_cast *>(_data._mem); int len = arr.size(); PoolVector::Read r = arr.read(); - return hash_djb2_buffer((uint8_t*)&r[0],len); + return hash_djb2_buffer((uint8_t *)&r[0], len); } break; case POOL_INT_ARRAY: { - const PoolVector& arr = *reinterpret_cast* >(_data._mem); + const PoolVector &arr = *reinterpret_cast *>(_data._mem); int len = arr.size(); PoolVector::Read r = arr.read(); - return hash_djb2_buffer((uint8_t*)&r[0],len*sizeof(int)); + return hash_djb2_buffer((uint8_t *)&r[0], len * sizeof(int)); } break; case POOL_REAL_ARRAY: { - const PoolVector& arr = *reinterpret_cast* >(_data._mem); + const PoolVector &arr = *reinterpret_cast *>(_data._mem); int len = arr.size(); PoolVector::Read r = arr.read(); - return hash_djb2_buffer((uint8_t*)&r[0],len*sizeof(real_t)); + return hash_djb2_buffer((uint8_t *)&r[0], len * sizeof(real_t)); } break; case POOL_STRING_ARRAY: { - uint32_t hash=5831; - const PoolVector& arr = *reinterpret_cast* >(_data._mem); + uint32_t hash = 5831; + const PoolVector &arr = *reinterpret_cast *>(_data._mem); int len = arr.size(); PoolVector::Read r = arr.read(); - for(int i=0;i& arr = *reinterpret_cast* >(_data._mem); + uint32_t hash = 5831; + const PoolVector &arr = *reinterpret_cast *>(_data._mem); int len = arr.size(); PoolVector::Read r = arr.read(); - for(int i=0;i& arr = *reinterpret_cast* >(_data._mem); + uint32_t hash = 5831; + const PoolVector &arr = *reinterpret_cast *>(_data._mem); int len = arr.size(); PoolVector::Read r = arr.read(); - for(int i=0;i& arr = *reinterpret_cast* >(_data._mem); + uint32_t hash = 5831; + const PoolVector &arr = *reinterpret_cast *>(_data._mem); int len = arr.size(); PoolVector::Read r = arr.read(); - for(int i=0;i& l = *reinterpret_cast*>(p_lhs);\ - const PoolVector& r = *reinterpret_cast*>(p_rhs);\ - \ - if(l.size() != r.size()) \ - return false; \ - \ - PoolVector::Read lr = l.read(); \ - PoolVector::Read rr = r.read(); \ - \ - for(int i = 0; i < l.size(); ++i) { \ - if(! p_compare_func((lr[i]), (rr[i]))) \ - return false; \ - }\ - \ - return true - -bool Variant::hash_compare(const Variant& p_variant) const { + (hash_compare_scalar((p_lhs).y, (p_rhs).y)) + +#define hash_compare_vector3(p_lhs, p_rhs) \ + (hash_compare_scalar((p_lhs).x, (p_rhs).x)) && \ + (hash_compare_scalar((p_lhs).y, (p_rhs).y)) && \ + (hash_compare_scalar((p_lhs).z, (p_rhs).z)) + +#define hash_compare_quat(p_lhs, p_rhs) \ + (hash_compare_scalar((p_lhs).x, (p_rhs).x)) && \ + (hash_compare_scalar((p_lhs).y, (p_rhs).y)) && \ + (hash_compare_scalar((p_lhs).z, (p_rhs).z)) && \ + (hash_compare_scalar((p_lhs).w, (p_rhs).w)) + +#define hash_compare_color(p_lhs, p_rhs) \ + (hash_compare_scalar((p_lhs).r, (p_rhs).r)) && \ + (hash_compare_scalar((p_lhs).g, (p_rhs).g)) && \ + (hash_compare_scalar((p_lhs).b, (p_rhs).b)) && \ + (hash_compare_scalar((p_lhs).a, (p_rhs).a)) + +#define hash_compare_pool_array(p_lhs, p_rhs, p_type, p_compare_func) \ + const PoolVector &l = *reinterpret_cast *>(p_lhs); \ + const PoolVector &r = *reinterpret_cast *>(p_rhs); \ + \ + if (l.size() != r.size()) \ + return false; \ + \ + PoolVector::Read lr = l.read(); \ + PoolVector::Read rr = r.read(); \ + \ + for (int i = 0; i < l.size(); ++i) { \ + if (!p_compare_func((lr[i]), (rr[i]))) \ + return false; \ + } \ + \ + return true + +bool Variant::hash_compare(const Variant &p_variant) const { if (type != p_variant.type) return false; - switch( type ) { + switch (type) { case REAL: { return hash_compare_scalar(_data._real, p_variant._data._real); } break; case VECTOR2: { - const Vector2* l = reinterpret_cast(_data._mem); - const Vector2* r = reinterpret_cast(p_variant._data._mem); + const Vector2 *l = reinterpret_cast(_data._mem); + const Vector2 *r = reinterpret_cast(p_variant._data._mem); return hash_compare_vector2(*l, *r); } break; case RECT2: { - const Rect2* l = reinterpret_cast(_data._mem); - const Rect2* r = reinterpret_cast(p_variant._data._mem); + const Rect2 *l = reinterpret_cast(_data._mem); + const Rect2 *r = reinterpret_cast(p_variant._data._mem); return (hash_compare_vector2(l->pos, r->pos)) && - (hash_compare_vector2(l->size, r->size)); + (hash_compare_vector2(l->size, r->size)); } break; case TRANSFORM2D: { - Transform2D* l = _data._transform2d; - Transform2D* r = p_variant._data._transform2d; + Transform2D *l = _data._transform2d; + Transform2D *r = p_variant._data._transform2d; - for(int i=0;i<3;i++) { - if (! (hash_compare_vector2(l->elements[i], r->elements[i]))) + for (int i = 0; i < 3; i++) { + if (!(hash_compare_vector2(l->elements[i], r->elements[i]))) return false; } @@ -2997,23 +2915,23 @@ bool Variant::hash_compare(const Variant& p_variant) const { } break; case VECTOR3: { - const Vector3* l = reinterpret_cast(_data._mem); - const Vector3* r = reinterpret_cast(p_variant._data._mem); + const Vector3 *l = reinterpret_cast(_data._mem); + const Vector3 *r = reinterpret_cast(p_variant._data._mem); return hash_compare_vector3(*l, *r); } break; case PLANE: { - const Plane* l = reinterpret_cast(_data._mem); - const Plane* r = reinterpret_cast(p_variant._data._mem); + const Plane *l = reinterpret_cast(_data._mem); + const Plane *r = reinterpret_cast(p_variant._data._mem); return (hash_compare_vector3(l->normal, r->normal)) && - (hash_compare_scalar(l->d, r->d)); + (hash_compare_scalar(l->d, r->d)); } break; case RECT3: { - const Rect3* l = _data._rect3; - const Rect3* r = p_variant._data._rect3; + const Rect3 *l = _data._rect3; + const Rect3 *r = p_variant._data._rect3; return (hash_compare_vector3(l->pos, r->pos) && (hash_compare_vector3(l->size, r->size))); @@ -3021,18 +2939,18 @@ bool Variant::hash_compare(const Variant& p_variant) const { } break; case QUAT: { - const Quat* l = reinterpret_cast(_data._mem); - const Quat* r = reinterpret_cast(p_variant._data._mem); + const Quat *l = reinterpret_cast(_data._mem); + const Quat *r = reinterpret_cast(p_variant._data._mem); return hash_compare_quat(*l, *r); } break; case BASIS: { - const Basis* l = _data._basis; - const Basis* r = p_variant._data._basis; + const Basis *l = _data._basis; + const Basis *r = p_variant._data._basis; - for(int i=0;i<3;i++) { - if (! (hash_compare_vector3(l->elements[i], r->elements[i]))) + for (int i = 0; i < 3; i++) { + if (!(hash_compare_vector3(l->elements[i], r->elements[i]))) return false; } @@ -3040,11 +2958,11 @@ bool Variant::hash_compare(const Variant& p_variant) const { } break; case TRANSFORM: { - const Transform* l = _data._transform; - const Transform* r = p_variant._data._transform; + const Transform *l = _data._transform; + const Transform *r = p_variant._data._transform; - for(int i=0;i<3;i++) { - if (! (hash_compare_vector3(l->basis.elements[i], r->basis.elements[i]))) + for (int i = 0; i < 3; i++) { + if (!(hash_compare_vector3(l->basis.elements[i], r->basis.elements[i]))) return false; } @@ -3052,21 +2970,21 @@ bool Variant::hash_compare(const Variant& p_variant) const { } break; case COLOR: { - const Color* l = reinterpret_cast(_data._mem); - const Color* r = reinterpret_cast(p_variant._data._mem); + const Color *l = reinterpret_cast(_data._mem); + const Color *r = reinterpret_cast(p_variant._data._mem); return hash_compare_color(*l, *r); } break; case ARRAY: { - const Array& l = *(reinterpret_cast(_data._mem)); - const Array& r = *(reinterpret_cast(p_variant._data._mem)); + const Array &l = *(reinterpret_cast(_data._mem)); + const Array &r = *(reinterpret_cast(p_variant._data._mem)); - if(l.size() != r.size()) + if (l.size() != r.size()) return false; - for(int i = 0; i < l.size(); ++i) { - if(! l[i].hash_compare(r[i])) + for (int i = 0; i < l.size(); ++i) { + if (!l[i].hash_compare(r[i])) return false; } @@ -3092,39 +3010,37 @@ bool Variant::hash_compare(const Variant& p_variant) const { default: bool v; Variant r; - evaluate(OP_EQUAL,*this,p_variant,r,v); + evaluate(OP_EQUAL, *this, p_variant, r, v); return r; - } + } return false; } - bool Variant::is_ref() const { - return type==OBJECT && !_get_obj().ref.is_null(); + return type == OBJECT && !_get_obj().ref.is_null(); } - Vector varray() { return Vector(); } -Vector varray(const Variant& p_arg1) { +Vector varray(const Variant &p_arg1) { Vector v; v.push_back(p_arg1); return v; } -Vector varray(const Variant& p_arg1,const Variant& p_arg2) { +Vector varray(const Variant &p_arg1, const Variant &p_arg2) { Vector v; v.push_back(p_arg1); v.push_back(p_arg2); return v; } -Vector varray(const Variant& p_arg1,const Variant& p_arg2,const Variant& p_arg3) { +Vector varray(const Variant &p_arg1, const Variant &p_arg2, const Variant &p_arg3) { Vector v; v.push_back(p_arg1); @@ -3132,7 +3048,7 @@ Vector varray(const Variant& p_arg1,const Variant& p_arg2,const Variant v.push_back(p_arg3); return v; } -Vector varray(const Variant& p_arg1,const Variant& p_arg2,const Variant& p_arg3,const Variant& p_arg4) { +Vector varray(const Variant &p_arg1, const Variant &p_arg2, const Variant &p_arg3, const Variant &p_arg4) { Vector v; v.push_back(p_arg1); @@ -3142,7 +3058,7 @@ Vector varray(const Variant& p_arg1,const Variant& p_arg2,const Variant return v; } -Vector varray(const Variant& p_arg1,const Variant& p_arg2,const Variant& p_arg3,const Variant& p_arg4,const Variant& p_arg5) { +Vector varray(const Variant &p_arg1, const Variant &p_arg2, const Variant &p_arg3, const Variant &p_arg4, const Variant &p_arg5) { Vector v; v.push_back(p_arg1); @@ -3151,57 +3067,53 @@ Vector varray(const Variant& p_arg1,const Variant& p_arg2,const Variant v.push_back(p_arg4); v.push_back(p_arg5); return v; - } -void Variant::static_assign(const Variant& p_variant) { - - +void Variant::static_assign(const Variant &p_variant) { } bool Variant::is_shared() const { - switch(type) { - - case OBJECT: return true; - case ARRAY: return true; - case DICTIONARY: return true; - default: {} + switch (type) { - } + case OBJECT: return true; + case ARRAY: return true; + case DICTIONARY: return true; + default: {} + } - return false; + return false; } -Variant Variant::call(const StringName& p_method,VARIANT_ARG_DECLARE) { +Variant Variant::call(const StringName &p_method, VARIANT_ARG_DECLARE) { VARIANT_ARGPTRS; - int argc=0; - for(int i=0;iget_type()==Variant::NIL) + 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); + Variant ret = call(p_method, argptr, argc, error); - switch(error.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)+"'."; + 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)+"'."; + 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+"'"; + String err = "Too many arguments for method '" + p_method + "'"; ERR_PRINT(err.utf8().get_data()); } break; default: {} @@ -3210,38 +3122,35 @@ Variant Variant::call(const StringName& p_method,VARIANT_ARG_DECLARE) { return ret; } -void Variant::construct_from_string(const String& p_string,Variant& r_value,ObjectConstruct p_obj_construct,void *p_construct_ud) { +void Variant::construct_from_string(const String &p_string, Variant &r_value, ObjectConstruct p_obj_construct, void *p_construct_ud) { - r_value=Variant(); + r_value = Variant(); } - String Variant::get_construct_string() const { String vars; - VariantWriter::write_to_string(*this,vars); + VariantWriter::write_to_string(*this, vars); return vars; - } -String Variant::get_call_error_text(Object* p_base, const StringName& p_method,const Variant** p_argptrs,int p_argcount,const Variant::CallError &ce) { - +String Variant::get_call_error_text(Object *p_base, const StringName &p_method, const Variant **p_argptrs, int p_argcount, const Variant::CallError &ce) { String err_text; - if (ce.error==Variant::CallError::CALL_ERROR_INVALID_ARGUMENT) { - int errorarg=ce.argument; - err_text="Cannot convert argument "+itos(errorarg+1)+" from "+Variant::get_type_name(p_argptrs[errorarg]->get_type())+" to "+Variant::get_type_name(ce.expected)+"."; - } else if (ce.error==Variant::CallError::CALL_ERROR_TOO_MANY_ARGUMENTS) { - err_text="Method expected "+itos(ce.argument)+" arguments, but called with "+itos(p_argcount)+"."; - } else if (ce.error==Variant::CallError::CALL_ERROR_TOO_FEW_ARGUMENTS) { - err_text="Method expected "+itos(ce.argument)+" arguments, but called with "+itos(p_argcount)+"."; - } else if (ce.error==Variant::CallError::CALL_ERROR_INVALID_METHOD) { - err_text="Method not found."; - } else if (ce.error==Variant::CallError::CALL_ERROR_INSTANCE_IS_NULL) { - err_text="Instance is null"; - } else if (ce.error==Variant::CallError::CALL_OK){ + if (ce.error == Variant::CallError::CALL_ERROR_INVALID_ARGUMENT) { + int errorarg = ce.argument; + err_text = "Cannot convert argument " + itos(errorarg + 1) + " from " + Variant::get_type_name(p_argptrs[errorarg]->get_type()) + " to " + Variant::get_type_name(ce.expected) + "."; + } else if (ce.error == Variant::CallError::CALL_ERROR_TOO_MANY_ARGUMENTS) { + err_text = "Method expected " + itos(ce.argument) + " arguments, but called with " + itos(p_argcount) + "."; + } else if (ce.error == Variant::CallError::CALL_ERROR_TOO_FEW_ARGUMENTS) { + err_text = "Method expected " + itos(ce.argument) + " arguments, but called with " + itos(p_argcount) + "."; + } else if (ce.error == Variant::CallError::CALL_ERROR_INVALID_METHOD) { + err_text = "Method not found."; + } else if (ce.error == Variant::CallError::CALL_ERROR_INSTANCE_IS_NULL) { + err_text = "Instance is null"; + } else if (ce.error == Variant::CallError::CALL_OK) { return "Call OK"; } @@ -3249,51 +3158,43 @@ String Variant::get_call_error_text(Object* p_base, const StringName& p_method,c Ref