godot/core/variant.h

460 lines
14 KiB
C++
Raw Normal View History

2014-02-10 01:10:30 +00:00
/*************************************************************************/
/* variant.h */
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* http://www.godotengine.org */
/*************************************************************************/
/* Copyright (c) 2007-2017 Juan Linietsky, Ariel Manzur. */
/* Copyright (c) 2014-2017 Godot Engine contributors (cf. AUTHORS.md) */
2014-02-10 01:10:30 +00: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. */
/*************************************************************************/
#ifndef VARIANT_H
#define VARIANT_H
/**
@author Juan Linietsky <reduzio@gmail.com>
*/
#include "array.h"
#include "color.h"
#include "dictionary.h"
2014-02-10 01:10:30 +00:00
#include "dvector.h"
#include "face3.h"
#include "io/ip_address.h"
#include "math_2d.h"
#include "matrix3.h"
2014-02-10 01:10:30 +00:00
#include "os/input_event.h"
#include "os/power.h"
#include "path_db.h"
#include "plane.h"
#include "quat.h"
#include "rect3.h"
2014-02-10 01:10:30 +00:00
#include "ref_ptr.h"
#include "rid.h"
#include "simple_type.h"
#include "transform.h"
#include "ustring.h"
#include "vector3.h"
2014-02-10 01:10:30 +00:00
class RefPtr;
class Object;
class Node; // helper
class Control; // helper
struct PropertyInfo;
struct MethodInfo;
typedef PoolVector<uint8_t> PoolByteArray;
typedef PoolVector<int> PoolIntArray;
typedef PoolVector<real_t> PoolRealArray;
typedef PoolVector<String> PoolStringArray;
typedef PoolVector<Vector2> PoolVector2Array;
typedef PoolVector<Vector3> PoolVector3Array;
typedef PoolVector<Color> PoolColorArray;
2014-02-10 01:10:30 +00:00
class Variant {
public:
enum Type {
2016-03-08 23:00:52 +00:00
NIL,
// atomic types
2014-02-10 01:10:30 +00:00
BOOL,
INT,
REAL,
STRING,
2016-03-08 23:00:52 +00:00
2014-02-10 01:10:30 +00:00
// math types
2016-03-08 23:00:52 +00:00
VECTOR2, // 5
2014-02-10 01:10:30 +00:00
RECT2,
VECTOR3,
TRANSFORM2D,
2014-02-10 01:10:30 +00:00
PLANE,
QUAT, // 10
RECT3,
BASIS,
2014-02-10 01:10:30 +00:00
TRANSFORM,
2016-03-08 23:00:52 +00:00
// misc types
2014-02-10 01:10:30 +00:00
COLOR,
NODE_PATH, // 15
2014-02-10 01:10:30 +00:00
_RID,
2016-03-08 23:00:52 +00:00
OBJECT,
2014-02-10 01:10:30 +00:00
INPUT_EVENT,
DICTIONARY,
ARRAY, // 20
2016-03-08 23:00:52 +00:00
2014-02-10 01:10:30 +00:00
// arrays
POOL_BYTE_ARRAY,
POOL_INT_ARRAY,
POOL_REAL_ARRAY,
POOL_STRING_ARRAY,
POOL_VECTOR2_ARRAY, // 25
POOL_VECTOR3_ARRAY,
POOL_COLOR_ARRAY,
2016-03-08 23:00:52 +00:00
2014-02-10 01:10:30 +00:00
VARIANT_MAX
2016-03-08 23:00:52 +00:00
};
2014-02-10 01:10:30 +00:00
private:
friend class _VariantCall;
// Variant takes 20 bytes when real_t is float, and 36 if double
// it only allocates extra memory for aabb/matrix.
2016-03-08 23:00:52 +00:00
2014-02-10 01:10:30 +00:00
Type type;
struct ObjData {
Object *obj;
RefPtr ref;
};
2016-03-08 23:00:52 +00:00
_FORCE_INLINE_ ObjData &_get_obj();
_FORCE_INLINE_ const ObjData &_get_obj() const;
2014-02-10 01:10:30 +00:00
union {
2016-03-08 23:00:52 +00:00
2014-02-10 01:10:30 +00:00
bool _bool;
int64_t _int;
2014-02-10 01:10:30 +00:00
double _real;
Transform2D *_transform2d;
Rect3 *_rect3;
Basis *_basis;
2016-03-08 23:00:52 +00:00
Transform *_transform;
2014-02-10 01:10:30 +00:00
RefPtr *_resource;
InputEvent *_input_event;
void *_ptr; //generic pointer
uint8_t _mem[sizeof(ObjData) > (sizeof(real_t) * 4) ? sizeof(ObjData) : (sizeof(real_t) * 4)];
2014-02-10 01:10:30 +00:00
} _data;
void reference(const Variant &p_variant);
2014-02-10 01:10:30 +00:00
void clear();
public:
2014-02-10 01:10:30 +00:00
_FORCE_INLINE_ Type get_type() const { return type; }
static String get_type_name(Variant::Type p_type);
static bool can_convert(Type p_type_from, Type p_type_to);
static bool can_convert_strict(Type p_type_from, Type p_type_to);
2014-02-10 01:10:30 +00:00
template <class T>
2014-02-10 01:10:30 +00:00
static Type get_type_for() {
2016-03-08 23:00:52 +00:00
2014-02-10 01:10:30 +00:00
GetSimpleType<T> t;
Variant v(t.type);
Type r = v.get_type();
return r;
2014-02-10 01:10:30 +00:00
}
2014-12-17 12:14:25 +00:00
2014-02-10 01:10:30 +00:00
bool is_ref() const;
_FORCE_INLINE_ bool is_num() const { return type == INT || type == REAL; };
_FORCE_INLINE_ bool is_array() const { return type >= ARRAY; };
2014-02-10 01:10:30 +00:00
bool is_shared() const;
bool is_zero() const;
bool is_one() const;
2014-02-10 01:10:30 +00:00
operator bool() const;
operator signed int() const;
operator unsigned int() const; // this is the real one
operator signed short() const;
operator unsigned short() const;
operator signed char() const;
operator unsigned char() const;
//operator long unsigned int() const;
operator int64_t() const;
operator uint64_t() const;
#ifdef NEED_LONG_INT
operator signed long() const;
operator unsigned long() const;
#endif
operator CharType() const;
operator float() const;
operator double() const;
operator String() const;
operator StringName() const;
operator Vector2() const;
operator Rect2() const;
operator Vector3() const;
operator Plane() const;
operator Rect3() const;
2014-02-10 01:10:30 +00:00
operator Quat() const;
operator Basis() const;
2014-02-10 01:10:30 +00:00
operator Transform() const;
operator Transform2D() const;
2014-02-10 01:10:30 +00:00
operator Color() const;
operator NodePath() const;
operator RefPtr() const;
operator RID() const;
operator InputEvent() const;
operator Object *() const;
operator Node *() const;
operator Control *() const;
2014-02-10 01:10:30 +00:00
operator Dictionary() const;
operator Array() const;
2016-03-08 23:00:52 +00:00
operator PoolVector<uint8_t>() const;
operator PoolVector<int>() const;
operator PoolVector<real_t>() const;
operator PoolVector<String>() const;
operator PoolVector<Vector3>() const;
operator PoolVector<Color>() const;
operator PoolVector<Plane>() const;
operator PoolVector<Face3>() const;
2014-02-10 01:10:30 +00:00
operator Vector<Variant>() const;
operator Vector<uint8_t>() const;
operator Vector<int>() const;
operator Vector<real_t>() const;
operator Vector<String>() const;
operator Vector<Vector3>() const;
operator Vector<Color>() const;
operator Vector<RID>() const;
operator Vector<Vector2>() const;
operator PoolVector<Vector2>() const;
2014-02-10 01:10:30 +00:00
operator Vector<Plane>() const;
// some core type enums to convert to
operator Margin() const;
operator Orientation() const;
operator IP_Address() const;
Variant(bool p_bool);
Variant(signed int p_int); // real one
Variant(unsigned int p_int);
#ifdef NEED_LONG_INT
Variant(signed long p_long); // real one
Variant(unsigned long p_long);
//Variant(long unsigned int p_long);
2014-02-10 01:10:30 +00:00
#endif
Variant(signed short p_short); // real one
Variant(unsigned short p_short);
Variant(signed char p_char); // real one
Variant(unsigned char p_char);
Variant(int64_t p_char); // real one
Variant(uint64_t p_char);
Variant(float p_float);
Variant(double p_double);
Variant(const String &p_string);
Variant(const StringName &p_string);
Variant(const char *const p_cstring);
Variant(const CharType *p_wstring);
Variant(const Vector2 &p_vector2);
Variant(const Rect2 &p_rect2);
Variant(const Vector3 &p_vector3);
Variant(const Plane &p_plane);
Variant(const Rect3 &p_aabb);
Variant(const Quat &p_quat);
Variant(const Basis &p_transform);
Variant(const Transform2D &p_transform);
Variant(const Transform &p_transform);
Variant(const Color &p_color);
Variant(const NodePath &p_path);
Variant(const RefPtr &p_resource);
Variant(const RID &p_rid);
Variant(const Object *p_object);
Variant(const InputEvent &p_input_event);
Variant(const Dictionary &p_dictionary);
Variant(const Array &p_array);
Variant(const PoolVector<Plane> &p_array); // helper
Variant(const PoolVector<uint8_t> &p_raw_array);
Variant(const PoolVector<int> &p_int_array);
Variant(const PoolVector<real_t> &p_real_array);
Variant(const PoolVector<String> &p_string_array);
Variant(const PoolVector<Vector3> &p_vector3_array);
Variant(const PoolVector<Color> &p_color_array);
Variant(const PoolVector<Face3> &p_face_array);
Variant(const Vector<Variant> &p_array);
Variant(const Vector<uint8_t> &p_raw_array);
Variant(const Vector<int> &p_int_array);
Variant(const Vector<real_t> &p_real_array);
Variant(const Vector<String> &p_string_array);
Variant(const Vector<Vector3> &p_vector3_array);
Variant(const Vector<Color> &p_color_array);
Variant(const Vector<Plane> &p_array); // helper
Variant(const Vector<RID> &p_array); // helper
Variant(const Vector<Vector2> &p_array); // helper
Variant(const PoolVector<Vector2> &p_array); // helper
Variant(const IP_Address &p_address);
2014-02-10 01:10:30 +00:00
enum Operator {
//comparation
OP_EQUAL,
OP_NOT_EQUAL,
OP_LESS,
OP_LESS_EQUAL,
OP_GREATER,
OP_GREATER_EQUAL,
//mathematic
OP_ADD,
OP_SUBSTRACT,
OP_MULTIPLY,
OP_DIVIDE,
OP_NEGATE,
OP_POSITIVE,
2014-02-10 01:10:30 +00:00
OP_MODULE,
OP_STRING_CONCAT,
//bitwise
OP_SHIFT_LEFT,
OP_SHIFT_RIGHT,
OP_BIT_AND,
OP_BIT_OR,
OP_BIT_XOR,
OP_BIT_NEGATE,
//logic
OP_AND,
OP_OR,
OP_XOR,
OP_NOT,
//containment
OP_IN,
OP_MAX
};
static String get_operator_name(Operator p_op);
static void evaluate(const Operator &p_op, const Variant &p_a, const Variant &p_b, Variant &r_ret, bool &r_valid);
static _FORCE_INLINE_ Variant evaluate(const Operator &p_op, const Variant &p_a, const Variant &p_b) {
2014-02-10 01:10:30 +00:00
bool valid = true;
2014-02-10 01:10:30 +00:00
Variant res;
evaluate(p_op, p_a, p_b, res, valid);
2014-02-10 01:10:30 +00:00
return res;
}
void zero();
static void blend(const Variant &a, const Variant &b, float c, Variant &r_dst);
static void interpolate(const Variant &a, const Variant &b, float c, Variant &r_dst);
2014-02-10 01:10:30 +00:00
struct CallError {
enum Error {
CALL_OK,
CALL_ERROR_INVALID_METHOD,
CALL_ERROR_INVALID_ARGUMENT,
CALL_ERROR_TOO_MANY_ARGUMENTS,
CALL_ERROR_TOO_FEW_ARGUMENTS,
CALL_ERROR_INSTANCE_IS_NULL,
};
Error error;
int argument;
Type expected;
};
void call_ptr(const StringName &p_method, const Variant **p_args, int p_argcount, Variant *r_ret, CallError &r_error);
Variant call(const StringName &p_method, const Variant **p_args, int p_argcount, CallError &r_error);
Variant call(const StringName &p_method, const Variant &p_arg1 = Variant(), const Variant &p_arg2 = Variant(), const Variant &p_arg3 = Variant(), const Variant &p_arg4 = Variant(), const Variant &p_arg5 = Variant());
static String get_call_error_text(Object *p_base, const StringName &p_method, const Variant **p_argptrs, int p_argcount, const Variant::CallError &ce);
static Variant construct(const Variant::Type, const Variant **p_args, int p_argcount, CallError &r_error, bool p_strict = true);
2014-02-10 01:10:30 +00:00
void get_method_list(List<MethodInfo> *p_list) const;
bool has_method(const StringName &p_method) const;
static Vector<Variant::Type> get_method_argument_types(Variant::Type p_type, const StringName &p_method);
static Vector<Variant> get_method_default_arguments(Variant::Type p_type, const StringName &p_method);
static Variant::Type get_method_return_type(Variant::Type p_type, const StringName &p_method, bool *r_has_return = NULL);
static Vector<StringName> get_method_argument_names(Variant::Type p_type, const StringName &p_method);
2014-02-10 01:10:30 +00:00
void set_named(const StringName &p_index, const Variant &p_value, bool *r_valid = NULL);
Variant get_named(const StringName &p_index, bool *r_valid = NULL) const;
2014-02-10 01:10:30 +00:00
void set(const Variant &p_index, const Variant &p_value, bool *r_valid = NULL);
Variant get(const Variant &p_index, bool *r_valid = NULL) const;
bool in(const Variant &p_index, bool *r_valid = NULL) const;
2014-02-10 01:10:30 +00:00
bool iter_init(Variant &r_iter, bool &r_valid) const;
bool iter_next(Variant &r_iter, bool &r_valid) const;
Variant iter_get(const Variant &r_iter, bool &r_valid) const;
2014-02-10 01:10:30 +00:00
void get_property_list(List<PropertyInfo> *p_list) const;
//argsVariant call()
bool operator==(const Variant &p_variant) const;
bool operator!=(const Variant &p_variant) const;
bool operator<(const Variant &p_variant) const;
2014-02-10 01:10:30 +00:00
uint32_t hash() const;
bool hash_compare(const Variant &p_variant) const;
2014-02-10 01:10:30 +00:00
bool booleanize(bool &valid) const;
void static_assign(const Variant &p_variant);
2014-02-10 01:10:30 +00:00
static void get_constructor_list(Variant::Type p_type, List<MethodInfo> *p_list);
static void get_numeric_constants_for_type(Variant::Type p_type, List<StringName> *p_constants);
static bool has_numeric_constant(Variant::Type p_type, const StringName &p_value);
static int get_numeric_constant_value(Variant::Type p_type, const StringName &p_value, bool *r_valid = NULL);
2014-02-10 01:10:30 +00:00
typedef String (*ObjectDeConstruct)(const Variant &p_object, void *ud);
typedef void (*ObjectConstruct)(const String &p_text, void *ud, Variant &r_value);
String get_construct_string() const;
static void construct_from_string(const String &p_string, Variant &r_value, ObjectConstruct p_obj_construct = NULL, void *p_construct_ud = NULL);
2014-02-10 01:10:30 +00:00
void operator=(const Variant &p_variant); // only this is enough for all the other types
Variant(const Variant &p_variant);
_FORCE_INLINE_ Variant() { type = NIL; }
_FORCE_INLINE_ ~Variant() {
if (type != Variant::NIL) clear();
}
2014-02-10 01:10:30 +00:00
};
//typedef Dictionary Dictionary; no
//typedef Array Array;
Vector<Variant> varray();
Vector<Variant> varray(const Variant &p_arg1);
Vector<Variant> varray(const Variant &p_arg1, const Variant &p_arg2);
Vector<Variant> varray(const Variant &p_arg1, const Variant &p_arg2, const Variant &p_arg3);
Vector<Variant> varray(const Variant &p_arg1, const Variant &p_arg2, const Variant &p_arg3, const Variant &p_arg4);
Vector<Variant> varray(const Variant &p_arg1, const Variant &p_arg2, const Variant &p_arg3, const Variant &p_arg4, const Variant &p_arg5);
2014-02-10 01:10:30 +00:00
struct VariantHasher {
static _FORCE_INLINE_ uint32_t hash(const Variant &p_variant) { return p_variant.hash(); }
2014-02-10 01:10:30 +00:00
};
struct VariantComparator {
static _FORCE_INLINE_ bool compare(const Variant &p_lhs, const Variant &p_rhs) { return p_lhs.hash_compare(p_rhs); }
};
2014-02-10 01:10:30 +00:00
Variant::ObjData &Variant::_get_obj() {
2014-02-10 01:10:30 +00:00
return *reinterpret_cast<ObjData *>(&_data._mem[0]);
2014-02-10 01:10:30 +00:00
}
const Variant::ObjData &Variant::_get_obj() const {
2014-02-10 01:10:30 +00:00
return *reinterpret_cast<const ObjData *>(&_data._mem[0]);
2014-02-10 01:10:30 +00:00
}
String vformat(const String &p_text, const Variant &p1 = Variant(), const Variant &p2 = Variant(), const Variant &p3 = Variant(), const Variant &p4 = Variant(), const Variant &p5 = Variant());
2014-02-10 01:10:30 +00:00
#endif