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

3545 lines
85 KiB
C++
Raw Normal View History

GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
/*************************************************************************/
/* variant_op.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 "object.h"
#include "script_language.h"
#include "core_string_names.h"
Variant::operator bool() const {
bool b;
return booleanize(b);
}
bool Variant::booleanize(bool &r_valid) const {
r_valid=true;
switch(type) {
case NIL: return false;
case BOOL: return _data._bool;
case INT: return _data._int;
case REAL: return _data._real;
case STRING: return (*reinterpret_cast<const String*>(_data._mem))!="";
case VECTOR2:
case RECT2:
case MATRIX32:
case VECTOR3:
case PLANE:
case _AABB:
case QUAT:
case MATRIX3:
case TRANSFORM:
case COLOR:
case IMAGE: r_valid=false; return false;
case _RID: return (*reinterpret_cast<const RID*>(_data._mem)).is_valid();
case OBJECT: return _get_obj().obj;
case NODE_PATH: return (*reinterpret_cast<const NodePath*>(_data._mem))!=NodePath();
case INPUT_EVENT:
case DICTIONARY:
case ARRAY:
case RAW_ARRAY:
case INT_ARRAY:
case REAL_ARRAY:
case STRING_ARRAY:
case VECTOR2_ARRAY:
case VECTOR3_ARRAY:
case COLOR_ARRAY:
r_valid=false;
return false;
default: {}
}
return false;
}
#define _RETURN(m_what) { r_ret=m_what; return; }
#define DEFAULT_OP_NUM(m_op,m_name,m_type)\
case m_name: {\
switch(p_b.type) {\
case BOOL: _RETURN(p_a._data.m_type m_op p_b._data._bool);\
case INT: _RETURN(p_a._data.m_type m_op p_b._data._int);\
case REAL: _RETURN(p_a._data.m_type m_op p_b._data._real);\
default: {}\
}\
r_valid=false;\
return;\
};
#define DEFAULT_OP_NUM_NEG(m_name,m_type)\
case m_name: {\
\
_RETURN( -p_a._data.m_type);\
};
#define DEFAULT_OP_NUM_VEC(m_op,m_name,m_type)\
case m_name: {\
switch(p_b.type) {\
case BOOL: _RETURN( p_a._data.m_type m_op p_b._data._bool);\
case INT: _RETURN( p_a._data.m_type m_op p_b._data._int);\
case REAL: _RETURN( p_a._data.m_type m_op p_b._data._real);\
Fix Variant vector2/vecotor3 multiply bug
2014-03-28 17:05:02 +01:00
case VECTOR2: _RETURN( p_a._data.m_type m_op *reinterpret_cast<const Vector2*>(p_b._data._mem));\
case VECTOR3: _RETURN( p_a._data.m_type m_op *reinterpret_cast<const Vector3*>(p_b._data._mem));\
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
default: {}\
}\
r_valid=false;\
return;\
};
#define DEFAULT_OP_STR(m_op,m_name,m_type)\
case m_name: {\
switch(p_b.type) {\
case STRING: _RETURN( *reinterpret_cast<const m_type*>(p_a._data._mem) m_op *reinterpret_cast<const String*>(p_b._data._mem));\
case NODE_PATH: _RETURN( *reinterpret_cast<const m_type*>(p_a._data._mem) m_op *reinterpret_cast<const NodePath*>(p_b._data._mem));\
default: {}\
}\
r_valid=false;\
return;\
};
#define DEFAULT_OP_LOCALMEM(m_op,m_name,m_type)\
case m_name: {switch(p_b.type) {\
case m_name: _RETURN( *reinterpret_cast<const m_type*>(p_a._data._mem) m_op *reinterpret_cast<const m_type*>(p_b._data._mem));\
default: {}\
}\
r_valid=false;\
return;}
#define DEFAULT_OP_LOCALMEM_NEG(m_name,m_type)\
case m_name: {\
_RETURN( -*reinterpret_cast<const m_type*>(p_a._data._mem));\
}
#define DEFAULT_OP_LOCALMEM_NUM(m_op,m_name,m_type)\
case m_name: {switch(p_b.type) {\
case m_name: _RETURN( *reinterpret_cast<const m_type*>(p_a._data._mem) m_op *reinterpret_cast<const m_type*>(p_b._data._mem));\
case BOOL: _RETURN( *reinterpret_cast<const m_type*>(p_a._data._mem) m_op p_b._data._bool);\
case INT: _RETURN( *reinterpret_cast<const m_type*>(p_a._data._mem) m_op p_b._data._int);\
case REAL: _RETURN( *reinterpret_cast<const m_type*>(p_a._data._mem) m_op p_b._data._real);\
default: {}\
}\
r_valid=false;\
return;}
#define DEFAULT_OP_PTR(m_op,m_name,m_sub)\
case m_name: {switch(p_b.type) {\
case m_name: _RETURN( p_a._data.m_sub m_op p_b._data.m_sub);\
default: {}\
}\
r_valid=false;\
return;}
#define DEFAULT_OP_PTRREF(m_op,m_name,m_sub)\
case m_name: {switch(p_b.type) {\
case m_name: _RETURN( *p_a._data.m_sub m_op *p_b._data.m_sub);\
default: {}\
}\
r_valid=false;\
return;}
#define DEFAULT_OP_ARRAY_EQ(m_name,m_type)\
Sort xml files, so order is constant Makes xml format work better with version control systems.
2015-05-01 02:53:41 +02:00
DEFAULT_OP_ARRAY_OP(m_name,m_type,!=,!=,true,false,false)
#define DEFAULT_OP_ARRAY_LT(m_name,m_type)\
DEFAULT_OP_ARRAY_OP(m_name,m_type,<,!=,false,a_len<array_b.size(),true)
#define DEFAULT_OP_ARRAY_OP(m_name,m_type,m_opa,m_opb,m_ret_def,m_ret_s,m_ret_f)\
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
case m_name: { \
if (p_a.type!=p_b.type) {\
r_valid=false;\
return;\
}\
const DVector<m_type> &array_a=*reinterpret_cast<const DVector<m_type> *>(p_a._data._mem);\
const DVector<m_type> &array_b=*reinterpret_cast<const DVector<m_type> *>(p_b._data._mem);\
\
int a_len = array_a.size();\
Sort xml files, so order is constant Makes xml format work better with version control systems.
2015-05-01 02:53:41 +02:00
if (a_len m_opa array_b.size()){\
_RETURN( m_ret_s);\
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
}else {\
\
DVector<m_type>::Read ra = array_a.read();\
DVector<m_type>::Read rb = array_b.read();\
\
for(int i=0;i<a_len;i++) {\
Sort xml files, so order is constant Makes xml format work better with version control systems.
2015-05-01 02:53:41 +02:00
if (ra[i] m_opb rb[i])\
_RETURN( m_ret_f);\
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
}\
\
Sort xml files, so order is constant Makes xml format work better with version control systems.
2015-05-01 02:53:41 +02:00
_RETURN( m_ret_def);\
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
}\
}
#define DEFAULT_OP_ARRAY_ADD(m_name,m_type)\
case m_name: { \
if (p_a.type!=p_b.type) {\
r_valid=false;\
_RETURN( NIL);\
}\
const DVector<m_type> &array_a=*reinterpret_cast<const DVector<m_type> *>(p_a._data._mem);\
const DVector<m_type> &array_b=*reinterpret_cast<const DVector<m_type> *>(p_b._data._mem);\
DVector<m_type> sum = array_a;\
sum.append_array(array_b);\
_RETURN( sum );\
}
#define DEFAULT_OP_FAIL(m_name)\
case m_name: {r_valid=false;\
return;}
void Variant::evaluate(const Operator& p_op, const Variant& p_a, const Variant& p_b, Variant &r_ret, bool &r_valid) {
r_valid=true;
switch(p_op) {
case OP_EQUAL: {
if ((int(p_a.type)*int(p_b.type))==0) {
//null case is an exception, one of both is null
if (p_a.type==p_b.type) //null against null is true
_RETURN(true);
//only against object is allowed
if (p_a.type==Variant::OBJECT) {
_RETURN(p_a._get_obj().obj==NULL);
} else if (p_b.type==Variant::OBJECT) {
_RETURN(p_b._get_obj().obj==NULL);
}
//otherwise, always false
_RETURN(false);
}
switch(p_a.type) {
case NIL: {
_RETURN(p_b.type==NIL || (p_b.type==Variant::OBJECT && !p_b._get_obj().obj));
} break;
DEFAULT_OP_NUM(==,BOOL,_bool);
DEFAULT_OP_NUM(==,INT,_int);
DEFAULT_OP_NUM(==,REAL,_real);
DEFAULT_OP_STR(==,STRING,String);
DEFAULT_OP_LOCALMEM(==,VECTOR2,Vector2);
DEFAULT_OP_LOCALMEM(==,RECT2,Rect2);
DEFAULT_OP_PTRREF(==,MATRIX32,_matrix32);
DEFAULT_OP_LOCALMEM(==,VECTOR3,Vector3);
DEFAULT_OP_LOCALMEM(==,PLANE,Plane);
DEFAULT_OP_LOCALMEM(==,QUAT,Quat);
DEFAULT_OP_PTRREF(==,_AABB,_aabb);
DEFAULT_OP_PTRREF(==,MATRIX3,_matrix3);
DEFAULT_OP_PTRREF(==,TRANSFORM,_transform);
DEFAULT_OP_LOCALMEM(==,COLOR,Color);
DEFAULT_OP_PTRREF(==,IMAGE,_image);
DEFAULT_OP_STR(==,NODE_PATH,NodePath);
DEFAULT_OP_LOCALMEM(==,_RID,RID);
case OBJECT: {
if (p_b.type==OBJECT)
_RETURN( (p_a._get_obj().obj == p_b._get_obj().obj) );
if (p_b.type==NIL)
_RETURN( !p_a._get_obj().obj );
} break;
DEFAULT_OP_PTRREF(==,INPUT_EVENT,_input_event);
case DICTIONARY: {
if (p_b.type!=DICTIONARY)
_RETURN( false );
const Dictionary *arr_a=reinterpret_cast<const Dictionary*>(p_a._data._mem);
const Dictionary *arr_b=reinterpret_cast<const Dictionary*>(p_b._data._mem);
_RETURN( *arr_a == *arr_b );
} break;
case ARRAY: {
if (p_b.type!=ARRAY)
_RETURN( false );
const Array *arr_a=reinterpret_cast<const Array*>(p_a._data._mem);
const Array *arr_b=reinterpret_cast<const Array*>(p_b._data._mem);
int l = arr_a->size();
if (arr_b->size()!=l)
_RETURN( false );
for(int i=0;i<l;i++) {
Fixed bug in array comparison, fixes #1712
2015-04-26 17:12:53 +02:00
if (!((*arr_a)[i]==(*arr_b)[i])) {
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
_RETURN( false );
Fixed bug in array comparison, fixes #1712
2015-04-26 17:12:53 +02:00
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
}
_RETURN( true );
} break;
DEFAULT_OP_ARRAY_EQ(RAW_ARRAY,uint8_t);
DEFAULT_OP_ARRAY_EQ(INT_ARRAY,int);
DEFAULT_OP_ARRAY_EQ(REAL_ARRAY,real_t);
DEFAULT_OP_ARRAY_EQ(STRING_ARRAY,String);
DEFAULT_OP_ARRAY_EQ(VECTOR2_ARRAY,Vector3);
DEFAULT_OP_ARRAY_EQ(VECTOR3_ARRAY,Vector3);
DEFAULT_OP_ARRAY_EQ(COLOR_ARRAY,Color);
case VARIANT_MAX: {
r_valid=false;
return;
} break;
}
} break;
case OP_NOT_EQUAL: {
Variant res;
evaluate(OP_EQUAL,p_a,p_b,res,r_valid);
if (!r_valid)
return;
if (res.type==BOOL)
res._data._bool=!res._data._bool;
_RETURN( res );
} break;
case OP_LESS: {
switch(p_a.type) {
DEFAULT_OP_FAIL(NIL);
DEFAULT_OP_NUM(<,BOOL,_bool);
DEFAULT_OP_NUM(<,INT,_int);
DEFAULT_OP_NUM(<,REAL,_real);
DEFAULT_OP_STR(<,STRING,String);
DEFAULT_OP_LOCALMEM(<,VECTOR2,Vector2);
DEFAULT_OP_FAIL(RECT2);
DEFAULT_OP_FAIL(MATRIX32);
DEFAULT_OP_LOCALMEM(<,VECTOR3,Vector3);
DEFAULT_OP_FAIL(PLANE);
DEFAULT_OP_FAIL(QUAT);
DEFAULT_OP_FAIL(_AABB);
DEFAULT_OP_FAIL(MATRIX3);
DEFAULT_OP_FAIL(TRANSFORM);
DEFAULT_OP_FAIL(COLOR);
DEFAULT_OP_FAIL(IMAGE);
DEFAULT_OP_FAIL(NODE_PATH);
DEFAULT_OP_LOCALMEM(<,_RID,RID);
case OBJECT: {
if (p_b.type==OBJECT)
_RETURN( (p_a._get_obj().obj < p_b._get_obj().obj) );
} break;
DEFAULT_OP_FAIL(INPUT_EVENT);
DEFAULT_OP_FAIL(DICTIONARY);
Sort xml files, so order is constant Makes xml format work better with version control systems.
2015-05-01 02:53:41 +02:00
case ARRAY: {
if (p_b.type!=ARRAY)
_RETURN( false );
const Array *arr_a=reinterpret_cast<const Array*>(p_a._data._mem);
const Array *arr_b=reinterpret_cast<const Array*>(p_b._data._mem);
int l = arr_a->size();
if (arr_b->size()<l)
_RETURN( false );
for(int i=0;i<l;i++) {
if (!((*arr_a)[i]<(*arr_b)[i])) {
_RETURN( true );
}
}
_RETURN( false );
} break;
DEFAULT_OP_ARRAY_LT(RAW_ARRAY,uint8_t);
DEFAULT_OP_ARRAY_LT(INT_ARRAY,int);
DEFAULT_OP_ARRAY_LT(REAL_ARRAY,real_t);
DEFAULT_OP_ARRAY_LT(STRING_ARRAY,String);
DEFAULT_OP_ARRAY_LT(VECTOR2_ARRAY,Vector3);
DEFAULT_OP_ARRAY_LT(VECTOR3_ARRAY,Vector3);
DEFAULT_OP_ARRAY_LT(COLOR_ARRAY,Color);
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
case VARIANT_MAX: {
r_valid=false;
return;
} break;
}
} break;
case OP_LESS_EQUAL: {
switch(p_a.type) {
DEFAULT_OP_FAIL(NIL);
DEFAULT_OP_NUM(<=,BOOL,_bool);
DEFAULT_OP_NUM(<=,INT,_int);
DEFAULT_OP_NUM(<=,REAL,_real);
DEFAULT_OP_STR(<=,STRING,String);
DEFAULT_OP_LOCALMEM(<=,VECTOR2,Vector2);
DEFAULT_OP_FAIL(RECT2);
DEFAULT_OP_FAIL(MATRIX32);
DEFAULT_OP_LOCALMEM(<=,VECTOR3,Vector3);
DEFAULT_OP_FAIL(PLANE);
DEFAULT_OP_FAIL(QUAT);
DEFAULT_OP_FAIL(_AABB);
DEFAULT_OP_FAIL(MATRIX3);
DEFAULT_OP_FAIL(TRANSFORM);
DEFAULT_OP_FAIL(COLOR);
DEFAULT_OP_FAIL(IMAGE);
DEFAULT_OP_FAIL(NODE_PATH);
DEFAULT_OP_LOCALMEM(<=,_RID,RID);
case OBJECT: {
if (p_b.type==OBJECT)
_RETURN( (p_a._get_obj().obj <= p_b._get_obj().obj) );
} break;
DEFAULT_OP_FAIL(INPUT_EVENT);
DEFAULT_OP_FAIL(DICTIONARY);
DEFAULT_OP_FAIL(ARRAY);
DEFAULT_OP_FAIL(RAW_ARRAY);
DEFAULT_OP_FAIL(INT_ARRAY);
DEFAULT_OP_FAIL(REAL_ARRAY);
DEFAULT_OP_FAIL(STRING_ARRAY);
DEFAULT_OP_FAIL(VECTOR2_ARRAY);
DEFAULT_OP_FAIL(VECTOR3_ARRAY);
DEFAULT_OP_FAIL(COLOR_ARRAY);
case VARIANT_MAX: {
r_valid=false;
return;
} break;
}
} break;
case OP_GREATER: {
Variant res;
evaluate(OP_LESS,p_b,p_a,res,r_valid);
if (!r_valid)
return;
_RETURN(res);
} break;
case OP_GREATER_EQUAL: {
Variant res;
evaluate(OP_LESS_EQUAL,p_b,p_a,res,r_valid);
if (!r_valid)
return;
_RETURN( res );
} break;
//mathematic
case OP_ADD: {
switch(p_a.type) {
DEFAULT_OP_FAIL(NIL);
DEFAULT_OP_NUM(+,BOOL,_bool);
DEFAULT_OP_NUM(+,INT,_int);
DEFAULT_OP_NUM(+,REAL,_real);
DEFAULT_OP_STR(+,STRING,String);
DEFAULT_OP_LOCALMEM(+,VECTOR2,Vector2);
DEFAULT_OP_FAIL(RECT2);
DEFAULT_OP_FAIL(MATRIX32);
DEFAULT_OP_LOCALMEM(+,VECTOR3,Vector3);
DEFAULT_OP_FAIL(PLANE);
Expose missing Quaternion operators. Scripts can now evaluate the following cases: - (quat * real) and (quat / real) - (quat + quat) and (quat - quat)
2016-06-21 23:26:38 +02:00
DEFAULT_OP_LOCALMEM(+, QUAT, Quat);
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
DEFAULT_OP_FAIL(_AABB);
DEFAULT_OP_FAIL(MATRIX3);
DEFAULT_OP_FAIL(TRANSFORM);
DEFAULT_OP_FAIL(COLOR);
DEFAULT_OP_FAIL(IMAGE);
DEFAULT_OP_FAIL(NODE_PATH);
DEFAULT_OP_FAIL(_RID);
DEFAULT_OP_FAIL(OBJECT);
DEFAULT_OP_FAIL(INPUT_EVENT);
DEFAULT_OP_FAIL(DICTIONARY);
case ARRAY: {
if (p_a.type!=p_b.type) {
r_valid=false;
return;
}
const Array &array_a=*reinterpret_cast<const Array *>(p_a._data._mem);
const Array &array_b=*reinterpret_cast<const Array *>(p_b._data._mem);
-Concatenating arrays keeps the shared property if any of the arrays is shared. Fixes #1646
2015-04-08 02:18:46 +02:00
Array sum(array_a.is_shared() || array_b.is_shared());
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
int asize=array_a.size();
int bsize=array_b.size();
sum.resize(asize+bsize);
for(int i=0;i<asize;i++)
sum[i]=array_a[i];
for(int i=0;i<bsize;i++)
sum[i+asize]=array_b[i];
_RETURN( sum );
}
DEFAULT_OP_ARRAY_ADD(RAW_ARRAY,uint8_t);
DEFAULT_OP_ARRAY_ADD(INT_ARRAY,int);
DEFAULT_OP_ARRAY_ADD(REAL_ARRAY,real_t);
DEFAULT_OP_ARRAY_ADD(STRING_ARRAY,String);
DEFAULT_OP_ARRAY_ADD(VECTOR2_ARRAY,Vector2);
DEFAULT_OP_ARRAY_ADD(VECTOR3_ARRAY,Vector3);
DEFAULT_OP_ARRAY_ADD(COLOR_ARRAY,Color);
case VARIANT_MAX: {
r_valid=false;
return;
} break;
}
} break;
case OP_SUBSTRACT: {
switch(p_a.type) {
DEFAULT_OP_FAIL(NIL);
DEFAULT_OP_NUM(-,BOOL,_bool);
DEFAULT_OP_NUM(-,INT,_int);
DEFAULT_OP_NUM(-,REAL,_real);
DEFAULT_OP_FAIL(STRING);
DEFAULT_OP_LOCALMEM(-,VECTOR2,Vector2);
DEFAULT_OP_FAIL(RECT2);
DEFAULT_OP_FAIL(MATRIX32);
DEFAULT_OP_LOCALMEM(-,VECTOR3,Vector3);
DEFAULT_OP_FAIL(PLANE);
Expose missing Quaternion operators. Scripts can now evaluate the following cases: - (quat * real) and (quat / real) - (quat + quat) and (quat - quat)
2016-06-21 23:26:38 +02:00
DEFAULT_OP_LOCALMEM(-, QUAT, Quat);
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
DEFAULT_OP_FAIL(_AABB);
DEFAULT_OP_FAIL(MATRIX3);
DEFAULT_OP_FAIL(TRANSFORM);
DEFAULT_OP_FAIL(COLOR);
DEFAULT_OP_FAIL(IMAGE);
DEFAULT_OP_FAIL(NODE_PATH);
DEFAULT_OP_FAIL(_RID);
DEFAULT_OP_FAIL(OBJECT);
DEFAULT_OP_FAIL(INPUT_EVENT);
DEFAULT_OP_FAIL(DICTIONARY);
DEFAULT_OP_FAIL(ARRAY);
DEFAULT_OP_FAIL(RAW_ARRAY);
DEFAULT_OP_FAIL(INT_ARRAY);
DEFAULT_OP_FAIL(REAL_ARRAY);
DEFAULT_OP_FAIL(STRING_ARRAY);
DEFAULT_OP_FAIL(VECTOR2_ARRAY);
DEFAULT_OP_FAIL(VECTOR3_ARRAY);
DEFAULT_OP_FAIL(COLOR_ARRAY);
case VARIANT_MAX: {
r_valid=false;
return;
} break;
}
} break;
case OP_MULTIPLY: {
switch(p_a.type) {
DEFAULT_OP_FAIL(NIL);
DEFAULT_OP_NUM(*,BOOL,_bool);
DEFAULT_OP_NUM_VEC(*,INT,_int);
DEFAULT_OP_NUM_VEC(*,REAL,_real);
DEFAULT_OP_FAIL(STRING);
DEFAULT_OP_LOCALMEM_NUM(*,VECTOR2,Vector2);
DEFAULT_OP_FAIL(RECT2);
-run script in editor -add search docs dialog that returns places string was found -added flash
2014-02-21 03:01:44 +01:00
case MATRIX32: {
if (p_b.type==MATRIX32) {
_RETURN( *p_a._data._matrix32 * *p_b._data._matrix32 );
};
support for 2D shadow casters Added support for 2D shadow casters. *DANGER* Shaders in CanvasItem CHANGED, if you are using shader in a CanvasItem and pull this, you will lose them. Shaders now work through a 2D material system similar to 3D. If you don't want to lose the 2D shader code, save the shader as a .shd, then create a material in CanvasItem and re-assign the shader.
2015-03-02 04:54:10 +01:00
if (p_b.type==VECTOR2) {
_RETURN( p_a._data._matrix32->xform( *(const Vector2*)p_b._data._mem) );
};
-run script in editor -add search docs dialog that returns places string was found -added flash
2014-02-21 03:01:44 +01:00
r_valid=false;
return;
} break;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
DEFAULT_OP_LOCALMEM_NUM(*,VECTOR3,Vector3);
DEFAULT_OP_FAIL(PLANE);
Implement Quat multiply operator, and xform method
2015-11-11 15:30:55 +01:00
case QUAT: {
switch(p_b.type) {
case VECTOR3: {
_RETURN( reinterpret_cast<const Quat*>(p_a._data._mem)->xform( *(const Vector3*)p_b._data._mem) );
} break;
case QUAT: {
_RETURN( *reinterpret_cast<const Quat*>(p_a._data._mem) * *reinterpret_cast<const Quat*>(p_b._data._mem) );
} break;
Expose missing Quaternion operators. Scripts can now evaluate the following cases: - (quat * real) and (quat / real) - (quat + quat) and (quat - quat)
2016-06-21 23:26:38 +02:00
case REAL: {
_RETURN( *reinterpret_cast<const Quat*>(p_a._data._mem) * p_b._data._real);
} break;
Fix warnings in core/variant_op.cpp Adds default cases in switches where needed, and replaces '0;' with ';;' in macro expansions (as suggested by @vnen in #5587).
2016-07-23 14:47:49 +02:00
default: {}
Implement Quat multiply operator, and xform method
2015-11-11 15:30:55 +01:00
};
r_valid=false;
return;
} break;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
DEFAULT_OP_FAIL(_AABB);
case MATRIX3: {
switch(p_b.type) {
case VECTOR3: {
_RETURN( p_a._data._matrix3->xform( *(const Vector3*)p_b._data._mem) );
} ;
case MATRIX3: {
_RETURN( *p_a._data._matrix3 * *p_b._data._matrix3 );
};
Fix warnings in core/variant_op.cpp Adds default cases in switches where needed, and replaces '0;' with ';;' in macro expansions (as suggested by @vnen in #5587).
2016-07-23 14:47:49 +02:00
default: {}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
} ;
r_valid=false;
return;
} break;
case TRANSFORM: {
switch(p_b.type) {
case VECTOR3: {
_RETURN( p_a._data._transform->xform( *(const Vector3*)p_b._data._mem) );
} ;
case TRANSFORM: {
_RETURN( *p_a._data._transform * *p_b._data._transform );
};
Fix warnings in core/variant_op.cpp Adds default cases in switches where needed, and replaces '0;' with ';;' in macro expansions (as suggested by @vnen in #5587).
2016-07-23 14:47:49 +02:00
default: {}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
} ;
r_valid=false;
return;
} break;
DEFAULT_OP_FAIL(COLOR);
DEFAULT_OP_FAIL(IMAGE);
DEFAULT_OP_FAIL(NODE_PATH);
DEFAULT_OP_FAIL(_RID);
DEFAULT_OP_FAIL(OBJECT);
DEFAULT_OP_FAIL(INPUT_EVENT);
DEFAULT_OP_FAIL(DICTIONARY);
DEFAULT_OP_FAIL(ARRAY);
DEFAULT_OP_FAIL(RAW_ARRAY);
DEFAULT_OP_FAIL(INT_ARRAY);
DEFAULT_OP_FAIL(REAL_ARRAY);
DEFAULT_OP_FAIL(STRING_ARRAY);
DEFAULT_OP_FAIL(VECTOR2_ARRAY);
DEFAULT_OP_FAIL(VECTOR3_ARRAY);
DEFAULT_OP_FAIL(COLOR_ARRAY);
case VARIANT_MAX: {
r_valid=false;
return;
} break;
}
} break;
case OP_DIVIDE: {
switch(p_a.type) {
remove trailing whitespace
2016-03-09 00:00:52 +01:00
DEFAULT_OP_FAIL(NIL);
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
DEFAULT_OP_NUM(/,BOOL,_bool);
case INT: {
switch(p_b.type) {
case BOOL: {
int b = p_b._data._bool;
if (b==0) {
r_valid=false;
_RETURN( "Division By False" );
}
_RETURN( p_a._data._int / b );
} break;
case INT: {
int b = p_b._data._int;
if (b==0) {
r_valid=false;
_RETURN( "Division By Zero" );
}
_RETURN( p_a._data._int / b );
} break;
case REAL: _RETURN( p_a._data._int / p_b._data._real );
default: {}
}
r_valid=false;
return;
};
DEFAULT_OP_NUM(/,REAL,_real);
DEFAULT_OP_FAIL(STRING);
DEFAULT_OP_LOCALMEM_NUM(/,VECTOR2,Vector2);
DEFAULT_OP_FAIL(RECT2);
DEFAULT_OP_FAIL(MATRIX32);
DEFAULT_OP_LOCALMEM_NUM(/,VECTOR3,Vector3);
DEFAULT_OP_FAIL(PLANE);
Expose missing Quaternion operators. Scripts can now evaluate the following cases: - (quat * real) and (quat / real) - (quat + quat) and (quat - quat)
2016-06-21 23:26:38 +02:00
case QUAT: {
if (p_b.type != REAL) {
r_valid = false;
return;
}
_RETURN( *reinterpret_cast<const Quat*>(p_a._data._mem) / p_b._data._real);
} break;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
DEFAULT_OP_FAIL(_AABB);
DEFAULT_OP_FAIL(MATRIX3);
DEFAULT_OP_FAIL(TRANSFORM);
DEFAULT_OP_FAIL(COLOR);
DEFAULT_OP_FAIL(IMAGE);
DEFAULT_OP_FAIL(NODE_PATH);
DEFAULT_OP_FAIL(_RID);
DEFAULT_OP_FAIL(OBJECT);
DEFAULT_OP_FAIL(INPUT_EVENT);
DEFAULT_OP_FAIL(DICTIONARY);
DEFAULT_OP_FAIL(ARRAY);
DEFAULT_OP_FAIL(RAW_ARRAY);
DEFAULT_OP_FAIL(INT_ARRAY);
DEFAULT_OP_FAIL(REAL_ARRAY);
DEFAULT_OP_FAIL(STRING_ARRAY);
DEFAULT_OP_FAIL(VECTOR2_ARRAY);
DEFAULT_OP_FAIL(VECTOR3_ARRAY);
DEFAULT_OP_FAIL(COLOR_ARRAY);
case VARIANT_MAX: {
r_valid=false;
return;
} break;
}
} break;
case OP_NEGATE: {
switch(p_a.type) {
DEFAULT_OP_FAIL(NIL);
DEFAULT_OP_NUM_NEG(BOOL,_bool);
DEFAULT_OP_NUM_NEG(INT,_int);
DEFAULT_OP_NUM_NEG(REAL,_real);
DEFAULT_OP_FAIL(STRING);
DEFAULT_OP_LOCALMEM_NEG(VECTOR2,Vector2);
DEFAULT_OP_FAIL(RECT2);
DEFAULT_OP_FAIL(MATRIX32);
DEFAULT_OP_LOCALMEM_NEG(VECTOR3,Vector3);
DEFAULT_OP_LOCALMEM_NEG(PLANE,Plane);
DEFAULT_OP_LOCALMEM_NEG(QUAT,Quat);
DEFAULT_OP_FAIL(_AABB);
DEFAULT_OP_FAIL(MATRIX3);
DEFAULT_OP_FAIL(TRANSFORM);
DEFAULT_OP_FAIL(COLOR);
DEFAULT_OP_FAIL(IMAGE);
DEFAULT_OP_FAIL(NODE_PATH);
DEFAULT_OP_FAIL(_RID);
DEFAULT_OP_FAIL(OBJECT);
DEFAULT_OP_FAIL(INPUT_EVENT);
DEFAULT_OP_FAIL(DICTIONARY);
DEFAULT_OP_FAIL(ARRAY);
DEFAULT_OP_FAIL(RAW_ARRAY);
DEFAULT_OP_FAIL(INT_ARRAY);
DEFAULT_OP_FAIL(REAL_ARRAY);
DEFAULT_OP_FAIL(STRING_ARRAY);
DEFAULT_OP_FAIL(VECTOR2_ARRAY);
DEFAULT_OP_FAIL(VECTOR3_ARRAY);
DEFAULT_OP_FAIL(COLOR_ARRAY);
case VARIANT_MAX: {
r_valid=false;
return;
} break;
}
} break;
case OP_MODULE: {
if (p_a.type==INT && p_b.type==INT) {
#ifdef DEBUG_ENABLED
if (p_b._data._int==0) {
r_valid=false;
_RETURN( "Division By Zero" );
}
#endif
_RETURN( p_a._data._int % p_b._data._int );
remove trailing whitespace
2016-03-09 00:00:52 +01:00
Added basic sprintf functionality (e.g. "fish %d %s" % [12, Vector2(1, 2)])
2015-01-10 21:44:20 +01:00
} else if (p_a.type==STRING) {
Correctly halt on error in sprintf parsing (fixes #1393)
2015-02-19 16:45:49 +01:00
const String* format=reinterpret_cast<const String*>(p_a._data._mem);
Added basic sprintf functionality (e.g. "fish %d %s" % [12, Vector2(1, 2)])
2015-01-10 21:44:20 +01:00
Correctly halt on error in sprintf parsing (fixes #1393)
2015-02-19 16:45:49 +01:00
String result;
bool error;
Added basic sprintf functionality (e.g. "fish %d %s" % [12, Vector2(1, 2)])
2015-01-10 21:44:20 +01:00
if (p_b.type==ARRAY) {
// e.g. "frog %s %d" % ["fish", 12]
Correctly halt on error in sprintf parsing (fixes #1393)
2015-02-19 16:45:49 +01:00
const Array* args=reinterpret_cast<const Array*>(p_b._data._mem);
result=format->sprintf(*args, &error);
Added basic sprintf functionality (e.g. "fish %d %s" % [12, Vector2(1, 2)])
2015-01-10 21:44:20 +01:00
} else {
// e.g. "frog %d" % 12
Correctly halt on error in sprintf parsing (fixes #1393)
2015-02-19 16:45:49 +01:00
Array args;
args.push_back(p_b);
result=format->sprintf(args, &error);
Added basic sprintf functionality (e.g. "fish %d %s" % [12, Vector2(1, 2)])
2015-01-10 21:44:20 +01:00
}
Correctly halt on error in sprintf parsing (fixes #1393)
2015-02-19 16:45:49 +01:00
r_valid = !error;
_RETURN(result);
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
}
r_valid=false;
return;
} break;
case OP_STRING_CONCAT: {
_RETURN( p_a.operator String() + p_b.operator String() );
} break;
//bitwise
case OP_SHIFT_LEFT: {
if (p_a.type==INT && p_b.type==INT)
_RETURN( p_a._data._int << p_b._data._int );
r_valid=false;
return;
} break;
case OP_SHIFT_RIGHT: {
if (p_a.type==INT && p_b.type==INT)
_RETURN( p_a._data._int >> p_b._data._int );
r_valid=false;
return;
} break;
case OP_BIT_AND: {
if (p_a.type==INT && p_b.type==INT)
_RETURN( p_a._data._int & p_b._data._int );
r_valid=false;
return;
} break;
case OP_BIT_OR: {
if (p_a.type==INT && p_b.type==INT)
_RETURN( p_a._data._int | p_b._data._int );
r_valid=false;
return;
} break;
case OP_BIT_XOR: {
if (p_a.type==INT && p_b.type==INT)
_RETURN( p_a._data._int ^ p_b._data._int );
r_valid=false;
return;
} break;
case OP_BIT_NEGATE: {
if (p_a.type==INT)
_RETURN( ~p_a._data._int );
r_valid=false;
return;
} break;
//logic
case OP_AND: {
bool l = p_a.booleanize(r_valid);
if (!r_valid)
return;
bool r = p_b.booleanize(r_valid);
if (!r_valid)
return;
_RETURN( l && r );
} break;
case OP_OR: {
bool l = p_a.booleanize(r_valid);
if (!r_valid)
return;
bool r = p_b.booleanize(r_valid);
if (!r_valid)
return;
_RETURN( l || r );
} break;
case OP_XOR: {
bool l = p_a.booleanize(r_valid);
if (!r_valid)
return;
bool r = p_b.booleanize(r_valid);
if (!r_valid)
return;
_RETURN( (l || r) && !(l && r) );
} break;
case OP_NOT: {
bool l = p_a.booleanize(r_valid);
if (!r_valid)
return;
_RETURN( !l );
} break;
case OP_IN: {
_RETURN( p_b.in(p_a,&r_valid) );
} break;
case OP_MAX: {
r_valid=false;
ERR_FAIL();
}
}
r_valid=false;
}
void Variant::set_named(const StringName& p_index, const Variant& p_value, bool *r_valid) {
if (type==OBJECT) {
#ifdef DEBUG_ENABLED
if (!_get_obj().obj) {
if (r_valid)
*r_valid=false;
return;
} else {
if (ScriptDebugger::get_singleton() && _get_obj().ref.is_null() && !ObjectDB::instance_validate(_get_obj().obj)) {
if (r_valid)
*r_valid=false;
return;
}
}
#endif
_get_obj().obj->set(p_index,p_value,r_valid);
return;
}
set(p_index.operator String(),p_value,r_valid);
}
Variant Variant::get_named(const StringName& p_index, bool *r_valid) const {
if (type==OBJECT) {
#ifdef DEBUG_ENABLED
if (!_get_obj().obj) {
if (r_valid)
*r_valid=false;
return "Instance base is null.";
} else {
if (ScriptDebugger::get_singleton() && _get_obj().ref.is_null() && !ObjectDB::instance_validate(_get_obj().obj)) {
if (r_valid)
*r_valid=false;
return "Attempted use of stray pointer object.";
}
}
#endif
return _get_obj().obj->get(p_index,r_valid);
}
return get(p_index.operator String(),r_valid);
}
Move repetitive code to macros In preparation for the following "allow negative indexing" commit, replace the repetitive array "set index" and "get index" code with macros. no functional changes were made, the resulting machine code is unchanged.
2016-05-26 23:35:33 +02:00
#define DEFAULT_OP_ARRAY_CMD(m_name, m_type, skip_test, cmd)\
case m_name: {\
skip_test;\
\
if (p_index.get_type()==Variant::INT || p_index.get_type()==Variant::REAL) {\
int index = p_index;\
m_type *arr=reinterpret_cast<m_type* >(_data._mem);\
\
Add support for Python-like negative indexing Negative indexing is a useful feature in Python, especially when combined with array slicing. Array slicing will hopefully be implemented later, but negative indexing is useful in its own right. A negative index is indexing from the end of an array, "array[-1] == array[array.size()-1]", using a negative index larger/smaller than the length of the array is still an error. While primarily useful for arrays and strings, support is also added to "array like" structures like Vector3 and Color. This is done just to be consistent; vector3[2] is much clearer than vector3[-1], but disallowing it while allowing it for an array with 3 elements seems confusing.
2016-05-28 16:12:10 +02:00
if (index<0)\
index += arr->size();\
Move repetitive code to macros In preparation for the following "allow negative indexing" commit, replace the repetitive array "set index" and "get index" code with macros. no functional changes were made, the resulting machine code is unchanged.
2016-05-26 23:35:33 +02:00
if (index>=0 && index<arr->size()) {\
valid=true;\
cmd;\
}\
}\
} break;
#define DEFAULT_OP_DVECTOR_SET(m_name, dv_type, skip_cond)\
DEFAULT_OP_ARRAY_CMD(m_name, DVector<dv_type>, if(skip_cond) return;, arr->set(index, p_value);return)
#define DEFAULT_OP_DVECTOR_GET(m_name, dv_type)\
Fix warnings in core/variant_op.cpp Adds default cases in switches where needed, and replaces '0;' with ';;' in macro expansions (as suggested by @vnen in #5587).
2016-07-23 14:47:49 +02:00
DEFAULT_OP_ARRAY_CMD(m_name, const DVector<dv_type>, ;, return arr->get(index))
Move repetitive code to macros In preparation for the following "allow negative indexing" commit, replace the repetitive array "set index" and "get index" code with macros. no functional changes were made, the resulting machine code is unchanged.
2016-05-26 23:35:33 +02:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
void Variant::set(const Variant& p_index, const Variant& p_value, bool *r_valid) {
static bool _dummy=false;
bool &valid = r_valid ? *r_valid : _dummy;
valid=false;
switch(type) {
case NIL: { return; } break;
case BOOL: { return; } break;
case INT: { return; } break;
case REAL: { return; } break;
case STRING: {
-assignment of ord to string index made valid #1072
2015-01-02 17:17:46 +01:00
if (p_index.type!=Variant::INT && p_index.type!=Variant::REAL)
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
return;
-assignment of ord to string index made valid #1072
2015-01-02 17:17:46 +01:00
int idx=p_index;
String *str=reinterpret_cast<String*>(_data._mem);
Add support for Python-like negative indexing Negative indexing is a useful feature in Python, especially when combined with array slicing. Array slicing will hopefully be implemented later, but negative indexing is useful in its own right. A negative index is indexing from the end of an array, "array[-1] == array[array.size()-1]", using a negative index larger/smaller than the length of the array is still an error. While primarily useful for arrays and strings, support is also added to "array like" structures like Vector3 and Color. This is done just to be consistent; vector3[2] is much clearer than vector3[-1], but disallowing it while allowing it for an array with 3 elements seems confusing.
2016-05-28 16:12:10 +02:00
int len = str->length();
if (idx<0)
idx += len;
if (idx<0 || idx>=len)
-assignment of ord to string index made valid #1072
2015-01-02 17:17:46 +01:00
return;
String chr;
if (p_value.type==Variant::INT || p_value.type==Variant::REAL) {
chr = String::chr(p_value);
} else if (p_value.type==Variant::STRING) {
chr = p_value;
} else {
return;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
}
Add support for Python-like negative indexing Negative indexing is a useful feature in Python, especially when combined with array slicing. Array slicing will hopefully be implemented later, but negative indexing is useful in its own right. A negative index is indexing from the end of an array, "array[-1] == array[array.size()-1]", using a negative index larger/smaller than the length of the array is still an error. While primarily useful for arrays and strings, support is also added to "array like" structures like Vector3 and Color. This is done just to be consistent; vector3[2] is much clearer than vector3[-1], but disallowing it while allowing it for an array with 3 elements seems confusing.
2016-05-28 16:12:10 +02:00
*str = str->substr(0,idx)+chr+str->substr(idx+1, len);
-assignment of ord to string index made valid #1072
2015-01-02 17:17:46 +01:00
valid=true;
return;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
} break;
case VECTOR2: {
if (p_value.type!=Variant::INT && p_value.type!=Variant::REAL)
return;
if (p_index.get_type()==Variant::INT || p_index.get_type()==Variant::REAL) {
// scalar index
int idx=p_index;
Add support for Python-like negative indexing Negative indexing is a useful feature in Python, especially when combined with array slicing. Array slicing will hopefully be implemented later, but negative indexing is useful in its own right. A negative index is indexing from the end of an array, "array[-1] == array[array.size()-1]", using a negative index larger/smaller than the length of the array is still an error. While primarily useful for arrays and strings, support is also added to "array like" structures like Vector3 and Color. This is done just to be consistent; vector3[2] is much clearer than vector3[-1], but disallowing it while allowing it for an array with 3 elements seems confusing.
2016-05-28 16:12:10 +02:00
if (idx<0)
idx += 2;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
if (idx>=0 && idx<2) {
Vector2 *v=reinterpret_cast<Vector2*>(_data._mem);
valid=true;
-fix assignment to vector types in script using integer indices crash (#978)
2015-01-02 19:53:02 +01:00
(*v)[idx]=p_value;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
return;
}
} else if (p_index.get_type()==Variant::STRING) {
//scalar name
const String *str=reinterpret_cast<const String*>(p_index._data._mem);
Vector2 *v=reinterpret_cast<Vector2*>(_data._mem);
if (*str=="x" || *str=="width") {
valid=true;
v->x=p_value;
return;
} else if (*str=="y" || *str=="height") {
valid=true;
v->y=p_value;
return;
}
}
} break; // 5
case RECT2: {
if (p_value.type!=Variant::VECTOR2)
return;
if (p_index.get_type()==Variant::STRING) {
//scalar name
const String *str=reinterpret_cast<const String*>(p_index._data._mem);
Rect2 *v=reinterpret_cast<Rect2*>(_data._mem);
if (*str=="pos") {
valid=true;
v->pos=p_value;
return;
} else if (*str=="size") {
valid=true;
v->size=p_value;
return;
} else if (*str=="end") {
valid=true;
v->size=Vector2(p_value) - v->pos;
return;
}
}
} break;
case MATRIX32: {
if (p_value.type!=Variant::VECTOR2)
return;
if (p_index.get_type()==Variant::INT || p_index.get_type()==Variant::REAL) {
int index = p_index;
Add support for Python-like negative indexing Negative indexing is a useful feature in Python, especially when combined with array slicing. Array slicing will hopefully be implemented later, but negative indexing is useful in its own right. A negative index is indexing from the end of an array, "array[-1] == array[array.size()-1]", using a negative index larger/smaller than the length of the array is still an error. While primarily useful for arrays and strings, support is also added to "array like" structures like Vector3 and Color. This is done just to be consistent; vector3[2] is much clearer than vector3[-1], but disallowing it while allowing it for an array with 3 elements seems confusing.
2016-05-28 16:12:10 +02:00
if (index<0)
index += 3;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
if (index>=0 && index<3) {
Matrix32 *v=_data._matrix32;
valid=true;
v->elements[index]=p_value;
return;
}
} else if (p_index.get_type()==Variant::STRING && p_value.get_type()==Variant::VECTOR2) {
//scalar name
const String *str=reinterpret_cast<const String*>(p_index._data._mem);
Matrix32 *v=_data._matrix32;
if (*str=="x") {
valid=true;
v->elements[0]=p_value;
return;
} else if (*str=="y" ) {
valid=true;
v->elements[1]=p_value;
return;
} else if (*str=="o" ) {
valid=true;
v->elements[2]=p_value;
return;
}
}
} break;
case VECTOR3: {
if (p_value.type!=Variant::INT && p_value.type!=Variant::REAL)
return;
if (p_index.get_type()==Variant::INT || p_index.get_type()==Variant::REAL) {
//scalar index
int idx=p_index;
Add support for Python-like negative indexing Negative indexing is a useful feature in Python, especially when combined with array slicing. Array slicing will hopefully be implemented later, but negative indexing is useful in its own right. A negative index is indexing from the end of an array, "array[-1] == array[array.size()-1]", using a negative index larger/smaller than the length of the array is still an error. While primarily useful for arrays and strings, support is also added to "array like" structures like Vector3 and Color. This is done just to be consistent; vector3[2] is much clearer than vector3[-1], but disallowing it while allowing it for an array with 3 elements seems confusing.
2016-05-28 16:12:10 +02:00
if (idx<0)
idx += 3;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
if (idx>=0 && idx<3) {
Vector3 *v=reinterpret_cast<Vector3*>(_data._mem);
valid=true;
-fix assignment to vector types in script using integer indices crash (#978)
2015-01-02 19:53:02 +01:00
(*v)[idx]=p_value;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
return;
}
} else if (p_index.get_type()==Variant::STRING) {
//scalar name
const String *str=reinterpret_cast<const String*>(p_index._data._mem);
Vector3 *v=reinterpret_cast<Vector3*>(_data._mem);
if (*str=="x") {
valid=true;
v->x=p_value;
return;
} else if (*str=="y" ) {
valid=true;
v->y=p_value;
return;
} else if (*str=="z" ) {
valid=true;
v->z=p_value;
return;
}
}
} break;
case PLANE: {
if (p_index.get_type()==Variant::STRING) {
//scalar name
const String *str=reinterpret_cast<const String*>(p_index._data._mem);
Plane *v=reinterpret_cast<Plane*>(_data._mem);
if (*str=="x") {
if (p_value.type!=Variant::INT && p_value.type!=Variant::REAL)
return;
valid=true;
v->normal.x=p_value;
return;
} else if (*str=="y" ) {
if (p_value.type!=Variant::INT && p_value.type!=Variant::REAL)
return;
valid=true;
v->normal.y=p_value;
return;
} else if (*str=="z" ) {
if (p_value.type!=Variant::INT && p_value.type!=Variant::REAL)
return;
valid=true;
v->normal.z=p_value;
return;
} else if (*str=="normal" ) {
if (p_value.type!=Variant::VECTOR3)
return;
valid=true;
v->normal=p_value;
return;
} else if (*str=="d" ) {
valid=true;
v->d=p_value;
return;
}
}
} break;
case QUAT: {
if (p_value.type!=Variant::INT && p_value.type!=Variant::REAL)
return;
if (p_index.get_type()==Variant::STRING) {
const String *str=reinterpret_cast<const String*>(p_index._data._mem);
Quat *v=reinterpret_cast<Quat*>(_data._mem);
if (*str=="x") {
valid=true;
v->x=p_value;
return;
} else if (*str=="y" ) {
valid=true;
v->y=p_value;
return;
} else if (*str=="z" ) {
valid=true;
v->z=p_value;
return;
} else if (*str=="w" ) {
valid=true;
v->w=p_value;
return;
}
}
} break;
case _AABB: {
if (p_value.type!=Variant::VECTOR3)
return;
3D Physics and Other Stuff -=-=-=-=-=-=-=-=-=-=-=-=-= -New Vehicle (Based on Bullet's RaycastVehicle) - Vehiclebody/VehicleWheel. Demo will come soon, old vehicle (CarBody) will go away soon too. -A lot of fixes to the 3D physics engine -Added KinematicBody with demo -Fixed the space query API for 2D (demo will come soon). 3D is WIP. -Fixed long-standing bug with body_enter/body_exit for Area and Area2D -Performance variables now includes physics (active bodies, collision pairs and islands) -Ability to see what's inside of instanced scenes! -Fixed Blend Shapes (no bs+skeleton yet) -Added an Android JavaClassWrapper singleton for using Android native classes directly from GDScript. This is very Alpha!
2014-09-03 04:13:40 +02:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
if (p_index.get_type()==Variant::STRING) {
//scalar name
const String *str=reinterpret_cast<const String*>(p_index._data._mem);
AABB *v=_data._aabb;
if (*str=="pos") {
valid=true;
v->pos=p_value;
return;
} else if (*str=="size") {
valid=true;
v->size=p_value;
return;
} else if (*str=="end") {
valid=true;
v->size=Vector3(p_value) - v->pos;
return;
}
}
} break; //sorry naming convention fail :( not like it's used often // 10
case MATRIX3: {
if (p_value.type!=Variant::VECTOR3)
return;
if (p_index.get_type()==Variant::INT || p_index.get_type()==Variant::REAL) {
int index = p_index;
Add support for Python-like negative indexing Negative indexing is a useful feature in Python, especially when combined with array slicing. Array slicing will hopefully be implemented later, but negative indexing is useful in its own right. A negative index is indexing from the end of an array, "array[-1] == array[array.size()-1]", using a negative index larger/smaller than the length of the array is still an error. While primarily useful for arrays and strings, support is also added to "array like" structures like Vector3 and Color. This is done just to be consistent; vector3[2] is much clearer than vector3[-1], but disallowing it while allowing it for an array with 3 elements seems confusing.
2016-05-28 16:12:10 +02:00
if (index<0)
index += 3;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
if (index>=0 && index<3) {
Matrix3 *v=_data._matrix3;
valid=true;
v->set_axis(index,p_value);
return;
}
3D Physics and Other Stuff -=-=-=-=-=-=-=-=-=-=-=-=-= -New Vehicle (Based on Bullet's RaycastVehicle) - Vehiclebody/VehicleWheel. Demo will come soon, old vehicle (CarBody) will go away soon too. -A lot of fixes to the 3D physics engine -Added KinematicBody with demo -Fixed the space query API for 2D (demo will come soon). 3D is WIP. -Fixed long-standing bug with body_enter/body_exit for Area and Area2D -Performance variables now includes physics (active bodies, collision pairs and islands) -Ability to see what's inside of instanced scenes! -Fixed Blend Shapes (no bs+skeleton yet) -Added an Android JavaClassWrapper singleton for using Android native classes directly from GDScript. This is very Alpha!
2014-09-03 04:13:40 +02:00
} else if (p_index.get_type()==Variant::STRING) {
const String *str=reinterpret_cast<const String*>(p_index._data._mem);
Matrix3 *v=_data._matrix3;
if (*str=="x") {
valid=true;
v->set_axis(0,p_value);
return;
} else if (*str=="y" ) {
valid=true;
v->set_axis(1,p_value);
return;
} else if (*str=="z" ) {
valid=true;
v->set_axis(2,p_value);
return;
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
}
} break;
case TRANSFORM: {
if (p_index.get_type()==Variant::INT || p_index.get_type()==Variant::REAL) {
if (p_value.type!=Variant::VECTOR3)
return;
int index = p_index;
Add support for Python-like negative indexing Negative indexing is a useful feature in Python, especially when combined with array slicing. Array slicing will hopefully be implemented later, but negative indexing is useful in its own right. A negative index is indexing from the end of an array, "array[-1] == array[array.size()-1]", using a negative index larger/smaller than the length of the array is still an error. While primarily useful for arrays and strings, support is also added to "array like" structures like Vector3 and Color. This is done just to be consistent; vector3[2] is much clearer than vector3[-1], but disallowing it while allowing it for an array with 3 elements seems confusing.
2016-05-28 16:12:10 +02:00
if (index<0)
index += 4;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
if (index>=0 && index<4) {
Transform *v=_data._transform;
valid=true;
if (index==3)
v->origin=p_value;
else
v->basis.set_axis(index,p_value);
return;
}
} if (p_index.get_type()==Variant::STRING) {
Transform *v=_data._transform;
const String *str=reinterpret_cast<const String*>(p_index._data._mem);
if (*str=="basis") {
if (p_value.type!=Variant::MATRIX3)
return;
valid=true;
v->basis=p_value;
return;
} if (*str=="origin") {
if (p_value.type!=Variant::VECTOR3)
return;
valid=true;
v->origin=p_value;
return;
}
}
} break;
case COLOR: {
if (p_value.type!=Variant::INT && p_value.type!=Variant::REAL)
return;
if (p_index.get_type()==Variant::STRING) {
const String *str=reinterpret_cast<const String*>(p_index._data._mem);
Color *v=reinterpret_cast<Color*>(_data._mem);
if (*str=="r") {
valid=true;
v->r=p_value;
return;
} else if (*str=="g" ) {
valid=true;
v->g=p_value;
return;
} else if (*str=="b" ) {
valid=true;
v->b=p_value;
return;
} else if (*str=="a" ) {
valid=true;
v->a=p_value;
return;
} else if (*str=="h") {
valid=true;
v->set_hsv(p_value,v->get_s(),v->get_v());
return;
} else if (*str=="s" ) {
valid=true;
v->set_hsv(v->get_h(),p_value,v->get_v());
return;
} else if (*str=="v" ) {
valid=true;
v->set_hsv(v->get_h(),v->get_s(),p_value);
return;
-Added Color8(r8,g8,b8,a8) function as well as .r8,.g8,.b8,.a8 members to Color, to deal with colors in the 0-255 range. Closes #2345
2015-12-31 22:26:49 +01:00
} else if (*str=="r8" ) {
valid=true;
Make Color.{rgba}8 return int instead float According to the class doc, these should be int. Also fixed a little bug: the setter for 'r8' changed the green value
2016-05-31 20:50:19 +02:00
v->r=float(p_value)/255.0;
-Added Color8(r8,g8,b8,a8) function as well as .r8,.g8,.b8,.a8 members to Color, to deal with colors in the 0-255 range. Closes #2345
2015-12-31 22:26:49 +01:00
return;
} else if (*str=="g8" ) {
valid=true;
v->g=float(p_value)/255.0;
return;
} else if (*str=="b8" ) {
valid=true;
v->b=float(p_value)/255.0;
return;
fixed string operator[], which was broken. Closes #2202
2016-01-02 18:58:27 +01:00
} else if (*str=="a8" ) {\
-Added Color8(r8,g8,b8,a8) function as well as .r8,.g8,.b8,.a8 members to Color, to deal with colors in the 0-255 range. Closes #2345
2015-12-31 22:26:49 +01:00
valid=true;
v->a=float(p_value)/255.0;
return;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
}
} else if (p_index.get_type()==Variant::INT) {
int idx = p_index;
Add support for Python-like negative indexing Negative indexing is a useful feature in Python, especially when combined with array slicing. Array slicing will hopefully be implemented later, but negative indexing is useful in its own right. A negative index is indexing from the end of an array, "array[-1] == array[array.size()-1]", using a negative index larger/smaller than the length of the array is still an error. While primarily useful for arrays and strings, support is also added to "array like" structures like Vector3 and Color. This is done just to be consistent; vector3[2] is much clearer than vector3[-1], but disallowing it while allowing it for an array with 3 elements seems confusing.
2016-05-28 16:12:10 +02:00
if (idx<0)
idx += 4;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
if (idx>=0 || idx<4) {
Color *v=reinterpret_cast<Color*>(_data._mem);
(*v)[idx]=p_value;
valid=true;
}
}
} break;
case IMAGE: { } break;
case NODE_PATH: { } break; // 15
case _RID: { } break;
case OBJECT: {
Object *obj=_get_obj().obj;
//only if debugging!
if (obj) {
#ifdef DEBUG_ENABLED
if (ScriptDebugger::get_singleton() && _get_obj().ref.is_null()) {
if (!ObjectDB::instance_validate(obj)) {
WARN_PRINT("Attempted use of stray pointer object.");
valid=false;
return;
}
}
#endif
if (p_index.get_type()!=Variant::STRING) {
obj->setvar(p_index,p_value,r_valid);
return;
}
return obj->set(p_index,p_value,r_valid);
}
} break;
case INPUT_EVENT: {
InputEvent &ie = *_data._input_event;
if (p_index.get_type()!=Variant::STRING)
return;
const String &str=*reinterpret_cast<const String*>(p_index._data._mem);
if (str=="type") {
if (p_value.type!=Variant::INT && p_value.type!=Variant::REAL)
return;
int type=p_value;
-scripts are converted to bytecode on export -fix bug in doc where touchscreen events were not documented
2014-02-25 13:31:47 +01:00
if (type<0 || type>=InputEvent::TYPE_MAX)
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
return; //fail
valid=true;
ie.type=InputEvent::Type(type);
return;
} else if (str=="device") {
if (p_value.type!=Variant::INT && p_value.type!=Variant::REAL)
return;
valid=true;
ie.device=p_value;
return;
} else if (str=="ID") {
if (p_value.type!=Variant::INT && p_value.type!=Variant::REAL)
return;
valid=true;
ie.ID=p_value;
return;
}
if (ie.type==InputEvent::KEY || ie.type==InputEvent::MOUSE_BUTTON || ie.type==InputEvent::MOUSE_MOTION) {
if (str=="shift") {
if (p_value.type!=Variant::INT && p_value.type!=Variant::REAL && p_value.type!=Variant::BOOL)
return;
valid=true;
ie.key.mod.shift=p_value;
return;
} if (str=="alt") {
if (p_value.type!=Variant::INT && p_value.type!=Variant::REAL && p_value.type!=Variant::BOOL)
return;
valid=true;
ie.key.mod.alt=p_value;
return;
} if (str=="control") {
if (p_value.type!=Variant::INT && p_value.type!=Variant::REAL && p_value.type!=Variant::BOOL)
return;
valid=true;
ie.key.mod.control=p_value;
return;
} if (str=="meta") {
if (p_value.type!=Variant::INT && p_value.type!=Variant::REAL && p_value.type!=Variant::BOOL)
return;
valid=true;
ie.key.mod.meta=p_value;
return;
}
}
if (ie.type==InputEvent::KEY) {
if (str=="pressed") {
if (p_value.type!=Variant::INT && p_value.type!=Variant::REAL && p_value.type!=Variant::BOOL)
return;
valid=true;
ie.key.pressed=p_value;
return;
} else if (str=="scancode") {
if (p_value.type!=Variant::INT && p_value.type!=Variant::REAL)
return;
valid=true;
ie.key.scancode=p_value;
return;
} else if (str=="unicode") {
if (p_value.type!=Variant::INT && p_value.type!=Variant::REAL)
return;
valid=true;
ie.key.unicode=p_value;
return;
} else if (str=="echo") {
if (p_value.type!=Variant::INT && p_value.type!=Variant::REAL && p_value.type!=Variant::BOOL)
return;
valid=true;
ie.key.echo=p_value;
return;
}
}
if (ie.type==InputEvent::MOUSE_MOTION || ie.type==InputEvent::MOUSE_BUTTON) {
if (str=="button_mask") {
if (p_value.type!=Variant::INT && p_value.type!=Variant::REAL)
return;
valid=true;
ie.mouse_button.button_mask=p_value;
return;
} else if (str=="x") {
if (p_value.type!=Variant::INT && p_value.type!=Variant::REAL)
return;
valid=true;
ie.mouse_button.x=p_value;
return;
} else if (str=="y") {
if (p_value.type!=Variant::INT && p_value.type!=Variant::REAL)
return;
valid=true;
ie.mouse_button.y=p_value;
return;
} else if (str=="pos") {
if (p_value.type!=Variant::VECTOR2)
return;
valid=true;
Point2 value=p_value;
ie.mouse_button.x=value.x;
ie.mouse_button.y=value.y;
return;
} else if (str=="global_x") {
if (p_value.type!=Variant::INT && p_value.type!=Variant::REAL)
return;
valid=true;
ie.mouse_button.global_x=p_value;
return;
} else if (str=="global_y") {
if (p_value.type!=Variant::INT && p_value.type!=Variant::REAL)
return;
valid=true;
ie.mouse_button.global_y=p_value;
return;
} else if (str=="global_pos") {
if (p_value.type!=Variant::VECTOR2)
return;
valid=true;
Point2 value=p_value;
ie.mouse_button.global_x=value.x;
ie.mouse_button.global_y=value.y;
return;
} /*else if (str=="pointer_index") {
valid=true;
return ie.mouse_button.pointer_index;
}*/
if (ie.type==InputEvent::MOUSE_MOTION) {
if (str=="relative_x") {
if (p_value.type!=Variant::INT && p_value.type!=Variant::REAL)
return;
valid=true;
ie.mouse_motion.relative_x=p_value;
return;
} else if (str=="relative_y") {
if (p_value.type!=Variant::INT && p_value.type!=Variant::REAL)
return;
valid=true;
ie.mouse_motion.relative_y=p_value;
return;
} else if (str=="relative_pos") {
if (p_value.type!=Variant::VECTOR2)
return;
valid=true;
Point2 value=p_value;
ie.mouse_motion.relative_x=value.x;
ie.mouse_motion.relative_y=value.y;
return;
}
if (str=="speed_x") {
if (p_value.type!=Variant::INT && p_value.type!=Variant::REAL)
return;
valid=true;
ie.mouse_motion.speed_x=p_value;
return;
} else if (str=="speed_y") {
if (p_value.type!=Variant::INT && p_value.type!=Variant::REAL)
return;
valid=true;
ie.mouse_motion.speed_y=p_value;
return;
} else if (str=="speed") {
if (p_value.type!=Variant::VECTOR2)
return;
valid=true;
Point2 value=p_value;
ie.mouse_motion.speed_x=value.x;
ie.mouse_motion.speed_y=value.y;
return;
}
} else if (ie.type==InputEvent::MOUSE_BUTTON) {
if (str=="button_index") {
if (p_value.type!=Variant::INT && p_value.type!=Variant::REAL)
return;
valid=true;
ie.mouse_button.button_index=p_value;
return;
} else if (str=="pressed") {
if (p_value.type!=Variant::INT && p_value.type!=Variant::REAL && p_value.type!=Variant::BOOL)
return;
valid=true;
ie.mouse_button.pressed=p_value;
return;
} else if (str=="doubleclick") {
if (p_value.type!=Variant::INT && p_value.type!=Variant::REAL && p_value.type!=Variant::BOOL)
return;
valid=true;
ie.mouse_button.doubleclick=p_value;
return;
}
}
}
if (ie.type==InputEvent::JOYSTICK_BUTTON) {
if (str=="button_index") {
if (p_value.type!=Variant::REAL && p_value.type!=Variant::INT)
return;
valid=true;
ie.joy_button.button_index=p_value;
return;
} if (str=="pressed") {
if (p_value.type!=Variant::INT && p_value.type!=Variant::REAL && p_value.type!=Variant::BOOL)
return;
valid=true;
ie.joy_button.pressed=p_value;
return;
} if (str=="pressure") {
if (p_value.type!=Variant::REAL && p_value.type!=Variant::INT)
return;
valid=true;
ie.joy_button.pressure=p_value;
return;
}
}
if (ie.type==InputEvent::JOYSTICK_MOTION) {
if (str=="axis") {
if (p_value.type!=Variant::REAL && p_value.type!=Variant::INT)
return;
valid=true;
ie.joy_motion.axis=p_value;
return;
} if (str=="value") {
if (p_value.type!=Variant::REAL && p_value.type!=Variant::INT)
return;
valid=true;
ie.joy_motion.axis_value=p_value;
return;
}
}
if (ie.type==InputEvent::SCREEN_TOUCH) {
if (str=="index") {
valid=true;
ie.screen_touch.index=p_value;
return;
} if (str=="x") {
valid=true;
ie.screen_touch.x=p_value;
return;
} if (str=="y") {
valid=true;
ie.screen_touch.y=p_value;
return;
} if (str=="pos") {
valid=true;
Vector2 v = p_value;
ie.screen_touch.x=v.x;
ie.screen_touch.y=v.y;
return;
} if (str=="pressed") {
valid=true;
ie.screen_touch.pressed=p_value;
return;
}
}
if (ie.type==InputEvent::SCREEN_DRAG) {
if (str=="index") {
valid=true;
ie.screen_drag.index=p_value;
return;
} if (str=="x") {
valid=true;
ie.screen_drag.x=p_value;
return;
} if (str=="y") {
valid=true;
ie.screen_drag.y=p_value;
return;
} if (str=="pos") {
valid=true;
Vector2 v = p_value;
ie.screen_drag.x=v.x;
ie.screen_drag.y=v.y;
return;
} if (str=="relative_x") {
valid=true;
ie.screen_drag.relative_x=p_value;
return;
} if (str=="relative_y") {
valid=true;
ie.screen_drag.relative_y=p_value;
return;
} if (str=="relative_pos") {
valid=true;
Vector2 v=p_value;
ie.screen_drag.relative_x=v.x;
ie.screen_drag.relative_y=v.y;
return;
} if (str=="speed_x") {
valid=true;
ie.screen_drag.speed_x=p_value;
return;
} if (str=="speed_y") {
valid=true;
ie.screen_drag.speed_y=p_value;
return;
} if (str=="speed") {
valid=true;
Vector2 v=p_value;
ie.screen_drag.speed_x=v.x;
ie.screen_drag.speed_y=v.y;
return;
}
}
Add InputEvent::ACTION get/set support for variant Add action_press/action_release method bind
2015-01-20 13:01:02 +01:00
if (ie.type == InputEvent::ACTION) {
if (str =="action") {
valid=true;
ie.action.action=p_value;
return;
}
else if (str == "pressed") {
valid=true;
ie.action.pressed=p_value;
return;
}
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
} break;
case DICTIONARY: {
Dictionary *dic=reinterpret_cast<Dictionary*>(_data._mem);
dic->operator [](p_index)=p_value;
valid=true; //always valid, i guess? should this really be ok?
return;
} break; // 20
Move repetitive code to macros In preparation for the following "allow negative indexing" commit, replace the repetitive array "set index" and "get index" code with macros. no functional changes were made, the resulting machine code is unchanged.
2016-05-26 23:35:33 +02:00
DEFAULT_OP_ARRAY_CMD(ARRAY, Array, ;, (*arr)[index]=p_value;return)
DEFAULT_OP_DVECTOR_SET(RAW_ARRAY, uint8_t, p_value.type != Variant::REAL && p_value.type != Variant::INT)
DEFAULT_OP_DVECTOR_SET(INT_ARRAY, int, p_value.type != Variant::REAL && p_value.type != Variant::INT)
DEFAULT_OP_DVECTOR_SET(REAL_ARRAY, real_t, p_value.type != Variant::REAL && p_value.type != Variant::INT)
DEFAULT_OP_DVECTOR_SET(STRING_ARRAY, String, p_value.type != Variant::STRING) // 25
DEFAULT_OP_DVECTOR_SET(VECTOR2_ARRAY, Vector2, p_value.type != Variant::VECTOR2)
DEFAULT_OP_DVECTOR_SET(VECTOR3_ARRAY, Vector3, p_value.type != Variant::VECTOR3)
DEFAULT_OP_DVECTOR_SET(COLOR_ARRAY, Color, p_value.type != Variant::COLOR)
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
default: return;
}
}
Variant Variant::get(const Variant& p_index, bool *r_valid) const {
static bool _dummy=false;
bool &valid = r_valid ? *r_valid : _dummy;
valid=false;
switch(type) {
case NIL: { return Variant(); } break;
case BOOL: { return Variant(); } break;
case INT: { return Variant(); } break;
case REAL: { return Variant(); } break;
case STRING: {
if (p_index.get_type()==Variant::INT || p_index.get_type()==Variant::REAL) {
//string index
int idx=p_index;
const String *str=reinterpret_cast<const String*>(_data._mem);
Add support for Python-like negative indexing Negative indexing is a useful feature in Python, especially when combined with array slicing. Array slicing will hopefully be implemented later, but negative indexing is useful in its own right. A negative index is indexing from the end of an array, "array[-1] == array[array.size()-1]", using a negative index larger/smaller than the length of the array is still an error. While primarily useful for arrays and strings, support is also added to "array like" structures like Vector3 and Color. This is done just to be consistent; vector3[2] is much clearer than vector3[-1], but disallowing it while allowing it for an array with 3 elements seems confusing.
2016-05-28 16:12:10 +02:00
if (idx<0)
idx += str->length();
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
if (idx >=0 && idx<str->length()) {
valid=true;
return str->substr(idx,1);
}
}
} break;
case VECTOR2: {
if (p_index.get_type()==Variant::INT || p_index.get_type()==Variant::REAL) {
// scalar index
int idx=p_index;
Add support for Python-like negative indexing Negative indexing is a useful feature in Python, especially when combined with array slicing. Array slicing will hopefully be implemented later, but negative indexing is useful in its own right. A negative index is indexing from the end of an array, "array[-1] == array[array.size()-1]", using a negative index larger/smaller than the length of the array is still an error. While primarily useful for arrays and strings, support is also added to "array like" structures like Vector3 and Color. This is done just to be consistent; vector3[2] is much clearer than vector3[-1], but disallowing it while allowing it for an array with 3 elements seems confusing.
2016-05-28 16:12:10 +02:00
if (idx<0)
idx += 2;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
if (idx>=0 && idx<2) {
const Vector2 *v=reinterpret_cast<const Vector2*>(_data._mem);
valid=true;
return (*v)[idx];
}
} else if (p_index.get_type()==Variant::STRING) {
//scalar name
const String *str=reinterpret_cast<const String*>(p_index._data._mem);
const Vector2 *v=reinterpret_cast<const Vector2*>(_data._mem);
if (*str=="x" || *str=="width") {
valid=true;
return v->x;
} else if (*str=="y" || *str=="height") {
valid=true;
return v->y;
}
}
} break; // 5
case RECT2: {
if (p_index.get_type()==Variant::STRING) {
//scalar name
const String *str=reinterpret_cast<const String*>(p_index._data._mem);
const Rect2 *v=reinterpret_cast<const Rect2*>(_data._mem);
if (*str=="pos") {
valid=true;
return v->pos;
} else if (*str=="size") {
valid=true;
return v->size;
} else if (*str=="end") {
valid=true;
return v->size+v->pos;
}
}
} break;
case VECTOR3: {
if (p_index.get_type()==Variant::INT || p_index.get_type()==Variant::REAL) {
//scalar index
int idx=p_index;
Add support for Python-like negative indexing Negative indexing is a useful feature in Python, especially when combined with array slicing. Array slicing will hopefully be implemented later, but negative indexing is useful in its own right. A negative index is indexing from the end of an array, "array[-1] == array[array.size()-1]", using a negative index larger/smaller than the length of the array is still an error. While primarily useful for arrays and strings, support is also added to "array like" structures like Vector3 and Color. This is done just to be consistent; vector3[2] is much clearer than vector3[-1], but disallowing it while allowing it for an array with 3 elements seems confusing.
2016-05-28 16:12:10 +02:00
if (idx<0)
idx += 3;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
if (idx>=0 && idx<3) {
const Vector3 *v=reinterpret_cast<const Vector3*>(_data._mem);
valid=true;
return (*v)[idx];
}
} else if (p_index.get_type()==Variant::STRING) {
//scalar name
const String *str=reinterpret_cast<const String*>(p_index._data._mem);
const Vector3 *v=reinterpret_cast<const Vector3*>(_data._mem);
if (*str=="x") {
valid=true;
return v->x;
} else if (*str=="y" ) {
valid=true;
return v->y;
} else if (*str=="z" ) {
valid=true;
return v->z;
}
}
} break;
case MATRIX32: {
if (p_index.get_type()==Variant::INT || p_index.get_type()==Variant::REAL) {
int index = p_index;
Add support for Python-like negative indexing Negative indexing is a useful feature in Python, especially when combined with array slicing. Array slicing will hopefully be implemented later, but negative indexing is useful in its own right. A negative index is indexing from the end of an array, "array[-1] == array[array.size()-1]", using a negative index larger/smaller than the length of the array is still an error. While primarily useful for arrays and strings, support is also added to "array like" structures like Vector3 and Color. This is done just to be consistent; vector3[2] is much clearer than vector3[-1], but disallowing it while allowing it for an array with 3 elements seems confusing.
2016-05-28 16:12:10 +02:00
if (index<0)
index += 3;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
if (index>=0 && index<3) {
const Matrix32 *v=_data._matrix32;
valid=true;
return v->elements[index];
}
} else if (p_index.get_type()==Variant::STRING) {
//scalar name
const String *str=reinterpret_cast<const String*>(p_index._data._mem);
const Matrix32 *v=_data._matrix32;
if (*str=="x") {
valid=true;
return v->elements[0];
} else if (*str=="y" ) {
valid=true;
return v->elements[1];
} else if (*str=="o" ) {
valid=true;
return v->elements[2];
}
}
} break;
case PLANE: {
if (p_index.get_type()==Variant::STRING) {
//scalar name
const String *str=reinterpret_cast<const String*>(p_index._data._mem);
const Plane *v=reinterpret_cast<const Plane*>(_data._mem);
if (*str=="x") {
valid=true;
return v->normal.x;
} else if (*str=="y" ) {
valid=true;
return v->normal.y;
} else if (*str=="z" ) {
valid=true;
return v->normal.z;
} else if (*str=="normal" ) {
valid=true;
return v->normal;
} else if (*str=="d" ) {
valid=true;
return v->d;
}
}
} break;
case QUAT: {
if (p_index.get_type()==Variant::STRING) {
const String *str=reinterpret_cast<const String*>(p_index._data._mem);
const Quat *v=reinterpret_cast<const Quat*>(_data._mem);
if (*str=="x") {
valid=true;
return v->x;
} else if (*str=="y" ) {
valid=true;
return v->y;
} else if (*str=="z" ) {
valid=true;
return v->z;
} else if (*str=="w" ) {
valid=true;
return v->w;
}
}
} break;
case _AABB: {
if (p_index.get_type()==Variant::STRING) {
//scalar name
const String *str=reinterpret_cast<const String*>(p_index._data._mem);
const AABB *v=_data._aabb;
if (*str=="pos") {
valid=true;
return v->pos;
} else if (*str=="size") {
valid=true;
return v->size;
} else if (*str=="end") {
valid=true;
return v->size+v->pos;
}
}
} break; //sorry naming convention fail :( not like it's used often // 10
case MATRIX3: {
if (p_index.get_type()==Variant::INT || p_index.get_type()==Variant::REAL) {
int index = p_index;
Add support for Python-like negative indexing Negative indexing is a useful feature in Python, especially when combined with array slicing. Array slicing will hopefully be implemented later, but negative indexing is useful in its own right. A negative index is indexing from the end of an array, "array[-1] == array[array.size()-1]", using a negative index larger/smaller than the length of the array is still an error. While primarily useful for arrays and strings, support is also added to "array like" structures like Vector3 and Color. This is done just to be consistent; vector3[2] is much clearer than vector3[-1], but disallowing it while allowing it for an array with 3 elements seems confusing.
2016-05-28 16:12:10 +02:00
if (index<0)
index += 3;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
if (index>=0 && index<3) {
const Matrix3 *v=_data._matrix3;
valid=true;
return v->get_axis(index);
}
3D Physics and Other Stuff -=-=-=-=-=-=-=-=-=-=-=-=-= -New Vehicle (Based on Bullet's RaycastVehicle) - Vehiclebody/VehicleWheel. Demo will come soon, old vehicle (CarBody) will go away soon too. -A lot of fixes to the 3D physics engine -Added KinematicBody with demo -Fixed the space query API for 2D (demo will come soon). 3D is WIP. -Fixed long-standing bug with body_enter/body_exit for Area and Area2D -Performance variables now includes physics (active bodies, collision pairs and islands) -Ability to see what's inside of instanced scenes! -Fixed Blend Shapes (no bs+skeleton yet) -Added an Android JavaClassWrapper singleton for using Android native classes directly from GDScript. This is very Alpha!
2014-09-03 04:13:40 +02:00
} else if (p_index.get_type()==Variant::STRING) {
const String *str=reinterpret_cast<const String*>(p_index._data._mem);
const Matrix3 *v=_data._matrix3;
if (*str=="x") {
valid=true;
return v->get_axis(0);
} else if (*str=="y" ) {
valid=true;
return v->get_axis(1);
} else if (*str=="z" ) {
valid=true;
return v->get_axis(2);
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
}
} break;
case TRANSFORM: {
if (p_index.get_type()==Variant::INT || p_index.get_type()==Variant::REAL) {
int index = p_index;
Add support for Python-like negative indexing Negative indexing is a useful feature in Python, especially when combined with array slicing. Array slicing will hopefully be implemented later, but negative indexing is useful in its own right. A negative index is indexing from the end of an array, "array[-1] == array[array.size()-1]", using a negative index larger/smaller than the length of the array is still an error. While primarily useful for arrays and strings, support is also added to "array like" structures like Vector3 and Color. This is done just to be consistent; vector3[2] is much clearer than vector3[-1], but disallowing it while allowing it for an array with 3 elements seems confusing.
2016-05-28 16:12:10 +02:00
if (index<0)
index += 4;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
if (index>=0 && index<4) {
const Transform *v=_data._transform;
valid=true;
return index==3?v->origin:v->basis.get_axis(index);
}
} if (p_index.get_type()==Variant::STRING) {
const Transform *v=_data._transform;
const String *str=reinterpret_cast<const String*>(p_index._data._mem);
if (*str=="basis") {
valid=true;
return v->basis;
} if (*str=="origin") {
valid=true;
return v->origin;
}
}
} break;
case COLOR: {
if (p_index.get_type()==Variant::STRING) {
const String *str=reinterpret_cast<const String*>(p_index._data._mem);
const Color *v=reinterpret_cast<const Color*>(_data._mem);
if (*str=="r") {
valid=true;
return v->r;
} else if (*str=="g" ) {
valid=true;
return v->g;
} else if (*str=="b" ) {
valid=true;
return v->b;
} else if (*str=="a" ) {
valid=true;
return v->a;
} else if (*str=="h") {
valid=true;
return v->get_h();
} else if (*str=="s" ) {
valid=true;
return v->get_s();
} else if (*str=="v" ) {
valid=true;
return v->get_v();
-Added Color8(r8,g8,b8,a8) function as well as .r8,.g8,.b8,.a8 members to Color, to deal with colors in the 0-255 range. Closes #2345
2015-12-31 22:26:49 +01:00
} else if (*str=="r8") {
valid=true;
Make Color.{rgba}8 return int instead float According to the class doc, these should be int. Also fixed a little bug: the setter for 'r8' changed the green value
2016-05-31 20:50:19 +02:00
return (int)Math::round(v->r*255.0);
-Added Color8(r8,g8,b8,a8) function as well as .r8,.g8,.b8,.a8 members to Color, to deal with colors in the 0-255 range. Closes #2345
2015-12-31 22:26:49 +01:00
} else if (*str=="g8" ) {
valid=true;
Make Color.{rgba}8 return int instead float According to the class doc, these should be int. Also fixed a little bug: the setter for 'r8' changed the green value
2016-05-31 20:50:19 +02:00
return (int)Math::round(v->g*255.0);
-Added Color8(r8,g8,b8,a8) function as well as .r8,.g8,.b8,.a8 members to Color, to deal with colors in the 0-255 range. Closes #2345
2015-12-31 22:26:49 +01:00
} else if (*str=="b8" ) {
valid=true;
Make Color.{rgba}8 return int instead float According to the class doc, these should be int. Also fixed a little bug: the setter for 'r8' changed the green value
2016-05-31 20:50:19 +02:00
return (int)Math::round(v->b*255.0);
-Added Color8(r8,g8,b8,a8) function as well as .r8,.g8,.b8,.a8 members to Color, to deal with colors in the 0-255 range. Closes #2345
2015-12-31 22:26:49 +01:00
} else if (*str=="a8" ) {
valid=true;
Make Color.{rgba}8 return int instead float According to the class doc, these should be int. Also fixed a little bug: the setter for 'r8' changed the green value
2016-05-31 20:50:19 +02:00
return (int)Math::round(v->a*255.0);
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
}
} else if (p_index.get_type()==Variant::INT) {
int idx = p_index;
Add support for Python-like negative indexing Negative indexing is a useful feature in Python, especially when combined with array slicing. Array slicing will hopefully be implemented later, but negative indexing is useful in its own right. A negative index is indexing from the end of an array, "array[-1] == array[array.size()-1]", using a negative index larger/smaller than the length of the array is still an error. While primarily useful for arrays and strings, support is also added to "array like" structures like Vector3 and Color. This is done just to be consistent; vector3[2] is much clearer than vector3[-1], but disallowing it while allowing it for an array with 3 elements seems confusing.
2016-05-28 16:12:10 +02:00
if (idx<0)
idx += 4;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
if (idx>=0 || idx<4) {
const Color *v=reinterpret_cast<const Color*>(_data._mem);
valid=true;
return (*v)[idx];
}
}
} break;
case IMAGE: { } break;
case NODE_PATH: { } break; // 15
case _RID: { } break;
case OBJECT: {
Object *obj = _get_obj().obj;
if (obj) {
#ifdef DEBUG_ENABLED
if (ScriptDebugger::get_singleton() && _get_obj().ref.is_null()) {
//only if debugging!
if (!ObjectDB::instance_validate(obj)) {
valid=false;
return "Attempted get on stray pointer.";
}
}
#endif
if (p_index.get_type()!=Variant::STRING) {
return obj->getvar(p_index,r_valid);
}
return obj->get(p_index,r_valid);
}
} break;
case INPUT_EVENT: {
InputEvent ie = operator InputEvent();
if (p_index.get_type()!=Variant::STRING)
break;
const String &str=*reinterpret_cast<const String*>(p_index._data._mem);
if (str=="type") {
valid=true;
return ie.type;
} else if (str=="device") {
valid=true;
return ie.device;
} else if (str=="ID") {
valid=true;
return ie.ID;
}
if (ie.type==InputEvent::KEY || ie.type==InputEvent::MOUSE_BUTTON || ie.type==InputEvent::MOUSE_MOTION) {
if (str=="shift") {
valid=true;
return ie.key.mod.shift;
} if (str=="alt") {
valid=true;
return ie.key.mod.alt;
} if (str=="control") {
valid=true;
return ie.key.mod.control;
} if (str=="meta") {
valid=true;
return ie.key.mod.meta;
}
}
if (ie.type==InputEvent::KEY) {
if (str=="pressed") {
valid=true;
return ie.key.pressed;
} else if (str=="scancode") {
valid=true;
return ie.key.scancode;
} else if (str=="unicode") {
valid=true;
return ie.key.unicode;
} else if (str=="echo") {
valid=true;
return ie.key.echo;
}
}
if (ie.type==InputEvent::MOUSE_MOTION || ie.type==InputEvent::MOUSE_BUTTON) {
if (str=="button_mask") {
valid=true;
return ie.mouse_button.button_mask;
} else if (str=="x") {
valid=true;
return ie.mouse_button.x;
} else if (str=="y") {
valid=true;
return ie.mouse_button.y;
} else if (str=="pos") {
valid=true;
return Point2(ie.mouse_button.x,ie.mouse_button.y);
} else if (str=="global_x") {
valid=true;
return ie.mouse_button.global_x;
} else if (str=="global_y") {
valid=true;
return ie.mouse_button.global_y;
} else if (str=="global_pos") {
valid=true;
return Point2(ie.mouse_button.global_x,ie.mouse_button.global_y);
} /*else if (str=="pointer_index") {
valid=true;
return ie.mouse_button.pointer_index;
}*/
if (ie.type==InputEvent::MOUSE_MOTION) {
if (str=="relative_x") {
valid=true;
return ie.mouse_motion.relative_x;
} else if (str=="relative_y") {
valid=true;
return ie.mouse_motion.relative_y;
} else if (str=="relative_pos") {
valid=true;
return Point2(ie.mouse_motion.relative_x,ie.mouse_motion.relative_y);
} else if (str=="speed_x") {
valid=true;
return ie.mouse_motion.speed_x;
} else if (str=="speed_y") {
valid=true;
return ie.mouse_motion.speed_y;
} else if (str=="speed") {
valid=true;
return Point2(ie.mouse_motion.speed_x,ie.mouse_motion.speed_y);
}
} else if (ie.type==InputEvent::MOUSE_BUTTON) {
if (str=="button_index") {
valid=true;
return ie.mouse_button.button_index;
} else if (str=="pressed") {
valid=true;
return ie.mouse_button.pressed;
} else if (str=="doubleclick") {
valid=true;
return ie.mouse_button.doubleclick;
}
}
}
if (ie.type==InputEvent::JOYSTICK_BUTTON) {
if (str=="button_index") {
valid=true;
return ie.joy_button.button_index;
} if (str=="pressed") {
valid=true;
return ie.joy_button.pressed;
} if (str=="pressure") {
valid=true;
return ie.joy_button.pressure;
}
}
if (ie.type==InputEvent::JOYSTICK_MOTION) {
if (str=="axis") {
valid=true;
return ie.joy_motion.axis;
} if (str=="value") {
valid=true;
return ie.joy_motion.axis_value;
remove trailing whitespace
2016-03-09 00:00:52 +01:00
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
}
if (ie.type==InputEvent::SCREEN_TOUCH) {
if (str=="index") {
valid=true;
return ie.screen_touch.index;
} if (str=="x") {
valid=true;
return ie.screen_touch.x;
} if (str=="y") {
valid=true;
return ie.screen_touch.y;
} if (str=="pos") {
valid=true;
return Vector2(ie.screen_touch.x,ie.screen_touch.y);
} if (str=="pressed") {
valid=true;
return ie.screen_touch.pressed;
}
}
if (ie.type==InputEvent::SCREEN_DRAG) {
if (str=="index") {
valid=true;
return ie.screen_drag.index;
} if (str=="x") {
valid=true;
return ie.screen_drag.x;
} if (str=="y") {
valid=true;
return ie.screen_drag.y;
} if (str=="pos") {
valid=true;
return Vector2(ie.screen_drag.x,ie.screen_drag.y);
} if (str=="relative_x") {
valid=true;
return ie.screen_drag.relative_x;
} if (str=="relative_y") {
valid=true;
return ie.screen_drag.relative_y;
} if (str=="relative_pos") {
valid=true;
return Vector2(ie.screen_drag.relative_x,ie.screen_drag.relative_y);
} if (str=="speed_x") {
valid=true;
return ie.screen_drag.speed_x;
} if (str=="speed_y") {
valid=true;
return ie.screen_drag.speed_y;
} if (str=="speed") {
valid=true;
return Vector2(ie.screen_drag.speed_x,ie.screen_drag.speed_y);
}
}
Add InputEvent::ACTION get/set support for variant Add action_press/action_release method bind
2015-01-20 13:01:02 +01:00
if (ie.type == InputEvent::ACTION) {
if (str =="action") {
valid=true;
return ie.action.action;
}
else if (str == "pressed") {
valid=true;
-Fixes from source code analyzizer, closes #1768
2015-05-01 15:44:08 +02:00
return ie.action.pressed;
Add InputEvent::ACTION get/set support for variant Add action_press/action_release method bind
2015-01-20 13:01:02 +01:00
}
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
} break;
case DICTIONARY: {
const Dictionary *dic=reinterpret_cast<const Dictionary*>(_data._mem);
const Variant * res = dic->getptr(p_index);
if (res) {
valid=true;
return *res;
}
} break; // 20
Fix warnings in core/variant_op.cpp Adds default cases in switches where needed, and replaces '0;' with ';;' in macro expansions (as suggested by @vnen in #5587).
2016-07-23 14:47:49 +02:00
DEFAULT_OP_ARRAY_CMD(ARRAY, const Array, ;, return (*arr)[index])
Move repetitive code to macros In preparation for the following "allow negative indexing" commit, replace the repetitive array "set index" and "get index" code with macros. no functional changes were made, the resulting machine code is unchanged.
2016-05-26 23:35:33 +02:00
DEFAULT_OP_DVECTOR_GET(RAW_ARRAY, uint8_t)
DEFAULT_OP_DVECTOR_GET(INT_ARRAY, int)
DEFAULT_OP_DVECTOR_GET(REAL_ARRAY, real_t)
DEFAULT_OP_DVECTOR_GET(STRING_ARRAY, String)
DEFAULT_OP_DVECTOR_GET(VECTOR2_ARRAY, Vector2)
DEFAULT_OP_DVECTOR_GET(VECTOR3_ARRAY, Vector3)
DEFAULT_OP_DVECTOR_GET(COLOR_ARRAY, Color)
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
default: return Variant();
}
return Variant();
}
bool Variant::in(const Variant& p_index, bool *r_valid) const {
if (r_valid)
*r_valid=true;
switch(type) {
case STRING: {
if (p_index.get_type()==Variant::STRING) {
//string index
String idx=p_index;
const String *str=reinterpret_cast<const String*>(_data._mem);
Fix String content test
2015-11-06 22:52:15 +01:00
return str->find(idx)!=-1;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
}
} break;
case OBJECT: {
Object *obj = _get_obj().obj;
if (obj) {
bool valid=false;
#ifdef DEBUG_ENABLED
if (ScriptDebugger::get_singleton() && _get_obj().ref.is_null()) {
//only if debugging!
if (!ObjectDB::instance_validate(obj)) {
if (r_valid) {
*r_valid=false;
}
return "Attempted get on stray pointer.";
}
}
#endif
if (p_index.get_type()!=Variant::STRING) {
obj->getvar(p_index,&valid);
} else {
obj->get(p_index,&valid);
}
return valid;
} else {
if (r_valid)
*r_valid=false;
}
return false;
} break;
case DICTIONARY: {
const Dictionary *dic=reinterpret_cast<const Dictionary*>(_data._mem);
return dic->has(p_index);
} break; // 20
case ARRAY: {
const Array *arr=reinterpret_cast<const Array* >(_data._mem);
int l = arr->size();
if (l) {
for(int i=0;i<l;i++) {
Fix "in" operator, make it use evaluate() instead of operator==
2015-12-11 14:15:05 +01:00
if (evaluate(OP_EQUAL,(*arr)[i],p_index))
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
return true;
}
}
return false;
} break;
case RAW_ARRAY: {
if (p_index.get_type()==Variant::INT || p_index.get_type()==Variant::REAL) {
int index = p_index;
const DVector<uint8_t> *arr=reinterpret_cast<const DVector<uint8_t>* >(_data._mem);
int l=arr->size();
if (l) {
DVector<uint8_t>::Read r = arr->read();
for(int i=0;i<l;i++) {
if (r[i]==index)
return true;
}
}
return false;
}
} break;
case INT_ARRAY: {
if (p_index.get_type()==Variant::INT || p_index.get_type()==Variant::REAL) {
int index = p_index;
const DVector<int> *arr=reinterpret_cast<const DVector<int>* >(_data._mem);
int l=arr->size();
if (l) {
DVector<int>::Read r = arr->read();
for(int i=0;i<l;i++) {
if (r[i]==index)
return true;
}
}
return false;
}
} break;
case REAL_ARRAY: {
if (p_index.get_type()==Variant::INT || p_index.get_type()==Variant::REAL) {
real_t index = p_index;
const DVector<real_t> *arr=reinterpret_cast<const DVector<real_t>* >(_data._mem);
int l=arr->size();
if (l) {
DVector<real_t>::Read r = arr->read();
for(int i=0;i<l;i++) {
if (r[i]==index)
return true;
}
}
return false;
}
} break;
case STRING_ARRAY: {
if (p_index.get_type()==Variant::STRING) {
String index = p_index;
const DVector<String> *arr=reinterpret_cast<const DVector<String>* >(_data._mem);
int l=arr->size();
if (l) {
DVector<String>::Read r = arr->read();
for(int i=0;i<l;i++) {
if (r[i]==index)
return true;
}
}
return false;
}
} break; //25
case VECTOR2_ARRAY: {
if (p_index.get_type()==Variant::VECTOR2) {
Vector2 index = p_index;
const DVector<Vector2> *arr=reinterpret_cast<const DVector<Vector2>* >(_data._mem);
int l=arr->size();
if (l) {
DVector<Vector2>::Read r = arr->read();
for(int i=0;i<l;i++) {
if (r[i]==index)
return true;
}
}
return false;
}
} break;
case VECTOR3_ARRAY: {
if (p_index.get_type()==Variant::VECTOR3) {
Vector3 index = p_index;
const DVector<Vector3> *arr=reinterpret_cast<const DVector<Vector3>* >(_data._mem);
int l=arr->size();
if (l) {
DVector<Vector3>::Read r = arr->read();
for(int i=0;i<l;i++) {
if (r[i]==index)
return true;
}
}
return false;
}
} break;
case COLOR_ARRAY: {
if (p_index.get_type()==Variant::COLOR) {
Color index = p_index;
const DVector<Color> *arr=reinterpret_cast<const DVector<Color>* >(_data._mem);
int l=arr->size();
if (l) {
DVector<Color>::Read r = arr->read();
for(int i=0;i<l;i++) {
if (r[i]==index)
return true;
}
}
return false;
}
} break;
default: {}
}
if (r_valid)
*r_valid=false;
return false;
}
void Variant::get_property_list(List<PropertyInfo> *p_list) const {
switch(type) {
case VECTOR2: {
p_list->push_back( PropertyInfo(Variant::REAL,"x"));
p_list->push_back( PropertyInfo(Variant::REAL,"y"));
p_list->push_back( PropertyInfo(Variant::REAL,"width"));
p_list->push_back( PropertyInfo(Variant::REAL,"height"));
} break; // 5
case RECT2: {
p_list->push_back( PropertyInfo(Variant::VECTOR2,"pos"));
p_list->push_back( PropertyInfo(Variant::VECTOR2,"size"));
p_list->push_back( PropertyInfo(Variant::VECTOR2,"end"));
} break;
case VECTOR3: {
p_list->push_back( PropertyInfo(Variant::REAL,"x"));
p_list->push_back( PropertyInfo(Variant::REAL,"y"));
p_list->push_back( PropertyInfo(Variant::REAL,"z"));
} break;
case MATRIX32: {
Fix return type of Matrix32 member vars Thanks to @bojidar-bg for localising the issue.
2015-11-23 19:07:32 +01:00
p_list->push_back( PropertyInfo(Variant::VECTOR2,"x"));
p_list->push_back( PropertyInfo(Variant::VECTOR2,"y"));
p_list->push_back( PropertyInfo(Variant::VECTOR2,"o"));
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
} break;
case PLANE: {
p_list->push_back( PropertyInfo(Variant::VECTOR3,"normal"));
p_list->push_back( PropertyInfo(Variant::REAL,"x"));
p_list->push_back( PropertyInfo(Variant::REAL,"y"));
p_list->push_back( PropertyInfo(Variant::REAL,"z"));
p_list->push_back( PropertyInfo(Variant::REAL,"d"));
} break;
case QUAT: {
p_list->push_back( PropertyInfo(Variant::REAL,"x"));
p_list->push_back( PropertyInfo(Variant::REAL,"y"));
p_list->push_back( PropertyInfo(Variant::REAL,"z"));
p_list->push_back( PropertyInfo(Variant::REAL,"w"));
} break;
case _AABB: {
p_list->push_back( PropertyInfo(Variant::VECTOR3,"pos"));
p_list->push_back( PropertyInfo(Variant::VECTOR3,"size"));
p_list->push_back( PropertyInfo(Variant::VECTOR3,"end"));
} break; //sorry naming convention fail :( not like it's used often // 10
case MATRIX3: {
p_list->push_back( PropertyInfo(Variant::VECTOR3,"x"));
p_list->push_back( PropertyInfo(Variant::VECTOR3,"y"));
p_list->push_back( PropertyInfo(Variant::VECTOR3,"z"));
} break;
case TRANSFORM: {
p_list->push_back( PropertyInfo(Variant::MATRIX3,"basis"));
p_list->push_back( PropertyInfo(Variant::VECTOR3,"origin"));
} break;
case COLOR: {
p_list->push_back( PropertyInfo(Variant::REAL,"r"));
p_list->push_back( PropertyInfo(Variant::REAL,"g"));
p_list->push_back( PropertyInfo(Variant::REAL,"b"));
p_list->push_back( PropertyInfo(Variant::REAL,"a"));
p_list->push_back( PropertyInfo(Variant::REAL,"h"));
p_list->push_back( PropertyInfo(Variant::REAL,"s"));
p_list->push_back( PropertyInfo(Variant::REAL,"v"));
-Added Color8(r8,g8,b8,a8) function as well as .r8,.g8,.b8,.a8 members to Color, to deal with colors in the 0-255 range. Closes #2345
2015-12-31 22:26:49 +01:00
p_list->push_back( PropertyInfo(Variant::INT,"r8"));
p_list->push_back( PropertyInfo(Variant::INT,"g8"));
p_list->push_back( PropertyInfo(Variant::INT,"b8"));
p_list->push_back( PropertyInfo(Variant::INT,"a8"));
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
} break;
case IMAGE: { } break;
case NODE_PATH: { } break; // 15
case _RID: { } break;
case OBJECT: {
Object *obj=_get_obj().obj;
if (obj) {
#ifdef DEBUG_ENABLED
if (ScriptDebugger::get_singleton() && _get_obj().ref.is_null()) {
//only if debugging!
if (!ObjectDB::instance_validate(obj)) {
WARN_PRINT("Attempted get_property list on stray pointer.");
return;
}
}
#endif
obj->get_property_list(p_list);
}
} break;
case INPUT_EVENT: {
InputEvent ie = operator InputEvent();
-scripts are converted to bytecode on export -fix bug in doc where touchscreen events were not documented
2014-02-25 13:31:47 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
p_list->push_back( PropertyInfo(Variant::INT,"type"));
p_list->push_back( PropertyInfo(Variant::INT,"device"));
p_list->push_back( PropertyInfo(Variant::INT,"ID"));
if (ie.type==InputEvent::KEY || ie.type==InputEvent::MOUSE_BUTTON || ie.type==InputEvent::MOUSE_MOTION) {
p_list->push_back( PropertyInfo(Variant::BOOL,"shift"));
p_list->push_back( PropertyInfo(Variant::BOOL,"alt"));
p_list->push_back( PropertyInfo(Variant::BOOL,"control"));
p_list->push_back( PropertyInfo(Variant::BOOL,"meta"));
}
if (ie.type==InputEvent::KEY) {
p_list->push_back( PropertyInfo(Variant::BOOL,"pressed") );
p_list->push_back( PropertyInfo(Variant::BOOL,"echo") );
p_list->push_back( PropertyInfo(Variant::INT,"scancode") );
p_list->push_back( PropertyInfo(Variant::INT,"unicode") );
}
if (ie.type==InputEvent::MOUSE_MOTION || ie.type==InputEvent::MOUSE_BUTTON) {
p_list->push_back( PropertyInfo(Variant::INT,"button_mask") );
p_list->push_back( PropertyInfo(Variant::INT,"x") );
p_list->push_back( PropertyInfo(Variant::INT,"y") );
p_list->push_back( PropertyInfo(Variant::VECTOR2,"pos") );
p_list->push_back( PropertyInfo(Variant::INT,"global_x") );
p_list->push_back( PropertyInfo(Variant::INT,"global_y") );
p_list->push_back( PropertyInfo(Variant::VECTOR2,"global_pos") );
if (ie.type==InputEvent::MOUSE_MOTION) {
p_list->push_back( PropertyInfo(Variant::INT,"relative_x") );
p_list->push_back( PropertyInfo(Variant::INT,"relative_y") );
p_list->push_back( PropertyInfo(Variant::VECTOR2,"relative_pos") );
p_list->push_back( PropertyInfo(Variant::REAL,"speed_x") );
p_list->push_back( PropertyInfo(Variant::REAL,"speed_y") );
p_list->push_back( PropertyInfo(Variant::VECTOR2,"speed") );
} else if (ie.type==InputEvent::MOUSE_BUTTON) {
p_list->push_back( PropertyInfo(Variant::INT,"button_index") );
p_list->push_back( PropertyInfo(Variant::BOOL,"pressed") );
p_list->push_back( PropertyInfo(Variant::BOOL,"doubleclick") );
}
}
if (ie.type==InputEvent::JOYSTICK_BUTTON) {
p_list->push_back( PropertyInfo(Variant::INT,"button_index") );
p_list->push_back( PropertyInfo(Variant::BOOL,"pressed") );
p_list->push_back( PropertyInfo(Variant::REAL,"pressure") );
}
if (ie.type==InputEvent::JOYSTICK_MOTION) {
p_list->push_back( PropertyInfo(Variant::INT,"axis") );
p_list->push_back( PropertyInfo(Variant::REAL,"value") );
}
if (ie.type==InputEvent::SCREEN_TOUCH) {
p_list->push_back( PropertyInfo(Variant::INT,"index") );
p_list->push_back( PropertyInfo(Variant::REAL,"x") );
p_list->push_back( PropertyInfo(Variant::REAL,"y") );
p_list->push_back( PropertyInfo(Variant::VECTOR2,"pos") );
p_list->push_back( PropertyInfo(Variant::BOOL,"pressed") );
}
if (ie.type==InputEvent::SCREEN_DRAG) {
p_list->push_back( PropertyInfo(Variant::INT,"index") );
p_list->push_back( PropertyInfo(Variant::REAL,"x") );
p_list->push_back( PropertyInfo(Variant::REAL,"y") );
p_list->push_back( PropertyInfo(Variant::VECTOR2,"pos") );
p_list->push_back( PropertyInfo(Variant::REAL,"relative_x") );
p_list->push_back( PropertyInfo(Variant::REAL,"relative_y") );
p_list->push_back( PropertyInfo(Variant::VECTOR2,"relative_pos") );
p_list->push_back( PropertyInfo(Variant::REAL,"speed_x") );
p_list->push_back( PropertyInfo(Variant::REAL,"speed_y") );
p_list->push_back( PropertyInfo(Variant::VECTOR2,"speed") );
}
} break;
case DICTIONARY: {
const Dictionary *dic=reinterpret_cast<const Dictionary*>(_data._mem);
List<Variant> keys;
dic->get_key_list(&keys);
for(List<Variant>::Element *E=keys.front();E;E=E->next()) {
if (E->get().get_type()==Variant::STRING) {
p_list->push_back(PropertyInfo(Variant::STRING,E->get()));
}
}
} break; // 20
case ARRAY:
case RAW_ARRAY:
case INT_ARRAY:
case REAL_ARRAY:
case STRING_ARRAY:
case VECTOR3_ARRAY:
case COLOR_ARRAY: {
//nothing
} break;
default: {}
}
}
bool Variant::iter_init(Variant& r_iter,bool &valid) const {
valid=true;
switch(type) {
case OBJECT: {
#ifdef DEBUG_ENABLED
if (!_get_obj().obj) {
valid=false;
return false;
}
if (ScriptDebugger::get_singleton() && _get_obj().ref.is_null() && !ObjectDB::instance_validate(_get_obj().obj)) {
valid=false;
return false;
}
#endif
Variant::CallError ce;
ce.error=Variant::CallError::CALL_OK;
Array ref(true);
ref.push_back(r_iter);
Variant vref=ref;
const Variant *refp[]={&vref};
Light Baker! -=-=-=-=-=-= -Support for lightmap baker, have fun figuring out how it works before tutorial is published.
2014-06-11 15:41:03 +02:00
Variant ret = _get_obj().obj->call(CoreStringNames::get_singleton()->_iter_init,refp,1,ce);
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
if (ref.size()!=1 || ce.error!=Variant::CallError::CALL_OK) {
valid=false;
return false;
}
r_iter=ref[0];
return ret;
} break;
Add support to String type in gdscript iteration. #5188
2016-06-26 22:03:42 +02:00
case STRING: {
const String *str=reinterpret_cast<const String*>(_data._mem);
if (str->empty())
return false;
r_iter = 0;
return true;
} break;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
case DICTIONARY: {
const Dictionary *dic=reinterpret_cast<const Dictionary*>(_data._mem);
if (dic->empty())
return false;
const Variant *next=dic->next(NULL);
r_iter=*next;
return true;
} break;
case ARRAY: {
const Array *arr=reinterpret_cast<const Array*>(_data._mem);
if (arr->empty())
return false;
r_iter=0;
return true;
} break;
case RAW_ARRAY: {
const DVector<uint8_t> *arr=reinterpret_cast<const DVector<uint8_t>*>(_data._mem);
if (arr->size()==0)
return false;
r_iter=0;
return true;
} break;
case INT_ARRAY: {
const DVector<int> *arr=reinterpret_cast<const DVector<int>*>(_data._mem);
if (arr->size()==0)
return false;
r_iter=0;
return true;
} break;
case REAL_ARRAY: {
const DVector<real_t> *arr=reinterpret_cast<const DVector<real_t>*>(_data._mem);
if (arr->size()==0)
return false;
r_iter=0;
return true;
} break;
case STRING_ARRAY: {
const DVector<String> *arr=reinterpret_cast<const DVector<String>*>(_data._mem);
if (arr->size()==0)
return false;
r_iter=0;
return true;
} break;
case VECTOR2_ARRAY: {
const DVector<Vector2> *arr=reinterpret_cast<const DVector<Vector2>*>(_data._mem);
if (arr->size()==0)
return false;
r_iter=0;
return true;
} break;
case VECTOR3_ARRAY: {
const DVector<Vector3> *arr=reinterpret_cast<const DVector<Vector3>*>(_data._mem);
if (arr->size()==0)
return false;
r_iter=0;
return true;
} break;
case COLOR_ARRAY: {
const DVector<Color> *arr=reinterpret_cast<const DVector<Color>*>(_data._mem);
if (arr->size()==0)
return false;
r_iter=0;
return true;
} break;
Fix warnings in core/variant_op.cpp Adds default cases in switches where needed, and replaces '0;' with ';;' in macro expansions (as suggested by @vnen in #5587).
2016-07-23 14:47:49 +02:00
default: {}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
}
valid=false;
return false;
}
bool Variant::iter_next(Variant& r_iter,bool &valid) const {
valid=true;
switch(type) {
case OBJECT: {
#ifdef DEBUG_ENABLED
if (!_get_obj().obj) {
valid=false;
return false;
}
if (ScriptDebugger::get_singleton() && _get_obj().ref.is_null() && !ObjectDB::instance_validate(_get_obj().obj)) {
valid=false;
return false;
}
#endif
Variant::CallError ce;
ce.error=Variant::CallError::CALL_OK;
Array ref(true);
ref.push_back(r_iter);
Variant vref=ref;
const Variant *refp[]={&vref};
Variant ret = _get_obj().obj->call(CoreStringNames::get_singleton()->_iter_next,refp,1,ce);
if (ref.size()!=1 || ce.error!=Variant::CallError::CALL_OK) {
valid=false;
return false;
}
r_iter=ref[0];
return ret;
} break;
Add support to String type in gdscript iteration. #5188
2016-06-26 22:03:42 +02:00
case STRING: {
const String *str=reinterpret_cast<const String*>(_data._mem);
int idx = r_iter;
idx++;
if (idx >= str->size())
return false;
r_iter = idx;
return true;
} break;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
case DICTIONARY: {
const Dictionary *dic=reinterpret_cast<const Dictionary*>(_data._mem);
const Variant *next=dic->next(&r_iter);
if (!next)
return false;
r_iter=*next;
return true;
} break;
case ARRAY: {
const Array *arr=reinterpret_cast<const Array*>(_data._mem);
int idx=r_iter;
idx++;
if (idx>=arr->size())
return false;
r_iter=idx;
return true;
} break;
case RAW_ARRAY: {
const DVector<uint8_t> *arr=reinterpret_cast<const DVector<uint8_t>*>(_data._mem);
int idx=r_iter;
idx++;
if (idx>=arr->size())
return false;
r_iter=idx;
return true;
} break;
case INT_ARRAY: {
const DVector<int> *arr=reinterpret_cast<const DVector<int>*>(_data._mem);
int idx=r_iter;
idx++;
if (idx>=arr->size())
return false;
r_iter=idx;
return true;
} break;
case REAL_ARRAY: {
const DVector<real_t> *arr=reinterpret_cast<const DVector<real_t>*>(_data._mem);
int idx=r_iter;
idx++;
if (idx>=arr->size())
return false;
r_iter=idx;
return true;
} break;
case STRING_ARRAY: {
const DVector<String> *arr=reinterpret_cast<const DVector<String>*>(_data._mem);
int idx=r_iter;
idx++;
if (idx>=arr->size())
return false;
r_iter=idx;
return true;
} break;
case VECTOR2_ARRAY: {
const DVector<Vector2> *arr=reinterpret_cast<const DVector<Vector2>*>(_data._mem);
int idx=r_iter;
idx++;
if (idx>=arr->size())
return false;
r_iter=idx;
return true;
} break;
case VECTOR3_ARRAY: {
const DVector<Vector3> *arr=reinterpret_cast<const DVector<Vector3>*>(_data._mem);
int idx=r_iter;
idx++;
if (idx>=arr->size())
return false;
r_iter=idx;
return true;
} break;
case COLOR_ARRAY: {
const DVector<Color> *arr=reinterpret_cast<const DVector<Color>*>(_data._mem);
int idx=r_iter;
idx++;
if (idx>=arr->size())
return false;
r_iter=idx;
return true;
} break;
Fix warnings in core/variant_op.cpp Adds default cases in switches where needed, and replaces '0;' with ';;' in macro expansions (as suggested by @vnen in #5587).
2016-07-23 14:47:49 +02:00
default: {}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
}
valid=false;
return false;
}
Variant Variant::iter_get(const Variant& r_iter,bool &r_valid) const {
r_valid=true;
switch(type) {
case OBJECT: {
#ifdef DEBUG_ENABLED
if (!_get_obj().obj) {
r_valid=false;
return Variant();
}
if (ScriptDebugger::get_singleton() && _get_obj().ref.is_null() && !ObjectDB::instance_validate(_get_obj().obj)) {
r_valid=false;
return Variant();
}
#endif
Variant::CallError ce;
ce.error=Variant::CallError::CALL_OK;
const Variant *refp[]={&r_iter};
Variant ret = _get_obj().obj->call(CoreStringNames::get_singleton()->_iter_get,refp,1,ce);
if (ce.error!=Variant::CallError::CALL_OK) {
r_valid=false;
return Variant();
}
//r_iter=ref[0];
return ret;
} break;
Add support to String type in gdscript iteration. #5188
2016-06-26 22:03:42 +02:00
case STRING: {
const String *str=reinterpret_cast<const String*>(_data._mem);
return str->substr(r_iter,1);
} break;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
case DICTIONARY: {
return r_iter; //iterator is the same as the key
} break;
case ARRAY: {
const Array *arr=reinterpret_cast<const Array*>(_data._mem);
int idx=r_iter;
#ifdef DEBUG_ENABLED
if (idx<0 || idx>=arr->size()) {
r_valid=false;
return Variant();
}
#endif
return arr->get(idx);
} break;
case RAW_ARRAY: {
const DVector<uint8_t> *arr=reinterpret_cast<const DVector<uint8_t>*>(_data._mem);
int idx=r_iter;
#ifdef DEBUG_ENABLED
if (idx<0 || idx>=arr->size()) {
r_valid=false;
return Variant();
}
#endif
return arr->get(idx);
} break;
case INT_ARRAY: {
const DVector<int> *arr=reinterpret_cast<const DVector<int>*>(_data._mem);
int idx=r_iter;
#ifdef DEBUG_ENABLED
if (idx<0 || idx>=arr->size()) {
r_valid=false;
return Variant();
}
#endif
return arr->get(idx);
} break;
case REAL_ARRAY: {
const DVector<real_t> *arr=reinterpret_cast<const DVector<real_t>*>(_data._mem);
int idx=r_iter;
#ifdef DEBUG_ENABLED
if (idx<0 || idx>=arr->size()) {
r_valid=false;
return Variant();
}
#endif
return arr->get(idx);
} break;
case STRING_ARRAY: {
const DVector<String> *arr=reinterpret_cast<const DVector<String>*>(_data._mem);
int idx=r_iter;
#ifdef DEBUG_ENABLED
if (idx<0 || idx>=arr->size()) {
r_valid=false;
return Variant();
}
#endif
return arr->get(idx);
} break;
case VECTOR2_ARRAY: {
const DVector<Vector2> *arr=reinterpret_cast<const DVector<Vector2>*>(_data._mem);
int idx=r_iter;
#ifdef DEBUG_ENABLED
if (idx<0 || idx>=arr->size()) {
r_valid=false;
return Variant();
}
#endif
return arr->get(idx);
} break;
case VECTOR3_ARRAY: {
const DVector<Vector3> *arr=reinterpret_cast<const DVector<Vector3>*>(_data._mem);
int idx=r_iter;
#ifdef DEBUG_ENABLED
if (idx<0 || idx>=arr->size()) {
r_valid=false;
return Variant();
}
#endif
return arr->get(idx);
} break;
case COLOR_ARRAY: {
const DVector<Color> *arr=reinterpret_cast<const DVector<Color>*>(_data._mem);
int idx=r_iter;
#ifdef DEBUG_ENABLED
if (idx<0 || idx>=arr->size()) {
r_valid=false;
return Variant();
}
#endif
return arr->get(idx);
} break;
Fix warnings in core/variant_op.cpp Adds default cases in switches where needed, and replaces '0;' with ';;' in macro expansions (as suggested by @vnen in #5587).
2016-07-23 14:47:49 +02:00
default: {}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
}
r_valid=false;
return Variant();
}
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::blend(const Variant& a, const Variant& b, float c, Variant &r_dst) {
if (a.type!=b.type) {
if(a.is_num() && b.is_num()) {
real_t va=a;
real_t vb=b;
r_dst=va + vb * c;
} else {
r_dst=a;
}
return;
}
switch(a.type) {
case NIL: { r_dst=Variant(); } return;
case INT:{
int va=a._data._int;
int vb=b._data._int;
r_dst=int(va + vb * c + 0.5);
} return;
case REAL:{
double ra=a._data._real;
double rb=b._data._real;
r_dst=ra + rb * c;
} return;
case VECTOR2:{ r_dst=*reinterpret_cast<const Vector2*>(a._data._mem)+*reinterpret_cast<const Vector2*>(b._data._mem)*c; } return;
case RECT2:{
const Rect2 *ra = reinterpret_cast<const Rect2*>(a._data._mem);
const Rect2 *rb = reinterpret_cast<const Rect2*>(b._data._mem);
r_dst=Rect2(ra->pos + rb->pos * c, ra->size + rb->size * c);
} return;
Variant::blend: add Quat, fix Vector3.
2016-03-08 12:38:19 +01:00
case VECTOR3:{ r_dst=*reinterpret_cast<const Vector3*>(a._data._mem)+*reinterpret_cast<const Vector3*>(b._data._mem)*c; } return;
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
case _AABB:{
const AABB *ra = reinterpret_cast<const AABB*>(a._data._mem);
const AABB *rb = reinterpret_cast<const AABB*>(b._data._mem);
r_dst=AABB(ra->pos + rb->pos * c, ra->size + rb->size * c);
} return;
Variant::blend: add Quat, fix Vector3.
2016-03-08 12:38:19 +01:00
case QUAT:{
Quat empty_rot;
const Quat *qa = reinterpret_cast<const Quat*>(a._data._mem);
const Quat *qb = reinterpret_cast<const Quat*>(b._data._mem);
r_dst=*qa * empty_rot.slerp(*qb,c);
} return;
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
case COLOR:{
const Color *ca = reinterpret_cast<const Color*>(a._data._mem);
const Color *cb = reinterpret_cast<const Color*>(b._data._mem);
float r = ca->r + cb->r * c;
float g = ca->g + cb->g * c;
float b = ca->b + cb->b * c;
float a = ca->a + cb->a * c;
r = r > 1.0 ? 1.0 : r;
g = g > 1.0 ? 1.0 : g;
b = b > 1.0 ? 1.0 : b;
a = a > 1.0 ? 1.0 : a;
r_dst=Color(r, g, b, a);
} return;
default:{ r_dst = c<0.5 ? a : b; } return;
}
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
void Variant::interpolate(const Variant& a, const Variant& b, float c,Variant &r_dst) {
if (a.type!=b.type) {
-Integers and Float should interpolate on animation, maybe fixes #1891, please test
2015-05-16 23:16:11 +02:00
if (a.is_num() && b.is_num()) {
//not as efficient but..
real_t va=a;
real_t vb=b;
r_dst=(1.0-c) * va + vb * c;
} else {
r_dst=a;
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
return;
}
switch(a.type) {
case NIL:{ r_dst=Variant(); } return;
case BOOL:{ r_dst=a; } return;
case INT:{
int va=a._data._int;
int vb=b._data._int;
Removing round from int interpolation This might break some animations that use int tracks in continuous mode, but it should provide a more uniform interpolation for things like sprite frames.
2016-05-17 18:27:49 +02:00
r_dst=int((1.0-c) * va + vb * c);
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
} return;
case REAL:{
real_t va=a._data._real;
real_t vb=b._data._real;
r_dst=(1.0-c) * va + vb * c;
} return;
case STRING:{
//this is pretty funny and bizarre, but artists like to use it for typewritter effects
String sa = *reinterpret_cast<const String*>(a._data._mem);
String sb = *reinterpret_cast<const String*>(b._data._mem);
String dst;
int csize=sb.length() * c + sa.length() * (1.0-c);
if (csize==0) {
r_dst="";
return;
}
dst.resize(csize+1);
dst[csize]=0;
int split = csize/2;
for(int i=0;i<csize;i++) {
CharType chr=' ';
if (i<split) {
if (i<sa.length())
chr=sa[i];
else if (i<sb.length())
chr=sb[i];
} else {
if (i<sb.length())
chr=sb[i];
else if (i<sa.length())
chr=sa[i];
}
dst[i]=chr;
}
r_dst=dst;
} return;
case VECTOR2:{ r_dst=reinterpret_cast<const Vector2*>(a._data._mem)->linear_interpolate(*reinterpret_cast<const Vector2*>(b._data._mem),c); } return;
case RECT2:{ r_dst = Rect2( reinterpret_cast<const Rect2*>(a._data._mem)->pos.linear_interpolate(reinterpret_cast<const Rect2*>(b._data._mem)->pos,c), reinterpret_cast<const Rect2*>(a._data._mem)->size.linear_interpolate(reinterpret_cast<const Rect2*>(b._data._mem)->size,c) ); } return;
case VECTOR3:{ r_dst=reinterpret_cast<const Vector3*>(a._data._mem)->linear_interpolate(*reinterpret_cast<const Vector3*>(b._data._mem),c); } return;
case MATRIX32:{ r_dst=a._data._matrix32->interpolate_with(*b._data._matrix32,c); } return;
case PLANE:{ r_dst=a; } return;
case QUAT:{ r_dst=reinterpret_cast<const Quat*>(a._data._mem)->slerp(*reinterpret_cast<const Quat*>(b._data._mem),c); } return;
case _AABB:{ r_dst=AABB( a._data._aabb->pos.linear_interpolate(b._data._aabb->pos,c), a._data._aabb->size.linear_interpolate(b._data._aabb->size,c) ); } return;
case MATRIX3:{ r_dst=Transform(*a._data._matrix3).interpolate_with(Transform(*b._data._matrix3),c).basis; } return;
case TRANSFORM:{ r_dst=a._data._transform->interpolate_with(*b._data._transform,c); } return;
case COLOR:{ r_dst=reinterpret_cast<const Color*>(a._data._mem)->linear_interpolate(*reinterpret_cast<const Color*>(b._data._mem),c); } return;
case IMAGE:{ r_dst=a; } return;
case NODE_PATH:{ r_dst=a; } return;
case _RID:{ r_dst=a; } return;
case OBJECT:{ r_dst=a; } return;
case INPUT_EVENT:{ r_dst=a; } return;
case DICTIONARY:{ } return;
case ARRAY:{ r_dst=a; } return;
case RAW_ARRAY:{ r_dst=a; } return;
case INT_ARRAY:{ r_dst=a; } return;
case REAL_ARRAY:{ r_dst=a; } return;
case STRING_ARRAY:{ r_dst=a; } return;
Polygon2D -=-=-=-=- Another gift for those who make 2D games: -Edit polygons, concave or convex, color them, texture them and uv-map them -Corresponding editor -Can have a custom pivot, so they are compatible with bones and IK
2014-07-07 22:44:21 +02:00
case VECTOR2_ARRAY:{
const DVector<Vector2> *arr_a=reinterpret_cast<const DVector<Vector2>* >(a._data._mem);
const DVector<Vector2> *arr_b=reinterpret_cast<const DVector<Vector2>* >(b._data._mem);
int sz = arr_a->size();
if (sz==0 || arr_b->size()!=sz) {
r_dst=a;
} else {
DVector<Vector2> v;
v.resize(sz);
{
DVector<Vector2>::Write vw=v.write();
DVector<Vector2>::Read ar=arr_a->read();
DVector<Vector2>::Read br=arr_b->read();
for(int i=0;i<sz;i++) {
vw[i]=ar[i].linear_interpolate(br[i],c);
}
}
r_dst=v;
}
} return;
case VECTOR3_ARRAY:{
const DVector<Vector3> *arr_a=reinterpret_cast<const DVector<Vector3>* >(a._data._mem);
const DVector<Vector3> *arr_b=reinterpret_cast<const DVector<Vector3>* >(b._data._mem);
int sz = arr_a->size();
if (sz==0 || arr_b->size()!=sz) {
r_dst=a;
} else {
DVector<Vector3> v;
v.resize(sz);
{
DVector<Vector3>::Write vw=v.write();
DVector<Vector3>::Read ar=arr_a->read();
DVector<Vector3>::Read br=arr_b->read();
for(int i=0;i<sz;i++) {
vw[i]=ar[i].linear_interpolate(br[i],c);
}
}
r_dst=v;
}
} return;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
case COLOR_ARRAY:{ r_dst=a; } return;
default: {
r_dst=a;
}
}
}
static const char *_op_names[Variant::OP_MAX]={
"==",
"!=",
"<",
"<=",
">",
">=",
"+",
"-",
"*",
"/",
"- (negation)",
"%",
"..",
"<<",
">>",
"&",
"|",
"^",
"~",
"and",
"or",
"xor",
"not",
"in"
};
String Variant::get_operator_name(Operator p_op) {
ERR_FAIL_INDEX_V(p_op,OP_MAX,"");
return _op_names[p_op];
}
Reference in a new issue Copy permalink