asgardius/virtualx-engine
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
virtualx-engine/core/variant.cpp

3095 lines
56 KiB
C++
Raw Normal View History

GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
/*************************************************************************/
/* variant.cpp */
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* http://www.godotengine.org */
/*************************************************************************/
Update copyright to 2016 in headers
2016-01-01 14:50:53 +01:00
/* Copyright (c) 2007-2016 Juan Linietsky, Ariel Manzur. */
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
/* */
/* Permission is hereby granted, free of charge, to any person obtaining */
/* a copy of this software and associated documentation files (the */
/* "Software"), to deal in the Software without restriction, including */
/* without limitation the rights to use, copy, modify, merge, publish, */
/* distribute, sublicense, and/or sell copies of the Software, and to */
/* permit persons to whom the Software is furnished to do so, subject to */
/* the following conditions: */
/* */
/* The above copyright notice and this permission notice shall be */
/* included in all copies or substantial portions of the Software. */
/* */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/*************************************************************************/
#include "variant.h"
#include "resource.h"
#include "print_string.h"
#include "scene/main/node.h"
#include "scene/gui/control.h"
#include "io/marshalls.h"
Ability to convert from nodes or other non resource with a get_rid() function to a rid
2015-04-25 01:45:07 +02:00
#include "core_string_names.h"
-Changed var2str and str2var in GDScript to use VariantWriter and VariantParser -It is now finally possible to parse back a variant from text!
2015-12-31 04:54:00 +01:00
#include "variant_parser.h"
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
String Variant::get_type_name(Variant::Type p_type) {
remove trailing whitespace
2016-03-09 00:00:52 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
switch( p_type ) {
case NIL: {
return "Nil";
} break;
// atomic types
case BOOL: {
return "bool";
} break;
case INT: {
return "int";
} break;
case REAL: {
-HttpClient: ’Content-Length’ is added to httprequest if not provided in the headers and a body exists -expressions in GDScript can take multiple lines if inside parenthesis (python-like) -Added \ to force linebreaks to GDscript (python-like) -added exclude objects from raycast -fixed crashes
2014-04-05 23:50:09 +02:00
return "float";
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
} 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,
-More strict argument type-checking, will make many bugs visible, fixes #1809 -added NOTIFICATION_INSTANCED
2015-05-04 23:30:57 +02:00
STRING,
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
NIL,
};
valid_types=valid;
} break;
case INT: {
static const Type valid[]={
BOOL,
REAL,
-More strict argument type-checking, will make many bugs visible, fixes #1809 -added NOTIFICATION_INSTANCED
2015-05-04 23:30:57 +02:00
STRING,
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
NIL,
};
valid_types=valid;
} break;
case REAL: {
static const Type valid[]={
BOOL,
INT,
-More strict argument type-checking, will make many bugs visible, fixes #1809 -added NOTIFICATION_INSTANCED
2015-05-04 23:30:57 +02:00
STRING,
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
NIL,
};
valid_types=valid;
} break;
case STRING: {
static const Type invalid[]={
OBJECT,
IMAGE,
NIL
};
invalid_types=invalid;
} break;
case MATRIX32: {
-More strict argument type-checking, will make many bugs visible, fixes #1809 -added NOTIFICATION_INSTANCED
2015-05-04 23:30:57 +02:00
static const Type valid[]={
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
TRANSFORM,
NIL
};
-More strict argument type-checking, will make many bugs visible, fixes #1809 -added NOTIFICATION_INSTANCED
2015-05-04 23:30:57 +02:00
valid_types=valid;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
} 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;
remove trailing whitespace
2016-03-09 00:00:52 +01:00
} break;
-Fixed a few bugs in Viewport -Made a few demos using Viewport to show it's true power! -Fixed some start-up error messages.
2014-04-10 05:18:27 +02:00
-More strict argument type-checking, will make many bugs visible, fixes #1809 -added NOTIFICATION_INSTANCED
2015-05-04 23:30:57 +02:00
case COLOR: {
static const Type valid[] = {
added conversion from int, string to color fixes #1971
2015-05-27 15:56:57 +02:00
STRING,
INT,
-More strict argument type-checking, will make many bugs visible, fixes #1809 -added NOTIFICATION_INSTANCED
2015-05-04 23:30:57 +02:00
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::can_convert_strict(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[]={
Made type-checking for arguments less trict between bool, int real. Fixes #1816
2015-05-05 14:53:37 +02:00
INT,
REAL,
-More strict argument type-checking, will make many bugs visible, fixes #1809 -added NOTIFICATION_INSTANCED
2015-05-04 23:30:57 +02:00
//STRING,
NIL,
};
valid_types=valid;
} break;
case INT: {
static const Type valid[]={
Made type-checking for arguments less trict between bool, int real. Fixes #1816
2015-05-05 14:53:37 +02:00
BOOL,
-More strict argument type-checking, will make many bugs visible, fixes #1809 -added NOTIFICATION_INSTANCED
2015-05-04 23:30:57 +02:00
REAL,
//STRING,
NIL,
};
valid_types=valid;
} break;
case REAL: {
static const Type valid[]={
Made type-checking for arguments less trict between bool, int real. Fixes #1816
2015-05-05 14:53:37 +02:00
BOOL,
-More strict argument type-checking, will make many bugs visible, fixes #1809 -added NOTIFICATION_INSTANCED
2015-05-04 23:30:57 +02:00
INT,
//STRING,
NIL,
};
valid_types=valid;
} break;
case STRING: {
static const Type valid[]={
NODE_PATH,
NIL
};
valid_types=valid;
} break;
case MATRIX32: {
static const Type valid[]={
TRANSFORM,
NIL
};
valid_types=valid;
} 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;
-Fixed a few bugs in Viewport -Made a few demos using Viewport to show it's true power! -Fixed some start-up error messages.
2014-04-10 05:18:27 +02:00
case COLOR: {
static const Type valid[] = {
STRING,
INT,
NIL,
};
valid_types = valid;
} break;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
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;
}
-Ability to roll-back script-exported properties to their default value on the script, closes #2128
2016-01-03 00:17:31 +01:00
bool Variant::operator!=(const Variant& p_variant) const {
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);
return r;
}
Sort xml files, so order is constant Makes xml format work better with version control systems.
2015-05-01 02:53:41 +02:00
bool Variant::operator<(const Variant& p_variant) const {
if (type!=p_variant.type) //if types differ, then order by type first
return type<p_variant.type;
bool v;
Variant r;
evaluate(OP_LESS,*this,p_variant,r,v);
return r;
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
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: {
added return keyword, fixes #1797
2015-05-04 05:53:33 +02:00
return *reinterpret_cast<const Quat*>(_data._mem)==Quat();
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
} 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;
}
Several performance improvements, mainly in loading and instancing scenes and resources. A general speedup should be apparent, with even more peformance increase when compiling optimized. WARNING: Tested and it seems to work, but if something breaks, please report.
2015-06-29 05:29:49 +02:00
bool Variant::is_one() const {
switch( type ) {
case NIL: {
return true;
} break;
// atomic types
case BOOL: {
return _data._bool==true;
} break;
case INT: {
return _data._int==1;
} break;
case REAL: {
return _data._real==1;
} break;
case VECTOR2: {
return *reinterpret_cast<const Vector2*>(_data._mem)==Vector2(1,1);
} break;
case RECT2: {
return *reinterpret_cast<const Rect2*>(_data._mem)==Rect2(1,1,1,1);
} break;
case VECTOR3: {
return *reinterpret_cast<const Vector3*>(_data._mem)==Vector3(1,1,1);
} break;
case PLANE: {
return *reinterpret_cast<const Plane*>(_data._mem)==Plane(1,1,1,1);
} break;
case COLOR: {
return *reinterpret_cast<const Color*>(_data._mem)==Color(1,1,1,1);
} break;
default: { return !is_zero(); }
}
return false;
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
void Variant::reference(const Variant& p_variant) {
remove trailing whitespace
2016-03-09 00:00:52 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
if (this == &p_variant)
return;
remove trailing whitespace
2016-03-09 00:00:52 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
clear();
remove trailing whitespace
2016-03-09 00:00:52 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
type=p_variant.type;
remove trailing whitespace
2016-03-09 00:00:52 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
switch( p_variant.type ) {
case NIL: {
remove trailing whitespace
2016-03-09 00:00:52 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
// none
} break;
remove trailing whitespace
2016-03-09 00:00:52 +01:00
// atomic types
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
case BOOL: {
remove trailing whitespace
2016-03-09 00:00:52 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
_data._bool=p_variant._data._bool;
} break;
case INT: {
remove trailing whitespace
2016-03-09 00:00:52 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
_data._int=p_variant._data._int;
remove trailing whitespace
2016-03-09 00:00:52 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
} break;
case REAL: {
remove trailing whitespace
2016-03-09 00:00:52 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
_data._real=p_variant._data._real;
remove trailing whitespace
2016-03-09 00:00:52 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
} break;
case STRING: {
remove trailing whitespace
2016-03-09 00:00:52 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
memnew_placement( _data._mem, String( *reinterpret_cast<const String*>(p_variant._data._mem) ) );
remove trailing whitespace
2016-03-09 00:00:52 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
} break;
remove trailing whitespace
2016-03-09 00:00:52 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
// math types
remove trailing whitespace
2016-03-09 00:00:52 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
case VECTOR2: {
remove trailing whitespace
2016-03-09 00:00:52 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
memnew_placement( _data._mem, Vector2( *reinterpret_cast<const Vector2*>(p_variant._data._mem) ) );
remove trailing whitespace
2016-03-09 00:00:52 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
} break;
case RECT2: {
remove trailing whitespace
2016-03-09 00:00:52 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
memnew_placement( _data._mem, Rect2( *reinterpret_cast<const Rect2*>(p_variant._data._mem) ) );
remove trailing whitespace
2016-03-09 00:00:52 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
} break;
case MATRIX32: {
_data._matrix32 = memnew( Matrix32( *p_variant._data._matrix32 ) );
} break;
case VECTOR3: {
remove trailing whitespace
2016-03-09 00:00:52 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
memnew_placement( _data._mem, Vector3( *reinterpret_cast<const Vector3*>(p_variant._data._mem) ) );
remove trailing whitespace
2016-03-09 00:00:52 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
} break;
case PLANE: {
remove trailing whitespace
2016-03-09 00:00:52 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
memnew_placement( _data._mem, Plane( *reinterpret_cast<const Plane*>(p_variant._data._mem) ) );
remove trailing whitespace
2016-03-09 00:00:52 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
} break;
remove trailing whitespace
2016-03-09 00:00:52 +01:00
/*
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
case QUAT: {
remove trailing whitespace
2016-03-09 00:00:52 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
} break;*/
case _AABB: {
remove trailing whitespace
2016-03-09 00:00:52 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
_data._aabb = memnew( AABB( *p_variant._data._aabb ) );
} break;
case QUAT: {
remove trailing whitespace
2016-03-09 00:00:52 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
memnew_placement( _data._mem, Quat( *reinterpret_cast<const Quat*>(p_variant._data._mem) ) );
remove trailing whitespace
2016-03-09 00:00:52 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
} break;
case MATRIX3: {
remove trailing whitespace
2016-03-09 00:00:52 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
_data._matrix3 = memnew( Matrix3( *p_variant._data._matrix3 ) );
remove trailing whitespace
2016-03-09 00:00:52 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
} break;
case TRANSFORM: {
remove trailing whitespace
2016-03-09 00:00:52 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
_data._transform = memnew( Transform( *p_variant._data._transform ) );
remove trailing whitespace
2016-03-09 00:00:52 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
} break;
remove trailing whitespace
2016-03-09 00:00:52 +01:00
// misc types
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
case COLOR: {
remove trailing whitespace
2016-03-09 00:00:52 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
memnew_placement( _data._mem, Color( *reinterpret_cast<const Color*>(p_variant._data._mem) ) );
remove trailing whitespace
2016-03-09 00:00:52 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
} break;
case IMAGE: {
remove trailing whitespace
2016-03-09 00:00:52 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
_data._image = memnew( Image( *p_variant._data._image ) );
remove trailing whitespace
2016-03-09 00:00:52 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
} break;
case _RID: {
remove trailing whitespace
2016-03-09 00:00:52 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
memnew_placement( _data._mem, RID( *reinterpret_cast<const RID*>(p_variant._data._mem) ) );
} break;
case OBJECT: {
remove trailing whitespace
2016-03-09 00:00:52 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
memnew_placement( _data._mem, ObjData( p_variant._get_obj() ) );
} break;
case NODE_PATH: {
remove trailing whitespace
2016-03-09 00:00:52 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
memnew_placement( _data._mem, NodePath( *reinterpret_cast<const NodePath*>(p_variant._data._mem) ) );
remove trailing whitespace
2016-03-09 00:00:52 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
} break;
case INPUT_EVENT: {
remove trailing whitespace
2016-03-09 00:00:52 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
_data._input_event= memnew( InputEvent( *p_variant._data._input_event ) );
remove trailing whitespace
2016-03-09 00:00:52 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
} break;
case DICTIONARY: {
remove trailing whitespace
2016-03-09 00:00:52 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
memnew_placement( _data._mem, Dictionary( *reinterpret_cast<const Dictionary*>(p_variant._data._mem) ) );
remove trailing whitespace
2016-03-09 00:00:52 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
} break;
case ARRAY: {
remove trailing whitespace
2016-03-09 00:00:52 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
memnew_placement( _data._mem, Array ( *reinterpret_cast<const Array*>(p_variant._data._mem) ) );
remove trailing whitespace
2016-03-09 00:00:52 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
} break;
remove trailing whitespace
2016-03-09 00:00:52 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
// arrays
case RAW_ARRAY: {
remove trailing whitespace
2016-03-09 00:00:52 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
memnew_placement( _data._mem, DVector<uint8_t> ( *reinterpret_cast<const DVector<uint8_t>*>(p_variant._data._mem) ) );
remove trailing whitespace
2016-03-09 00:00:52 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
} break;
case INT_ARRAY: {
remove trailing whitespace
2016-03-09 00:00:52 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
memnew_placement( _data._mem, DVector<int> ( *reinterpret_cast<const DVector<int>*>(p_variant._data._mem) ) );
remove trailing whitespace
2016-03-09 00:00:52 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
} break;
case REAL_ARRAY: {
remove trailing whitespace
2016-03-09 00:00:52 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
memnew_placement( _data._mem, DVector<real_t> ( *reinterpret_cast<const DVector<real_t>*>(p_variant._data._mem) ) );
remove trailing whitespace
2016-03-09 00:00:52 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
} break;
case STRING_ARRAY: {
remove trailing whitespace
2016-03-09 00:00:52 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
memnew_placement( _data._mem, DVector<String> ( *reinterpret_cast<const DVector<String>*>(p_variant._data._mem) ) );
remove trailing whitespace
2016-03-09 00:00:52 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
} break;
case VECTOR2_ARRAY: {
memnew_placement( _data._mem, DVector<Vector2> ( *reinterpret_cast<const DVector<Vector2>*>(p_variant._data._mem) ) );
} break;
case VECTOR3_ARRAY: {
remove trailing whitespace
2016-03-09 00:00:52 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
memnew_placement( _data._mem, DVector<Vector3> ( *reinterpret_cast<const DVector<Vector3>*>(p_variant._data._mem) ) );
remove trailing whitespace
2016-03-09 00:00:52 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
} break;
case COLOR_ARRAY: {
remove trailing whitespace
2016-03-09 00:00:52 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
memnew_placement( _data._mem, DVector<Color> ( *reinterpret_cast<const DVector<Color>*>(p_variant._data._mem) ) );
remove trailing whitespace
2016-03-09 00:00:52 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
} break;
default: {}
remove trailing whitespace
2016-03-09 00:00:52 +01:00
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
}
AnimationTreePlayer: blend value tracks (closes #2299) Variant: - zero() sets a Variant to the appropriate type of zero value - blend() blends part of one Variant on top of another.
2016-02-18 04:34:49 +01:00
void Variant::zero() {
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<Vector2*>(this->_data._mem) = Vector2(); break;
case RECT2: *reinterpret_cast<Rect2*>(this->_data._mem) = Rect2(); break;
case VECTOR3: *reinterpret_cast<Vector3*>(this->_data._mem) = Vector3(); break;
case PLANE: *reinterpret_cast<Plane*>(this->_data._mem) = Plane(); break;
case QUAT: *reinterpret_cast<Quat*>(this->_data._mem) = Quat(); break;
case COLOR: *reinterpret_cast<Color*>(this->_data._mem) = Color(); break;
default: this->clear(); break;
}
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
void Variant::clear() {
switch(type) {
case STRING: {
remove trailing whitespace
2016-03-09 00:00:52 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
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: {
remove trailing whitespace
2016-03-09 00:00:52 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
memdelete( _data._aabb );
remove trailing whitespace
2016-03-09 00:00:52 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
} break;
case MATRIX3: {
remove trailing whitespace
2016-03-09 00:00:52 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
memdelete( _data._matrix3 );
} break;
case TRANSFORM: {
remove trailing whitespace
2016-03-09 00:00:52 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
memdelete( _data._transform );
remove trailing whitespace
2016-03-09 00:00:52 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
} break;
remove trailing whitespace
2016-03-09 00:00:52 +01:00
// misc types
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
case IMAGE: {
remove trailing whitespace
2016-03-09 00:00:52 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
memdelete( _data._image );
remove trailing whitespace
2016-03-09 00:00:52 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
} break;
case NODE_PATH: {
remove trailing whitespace
2016-03-09 00:00:52 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
reinterpret_cast<NodePath*>(_data._mem)->~NodePath();
remove trailing whitespace
2016-03-09 00:00:52 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
} break;
case OBJECT: {
remove trailing whitespace
2016-03-09 00:00:52 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
_get_obj().obj=NULL;
_get_obj().ref.unref();
} break;
case _RID: {
// not much need probably
reinterpret_cast<RID*>(_data._mem)->~RID();
} break;
case DICTIONARY: {
remove trailing whitespace
2016-03-09 00:00:52 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
reinterpret_cast<Dictionary*>(_data._mem)->~Dictionary();
remove trailing whitespace
2016-03-09 00:00:52 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
} break;
case ARRAY: {
remove trailing whitespace
2016-03-09 00:00:52 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
reinterpret_cast<Array*>(_data._mem)->~Array();
remove trailing whitespace
2016-03-09 00:00:52 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
} break;
case INPUT_EVENT: {
remove trailing whitespace
2016-03-09 00:00:52 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
memdelete( _data._input_event );
remove trailing whitespace
2016-03-09 00:00:52 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
} break;
remove trailing whitespace
2016-03-09 00:00:52 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
// arrays
case RAW_ARRAY: {
remove trailing whitespace
2016-03-09 00:00:52 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
reinterpret_cast< DVector<uint8_t>* >(_data._mem)->~DVector<uint8_t>();
remove trailing whitespace
2016-03-09 00:00:52 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
} break;
case INT_ARRAY: {
remove trailing whitespace
2016-03-09 00:00:52 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
reinterpret_cast< DVector<int>* >(_data._mem)->~DVector<int>();
remove trailing whitespace
2016-03-09 00:00:52 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
} break;
case REAL_ARRAY: {
remove trailing whitespace
2016-03-09 00:00:52 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
reinterpret_cast< DVector<real_t>* >(_data._mem)->~DVector<real_t>();
remove trailing whitespace
2016-03-09 00:00:52 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
} break;
case STRING_ARRAY: {
remove trailing whitespace
2016-03-09 00:00:52 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
reinterpret_cast< DVector<String>* >(_data._mem)->~DVector<String>();
remove trailing whitespace
2016-03-09 00:00:52 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
} break;
case VECTOR2_ARRAY: {
reinterpret_cast< DVector<Vector2>* >(_data._mem)->~DVector<Vector2>();
} break;
case VECTOR3_ARRAY: {
remove trailing whitespace
2016-03-09 00:00:52 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
reinterpret_cast< DVector<Vector3>* >(_data._mem)->~DVector<Vector3>();
remove trailing whitespace
2016-03-09 00:00:52 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
} break;
case COLOR_ARRAY: {
remove trailing whitespace
2016-03-09 00:00:52 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
reinterpret_cast< DVector<Color>* >(_data._mem)->~DVector<Color>();
remove trailing whitespace
2016-03-09 00:00:52 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
} break;
default: {} /* not needed */
}
remove trailing whitespace
2016-03-09 00:00:52 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
type=NIL;
}
remove trailing whitespace
2016-03-09 00:00:52 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
Variant::operator signed int() const {
switch( type ) {
remove trailing whitespace
2016-03-09 00:00:52 +01:00
case NIL: return 0;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
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: {
remove trailing whitespace
2016-03-09 00:00:52 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
return 0;
remove trailing whitespace
2016-03-09 00:00:52 +01:00
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
}
remove trailing whitespace
2016-03-09 00:00:52 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
return 0;
}
Variant::operator unsigned int() const {
switch( type ) {
remove trailing whitespace
2016-03-09 00:00:52 +01:00
case NIL: return 0;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
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: {
remove trailing whitespace
2016-03-09 00:00:52 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
return 0;
remove trailing whitespace
2016-03-09 00:00:52 +01:00
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
}
remove trailing whitespace
2016-03-09 00:00:52 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
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 ) {
remove trailing whitespace
2016-03-09 00:00:52 +01:00
case NIL: return 0;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
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: {
remove trailing whitespace
2016-03-09 00:00:52 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
return 0;
remove trailing whitespace
2016-03-09 00:00:52 +01:00
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
}
remove trailing whitespace
2016-03-09 00:00:52 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
return 0;
}
Variant::operator unsigned short() const {
switch( type ) {
remove trailing whitespace
2016-03-09 00:00:52 +01:00
case NIL: return 0;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
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: {
remove trailing whitespace
2016-03-09 00:00:52 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
return 0;
remove trailing whitespace
2016-03-09 00:00:52 +01:00
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
}
remove trailing whitespace
2016-03-09 00:00:52 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
return 0;
}
Variant::operator signed char() const {
switch( type ) {
remove trailing whitespace
2016-03-09 00:00:52 +01:00
case NIL: return 0;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
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: {
remove trailing whitespace
2016-03-09 00:00:52 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
return 0;
remove trailing whitespace
2016-03-09 00:00:52 +01:00
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
}
remove trailing whitespace
2016-03-09 00:00:52 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
return 0;
}
Variant::operator unsigned char() const {
switch( type ) {
remove trailing whitespace
2016-03-09 00:00:52 +01:00
case NIL: return 0;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
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: {
remove trailing whitespace
2016-03-09 00:00:52 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
return 0;
remove trailing whitespace
2016-03-09 00:00:52 +01:00
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
}
remove trailing whitespace
2016-03-09 00:00:52 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
return 0;
}
#ifndef CHARTYPE_16BITS
Variant::operator CharType() const {
return operator unsigned int();
}
#endif
Variant::operator float() const {
switch( type ) {
remove trailing whitespace
2016-03-09 00:00:52 +01:00
case NIL: return 0;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
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: {
remove trailing whitespace
2016-03-09 00:00:52 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
return 0;
remove trailing whitespace
2016-03-09 00:00:52 +01:00
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
}
remove trailing whitespace
2016-03-09 00:00:52 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
return 0;
}
Variant::operator double() const {
switch( type ) {
remove trailing whitespace
2016-03-09 00:00:52 +01:00
case NIL: return 0;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
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: {
remove trailing whitespace
2016-03-09 00:00:52 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
return 0;
remove trailing whitespace
2016-03-09 00:00:52 +01:00
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
}
remove trailing whitespace
2016-03-09 00:00:52 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
return true;
}
Variant::operator StringName() const {
remove trailing whitespace
2016-03-09 00:00:52 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
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 ) {
remove trailing whitespace
2016-03-09 00:00:52 +01:00
case NIL: return "";
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
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();
remove trailing whitespace
2016-03-09 00:00:52 +01:00
//case QUAT:
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
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: {
remove trailing whitespace
2016-03-09 00:00:52 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
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+")";
}
remove trailing whitespace
2016-03-09 00:00:52 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
return str;
} break;
Add missing Vector2Array case to Variant::operator String() - Correcly display Vector2Array default arguments in the documentation
2016-05-04 15:04:12 +02:00
case VECTOR2_ARRAY: {
DVector<Vector2> vec = operator DVector<Vector2>();
String str;
for(int i=0;i<vec.size();i++) {
if (i>0)
str+=", ";
str=str+Variant( vec[i] );
}
return str;
} break;
remove trailing whitespace
2016-03-09 00:00:52 +01:00
case VECTOR3_ARRAY: {
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
DVector<Vector3> vec = operator DVector<Vector3>();
String str;
for(int i=0;i<vec.size();i++) {
remove trailing whitespace
2016-03-09 00:00:52 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
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: {
merged some stuff for okam
2015-09-04 04:24:55 +02:00
if (_get_obj().obj) {
#ifdef DEBUG_ENABLED
if (ScriptDebugger::get_singleton() && _get_obj().ref.is_null()) {
//only if debugging!
if (!ObjectDB::instance_validate(_get_obj().obj)) {
return "[Deleted Object]";
};
};
#endif
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
return "["+_get_obj().obj->get_type()+":"+itos(_get_obj().obj->get_instance_ID())+"]";
merged some stuff for okam
2015-09-04 04:24:55 +02:00
} else
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
return "[Object:null]";
} break;
default: {
return "["+get_type_name(type)+"]";
remove trailing whitespace
2016-03-09 00:00:52 +01:00
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
}
remove trailing whitespace
2016-03-09 00:00:52 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
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;
A bit of everything: -IMA-ADPCM support for samples, this means that sound effects can be compressed and use 4 timess less RAM. -New 3D import workflow based on Wavefront OBJ. Import single objects as mesh resources instead of full scenes. Many people prefers to work this way. Just like the rest of the imported resources, these are updated in realtime if modified externally. -Mesh resources now support naming surfaces. This helps reimporting to identify which user-created materials must be kept. -Several fixes and improvements to SurfaceTool. -Anti Aliasing added to WorldEnvironment effects (using FXAA) -2D Physics bodies (RigidBody, KinematicBody, etc), Raycasts, Tilemap, etc support collision layers. This makes easy to group which objects collide against which. -2D Trigger shapes can now also trigger collision reporting in other 2D bodies (it used to be in Area2D before) -Viewport render target textures can now be filtered. -Few fixes in GDscript make it easier to work with static functions and class members. -Several and many bugfixes.
2014-05-14 06:22:15 +02:00
else if (type==QUAT)
return *reinterpret_cast<const Quat*>(_data._mem);
else if (type==TRANSFORM)
return _data._transform->basis;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
else
return Matrix3();
}
Variant::operator Quat() const {
if (type==QUAT)
return *reinterpret_cast<const Quat*>(_data._mem);
A bit of everything: -IMA-ADPCM support for samples, this means that sound effects can be compressed and use 4 timess less RAM. -New 3D import workflow based on Wavefront OBJ. Import single objects as mesh resources instead of full scenes. Many people prefers to work this way. Just like the rest of the imported resources, these are updated in realtime if modified externally. -Mesh resources now support naming surfaces. This helps reimporting to identify which user-created materials must be kept. -Several fixes and improvements to SurfaceTool. -Anti Aliasing added to WorldEnvironment effects (using FXAA) -2D Physics bodies (RigidBody, KinematicBody, etc), Raycasts, Tilemap, etc support collision layers. This makes easy to group which objects collide against which. -2D Trigger shapes can now also trigger collision reporting in other 2D bodies (it used to be in Area2D before) -Viewport render target textures can now be filtered. -Few fixes in GDscript make it easier to work with static functions and class members. -Several and many bugfixes.
2014-05-14 06:22:15 +02:00
else if (type==MATRIX3)
return *_data._matrix3;
else if (type==TRANSFORM)
return _data._transform->basis;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
else
return Quat();
}
Variant::operator Transform() const {
if (type==TRANSFORM)
return *_data._transform;
else if (type==MATRIX3)
return Transform(*_data._matrix3,Vector3());
A bit of everything: -IMA-ADPCM support for samples, this means that sound effects can be compressed and use 4 timess less RAM. -New 3D import workflow based on Wavefront OBJ. Import single objects as mesh resources instead of full scenes. Many people prefers to work this way. Just like the rest of the imported resources, these are updated in realtime if modified externally. -Mesh resources now support naming surfaces. This helps reimporting to identify which user-created materials must be kept. -Several fixes and improvements to SurfaceTool. -Anti Aliasing added to WorldEnvironment effects (using FXAA) -2D Physics bodies (RigidBody, KinematicBody, etc), Raycasts, Tilemap, etc support collision layers. This makes easy to group which objects collide against which. -2D Trigger shapes can now also trigger collision reporting in other 2D bodies (it used to be in Area2D before) -Viewport render target textures can now be filtered. -Few fixes in GDscript make it easier to work with static functions and class members. -Several and many bugfixes.
2014-05-14 06:22:15 +02:00
else if (type==QUAT)
return Transform(Matrix3(*reinterpret_cast<const Quat*>(_data._mem)),Vector3());
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
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);
added conversion from int, string to color fixes #1971
2015-05-27 15:56:57 +02:00
else if (type==STRING)
return Color::html( operator String() );
else if (type==INT)
return Color::hex( operator int() );
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
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();
Ability to convert from nodes or other non resource with a get_rid() function to a rid
2015-04-25 01:45:07 +02:00
} 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) {
return ret;
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
return RID();
Ability to convert from nodes or other non resource with a get_rid() function to a rid
2015-04-25 01:45:07 +02:00
} else {
return RID();
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
}
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 {
remove trailing whitespace
2016-03-09 00:00:52 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
if (type==INPUT_EVENT)
return *reinterpret_cast<const InputEvent*>(_data._input_event);
else
return InputEvent();
}
Variant::operator Dictionary() const {
remove trailing whitespace
2016-03-09 00:00:52 +01:00
if (type==DICTIONARY)
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
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 {
remove trailing whitespace
2016-03-09 00:00:52 +01:00
if (type==ARRAY)
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
return *reinterpret_cast<const Array*>(_data._mem);
remove trailing whitespace
2016-03-09 00:00:52 +01:00
else
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
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 {
remove trailing whitespace
2016-03-09 00:00:52 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
Array from=operator Array();
Vector<Variant> to;
int len=from.size();
to.resize(len);
for (int i=0;i<len;i++) {
remove trailing whitespace
2016-03-09 00:00:52 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
to[i]=from[i];
}
return to;
remove trailing whitespace
2016-03-09 00:00:52 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
}
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++) {
remove trailing whitespace
2016-03-09 00:00:52 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
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++) {
remove trailing whitespace
2016-03-09 00:00:52 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
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++) {
remove trailing whitespace
2016-03-09 00:00:52 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
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++) {
remove trailing whitespace
2016-03-09 00:00:52 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
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++) {
remove trailing whitespace
2016-03-09 00:00:52 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
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) {
remove trailing whitespace
2016-03-09 00:00:52 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
type=INT;
_data._int=p_int;
remove trailing whitespace
2016-03-09 00:00:52 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
}
Variant::Variant(unsigned long p_int) {
remove trailing whitespace
2016-03-09 00:00:52 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
type=INT;
_data._int=p_int;
remove trailing whitespace
2016-03-09 00:00:52 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
}
#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) {
remove trailing whitespace
2016-03-09 00:00:52 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
type=STRING;
memnew_placement( _data._mem, String( p_string.operator String() ) );
remove trailing whitespace
2016-03-09 00:00:52 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
}
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) {
remove trailing whitespace
2016-03-09 00:00:52 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
type=INPUT_EVENT;
remove trailing whitespace
2016-03-09 00:00:52 +01:00
_data._input_event = memnew( InputEvent(p_input_event) );
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
}
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) {
remove trailing whitespace
2016-03-09 00:00:52 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
type=DICTIONARY;
memnew_placement( _data._mem, (Dictionary)( p_dictionary) );
remove trailing whitespace
2016-03-09 00:00:52 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
}
Variant::Variant(const Array& p_array) {
type=ARRAY;
memnew_placement( _data._mem, Array(p_array) );
}
Variant::Variant(const DVector<Plane>& p_array) {
remove trailing whitespace
2016-03-09 00:00:52 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
type=ARRAY;
Array *plane_array=memnew_placement( _data._mem, Array );
remove trailing whitespace
2016-03-09 00:00:52 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
plane_array->resize( p_array.size() );
remove trailing whitespace
2016-03-09 00:00:52 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
for (int i=0;i<p_array.size();i++) {
remove trailing whitespace
2016-03-09 00:00:52 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
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;
}
begin new serialization framework also got rid of STL dependency on triangulator
2015-02-15 05:19:46 +01:00
void Variant::construct_from_string(const String& p_string,Variant& r_value,ObjectConstruct p_obj_construct,void *p_construct_ud) {
r_value=Variant();
}
New Code Completion -=-=-=-=-=-=-=-=-=- -Massive improvement to code completion -Argument hinting for functions If you manage to out-smart the code-completion in a situation where completion should be possible to guess, let me know. Please enter the commit message for your changes. Lines starting
2014-12-17 02:31:57 +01:00
begin new serialization framework also got rid of STL dependency on triangulator
2015-02-15 05:19:46 +01:00
-Changed var2str and str2var in GDScript to use VariantWriter and VariantParser -It is now finally possible to parse back a variant from text!
2015-12-31 04:54:00 +01:00
String Variant::get_construct_string() const {
New Code Completion -=-=-=-=-=-=-=-=-=- -Massive improvement to code completion -Argument hinting for functions If you manage to out-smart the code-completion in a situation where completion should be possible to guess, let me know. Please enter the commit message for your changes. Lines starting
2014-12-17 02:31:57 +01:00
-Changed var2str and str2var in GDScript to use VariantWriter and VariantParser -It is now finally possible to parse back a variant from text!
2015-12-31 04:54:00 +01:00
String vars;
VariantWriter::write_to_string(*this,vars);
New Code Completion -=-=-=-=-=-=-=-=-=- -Massive improvement to code completion -Argument hinting for functions If you manage to out-smart the code-completion in a situation where completion should be possible to guess, let me know. Please enter the commit message for your changes. Lines starting
2014-12-17 02:31:57 +01:00
-Changed var2str and str2var in GDScript to use VariantWriter and VariantParser -It is now finally possible to parse back a variant from text!
2015-12-31 04:54:00 +01:00
return vars;
New Code Completion -=-=-=-=-=-=-=-=-=- -Massive improvement to code completion -Argument hinting for functions If you manage to out-smart the code-completion in a situation where completion should be possible to guess, let me know. Please enter the commit message for your changes. Lines starting
2014-12-17 02:31:57 +01:00
}
-make signals throw an error when target method is not found, fixes #2036 -removed 4 arguments limit for emit_signal() from script -remvoed 4 arguments limit for call_deferred() from script
2016-01-04 13:35:21 +01:00
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="Expected "+itos(ce.argument)+" arguments.";
} else if (ce.error==Variant::CallError::CALL_ERROR_TOO_FEW_ARGUMENTS) {
err_text="Expected "+itos(ce.argument)+" arguments.";
} 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";
}
String class_name = p_base->get_type();
Ref<Script> script = p_base->get_script();
if (script.is_valid() && script->get_path().is_resource_file()) {
class_name+="("+script->get_path().get_file()+")";
}
return "'"+class_name+"::"+String(p_method)+"': "+err_text;
}
-Added configuration warning system for nodes -Added a new "add" and "instance" buttons for scene tree -Added a vformat() function to ease translation work
2016-05-17 23:27:15 +02:00
String vformat(const String& p_text, const Variant& p1,const Variant& p2,const Variant& p3,const Variant& p4,const Variant& p5) {
Array args;
if (p1.get_type()!=Variant::NIL) {
args.push_back(p1);
if (p2.get_type()!=Variant::NIL) {
args.push_back(p2);
if (p3.get_type()!=Variant::NIL) {
args.push_back(p3);
if (p4.get_type()!=Variant::NIL) {
args.push_back(p4);
if (p5.get_type()!=Variant::NIL) {
args.push_back(p5);
}
}
}
}
}
bool error=false;
String fmt = p_text.sprintf(args,&error);
ERR_FAIL_COND_V(error,String());
return fmt;
}
Reference in a new issue Copy permalink