godotengine
/
godot
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
godot/core/variant_op.cpp

3762 lines
114 KiB
C++
Raw Normal View History

GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
/*************************************************************************/
/* variant_op.cpp */
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
Use HTTPS URL for Godot's website in the headers
2017-08-27 12:16:55 +00:00
/* https://godotengine.org */
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
/*************************************************************************/
Update copyright statements to 2018 Happy new year to the wonderful Godot community!
2018-01-01 13:40:08 +00:00
/* Copyright (c) 2007-2018 Juan Linietsky, Ariel Manzur. */
/* Copyright (c) 2014-2018 Godot Engine contributors (cf. AUTHORS.md) */
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
/* */
/* Permission is hereby granted, free of charge, to any person obtaining */
/* a copy of this software and associated documentation files (the */
/* "Software"), to deal in the Software without restriction, including */
/* without limitation the rights to use, copy, modify, merge, publish, */
/* distribute, sublicense, and/or sell copies of the Software, and to */
/* permit persons to whom the Software is furnished to do so, subject to */
/* the following conditions: */
/* */
/* The above copyright notice and this permission notice shall be */
/* included in all copies or substantial portions of the Software. */
/* */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/*************************************************************************/
Add missing copyright headers and fix formatting Using `misc/scripts/fix_headers.py` on all Godot files. Some missing header guards were added, and the header inclusion order was fixed in the Bullet module.
2018-01-04 23:50:27 +00:00
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
#include "variant.h"
Style: Cleanups, added headers, renamed files Made sure files in core/ and tools/ have a proper Godot license header when written by us. Also renamed aabb.{cpp,h} and object_type_db.{cpp,h} to rect3.{cpp,h} and class_db.{cpp,h} respectively. Also added a proper header to core/io/base64.{c,h} after clarifying the licensing with the original author (public domain).
2017-01-16 07:04:19 +00:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
#include "core_string_names.h"
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
#include "object.h"
#include "script_language.h"
Style: Cleanups, added headers, renamed files Made sure files in core/ and tools/ have a proper Godot license header when written by us. Also renamed aabb.{cpp,h} and object_type_db.{cpp,h} to rect3.{cpp,h} and class_db.{cpp,h} respectively. Also added a proper header to core/io/base64.{c,h} after clarifying the licensing with the original author (public domain).
2017-01-16 07:04:19 +00:00
Move Variant::evaluate() switch to computed goto In an effort to make GDScript a little faster replace the double switch() with a computed goto on compilers that set __GNUC__. For compilers that don't support computed goto it will fall back to regular switch/case statements. In addition disable using boolean values in a mathematical context. Now boolean values can only be compared with other booleans. Booleans will also no longer be coerced to integers. This PR replaces #11308 and fixes #11291
2017-09-17 00:32:05 +00:00
#define CASE_TYPE_ALL(PREFIX, OP) \
CASE_TYPE(PREFIX, OP, INT) \
CASE_TYPE_ALL_BUT_INT(PREFIX, OP)
#define CASE_TYPE_ALL_BUT_INT(PREFIX, OP) \
CASE_TYPE(PREFIX, OP, NIL) \
CASE_TYPE(PREFIX, OP, BOOL) \
CASE_TYPE(PREFIX, OP, REAL) \
CASE_TYPE(PREFIX, OP, STRING) \
CASE_TYPE(PREFIX, OP, VECTOR2) \
CASE_TYPE(PREFIX, OP, RECT2) \
CASE_TYPE(PREFIX, OP, VECTOR3) \
CASE_TYPE(PREFIX, OP, TRANSFORM2D) \
CASE_TYPE(PREFIX, OP, PLANE) \
CASE_TYPE(PREFIX, OP, QUAT) \
Rename Rect3 to AABB. Fixes #12973.
2017-11-17 02:09:00 +00:00
CASE_TYPE(PREFIX, OP, AABB) \
Move Variant::evaluate() switch to computed goto In an effort to make GDScript a little faster replace the double switch() with a computed goto on compilers that set __GNUC__. For compilers that don't support computed goto it will fall back to regular switch/case statements. In addition disable using boolean values in a mathematical context. Now boolean values can only be compared with other booleans. Booleans will also no longer be coerced to integers. This PR replaces #11308 and fixes #11291
2017-09-17 00:32:05 +00:00
CASE_TYPE(PREFIX, OP, BASIS) \
CASE_TYPE(PREFIX, OP, TRANSFORM) \
CASE_TYPE(PREFIX, OP, COLOR) \
CASE_TYPE(PREFIX, OP, NODE_PATH) \
CASE_TYPE(PREFIX, OP, _RID) \
CASE_TYPE(PREFIX, OP, OBJECT) \
CASE_TYPE(PREFIX, OP, DICTIONARY) \
CASE_TYPE(PREFIX, OP, ARRAY) \
CASE_TYPE(PREFIX, OP, POOL_BYTE_ARRAY) \
CASE_TYPE(PREFIX, OP, POOL_INT_ARRAY) \
CASE_TYPE(PREFIX, OP, POOL_REAL_ARRAY) \
CASE_TYPE(PREFIX, OP, POOL_STRING_ARRAY) \
CASE_TYPE(PREFIX, OP, POOL_VECTOR2_ARRAY) \
CASE_TYPE(PREFIX, OP, POOL_VECTOR3_ARRAY) \
CASE_TYPE(PREFIX, OP, POOL_COLOR_ARRAY)
#ifdef __GNUC__
#define TYPE(PREFIX, OP, TYPE) &&PREFIX##_##OP##_##TYPE
/* clang-format off */
#define TYPES(PREFIX, OP) { \
TYPE(PREFIX, OP, NIL), \
TYPE(PREFIX, OP, BOOL), \
TYPE(PREFIX, OP, INT), \
TYPE(PREFIX, OP, REAL), \
TYPE(PREFIX, OP, STRING), \
TYPE(PREFIX, OP, VECTOR2), \
TYPE(PREFIX, OP, RECT2), \
TYPE(PREFIX, OP, VECTOR3), \
TYPE(PREFIX, OP, TRANSFORM2D), \
TYPE(PREFIX, OP, PLANE), \
TYPE(PREFIX, OP, QUAT), \
Rename Rect3 to AABB. Fixes #12973.
2017-11-17 02:09:00 +00:00
TYPE(PREFIX, OP, AABB), \
Move Variant::evaluate() switch to computed goto In an effort to make GDScript a little faster replace the double switch() with a computed goto on compilers that set __GNUC__. For compilers that don't support computed goto it will fall back to regular switch/case statements. In addition disable using boolean values in a mathematical context. Now boolean values can only be compared with other booleans. Booleans will also no longer be coerced to integers. This PR replaces #11308 and fixes #11291
2017-09-17 00:32:05 +00:00
TYPE(PREFIX, OP, BASIS), \
TYPE(PREFIX, OP, TRANSFORM), \
TYPE(PREFIX, OP, COLOR), \
TYPE(PREFIX, OP, NODE_PATH), \
TYPE(PREFIX, OP, _RID), \
TYPE(PREFIX, OP, OBJECT), \
TYPE(PREFIX, OP, DICTIONARY), \
TYPE(PREFIX, OP, ARRAY), \
TYPE(PREFIX, OP, POOL_BYTE_ARRAY), \
TYPE(PREFIX, OP, POOL_INT_ARRAY), \
TYPE(PREFIX, OP, POOL_REAL_ARRAY), \
TYPE(PREFIX, OP, POOL_STRING_ARRAY), \
TYPE(PREFIX, OP, POOL_VECTOR2_ARRAY), \
TYPE(PREFIX, OP, POOL_VECTOR3_ARRAY), \
TYPE(PREFIX, OP, POOL_COLOR_ARRAY), \
}
/* clang-format on */
Make variant_op jumptable const Not doing this was a bit of an oversight
2017-09-25 16:29:44 +00:00
#define CASES(PREFIX) static const void *switch_table_##PREFIX[25][27] = { \
TYPES(PREFIX, OP_EQUAL), \
TYPES(PREFIX, OP_NOT_EQUAL), \
TYPES(PREFIX, OP_LESS), \
TYPES(PREFIX, OP_LESS_EQUAL), \
TYPES(PREFIX, OP_GREATER), \
TYPES(PREFIX, OP_GREATER_EQUAL), \
TYPES(PREFIX, OP_ADD), \
TYPES(PREFIX, OP_SUBTRACT), \
TYPES(PREFIX, OP_MULTIPLY), \
TYPES(PREFIX, OP_DIVIDE), \
TYPES(PREFIX, OP_NEGATE), \
TYPES(PREFIX, OP_POSITIVE), \
TYPES(PREFIX, OP_MODULE), \
TYPES(PREFIX, OP_STRING_CONCAT), \
TYPES(PREFIX, OP_SHIFT_LEFT), \
TYPES(PREFIX, OP_SHIFT_RIGHT), \
TYPES(PREFIX, OP_BIT_AND), \
TYPES(PREFIX, OP_BIT_OR), \
TYPES(PREFIX, OP_BIT_XOR), \
TYPES(PREFIX, OP_BIT_NEGATE), \
TYPES(PREFIX, OP_AND), \
TYPES(PREFIX, OP_OR), \
TYPES(PREFIX, OP_XOR), \
TYPES(PREFIX, OP_NOT), \
TYPES(PREFIX, OP_IN), \
Move Variant::evaluate() switch to computed goto In an effort to make GDScript a little faster replace the double switch() with a computed goto on compilers that set __GNUC__. For compilers that don't support computed goto it will fall back to regular switch/case statements. In addition disable using boolean values in a mathematical context. Now boolean values can only be compared with other booleans. Booleans will also no longer be coerced to integers. This PR replaces #11308 and fixes #11291
2017-09-17 00:32:05 +00:00
}
#define SWITCH(PREFIX, op, val) goto *switch_table_##PREFIX[op][val];
#define SWITCH_OP(PREFIX, OP, val)
#define CASE_TYPE(PREFIX, OP, TYPE) PREFIX##_##OP##_##TYPE:
#else
#define CASES(PREFIX)
#define SWITCH(PREFIX, op, val) switch (op)
#define SWITCH_OP(PREFIX, OP, val) \
case OP: \
switch (val)
#define CASE_TYPE(PREFIX, OP, TYPE) case TYPE:
#endif
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
Variant::operator bool() const {
Allow booleanization of all types We now allow booleanization of all types. This means that empty versions of all types now evaluate to false. So a Vector2(0,0), Dictionary(), etc. This allows you to write GDScript like: if not Dictionary(): print("Empty dict") Booleanization can now also no longer fail. There is no more valid flag, this changes Variant and GDNative API.
2017-09-18 18:02:47 +00:00
return booleanize();
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
}
Fix typos with codespell Found via `codespell -q 3 --skip="./thirdparty,./editor/translations" -I ../godot-word-whitelist.txt` Whitelist consists of: ``` ang doubleclick lod nd que te unselect ```
2018-02-21 16:30:55 +00:00
// We consider all uninitialized or empty types to be false based on the type's
Allow booleanization of all types We now allow booleanization of all types. This means that empty versions of all types now evaluate to false. So a Vector2(0,0), Dictionary(), etc. This allows you to write GDScript like: if not Dictionary(): print("Empty dict") Booleanization can now also no longer fail. There is no more valid flag, this changes Variant and GDNative API.
2017-09-18 18:02:47 +00:00
// zeroiness.
bool Variant::booleanize() const {
return !is_zero();
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
#define _RETURN(m_what) \
{ \
r_ret = m_what; \
return; \
}
Revert "Make nan==nan true for GDScript"
2017-02-14 20:05:16 +00:00
Move Variant::evaluate() switch to computed goto In an effort to make GDScript a little faster replace the double switch() with a computed goto on compilers that set __GNUC__. For compilers that don't support computed goto it will fall back to regular switch/case statements. In addition disable using boolean values in a mathematical context. Now boolean values can only be compared with other booleans. Booleans will also no longer be coerced to integers. This PR replaces #11308 and fixes #11291
2017-09-17 00:32:05 +00:00
#define _RETURN_FAIL \
{ \
r_valid = false; \
return; \
}
Allow equality checks between null and arbitrary types Uninitialzed values in GDScript are of type NIL so not allowing null comparisons did end up breaking some code. This commit reenables NULL equality checks for all types. We're going to have to figure out how to make this fast for the compiler later.
2017-09-20 09:32:47 +00:00
#define DEFAULT_OP_NUM(m_prefix, m_op_name, m_name, m_op, m_type) \
CASE_TYPE(m_prefix, m_op_name, m_name) { \
if (p_b.type == INT) _RETURN(p_a._data.m_type m_op p_b._data._int); \
if (p_b.type == REAL) _RETURN(p_a._data.m_type m_op p_b._data._real); \
\
_RETURN_FAIL \
};
#define DEFAULT_OP_NUM_NULL(m_prefix, m_op_name, m_name, m_op, m_type) \
CASE_TYPE(m_prefix, m_op_name, m_name) { \
if (p_b.type == INT) _RETURN(p_a._data.m_type m_op p_b._data._int); \
if (p_b.type == REAL) _RETURN(p_a._data.m_type m_op p_b._data._real); \
Fix a potential bug hinted by clang
2018-03-09 19:19:25 +00:00
if (p_b.type == NIL) _RETURN(!(p_b.type m_op NIL)); \
Allow equality checks between null and arbitrary types Uninitialzed values in GDScript are of type NIL so not allowing null comparisons did end up breaking some code. This commit reenables NULL equality checks for all types. We're going to have to figure out how to make this fast for the compiler later.
2017-09-20 09:32:47 +00:00
\
_RETURN_FAIL \
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
};
Move Variant::evaluate() switch to computed goto In an effort to make GDScript a little faster replace the double switch() with a computed goto on compilers that set __GNUC__. For compilers that don't support computed goto it will fall back to regular switch/case statements. In addition disable using boolean values in a mathematical context. Now boolean values can only be compared with other booleans. Booleans will also no longer be coerced to integers. This PR replaces #11308 and fixes #11291
2017-09-17 00:32:05 +00:00
#ifdef DEBUG_ENABLED
#define DEFAULT_OP_NUM_DIV(m_prefix, m_op_name, m_name, m_type) \
CASE_TYPE(m_prefix, m_op_name, m_name) { \
Allow equality checks between null and arbitrary types Uninitialzed values in GDScript are of type NIL so not allowing null comparisons did end up breaking some code. This commit reenables NULL equality checks for all types. We're going to have to figure out how to make this fast for the compiler later.
2017-09-20 09:32:47 +00:00
if (p_b.type == INT) { \
if (p_b._data._int == 0) { \
r_valid = false; \
_RETURN("Division By Zero"); \
Move Variant::evaluate() switch to computed goto In an effort to make GDScript a little faster replace the double switch() with a computed goto on compilers that set __GNUC__. For compilers that don't support computed goto it will fall back to regular switch/case statements. In addition disable using boolean values in a mathematical context. Now boolean values can only be compared with other booleans. Booleans will also no longer be coerced to integers. This PR replaces #11308 and fixes #11291
2017-09-17 00:32:05 +00:00
} \
Allow equality checks between null and arbitrary types Uninitialzed values in GDScript are of type NIL so not allowing null comparisons did end up breaking some code. This commit reenables NULL equality checks for all types. We're going to have to figure out how to make this fast for the compiler later.
2017-09-20 09:32:47 +00:00
_RETURN(p_a._data.m_type / p_b._data._int); \
} \
if (p_b.type == REAL) { \
if (p_b._data._real == 0) { \
r_valid = false; \
_RETURN("Division By Zero"); \
Move Variant::evaluate() switch to computed goto In an effort to make GDScript a little faster replace the double switch() with a computed goto on compilers that set __GNUC__. For compilers that don't support computed goto it will fall back to regular switch/case statements. In addition disable using boolean values in a mathematical context. Now boolean values can only be compared with other booleans. Booleans will also no longer be coerced to integers. This PR replaces #11308 and fixes #11291
2017-09-17 00:32:05 +00:00
} \
Allow equality checks between null and arbitrary types Uninitialzed values in GDScript are of type NIL so not allowing null comparisons did end up breaking some code. This commit reenables NULL equality checks for all types. We're going to have to figure out how to make this fast for the compiler later.
2017-09-20 09:32:47 +00:00
_RETURN(p_a._data.m_type / p_b._data._real); \
Move Variant::evaluate() switch to computed goto In an effort to make GDScript a little faster replace the double switch() with a computed goto on compilers that set __GNUC__. For compilers that don't support computed goto it will fall back to regular switch/case statements. In addition disable using boolean values in a mathematical context. Now boolean values can only be compared with other booleans. Booleans will also no longer be coerced to integers. This PR replaces #11308 and fixes #11291
2017-09-17 00:32:05 +00:00
} \
Allow equality checks between null and arbitrary types Uninitialzed values in GDScript are of type NIL so not allowing null comparisons did end up breaking some code. This commit reenables NULL equality checks for all types. We're going to have to figure out how to make this fast for the compiler later.
2017-09-20 09:32:47 +00:00
\
_RETURN_FAIL \
Move Variant::evaluate() switch to computed goto In an effort to make GDScript a little faster replace the double switch() with a computed goto on compilers that set __GNUC__. For compilers that don't support computed goto it will fall back to regular switch/case statements. In addition disable using boolean values in a mathematical context. Now boolean values can only be compared with other booleans. Booleans will also no longer be coerced to integers. This PR replaces #11308 and fixes #11291
2017-09-17 00:32:05 +00:00
};
#else
Allow equality checks between null and arbitrary types Uninitialzed values in GDScript are of type NIL so not allowing null comparisons did end up breaking some code. This commit reenables NULL equality checks for all types. We're going to have to figure out how to make this fast for the compiler later.
2017-09-20 09:32:47 +00:00
#define DEFAULT_OP_NUM_DIV(m_prefix, m_op_name, m_name, m_type) \
CASE_TYPE(m_prefix, m_op_name, m_name) { \
if (p_b.type == INT) _RETURN(p_a._data.m_type / p_b._data._int); \
if (p_b.type == REAL) _RETURN(p_a._data.m_type / p_b._data._real); \
\
_RETURN_FAIL \
Move Variant::evaluate() switch to computed goto In an effort to make GDScript a little faster replace the double switch() with a computed goto on compilers that set __GNUC__. For compilers that don't support computed goto it will fall back to regular switch/case statements. In addition disable using boolean values in a mathematical context. Now boolean values can only be compared with other booleans. Booleans will also no longer be coerced to integers. This PR replaces #11308 and fixes #11291
2017-09-17 00:32:05 +00:00
};
#endif
#define DEFAULT_OP_NUM_NEG(m_prefix, m_op_name, m_name, m_type) \
CASE_TYPE(m_prefix, m_op_name, m_name) { \
_RETURN(-p_a._data.m_type); \
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
};
Move Variant::evaluate() switch to computed goto In an effort to make GDScript a little faster replace the double switch() with a computed goto on compilers that set __GNUC__. For compilers that don't support computed goto it will fall back to regular switch/case statements. In addition disable using boolean values in a mathematical context. Now boolean values can only be compared with other booleans. Booleans will also no longer be coerced to integers. This PR replaces #11308 and fixes #11291
2017-09-17 00:32:05 +00:00
#define DEFAULT_OP_NUM_POS(m_prefix, m_op_name, m_name, m_type) \
CASE_TYPE(m_prefix, m_op_name, m_name) { \
_RETURN(p_a._data.m_type); \
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
};
Allow equality checks between null and arbitrary types Uninitialzed values in GDScript are of type NIL so not allowing null comparisons did end up breaking some code. This commit reenables NULL equality checks for all types. We're going to have to figure out how to make this fast for the compiler later.
2017-09-20 09:32:47 +00:00
#define DEFAULT_OP_NUM_VEC(m_prefix, m_op_name, m_name, m_op, m_type) \
CASE_TYPE(m_prefix, m_op_name, m_name) { \
if (p_b.type == INT) _RETURN(p_a._data.m_type m_op p_b._data._int); \
if (p_b.type == REAL) _RETURN(p_a._data.m_type m_op p_b._data._real); \
if (p_b.type == VECTOR2) _RETURN(p_a._data.m_type m_op *reinterpret_cast<const Vector2 *>(p_b._data._mem)); \
if (p_b.type == VECTOR3) _RETURN(p_a._data.m_type m_op *reinterpret_cast<const Vector3 *>(p_b._data._mem)); \
\
_RETURN_FAIL \
};
#define DEFAULT_OP_STR_REV(m_prefix, m_op_name, m_name, m_op, m_type) \
CASE_TYPE(m_prefix, m_op_name, m_name) { \
if (p_b.type == STRING) _RETURN(*reinterpret_cast<const m_type *>(p_b._data._mem) m_op *reinterpret_cast<const String *>(p_a._data._mem)); \
if (p_b.type == NODE_PATH) _RETURN(*reinterpret_cast<const m_type *>(p_b._data._mem) m_op *reinterpret_cast<const NodePath *>(p_a._data._mem)); \
\
_RETURN_FAIL \
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
};
Allow equality checks between null and arbitrary types Uninitialzed values in GDScript are of type NIL so not allowing null comparisons did end up breaking some code. This commit reenables NULL equality checks for all types. We're going to have to figure out how to make this fast for the compiler later.
2017-09-20 09:32:47 +00:00
#define DEFAULT_OP_STR(m_prefix, m_op_name, m_name, m_op, m_type) \
CASE_TYPE(m_prefix, m_op_name, m_name) { \
if (p_b.type == STRING) _RETURN(*reinterpret_cast<const m_type *>(p_a._data._mem) m_op *reinterpret_cast<const String *>(p_b._data._mem)); \
if (p_b.type == NODE_PATH) _RETURN(*reinterpret_cast<const m_type *>(p_a._data._mem) m_op *reinterpret_cast<const NodePath *>(p_b._data._mem)); \
\
_RETURN_FAIL \
Move Variant::evaluate() switch to computed goto In an effort to make GDScript a little faster replace the double switch() with a computed goto on compilers that set __GNUC__. For compilers that don't support computed goto it will fall back to regular switch/case statements. In addition disable using boolean values in a mathematical context. Now boolean values can only be compared with other booleans. Booleans will also no longer be coerced to integers. This PR replaces #11308 and fixes #11291
2017-09-17 00:32:05 +00:00
};
Allow equality checks between null and arbitrary types Uninitialzed values in GDScript are of type NIL so not allowing null comparisons did end up breaking some code. This commit reenables NULL equality checks for all types. We're going to have to figure out how to make this fast for the compiler later.
2017-09-20 09:32:47 +00:00
#define DEFAULT_OP_STR_NULL(m_prefix, m_op_name, m_name, m_op, m_type) \
CASE_TYPE(m_prefix, m_op_name, m_name) { \
if (p_b.type == STRING) _RETURN(*reinterpret_cast<const m_type *>(p_a._data._mem) m_op *reinterpret_cast<const String *>(p_b._data._mem)); \
if (p_b.type == NODE_PATH) _RETURN(*reinterpret_cast<const m_type *>(p_a._data._mem) m_op *reinterpret_cast<const NodePath *>(p_b._data._mem)); \
Fix a potential bug hinted by clang
2018-03-09 19:19:25 +00:00
if (p_b.type == NIL) _RETURN(!(p_b.type m_op NIL)); \
Allow equality checks between null and arbitrary types Uninitialzed values in GDScript are of type NIL so not allowing null comparisons did end up breaking some code. This commit reenables NULL equality checks for all types. We're going to have to figure out how to make this fast for the compiler later.
2017-09-20 09:32:47 +00:00
\
_RETURN_FAIL \
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
};
Move Variant::evaluate() switch to computed goto In an effort to make GDScript a little faster replace the double switch() with a computed goto on compilers that set __GNUC__. For compilers that don't support computed goto it will fall back to regular switch/case statements. In addition disable using boolean values in a mathematical context. Now boolean values can only be compared with other booleans. Booleans will also no longer be coerced to integers. This PR replaces #11308 and fixes #11291
2017-09-17 00:32:05 +00:00
#define DEFAULT_OP_LOCALMEM_REV(m_prefix, m_op_name, m_name, m_op, m_type) \
CASE_TYPE(m_prefix, m_op_name, m_name) { \
if (p_b.type == m_name) \
_RETURN(*reinterpret_cast<const m_type *>(p_b._data._mem) m_op *reinterpret_cast<const m_type *>(p_a._data._mem)); \
Allow equality checks between null and arbitrary types Uninitialzed values in GDScript are of type NIL so not allowing null comparisons did end up breaking some code. This commit reenables NULL equality checks for all types. We're going to have to figure out how to make this fast for the compiler later.
2017-09-20 09:32:47 +00:00
\
_RETURN_FAIL \
Move Variant::evaluate() switch to computed goto In an effort to make GDScript a little faster replace the double switch() with a computed goto on compilers that set __GNUC__. For compilers that don't support computed goto it will fall back to regular switch/case statements. In addition disable using boolean values in a mathematical context. Now boolean values can only be compared with other booleans. Booleans will also no longer be coerced to integers. This PR replaces #11308 and fixes #11291
2017-09-17 00:32:05 +00:00
};
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
Move Variant::evaluate() switch to computed goto In an effort to make GDScript a little faster replace the double switch() with a computed goto on compilers that set __GNUC__. For compilers that don't support computed goto it will fall back to regular switch/case statements. In addition disable using boolean values in a mathematical context. Now boolean values can only be compared with other booleans. Booleans will also no longer be coerced to integers. This PR replaces #11308 and fixes #11291
2017-09-17 00:32:05 +00:00
#define DEFAULT_OP_LOCALMEM(m_prefix, m_op_name, m_name, m_op, m_type) \
CASE_TYPE(m_prefix, m_op_name, m_name) { \
if (p_b.type == m_name) \
_RETURN(*reinterpret_cast<const m_type *>(p_a._data._mem) m_op *reinterpret_cast<const m_type *>(p_b._data._mem)); \
Allow equality checks between null and arbitrary types Uninitialzed values in GDScript are of type NIL so not allowing null comparisons did end up breaking some code. This commit reenables NULL equality checks for all types. We're going to have to figure out how to make this fast for the compiler later.
2017-09-20 09:32:47 +00:00
\
_RETURN_FAIL \
};
#define DEFAULT_OP_LOCALMEM_NULL(m_prefix, m_op_name, m_name, m_op, m_type) \
CASE_TYPE(m_prefix, m_op_name, m_name) { \
if (p_b.type == m_name) \
_RETURN(*reinterpret_cast<const m_type *>(p_a._data._mem) m_op *reinterpret_cast<const m_type *>(p_b._data._mem)); \
if (p_b.type == NIL) \
Fix a potential bug hinted by clang
2018-03-09 19:19:25 +00:00
_RETURN(!(p_b.type m_op NIL)); \
Allow equality checks between null and arbitrary types Uninitialzed values in GDScript are of type NIL so not allowing null comparisons did end up breaking some code. This commit reenables NULL equality checks for all types. We're going to have to figure out how to make this fast for the compiler later.
2017-09-20 09:32:47 +00:00
\
_RETURN_FAIL \
Move Variant::evaluate() switch to computed goto In an effort to make GDScript a little faster replace the double switch() with a computed goto on compilers that set __GNUC__. For compilers that don't support computed goto it will fall back to regular switch/case statements. In addition disable using boolean values in a mathematical context. Now boolean values can only be compared with other booleans. Booleans will also no longer be coerced to integers. This PR replaces #11308 and fixes #11291
2017-09-17 00:32:05 +00:00
};
#define DEFAULT_OP_LOCALMEM_NEG(m_prefix, m_op_name, m_name, m_type) \
CASE_TYPE(m_prefix, m_op_name, m_name) { \
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
_RETURN(-*reinterpret_cast<const m_type *>(p_a._data._mem)); \
}
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
Move Variant::evaluate() switch to computed goto In an effort to make GDScript a little faster replace the double switch() with a computed goto on compilers that set __GNUC__. For compilers that don't support computed goto it will fall back to regular switch/case statements. In addition disable using boolean values in a mathematical context. Now boolean values can only be compared with other booleans. Booleans will also no longer be coerced to integers. This PR replaces #11308 and fixes #11291
2017-09-17 00:32:05 +00:00
#define DEFAULT_OP_LOCALMEM_POS(m_prefix, m_op_name, m_name, m_type) \
CASE_TYPE(m_prefix, m_op_name, m_name) { \
_RETURN(*reinterpret_cast<const m_type *>(p_a._data._mem)); \
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
}
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
Allow equality checks between null and arbitrary types Uninitialzed values in GDScript are of type NIL so not allowing null comparisons did end up breaking some code. This commit reenables NULL equality checks for all types. We're going to have to figure out how to make this fast for the compiler later.
2017-09-20 09:32:47 +00:00
#define DEFAULT_OP_LOCALMEM_NUM(m_prefix, m_op_name, m_name, m_op, m_type) \
CASE_TYPE(m_prefix, m_op_name, m_name) { \
if (p_b.type == m_name) _RETURN(*reinterpret_cast<const m_type *>(p_a._data._mem) m_op *reinterpret_cast<const m_type *>(p_b._data._mem)); \
if (p_b.type == INT) _RETURN(*reinterpret_cast<const m_type *>(p_a._data._mem) m_op p_b._data._int); \
if (p_b.type == REAL) _RETURN(*reinterpret_cast<const m_type *>(p_a._data._mem) m_op p_b._data._real); \
\
_RETURN_FAIL \
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
}
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
Allow equality checks between null and arbitrary types Uninitialzed values in GDScript are of type NIL so not allowing null comparisons did end up breaking some code. This commit reenables NULL equality checks for all types. We're going to have to figure out how to make this fast for the compiler later.
2017-09-20 09:32:47 +00:00
#define DEFAULT_OP_PTR(m_op, m_name, m_sub) \
CASE_TYPE(m_prefix, m_op_name, m_name) { \
if (p_b.type == m_name) \
_RETURN(p_a._data.m_sub m_op p_b._data.m_sub); \
\
_RETURN_FAIL \
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
}
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
Move Variant::evaluate() switch to computed goto In an effort to make GDScript a little faster replace the double switch() with a computed goto on compilers that set __GNUC__. For compilers that don't support computed goto it will fall back to regular switch/case statements. In addition disable using boolean values in a mathematical context. Now boolean values can only be compared with other booleans. Booleans will also no longer be coerced to integers. This PR replaces #11308 and fixes #11291
2017-09-17 00:32:05 +00:00
#define DEFAULT_OP_PTRREF(m_prefix, m_op_name, m_name, m_op, m_sub) \
CASE_TYPE(m_prefix, m_op_name, m_name) { \
if (p_b.type == m_name) \
_RETURN(*p_a._data.m_sub m_op *p_b._data.m_sub); \
Allow equality checks between null and arbitrary types Uninitialzed values in GDScript are of type NIL so not allowing null comparisons did end up breaking some code. This commit reenables NULL equality checks for all types. We're going to have to figure out how to make this fast for the compiler later.
2017-09-20 09:32:47 +00:00
\
_RETURN_FAIL \
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
}
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
Allow equality checks between null and arbitrary types Uninitialzed values in GDScript are of type NIL so not allowing null comparisons did end up breaking some code. This commit reenables NULL equality checks for all types. We're going to have to figure out how to make this fast for the compiler later.
2017-09-20 09:32:47 +00:00
#define DEFAULT_OP_PTRREF_NULL(m_prefix, m_op_name, m_name, m_op, m_sub) \
CASE_TYPE(m_prefix, m_op_name, m_name) { \
if (p_b.type == m_name) \
_RETURN(*p_a._data.m_sub m_op *p_b._data.m_sub); \
if (p_b.type == NIL) \
Fix a potential bug hinted by clang
2018-03-09 19:19:25 +00:00
_RETURN(!(p_b.type m_op NIL)); \
Allow equality checks between null and arbitrary types Uninitialzed values in GDScript are of type NIL so not allowing null comparisons did end up breaking some code. This commit reenables NULL equality checks for all types. We're going to have to figure out how to make this fast for the compiler later.
2017-09-20 09:32:47 +00:00
\
_RETURN_FAIL \
}
#define DEFAULT_OP_ARRAY_EQ(m_prefix, m_op_name, m_name, m_type) \
CASE_TYPE(m_prefix, m_op_name, m_name) { \
if (p_b.type == NIL) \
_RETURN(false) \
DEFAULT_OP_ARRAY_OP_BODY(m_prefix, m_op_name, m_name, m_type, !=, !=, true, false, false) \
}
Move Variant::evaluate() switch to computed goto In an effort to make GDScript a little faster replace the double switch() with a computed goto on compilers that set __GNUC__. For compilers that don't support computed goto it will fall back to regular switch/case statements. In addition disable using boolean values in a mathematical context. Now boolean values can only be compared with other booleans. Booleans will also no longer be coerced to integers. This PR replaces #11308 and fixes #11291
2017-09-17 00:32:05 +00:00
Implement operator != on Pool*Array types These types previously had equality checks but not inequality checks. Add these too. This fixes #11466
2017-09-21 20:07:31 +00:00
#define DEFAULT_OP_ARRAY_NEQ(m_prefix, m_op_name, m_name, m_type) \
CASE_TYPE(m_prefix, m_op_name, m_name) { \
if (p_b.type == NIL) \
_RETURN(true) \
Fix NEQ operation between 2 different Arrays it was returning false if it found the same content in both arrays which isn't correct, it should return true when it finds different values
2018-01-06 02:58:04 +00:00
DEFAULT_OP_ARRAY_OP_BODY(m_prefix, m_op_name, m_name, m_type, !=, !=, false, true, true) \
Implement operator != on Pool*Array types These types previously had equality checks but not inequality checks. Add these too. This fixes #11466
2017-09-21 20:07:31 +00:00
}
Move Variant::evaluate() switch to computed goto In an effort to make GDScript a little faster replace the double switch() with a computed goto on compilers that set __GNUC__. For compilers that don't support computed goto it will fall back to regular switch/case statements. In addition disable using boolean values in a mathematical context. Now boolean values can only be compared with other booleans. Booleans will also no longer be coerced to integers. This PR replaces #11308 and fixes #11291
2017-09-17 00:32:05 +00:00
#define DEFAULT_OP_ARRAY_LT(m_prefix, m_op_name, m_name, m_type) \
DEFAULT_OP_ARRAY_OP(m_prefix, m_op_name, m_name, m_type, <, !=, false, a_len < array_b.size(), true)
#define DEFAULT_OP_ARRAY_GT(m_prefix, m_op_name, m_name, m_type) \
DEFAULT_OP_ARRAY_OP(m_prefix, m_op_name, m_name, m_type, >, !=, false, a_len < array_b.size(), true)
Allow equality checks between null and arbitrary types Uninitialzed values in GDScript are of type NIL so not allowing null comparisons did end up breaking some code. This commit reenables NULL equality checks for all types. We're going to have to figure out how to make this fast for the compiler later.
2017-09-20 09:32:47 +00:00
#define DEFAULT_OP_ARRAY_OP(m_prefix, m_op_name, m_name, m_type, m_opa, m_opb, m_ret_def, m_ret_s, m_ret_f) \
CASE_TYPE(m_prefix, m_op_name, m_name) { \
DEFAULT_OP_ARRAY_OP_BODY(m_prefix, m_op_name, m_name, m_type, m_opa, m_opb, m_ret_def, m_ret_s, m_ret_f) \
}
#define DEFAULT_OP_ARRAY_OP_BODY(m_prefix, m_op_name, m_name, m_type, m_opa, m_opb, m_ret_def, m_ret_s, m_ret_f) \
if (p_a.type != p_b.type) \
_RETURN_FAIL \
\
const PoolVector<m_type> &array_a = *reinterpret_cast<const PoolVector<m_type> *>(p_a._data._mem); \
const PoolVector<m_type> &array_b = *reinterpret_cast<const PoolVector<m_type> *>(p_b._data._mem); \
\
int a_len = array_a.size(); \
if (a_len m_opa array_b.size()) { \
_RETURN(m_ret_s); \
} else { \
\
PoolVector<m_type>::Read ra = array_a.read(); \
PoolVector<m_type>::Read rb = array_b.read(); \
\
for (int i = 0; i < a_len; i++) { \
if (ra[i] m_opb rb[i]) \
_RETURN(m_ret_f); \
} \
\
_RETURN(m_ret_def); \
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
}
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
Move Variant::evaluate() switch to computed goto In an effort to make GDScript a little faster replace the double switch() with a computed goto on compilers that set __GNUC__. For compilers that don't support computed goto it will fall back to regular switch/case statements. In addition disable using boolean values in a mathematical context. Now boolean values can only be compared with other booleans. Booleans will also no longer be coerced to integers. This PR replaces #11308 and fixes #11291
2017-09-17 00:32:05 +00:00
#define DEFAULT_OP_ARRAY_ADD(m_prefix, m_op_name, m_name, m_type) \
CASE_TYPE(m_prefix, m_op_name, m_name) { \
Allow equality checks between null and arbitrary types Uninitialzed values in GDScript are of type NIL so not allowing null comparisons did end up breaking some code. This commit reenables NULL equality checks for all types. We're going to have to figure out how to make this fast for the compiler later.
2017-09-20 09:32:47 +00:00
if (p_a.type != p_b.type) \
_RETURN_FAIL; \
\
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
const PoolVector<m_type> &array_a = *reinterpret_cast<const PoolVector<m_type> *>(p_a._data._mem); \
const PoolVector<m_type> &array_b = *reinterpret_cast<const PoolVector<m_type> *>(p_b._data._mem); \
PoolVector<m_type> sum = array_a; \
sum.append_array(array_b); \
_RETURN(sum); \
}
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
Move Variant::evaluate() switch to computed goto In an effort to make GDScript a little faster replace the double switch() with a computed goto on compilers that set __GNUC__. For compilers that don't support computed goto it will fall back to regular switch/case statements. In addition disable using boolean values in a mathematical context. Now boolean values can only be compared with other booleans. Booleans will also no longer be coerced to integers. This PR replaces #11308 and fixes #11291
2017-09-17 00:32:05 +00:00
void Variant::evaluate(const Operator &p_op, const Variant &p_a,
const Variant &p_b, Variant &r_ret, bool &r_valid) {
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
Move Variant::evaluate() switch to computed goto In an effort to make GDScript a little faster replace the double switch() with a computed goto on compilers that set __GNUC__. For compilers that don't support computed goto it will fall back to regular switch/case statements. In addition disable using boolean values in a mathematical context. Now boolean values can only be compared with other booleans. Booleans will also no longer be coerced to integers. This PR replaces #11308 and fixes #11291
2017-09-17 00:32:05 +00:00
CASES(math);
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
r_valid = true;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
Move Variant::evaluate() switch to computed goto In an effort to make GDScript a little faster replace the double switch() with a computed goto on compilers that set __GNUC__. For compilers that don't support computed goto it will fall back to regular switch/case statements. In addition disable using boolean values in a mathematical context. Now boolean values can only be compared with other booleans. Booleans will also no longer be coerced to integers. This PR replaces #11308 and fixes #11291
2017-09-17 00:32:05 +00:00
SWITCH(math, p_op, p_a.type) {
SWITCH_OP(math, OP_EQUAL, p_a.type) {
CASE_TYPE(math, OP_EQUAL, NIL) {
if (p_b.type == NIL) _RETURN(true);
if (p_b.type == OBJECT)
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
_RETURN(p_b._get_obj().obj == NULL);
Allow equality checks between null and arbitrary types Uninitialzed values in GDScript are of type NIL so not allowing null comparisons did end up breaking some code. This commit reenables NULL equality checks for all types. We're going to have to figure out how to make this fast for the compiler later.
2017-09-20 09:32:47 +00:00
_RETURN(false);
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
}
Move Variant::evaluate() switch to computed goto In an effort to make GDScript a little faster replace the double switch() with a computed goto on compilers that set __GNUC__. For compilers that don't support computed goto it will fall back to regular switch/case statements. In addition disable using boolean values in a mathematical context. Now boolean values can only be compared with other booleans. Booleans will also no longer be coerced to integers. This PR replaces #11308 and fixes #11291
2017-09-17 00:32:05 +00:00
CASE_TYPE(math, OP_EQUAL, BOOL) {
Allow equality checks between null and arbitrary types Uninitialzed values in GDScript are of type NIL so not allowing null comparisons did end up breaking some code. This commit reenables NULL equality checks for all types. We're going to have to figure out how to make this fast for the compiler later.
2017-09-20 09:32:47 +00:00
if (p_b.type != BOOL) {
if (p_b.type == NIL)
_RETURN(false);
Be type-strict checking on equality checks After a short discussion with @reduz and @karroffel we decided to make all non number/number comparisons return type errors on comparisons. Now bool == bool is allowed but Vector2 == Vector3 is a type error and no longer 'not equal'. The same has been done for the != operators. In addition I forgot to add some failures to some Object operators meaning that there was a potential for a crasher.
2017-09-18 11:09:06 +00:00
_RETURN_FAIL;
Allow equality checks between null and arbitrary types Uninitialzed values in GDScript are of type NIL so not allowing null comparisons did end up breaking some code. This commit reenables NULL equality checks for all types. We're going to have to figure out how to make this fast for the compiler later.
2017-09-20 09:32:47 +00:00
}
Move Variant::evaluate() switch to computed goto In an effort to make GDScript a little faster replace the double switch() with a computed goto on compilers that set __GNUC__. For compilers that don't support computed goto it will fall back to regular switch/case statements. In addition disable using boolean values in a mathematical context. Now boolean values can only be compared with other booleans. Booleans will also no longer be coerced to integers. This PR replaces #11308 and fixes #11291
2017-09-17 00:32:05 +00:00
_RETURN(p_a._data._bool == p_b._data._bool);
}
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
Move Variant::evaluate() switch to computed goto In an effort to make GDScript a little faster replace the double switch() with a computed goto on compilers that set __GNUC__. For compilers that don't support computed goto it will fall back to regular switch/case statements. In addition disable using boolean values in a mathematical context. Now boolean values can only be compared with other booleans. Booleans will also no longer be coerced to integers. This PR replaces #11308 and fixes #11291
2017-09-17 00:32:05 +00:00
CASE_TYPE(math, OP_EQUAL, 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 == NULL);
Allow equality checks between null and arbitrary types Uninitialzed values in GDScript are of type NIL so not allowing null comparisons did end up breaking some code. This commit reenables NULL equality checks for all types. We're going to have to figure out how to make this fast for the compiler later.
2017-09-20 09:32:47 +00:00
Be type-strict checking on equality checks After a short discussion with @reduz and @karroffel we decided to make all non number/number comparisons return type errors on comparisons. Now bool == bool is allowed but Vector2 == Vector3 is a type error and no longer 'not equal'. The same has been done for the != operators. In addition I forgot to add some failures to some Object operators meaning that there was a potential for a crasher.
2017-09-18 11:09:06 +00:00
_RETURN_FAIL;
Move Variant::evaluate() switch to computed goto In an effort to make GDScript a little faster replace the double switch() with a computed goto on compilers that set __GNUC__. For compilers that don't support computed goto it will fall back to regular switch/case statements. In addition disable using boolean values in a mathematical context. Now boolean values can only be compared with other booleans. Booleans will also no longer be coerced to integers. This PR replaces #11308 and fixes #11291
2017-09-17 00:32:05 +00:00
}
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
Move Variant::evaluate() switch to computed goto In an effort to make GDScript a little faster replace the double switch() with a computed goto on compilers that set __GNUC__. For compilers that don't support computed goto it will fall back to regular switch/case statements. In addition disable using boolean values in a mathematical context. Now boolean values can only be compared with other booleans. Booleans will also no longer be coerced to integers. This PR replaces #11308 and fixes #11291
2017-09-17 00:32:05 +00:00
CASE_TYPE(math, OP_EQUAL, DICTIONARY) {
Allow equality checks between null and arbitrary types Uninitialzed values in GDScript are of type NIL so not allowing null comparisons did end up breaking some code. This commit reenables NULL equality checks for all types. We're going to have to figure out how to make this fast for the compiler later.
2017-09-20 09:32:47 +00:00
if (p_b.type != DICTIONARY) {
if (p_b.type == NIL)
_RETURN(false);
Be type-strict checking on equality checks After a short discussion with @reduz and @karroffel we decided to make all non number/number comparisons return type errors on comparisons. Now bool == bool is allowed but Vector2 == Vector3 is a type error and no longer 'not equal'. The same has been done for the != operators. In addition I forgot to add some failures to some Object operators meaning that there was a potential for a crasher.
2017-09-18 11:09:06 +00:00
_RETURN_FAIL;
Allow equality checks between null and arbitrary types Uninitialzed values in GDScript are of type NIL so not allowing null comparisons did end up breaking some code. This commit reenables NULL equality checks for all types. We're going to have to figure out how to make this fast for the compiler later.
2017-09-20 09:32:47 +00:00
}
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
Move Variant::evaluate() switch to computed goto In an effort to make GDScript a little faster replace the double switch() with a computed goto on compilers that set __GNUC__. For compilers that don't support computed goto it will fall back to regular switch/case statements. In addition disable using boolean values in a mathematical context. Now boolean values can only be compared with other booleans. Booleans will also no longer be coerced to integers. This PR replaces #11308 and fixes #11291
2017-09-17 00:32:05 +00:00
const Dictionary *arr_a = reinterpret_cast<const Dictionary *>(p_a._data._mem);
const Dictionary *arr_b = reinterpret_cast<const Dictionary *>(p_b._data._mem);
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
Move Variant::evaluate() switch to computed goto In an effort to make GDScript a little faster replace the double switch() with a computed goto on compilers that set __GNUC__. For compilers that don't support computed goto it will fall back to regular switch/case statements. In addition disable using boolean values in a mathematical context. Now boolean values can only be compared with other booleans. Booleans will also no longer be coerced to integers. This PR replaces #11308 and fixes #11291
2017-09-17 00:32:05 +00:00
_RETURN(*arr_a == *arr_b);
}
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
Move Variant::evaluate() switch to computed goto In an effort to make GDScript a little faster replace the double switch() with a computed goto on compilers that set __GNUC__. For compilers that don't support computed goto it will fall back to regular switch/case statements. In addition disable using boolean values in a mathematical context. Now boolean values can only be compared with other booleans. Booleans will also no longer be coerced to integers. This PR replaces #11308 and fixes #11291
2017-09-17 00:32:05 +00:00
CASE_TYPE(math, OP_EQUAL, ARRAY) {
Allow equality checks between null and arbitrary types Uninitialzed values in GDScript are of type NIL so not allowing null comparisons did end up breaking some code. This commit reenables NULL equality checks for all types. We're going to have to figure out how to make this fast for the compiler later.
2017-09-20 09:32:47 +00:00
if (p_b.type != ARRAY) {
if (p_b.type == NIL)
_RETURN(false);
Be type-strict checking on equality checks After a short discussion with @reduz and @karroffel we decided to make all non number/number comparisons return type errors on comparisons. Now bool == bool is allowed but Vector2 == Vector3 is a type error and no longer 'not equal'. The same has been done for the != operators. In addition I forgot to add some failures to some Object operators meaning that there was a potential for a crasher.
2017-09-18 11:09:06 +00:00
_RETURN_FAIL;
Allow equality checks between null and arbitrary types Uninitialzed values in GDScript are of type NIL so not allowing null comparisons did end up breaking some code. This commit reenables NULL equality checks for all types. We're going to have to figure out how to make this fast for the compiler later.
2017-09-20 09:32:47 +00:00
}
Move Variant::evaluate() switch to computed goto In an effort to make GDScript a little faster replace the double switch() with a computed goto on compilers that set __GNUC__. For compilers that don't support computed goto it will fall back to regular switch/case statements. In addition disable using boolean values in a mathematical context. Now boolean values can only be compared with other booleans. Booleans will also no longer be coerced to integers. This PR replaces #11308 and fixes #11291
2017-09-17 00:32:05 +00:00
const Array *arr_a = reinterpret_cast<const Array *>(p_a._data._mem);
const Array *arr_b = reinterpret_cast<const Array *>(p_b._data._mem);
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
Move Variant::evaluate() switch to computed goto In an effort to make GDScript a little faster replace the double switch() with a computed goto on compilers that set __GNUC__. For compilers that don't support computed goto it will fall back to regular switch/case statements. In addition disable using boolean values in a mathematical context. Now boolean values can only be compared with other booleans. Booleans will also no longer be coerced to integers. This PR replaces #11308 and fixes #11291
2017-09-17 00:32:05 +00:00
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])) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
_RETURN(false);
Move Variant::evaluate() switch to computed goto In an effort to make GDScript a little faster replace the double switch() with a computed goto on compilers that set __GNUC__. For compilers that don't support computed goto it will fall back to regular switch/case statements. In addition disable using boolean values in a mathematical context. Now boolean values can only be compared with other booleans. Booleans will also no longer be coerced to integers. This PR replaces #11308 and fixes #11291
2017-09-17 00:32:05 +00:00
}
}
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
Move Variant::evaluate() switch to computed goto In an effort to make GDScript a little faster replace the double switch() with a computed goto on compilers that set __GNUC__. For compilers that don't support computed goto it will fall back to regular switch/case statements. In addition disable using boolean values in a mathematical context. Now boolean values can only be compared with other booleans. Booleans will also no longer be coerced to integers. This PR replaces #11308 and fixes #11291
2017-09-17 00:32:05 +00:00
_RETURN(true);
}
Allow equality checks between null and arbitrary types Uninitialzed values in GDScript are of type NIL so not allowing null comparisons did end up breaking some code. This commit reenables NULL equality checks for all types. We're going to have to figure out how to make this fast for the compiler later.
2017-09-20 09:32:47 +00:00
DEFAULT_OP_NUM_NULL(math, OP_EQUAL, INT, ==, _int);
DEFAULT_OP_NUM_NULL(math, OP_EQUAL, REAL, ==, _real);
DEFAULT_OP_STR_NULL(math, OP_EQUAL, STRING, ==, String);
DEFAULT_OP_LOCALMEM_NULL(math, OP_EQUAL, VECTOR2, ==, Vector2);
DEFAULT_OP_LOCALMEM_NULL(math, OP_EQUAL, RECT2, ==, Rect2);
DEFAULT_OP_PTRREF_NULL(math, OP_EQUAL, TRANSFORM2D, ==, _transform2d);
DEFAULT_OP_LOCALMEM_NULL(math, OP_EQUAL, VECTOR3, ==, Vector3);
DEFAULT_OP_LOCALMEM_NULL(math, OP_EQUAL, PLANE, ==, Plane);
DEFAULT_OP_LOCALMEM_NULL(math, OP_EQUAL, QUAT, ==, Quat);
Rename Rect3 to AABB. Fixes #12973.
2017-11-17 02:09:00 +00:00
DEFAULT_OP_PTRREF_NULL(math, OP_EQUAL, AABB, ==, _aabb);
Allow equality checks between null and arbitrary types Uninitialzed values in GDScript are of type NIL so not allowing null comparisons did end up breaking some code. This commit reenables NULL equality checks for all types. We're going to have to figure out how to make this fast for the compiler later.
2017-09-20 09:32:47 +00:00
DEFAULT_OP_PTRREF_NULL(math, OP_EQUAL, BASIS, ==, _basis);
DEFAULT_OP_PTRREF_NULL(math, OP_EQUAL, TRANSFORM, ==, _transform);
DEFAULT_OP_LOCALMEM_NULL(math, OP_EQUAL, COLOR, ==, Color);
DEFAULT_OP_STR_NULL(math, OP_EQUAL, NODE_PATH, ==, NodePath);
DEFAULT_OP_LOCALMEM_NULL(math, OP_EQUAL, _RID, ==, RID);
Move Variant::evaluate() switch to computed goto In an effort to make GDScript a little faster replace the double switch() with a computed goto on compilers that set __GNUC__. For compilers that don't support computed goto it will fall back to regular switch/case statements. In addition disable using boolean values in a mathematical context. Now boolean values can only be compared with other booleans. Booleans will also no longer be coerced to integers. This PR replaces #11308 and fixes #11291
2017-09-17 00:32:05 +00:00
DEFAULT_OP_ARRAY_EQ(math, OP_EQUAL, POOL_BYTE_ARRAY, uint8_t);
DEFAULT_OP_ARRAY_EQ(math, OP_EQUAL, POOL_INT_ARRAY, int);
DEFAULT_OP_ARRAY_EQ(math, OP_EQUAL, POOL_REAL_ARRAY, real_t);
DEFAULT_OP_ARRAY_EQ(math, OP_EQUAL, POOL_STRING_ARRAY, String);
DEFAULT_OP_ARRAY_EQ(math, OP_EQUAL, POOL_VECTOR2_ARRAY, Vector2);
DEFAULT_OP_ARRAY_EQ(math, OP_EQUAL, POOL_VECTOR3_ARRAY, Vector3);
DEFAULT_OP_ARRAY_EQ(math, OP_EQUAL, POOL_COLOR_ARRAY, Color);
}
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
Move Variant::evaluate() switch to computed goto In an effort to make GDScript a little faster replace the double switch() with a computed goto on compilers that set __GNUC__. For compilers that don't support computed goto it will fall back to regular switch/case statements. In addition disable using boolean values in a mathematical context. Now boolean values can only be compared with other booleans. Booleans will also no longer be coerced to integers. This PR replaces #11308 and fixes #11291
2017-09-17 00:32:05 +00:00
SWITCH_OP(math, OP_NOT_EQUAL, p_a.type) {
CASE_TYPE(math, OP_NOT_EQUAL, NIL) {
if (p_b.type == NIL) _RETURN(false);
if (p_b.type == OBJECT)
_RETURN(p_b._get_obj().obj != NULL);
Allow equality checks between null and arbitrary types Uninitialzed values in GDScript are of type NIL so not allowing null comparisons did end up breaking some code. This commit reenables NULL equality checks for all types. We're going to have to figure out how to make this fast for the compiler later.
2017-09-20 09:32:47 +00:00
_RETURN(true);
Move Variant::evaluate() switch to computed goto In an effort to make GDScript a little faster replace the double switch() with a computed goto on compilers that set __GNUC__. For compilers that don't support computed goto it will fall back to regular switch/case statements. In addition disable using boolean values in a mathematical context. Now boolean values can only be compared with other booleans. Booleans will also no longer be coerced to integers. This PR replaces #11308 and fixes #11291
2017-09-17 00:32:05 +00:00
}
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
Move Variant::evaluate() switch to computed goto In an effort to make GDScript a little faster replace the double switch() with a computed goto on compilers that set __GNUC__. For compilers that don't support computed goto it will fall back to regular switch/case statements. In addition disable using boolean values in a mathematical context. Now boolean values can only be compared with other booleans. Booleans will also no longer be coerced to integers. This PR replaces #11308 and fixes #11291
2017-09-17 00:32:05 +00:00
CASE_TYPE(math, OP_NOT_EQUAL, BOOL) {
Allow equality checks between null and arbitrary types Uninitialzed values in GDScript are of type NIL so not allowing null comparisons did end up breaking some code. This commit reenables NULL equality checks for all types. We're going to have to figure out how to make this fast for the compiler later.
2017-09-20 09:32:47 +00:00
if (p_b.type != BOOL) {
if (p_b.type == NIL)
_RETURN(true);
Be type-strict checking on equality checks After a short discussion with @reduz and @karroffel we decided to make all non number/number comparisons return type errors on comparisons. Now bool == bool is allowed but Vector2 == Vector3 is a type error and no longer 'not equal'. The same has been done for the != operators. In addition I forgot to add some failures to some Object operators meaning that there was a potential for a crasher.
2017-09-18 11:09:06 +00:00
_RETURN_FAIL;
Allow equality checks between null and arbitrary types Uninitialzed values in GDScript are of type NIL so not allowing null comparisons did end up breaking some code. This commit reenables NULL equality checks for all types. We're going to have to figure out how to make this fast for the compiler later.
2017-09-20 09:32:47 +00:00
}
Move Variant::evaluate() switch to computed goto In an effort to make GDScript a little faster replace the double switch() with a computed goto on compilers that set __GNUC__. For compilers that don't support computed goto it will fall back to regular switch/case statements. In addition disable using boolean values in a mathematical context. Now boolean values can only be compared with other booleans. Booleans will also no longer be coerced to integers. This PR replaces #11308 and fixes #11291
2017-09-17 00:32:05 +00:00
_RETURN(p_a._data._bool != p_b._data._bool);
}
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
Move Variant::evaluate() switch to computed goto In an effort to make GDScript a little faster replace the double switch() with a computed goto on compilers that set __GNUC__. For compilers that don't support computed goto it will fall back to regular switch/case statements. In addition disable using boolean values in a mathematical context. Now boolean values can only be compared with other booleans. Booleans will also no longer be coerced to integers. This PR replaces #11308 and fixes #11291
2017-09-17 00:32:05 +00:00
CASE_TYPE(math, OP_NOT_EQUAL, 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 != NULL);
Allow equality checks between null and arbitrary types Uninitialzed values in GDScript are of type NIL so not allowing null comparisons did end up breaking some code. This commit reenables NULL equality checks for all types. We're going to have to figure out how to make this fast for the compiler later.
2017-09-20 09:32:47 +00:00
Be type-strict checking on equality checks After a short discussion with @reduz and @karroffel we decided to make all non number/number comparisons return type errors on comparisons. Now bool == bool is allowed but Vector2 == Vector3 is a type error and no longer 'not equal'. The same has been done for the != operators. In addition I forgot to add some failures to some Object operators meaning that there was a potential for a crasher.
2017-09-18 11:09:06 +00:00
_RETURN_FAIL;
Move Variant::evaluate() switch to computed goto In an effort to make GDScript a little faster replace the double switch() with a computed goto on compilers that set __GNUC__. For compilers that don't support computed goto it will fall back to regular switch/case statements. In addition disable using boolean values in a mathematical context. Now boolean values can only be compared with other booleans. Booleans will also no longer be coerced to integers. This PR replaces #11308 and fixes #11291
2017-09-17 00:32:05 +00:00
}
CASE_TYPE(math, OP_NOT_EQUAL, DICTIONARY) {
Allow equality checks between null and arbitrary types Uninitialzed values in GDScript are of type NIL so not allowing null comparisons did end up breaking some code. This commit reenables NULL equality checks for all types. We're going to have to figure out how to make this fast for the compiler later.
2017-09-20 09:32:47 +00:00
if (p_b.type != DICTIONARY) {
if (p_b.type == NIL)
_RETURN(true);
Be type-strict checking on equality checks After a short discussion with @reduz and @karroffel we decided to make all non number/number comparisons return type errors on comparisons. Now bool == bool is allowed but Vector2 == Vector3 is a type error and no longer 'not equal'. The same has been done for the != operators. In addition I forgot to add some failures to some Object operators meaning that there was a potential for a crasher.
2017-09-18 11:09:06 +00:00
_RETURN_FAIL;
Allow equality checks between null and arbitrary types Uninitialzed values in GDScript are of type NIL so not allowing null comparisons did end up breaking some code. This commit reenables NULL equality checks for all types. We're going to have to figure out how to make this fast for the compiler later.
2017-09-20 09:32:47 +00:00
}
Move Variant::evaluate() switch to computed goto In an effort to make GDScript a little faster replace the double switch() with a computed goto on compilers that set __GNUC__. For compilers that don't support computed goto it will fall back to regular switch/case statements. In addition disable using boolean values in a mathematical context. Now boolean values can only be compared with other booleans. Booleans will also no longer be coerced to integers. This PR replaces #11308 and fixes #11291
2017-09-17 00:32:05 +00:00
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) == false);
}
CASE_TYPE(math, OP_NOT_EQUAL, ARRAY) {
Allow equality checks between null and arbitrary types Uninitialzed values in GDScript are of type NIL so not allowing null comparisons did end up breaking some code. This commit reenables NULL equality checks for all types. We're going to have to figure out how to make this fast for the compiler later.
2017-09-20 09:32:47 +00:00
if (p_b.type != ARRAY) {
if (p_b.type == NIL)
_RETURN(true);
Be type-strict checking on equality checks After a short discussion with @reduz and @karroffel we decided to make all non number/number comparisons return type errors on comparisons. Now bool == bool is allowed but Vector2 == Vector3 is a type error and no longer 'not equal'. The same has been done for the != operators. In addition I forgot to add some failures to some Object operators meaning that there was a potential for a crasher.
2017-09-18 11:09:06 +00:00
_RETURN_FAIL;
Allow equality checks between null and arbitrary types Uninitialzed values in GDScript are of type NIL so not allowing null comparisons did end up breaking some code. This commit reenables NULL equality checks for all types. We're going to have to figure out how to make this fast for the compiler later.
2017-09-20 09:32:47 +00:00
}
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
Move Variant::evaluate() switch to computed goto In an effort to make GDScript a little faster replace the double switch() with a computed goto on compilers that set __GNUC__. For compilers that don't support computed goto it will fall back to regular switch/case statements. In addition disable using boolean values in a mathematical context. Now boolean values can only be compared with other booleans. Booleans will also no longer be coerced to integers. This PR replaces #11308 and fixes #11291
2017-09-17 00:32:05 +00:00
const Array *arr_a = reinterpret_cast<const Array *>(p_a._data._mem);
const Array *arr_b = reinterpret_cast<const Array *>(p_b._data._mem);
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
Move Variant::evaluate() switch to computed goto In an effort to make GDScript a little faster replace the double switch() with a computed goto on compilers that set __GNUC__. For compilers that don't support computed goto it will fall back to regular switch/case statements. In addition disable using boolean values in a mathematical context. Now boolean values can only be compared with other booleans. Booleans will also no longer be coerced to integers. This PR replaces #11308 and fixes #11291
2017-09-17 00:32:05 +00:00
int l = arr_a->size();
if (arr_b->size() != l)
_RETURN(true);
for (int i = 0; i < l; i++) {
Fix NEQ operation between 2 different Arrays it was returning false if it found the same content in both arrays which isn't correct, it should return true when it finds different values
2018-01-06 02:58:04 +00:00
if (((*arr_a)[i] != (*arr_b)[i])) {
_RETURN(true);
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
}
Move Variant::evaluate() switch to computed goto In an effort to make GDScript a little faster replace the double switch() with a computed goto on compilers that set __GNUC__. For compilers that don't support computed goto it will fall back to regular switch/case statements. In addition disable using boolean values in a mathematical context. Now boolean values can only be compared with other booleans. Booleans will also no longer be coerced to integers. This PR replaces #11308 and fixes #11291
2017-09-17 00:32:05 +00:00
}
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
Fix NEQ operation between 2 different Arrays it was returning false if it found the same content in both arrays which isn't correct, it should return true when it finds different values
2018-01-06 02:58:04 +00:00
_RETURN(false);
Move Variant::evaluate() switch to computed goto In an effort to make GDScript a little faster replace the double switch() with a computed goto on compilers that set __GNUC__. For compilers that don't support computed goto it will fall back to regular switch/case statements. In addition disable using boolean values in a mathematical context. Now boolean values can only be compared with other booleans. Booleans will also no longer be coerced to integers. This PR replaces #11308 and fixes #11291
2017-09-17 00:32:05 +00:00
}
Allow equality checks between null and arbitrary types Uninitialzed values in GDScript are of type NIL so not allowing null comparisons did end up breaking some code. This commit reenables NULL equality checks for all types. We're going to have to figure out how to make this fast for the compiler later.
2017-09-20 09:32:47 +00:00
DEFAULT_OP_NUM_NULL(math, OP_NOT_EQUAL, INT, !=, _int);
DEFAULT_OP_NUM_NULL(math, OP_NOT_EQUAL, REAL, !=, _real);
DEFAULT_OP_STR_NULL(math, OP_NOT_EQUAL, STRING, !=, String);
DEFAULT_OP_LOCALMEM_NULL(math, OP_NOT_EQUAL, VECTOR2, !=, Vector2);
DEFAULT_OP_LOCALMEM_NULL(math, OP_NOT_EQUAL, RECT2, !=, Rect2);
DEFAULT_OP_PTRREF_NULL(math, OP_NOT_EQUAL, TRANSFORM2D, !=, _transform2d);
DEFAULT_OP_LOCALMEM_NULL(math, OP_NOT_EQUAL, VECTOR3, !=, Vector3);
DEFAULT_OP_LOCALMEM_NULL(math, OP_NOT_EQUAL, PLANE, !=, Plane);
DEFAULT_OP_LOCALMEM_NULL(math, OP_NOT_EQUAL, QUAT, !=, Quat);
Rename Rect3 to AABB. Fixes #12973.
2017-11-17 02:09:00 +00:00
DEFAULT_OP_PTRREF_NULL(math, OP_NOT_EQUAL, AABB, !=, _aabb);
Allow equality checks between null and arbitrary types Uninitialzed values in GDScript are of type NIL so not allowing null comparisons did end up breaking some code. This commit reenables NULL equality checks for all types. We're going to have to figure out how to make this fast for the compiler later.
2017-09-20 09:32:47 +00:00
DEFAULT_OP_PTRREF_NULL(math, OP_NOT_EQUAL, BASIS, !=, _basis);
DEFAULT_OP_PTRREF_NULL(math, OP_NOT_EQUAL, TRANSFORM, !=, _transform);
DEFAULT_OP_LOCALMEM_NULL(math, OP_NOT_EQUAL, COLOR, !=, Color);
DEFAULT_OP_STR_NULL(math, OP_NOT_EQUAL, NODE_PATH, !=, NodePath);
DEFAULT_OP_LOCALMEM_NULL(math, OP_NOT_EQUAL, _RID, !=, RID);
Move Variant::evaluate() switch to computed goto In an effort to make GDScript a little faster replace the double switch() with a computed goto on compilers that set __GNUC__. For compilers that don't support computed goto it will fall back to regular switch/case statements. In addition disable using boolean values in a mathematical context. Now boolean values can only be compared with other booleans. Booleans will also no longer be coerced to integers. This PR replaces #11308 and fixes #11291
2017-09-17 00:32:05 +00:00
Implement operator != on Pool*Array types These types previously had equality checks but not inequality checks. Add these too. This fixes #11466
2017-09-21 20:07:31 +00:00
DEFAULT_OP_ARRAY_NEQ(math, OP_NOT_EQUAL, POOL_BYTE_ARRAY, uint8_t);
DEFAULT_OP_ARRAY_NEQ(math, OP_NOT_EQUAL, POOL_INT_ARRAY, int);
DEFAULT_OP_ARRAY_NEQ(math, OP_NOT_EQUAL, POOL_REAL_ARRAY, real_t);
DEFAULT_OP_ARRAY_NEQ(math, OP_NOT_EQUAL, POOL_STRING_ARRAY, String);
DEFAULT_OP_ARRAY_NEQ(math, OP_NOT_EQUAL, POOL_VECTOR2_ARRAY, Vector2);
DEFAULT_OP_ARRAY_NEQ(math, OP_NOT_EQUAL, POOL_VECTOR3_ARRAY, Vector3);
DEFAULT_OP_ARRAY_NEQ(math, OP_NOT_EQUAL, POOL_COLOR_ARRAY, Color);
Move Variant::evaluate() switch to computed goto In an effort to make GDScript a little faster replace the double switch() with a computed goto on compilers that set __GNUC__. For compilers that don't support computed goto it will fall back to regular switch/case statements. In addition disable using boolean values in a mathematical context. Now boolean values can only be compared with other booleans. Booleans will also no longer be coerced to integers. This PR replaces #11308 and fixes #11291
2017-09-17 00:32:05 +00:00
}
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
Move Variant::evaluate() switch to computed goto In an effort to make GDScript a little faster replace the double switch() with a computed goto on compilers that set __GNUC__. For compilers that don't support computed goto it will fall back to regular switch/case statements. In addition disable using boolean values in a mathematical context. Now boolean values can only be compared with other booleans. Booleans will also no longer be coerced to integers. This PR replaces #11308 and fixes #11291
2017-09-17 00:32:05 +00:00
SWITCH_OP(math, OP_LESS, p_a.type) {
CASE_TYPE(math, OP_LESS, BOOL) {
if (p_b.type != BOOL)
_RETURN_FAIL;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
Move Variant::evaluate() switch to computed goto In an effort to make GDScript a little faster replace the double switch() with a computed goto on compilers that set __GNUC__. For compilers that don't support computed goto it will fall back to regular switch/case statements. In addition disable using boolean values in a mathematical context. Now boolean values can only be compared with other booleans. Booleans will also no longer be coerced to integers. This PR replaces #11308 and fixes #11291
2017-09-17 00:32:05 +00:00
if (p_a._data._bool == p_b._data._bool)
_RETURN(false);
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
Move Variant::evaluate() switch to computed goto In an effort to make GDScript a little faster replace the double switch() with a computed goto on compilers that set __GNUC__. For compilers that don't support computed goto it will fall back to regular switch/case statements. In addition disable using boolean values in a mathematical context. Now boolean values can only be compared with other booleans. Booleans will also no longer be coerced to integers. This PR replaces #11308 and fixes #11291
2017-09-17 00:32:05 +00:00
if (p_a._data._bool && !p_b._data._bool)
_RETURN(false);
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
Move Variant::evaluate() switch to computed goto In an effort to make GDScript a little faster replace the double switch() with a computed goto on compilers that set __GNUC__. For compilers that don't support computed goto it will fall back to regular switch/case statements. In addition disable using boolean values in a mathematical context. Now boolean values can only be compared with other booleans. Booleans will also no longer be coerced to integers. This PR replaces #11308 and fixes #11291
2017-09-17 00:32:05 +00:00
_RETURN(true);
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
}
Sort xml files, so order is constant Makes xml format work better with version control systems.
2015-05-01 00:53:41 +00:00
Move Variant::evaluate() switch to computed goto In an effort to make GDScript a little faster replace the double switch() with a computed goto on compilers that set __GNUC__. For compilers that don't support computed goto it will fall back to regular switch/case statements. In addition disable using boolean values in a mathematical context. Now boolean values can only be compared with other booleans. Booleans will also no longer be coerced to integers. This PR replaces #11308 and fixes #11291
2017-09-17 00:32:05 +00:00
CASE_TYPE(math, OP_LESS, OBJECT) {
Be type-strict checking on equality checks After a short discussion with @reduz and @karroffel we decided to make all non number/number comparisons return type errors on comparisons. Now bool == bool is allowed but Vector2 == Vector3 is a type error and no longer 'not equal'. The same has been done for the != operators. In addition I forgot to add some failures to some Object operators meaning that there was a potential for a crasher.
2017-09-18 11:09:06 +00:00
if (p_b.type != OBJECT)
_RETURN_FAIL;
_RETURN((p_a._get_obj().obj < p_b._get_obj().obj));
Move Variant::evaluate() switch to computed goto In an effort to make GDScript a little faster replace the double switch() with a computed goto on compilers that set __GNUC__. For compilers that don't support computed goto it will fall back to regular switch/case statements. In addition disable using boolean values in a mathematical context. Now boolean values can only be compared with other booleans. Booleans will also no longer be coerced to integers. This PR replaces #11308 and fixes #11291
2017-09-17 00:32:05 +00:00
}
Sort xml files, so order is constant Makes xml format work better with version control systems.
2015-05-01 00:53:41 +00:00
Move Variant::evaluate() switch to computed goto In an effort to make GDScript a little faster replace the double switch() with a computed goto on compilers that set __GNUC__. For compilers that don't support computed goto it will fall back to regular switch/case statements. In addition disable using boolean values in a mathematical context. Now boolean values can only be compared with other booleans. Booleans will also no longer be coerced to integers. This PR replaces #11308 and fixes #11291
2017-09-17 00:32:05 +00:00
CASE_TYPE(math, OP_LESS, ARRAY) {
if (p_b.type != ARRAY)
Be type-strict checking on equality checks After a short discussion with @reduz and @karroffel we decided to make all non number/number comparisons return type errors on comparisons. Now bool == bool is allowed but Vector2 == Vector3 is a type error and no longer 'not equal'. The same has been done for the != operators. In addition I forgot to add some failures to some Object operators meaning that there was a potential for a crasher.
2017-09-18 11:09:06 +00:00
_RETURN_FAIL;
Move Variant::evaluate() switch to computed goto In an effort to make GDScript a little faster replace the double switch() with a computed goto on compilers that set __GNUC__. For compilers that don't support computed goto it will fall back to regular switch/case statements. In addition disable using boolean values in a mathematical context. Now boolean values can only be compared with other booleans. Booleans will also no longer be coerced to integers. This PR replaces #11308 and fixes #11291
2017-09-17 00:32:05 +00:00
const Array *arr_a = reinterpret_cast<const Array *>(p_a._data._mem);
const Array *arr_b = reinterpret_cast<const Array *>(p_b._data._mem);
Sort xml files, so order is constant Makes xml format work better with version control systems.
2015-05-01 00:53:41 +00:00
Move Variant::evaluate() switch to computed goto In an effort to make GDScript a little faster replace the double switch() with a computed goto on compilers that set __GNUC__. For compilers that don't support computed goto it will fall back to regular switch/case statements. In addition disable using boolean values in a mathematical context. Now boolean values can only be compared with other booleans. Booleans will also no longer be coerced to integers. This PR replaces #11308 and fixes #11291
2017-09-17 00:32:05 +00:00
int l = arr_a->size();
if (arr_b->size() < l)
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
_RETURN(false);
Move Variant::evaluate() switch to computed goto In an effort to make GDScript a little faster replace the double switch() with a computed goto on compilers that set __GNUC__. For compilers that don't support computed goto it will fall back to regular switch/case statements. In addition disable using boolean values in a mathematical context. Now boolean values can only be compared with other booleans. Booleans will also no longer be coerced to integers. This PR replaces #11308 and fixes #11291
2017-09-17 00:32:05 +00:00
for (int i = 0; i < l; i++) {
if (!((*arr_a)[i] < (*arr_b)[i])) {
_RETURN(true);
}
}
Sort xml files, so order is constant Makes xml format work better with version control systems.
2015-05-01 00:53:41 +00:00
Move Variant::evaluate() switch to computed goto In an effort to make GDScript a little faster replace the double switch() with a computed goto on compilers that set __GNUC__. For compilers that don't support computed goto it will fall back to regular switch/case statements. In addition disable using boolean values in a mathematical context. Now boolean values can only be compared with other booleans. Booleans will also no longer be coerced to integers. This PR replaces #11308 and fixes #11291
2017-09-17 00:32:05 +00:00
_RETURN(false);
}
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
Move Variant::evaluate() switch to computed goto In an effort to make GDScript a little faster replace the double switch() with a computed goto on compilers that set __GNUC__. For compilers that don't support computed goto it will fall back to regular switch/case statements. In addition disable using boolean values in a mathematical context. Now boolean values can only be compared with other booleans. Booleans will also no longer be coerced to integers. This PR replaces #11308 and fixes #11291
2017-09-17 00:32:05 +00:00
DEFAULT_OP_NUM(math, OP_LESS, INT, <, _int);
DEFAULT_OP_NUM(math, OP_LESS, REAL, <, _real);
DEFAULT_OP_STR(math, OP_LESS, STRING, <, String);
DEFAULT_OP_LOCALMEM(math, OP_LESS, VECTOR2, <, Vector2);
DEFAULT_OP_LOCALMEM(math, OP_LESS, VECTOR3, <, Vector3);
DEFAULT_OP_LOCALMEM(math, OP_LESS, _RID, <, RID);
DEFAULT_OP_ARRAY_LT(math, OP_LESS, POOL_BYTE_ARRAY, uint8_t);
DEFAULT_OP_ARRAY_LT(math, OP_LESS, POOL_INT_ARRAY, int);
DEFAULT_OP_ARRAY_LT(math, OP_LESS, POOL_REAL_ARRAY, real_t);
DEFAULT_OP_ARRAY_LT(math, OP_LESS, POOL_STRING_ARRAY, String);
DEFAULT_OP_ARRAY_LT(math, OP_LESS, POOL_VECTOR2_ARRAY, Vector3);
DEFAULT_OP_ARRAY_LT(math, OP_LESS, POOL_VECTOR3_ARRAY, Vector3);
DEFAULT_OP_ARRAY_LT(math, OP_LESS, POOL_COLOR_ARRAY, Color);
CASE_TYPE(math, OP_LESS, NIL)
CASE_TYPE(math, OP_LESS, RECT2)
CASE_TYPE(math, OP_LESS, TRANSFORM2D)
CASE_TYPE(math, OP_LESS, PLANE)
CASE_TYPE(math, OP_LESS, QUAT)
Rename Rect3 to AABB. Fixes #12973.
2017-11-17 02:09:00 +00:00
CASE_TYPE(math, OP_LESS, AABB)
Move Variant::evaluate() switch to computed goto In an effort to make GDScript a little faster replace the double switch() with a computed goto on compilers that set __GNUC__. For compilers that don't support computed goto it will fall back to regular switch/case statements. In addition disable using boolean values in a mathematical context. Now boolean values can only be compared with other booleans. Booleans will also no longer be coerced to integers. This PR replaces #11308 and fixes #11291
2017-09-17 00:32:05 +00:00
CASE_TYPE(math, OP_LESS, BASIS)
CASE_TYPE(math, OP_LESS, TRANSFORM)
CASE_TYPE(math, OP_LESS, COLOR)
CASE_TYPE(math, OP_LESS, NODE_PATH)
CASE_TYPE(math, OP_LESS, DICTIONARY)
_RETURN_FAIL;
}
SWITCH_OP(math, OP_LESS_EQUAL, p_a.type) {
CASE_TYPE(math, OP_LESS_EQUAL, OBJECT) {
Be type-strict checking on equality checks After a short discussion with @reduz and @karroffel we decided to make all non number/number comparisons return type errors on comparisons. Now bool == bool is allowed but Vector2 == Vector3 is a type error and no longer 'not equal'. The same has been done for the != operators. In addition I forgot to add some failures to some Object operators meaning that there was a potential for a crasher.
2017-09-18 11:09:06 +00:00
if (p_b.type != OBJECT)
_RETURN_FAIL;
_RETURN((p_a._get_obj().obj <= p_b._get_obj().obj));
Move Variant::evaluate() switch to computed goto In an effort to make GDScript a little faster replace the double switch() with a computed goto on compilers that set __GNUC__. For compilers that don't support computed goto it will fall back to regular switch/case statements. In addition disable using boolean values in a mathematical context. Now boolean values can only be compared with other booleans. Booleans will also no longer be coerced to integers. This PR replaces #11308 and fixes #11291
2017-09-17 00:32:05 +00:00
}
DEFAULT_OP_NUM(math, OP_LESS_EQUAL, INT, <=, _int);
DEFAULT_OP_NUM(math, OP_LESS_EQUAL, REAL, <=, _real);
DEFAULT_OP_STR(math, OP_LESS_EQUAL, STRING, <=, String);
DEFAULT_OP_LOCALMEM(math, OP_LESS_EQUAL, VECTOR2, <=, Vector2);
DEFAULT_OP_LOCALMEM(math, OP_LESS_EQUAL, VECTOR3, <=, Vector3);
DEFAULT_OP_LOCALMEM(math, OP_LESS_EQUAL, _RID, <=, RID);
CASE_TYPE(math, OP_LESS_EQUAL, NIL)
CASE_TYPE(math, OP_LESS_EQUAL, BOOL)
CASE_TYPE(math, OP_LESS_EQUAL, RECT2)
CASE_TYPE(math, OP_LESS_EQUAL, TRANSFORM2D)
CASE_TYPE(math, OP_LESS_EQUAL, PLANE)
CASE_TYPE(math, OP_LESS_EQUAL, QUAT)
Rename Rect3 to AABB. Fixes #12973.
2017-11-17 02:09:00 +00:00
CASE_TYPE(math, OP_LESS_EQUAL, AABB)
Move Variant::evaluate() switch to computed goto In an effort to make GDScript a little faster replace the double switch() with a computed goto on compilers that set __GNUC__. For compilers that don't support computed goto it will fall back to regular switch/case statements. In addition disable using boolean values in a mathematical context. Now boolean values can only be compared with other booleans. Booleans will also no longer be coerced to integers. This PR replaces #11308 and fixes #11291
2017-09-17 00:32:05 +00:00
CASE_TYPE(math, OP_LESS_EQUAL, BASIS)
CASE_TYPE(math, OP_LESS_EQUAL, TRANSFORM)
CASE_TYPE(math, OP_LESS_EQUAL, COLOR)
CASE_TYPE(math, OP_LESS_EQUAL, NODE_PATH)
CASE_TYPE(math, OP_LESS_EQUAL, DICTIONARY)
CASE_TYPE(math, OP_LESS_EQUAL, ARRAY)
CASE_TYPE(math, OP_LESS_EQUAL, POOL_BYTE_ARRAY);
CASE_TYPE(math, OP_LESS_EQUAL, POOL_INT_ARRAY);
CASE_TYPE(math, OP_LESS_EQUAL, POOL_REAL_ARRAY);
CASE_TYPE(math, OP_LESS_EQUAL, POOL_STRING_ARRAY);
CASE_TYPE(math, OP_LESS_EQUAL, POOL_VECTOR2_ARRAY);
CASE_TYPE(math, OP_LESS_EQUAL, POOL_VECTOR3_ARRAY);
CASE_TYPE(math, OP_LESS_EQUAL, POOL_COLOR_ARRAY);
_RETURN_FAIL;
}
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
Move Variant::evaluate() switch to computed goto In an effort to make GDScript a little faster replace the double switch() with a computed goto on compilers that set __GNUC__. For compilers that don't support computed goto it will fall back to regular switch/case statements. In addition disable using boolean values in a mathematical context. Now boolean values can only be compared with other booleans. Booleans will also no longer be coerced to integers. This PR replaces #11308 and fixes #11291
2017-09-17 00:32:05 +00:00
SWITCH_OP(math, OP_GREATER, p_a.type) {
CASE_TYPE(math, OP_GREATER, BOOL) {
if (p_b.type != BOOL)
_RETURN_FAIL;
if (p_a._data._bool == p_b._data._bool)
_RETURN(false);
if (!p_a._data._bool && p_b._data._bool)
_RETURN(false);
_RETURN(true);
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
}
Move Variant::evaluate() switch to computed goto In an effort to make GDScript a little faster replace the double switch() with a computed goto on compilers that set __GNUC__. For compilers that don't support computed goto it will fall back to regular switch/case statements. In addition disable using boolean values in a mathematical context. Now boolean values can only be compared with other booleans. Booleans will also no longer be coerced to integers. This PR replaces #11308 and fixes #11291
2017-09-17 00:32:05 +00:00
CASE_TYPE(math, OP_GREATER, OBJECT) {
Be type-strict checking on equality checks After a short discussion with @reduz and @karroffel we decided to make all non number/number comparisons return type errors on comparisons. Now bool == bool is allowed but Vector2 == Vector3 is a type error and no longer 'not equal'. The same has been done for the != operators. In addition I forgot to add some failures to some Object operators meaning that there was a potential for a crasher.
2017-09-18 11:09:06 +00:00
if (p_b.type != OBJECT)
_RETURN_FAIL;
_RETURN((p_a._get_obj().obj > p_b._get_obj().obj));
Move Variant::evaluate() switch to computed goto In an effort to make GDScript a little faster replace the double switch() with a computed goto on compilers that set __GNUC__. For compilers that don't support computed goto it will fall back to regular switch/case statements. In addition disable using boolean values in a mathematical context. Now boolean values can only be compared with other booleans. Booleans will also no longer be coerced to integers. This PR replaces #11308 and fixes #11291
2017-09-17 00:32:05 +00:00
}
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
Move Variant::evaluate() switch to computed goto In an effort to make GDScript a little faster replace the double switch() with a computed goto on compilers that set __GNUC__. For compilers that don't support computed goto it will fall back to regular switch/case statements. In addition disable using boolean values in a mathematical context. Now boolean values can only be compared with other booleans. Booleans will also no longer be coerced to integers. This PR replaces #11308 and fixes #11291
2017-09-17 00:32:05 +00:00
CASE_TYPE(math, OP_GREATER, ARRAY) {
if (p_b.type != ARRAY)
Be type-strict checking on equality checks After a short discussion with @reduz and @karroffel we decided to make all non number/number comparisons return type errors on comparisons. Now bool == bool is allowed but Vector2 == Vector3 is a type error and no longer 'not equal'. The same has been done for the != operators. In addition I forgot to add some failures to some Object operators meaning that there was a potential for a crasher.
2017-09-18 11:09:06 +00:00
_RETURN_FAIL;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
Move Variant::evaluate() switch to computed goto In an effort to make GDScript a little faster replace the double switch() with a computed goto on compilers that set __GNUC__. For compilers that don't support computed goto it will fall back to regular switch/case statements. In addition disable using boolean values in a mathematical context. Now boolean values can only be compared with other booleans. Booleans will also no longer be coerced to integers. This PR replaces #11308 and fixes #11291
2017-09-17 00:32:05 +00:00
const Array *arr_a = reinterpret_cast<const Array *>(p_a._data._mem);
const Array *arr_b = reinterpret_cast<const Array *>(p_b._data._mem);
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
Move Variant::evaluate() switch to computed goto In an effort to make GDScript a little faster replace the double switch() with a computed goto on compilers that set __GNUC__. For compilers that don't support computed goto it will fall back to regular switch/case statements. In addition disable using boolean values in a mathematical context. Now boolean values can only be compared with other booleans. Booleans will also no longer be coerced to integers. This PR replaces #11308 and fixes #11291
2017-09-17 00:32:05 +00:00
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(false);
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
}
}
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
Move Variant::evaluate() switch to computed goto In an effort to make GDScript a little faster replace the double switch() with a computed goto on compilers that set __GNUC__. For compilers that don't support computed goto it will fall back to regular switch/case statements. In addition disable using boolean values in a mathematical context. Now boolean values can only be compared with other booleans. Booleans will also no longer be coerced to integers. This PR replaces #11308 and fixes #11291
2017-09-17 00:32:05 +00:00
_RETURN(true);
}
DEFAULT_OP_NUM(math, OP_GREATER, INT, >, _int);
DEFAULT_OP_NUM(math, OP_GREATER, REAL, >, _real);
DEFAULT_OP_STR_REV(math, OP_GREATER, STRING, <, String);
DEFAULT_OP_LOCALMEM_REV(math, OP_GREATER, VECTOR2, <, Vector2);
DEFAULT_OP_LOCALMEM_REV(math, OP_GREATER, VECTOR3, <, Vector3);
DEFAULT_OP_LOCALMEM_REV(math, OP_GREATER, _RID, <, RID);
DEFAULT_OP_ARRAY_GT(math, OP_GREATER, POOL_BYTE_ARRAY, uint8_t);
DEFAULT_OP_ARRAY_GT(math, OP_GREATER, POOL_INT_ARRAY, int);
DEFAULT_OP_ARRAY_GT(math, OP_GREATER, POOL_REAL_ARRAY, real_t);
DEFAULT_OP_ARRAY_GT(math, OP_GREATER, POOL_STRING_ARRAY, String);
DEFAULT_OP_ARRAY_GT(math, OP_GREATER, POOL_VECTOR2_ARRAY, Vector3);
DEFAULT_OP_ARRAY_GT(math, OP_GREATER, POOL_VECTOR3_ARRAY, Vector3);
DEFAULT_OP_ARRAY_GT(math, OP_GREATER, POOL_COLOR_ARRAY, Color);
CASE_TYPE(math, OP_GREATER, NIL)
CASE_TYPE(math, OP_GREATER, RECT2)
CASE_TYPE(math, OP_GREATER, TRANSFORM2D)
CASE_TYPE(math, OP_GREATER, PLANE)
CASE_TYPE(math, OP_GREATER, QUAT)
Rename Rect3 to AABB. Fixes #12973.
2017-11-17 02:09:00 +00:00
CASE_TYPE(math, OP_GREATER, AABB)
Move Variant::evaluate() switch to computed goto In an effort to make GDScript a little faster replace the double switch() with a computed goto on compilers that set __GNUC__. For compilers that don't support computed goto it will fall back to regular switch/case statements. In addition disable using boolean values in a mathematical context. Now boolean values can only be compared with other booleans. Booleans will also no longer be coerced to integers. This PR replaces #11308 and fixes #11291
2017-09-17 00:32:05 +00:00
CASE_TYPE(math, OP_GREATER, BASIS)
CASE_TYPE(math, OP_GREATER, TRANSFORM)
CASE_TYPE(math, OP_GREATER, COLOR)
CASE_TYPE(math, OP_GREATER, NODE_PATH)
CASE_TYPE(math, OP_GREATER, DICTIONARY)
_RETURN_FAIL;
}
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
Move Variant::evaluate() switch to computed goto In an effort to make GDScript a little faster replace the double switch() with a computed goto on compilers that set __GNUC__. For compilers that don't support computed goto it will fall back to regular switch/case statements. In addition disable using boolean values in a mathematical context. Now boolean values can only be compared with other booleans. Booleans will also no longer be coerced to integers. This PR replaces #11308 and fixes #11291
2017-09-17 00:32:05 +00:00
SWITCH_OP(math, OP_GREATER_EQUAL, p_a.type) {
CASE_TYPE(math, OP_GREATER_EQUAL, OBJECT) {
Be type-strict checking on equality checks After a short discussion with @reduz and @karroffel we decided to make all non number/number comparisons return type errors on comparisons. Now bool == bool is allowed but Vector2 == Vector3 is a type error and no longer 'not equal'. The same has been done for the != operators. In addition I forgot to add some failures to some Object operators meaning that there was a potential for a crasher.
2017-09-18 11:09:06 +00:00
if (p_b.type != OBJECT)
_RETURN_FAIL;
_RETURN((p_a._get_obj().obj >= p_b._get_obj().obj));
Move Variant::evaluate() switch to computed goto In an effort to make GDScript a little faster replace the double switch() with a computed goto on compilers that set __GNUC__. For compilers that don't support computed goto it will fall back to regular switch/case statements. In addition disable using boolean values in a mathematical context. Now boolean values can only be compared with other booleans. Booleans will also no longer be coerced to integers. This PR replaces #11308 and fixes #11291
2017-09-17 00:32:05 +00:00
}
DEFAULT_OP_NUM(math, OP_GREATER_EQUAL, INT, >=, _int);
DEFAULT_OP_NUM(math, OP_GREATER_EQUAL, REAL, >=, _real);
DEFAULT_OP_STR_REV(math, OP_GREATER_EQUAL, STRING, <=, String);
DEFAULT_OP_LOCALMEM_REV(math, OP_GREATER_EQUAL, VECTOR2, <=, Vector2);
DEFAULT_OP_LOCALMEM_REV(math, OP_GREATER_EQUAL, VECTOR3, <=, Vector3);
DEFAULT_OP_LOCALMEM_REV(math, OP_GREATER_EQUAL, _RID, <=, RID);
CASE_TYPE(math, OP_GREATER_EQUAL, NIL)
CASE_TYPE(math, OP_GREATER_EQUAL, BOOL)
CASE_TYPE(math, OP_GREATER_EQUAL, RECT2)
CASE_TYPE(math, OP_GREATER_EQUAL, TRANSFORM2D)
CASE_TYPE(math, OP_GREATER_EQUAL, PLANE)
CASE_TYPE(math, OP_GREATER_EQUAL, QUAT)
Rename Rect3 to AABB. Fixes #12973.
2017-11-17 02:09:00 +00:00
CASE_TYPE(math, OP_GREATER_EQUAL, AABB)
Move Variant::evaluate() switch to computed goto In an effort to make GDScript a little faster replace the double switch() with a computed goto on compilers that set __GNUC__. For compilers that don't support computed goto it will fall back to regular switch/case statements. In addition disable using boolean values in a mathematical context. Now boolean values can only be compared with other booleans. Booleans will also no longer be coerced to integers. This PR replaces #11308 and fixes #11291
2017-09-17 00:32:05 +00:00
CASE_TYPE(math, OP_GREATER_EQUAL, BASIS)
CASE_TYPE(math, OP_GREATER_EQUAL, TRANSFORM)
CASE_TYPE(math, OP_GREATER_EQUAL, COLOR)
CASE_TYPE(math, OP_GREATER_EQUAL, NODE_PATH)
CASE_TYPE(math, OP_GREATER_EQUAL, DICTIONARY)
CASE_TYPE(math, OP_GREATER_EQUAL, ARRAY)
CASE_TYPE(math, OP_GREATER_EQUAL, POOL_BYTE_ARRAY);
CASE_TYPE(math, OP_GREATER_EQUAL, POOL_INT_ARRAY);
CASE_TYPE(math, OP_GREATER_EQUAL, POOL_REAL_ARRAY);
CASE_TYPE(math, OP_GREATER_EQUAL, POOL_STRING_ARRAY);
CASE_TYPE(math, OP_GREATER_EQUAL, POOL_VECTOR2_ARRAY);
CASE_TYPE(math, OP_GREATER_EQUAL, POOL_VECTOR3_ARRAY);
CASE_TYPE(math, OP_GREATER_EQUAL, POOL_COLOR_ARRAY);
_RETURN_FAIL;
}
-run script in editor -add search docs dialog that returns places string was found -added flash
2014-02-21 02:01:44 +00:00
Move Variant::evaluate() switch to computed goto In an effort to make GDScript a little faster replace the double switch() with a computed goto on compilers that set __GNUC__. For compilers that don't support computed goto it will fall back to regular switch/case statements. In addition disable using boolean values in a mathematical context. Now boolean values can only be compared with other booleans. Booleans will also no longer be coerced to integers. This PR replaces #11308 and fixes #11291
2017-09-17 00:32:05 +00:00
SWITCH_OP(math, OP_ADD, p_a.type) {
CASE_TYPE(math, OP_ADD, ARRAY) {
Be type-strict checking on equality checks After a short discussion with @reduz and @karroffel we decided to make all non number/number comparisons return type errors on comparisons. Now bool == bool is allowed but Vector2 == Vector3 is a type error and no longer 'not equal'. The same has been done for the != operators. In addition I forgot to add some failures to some Object operators meaning that there was a potential for a crasher.
2017-09-18 11:09:06 +00:00
if (p_a.type != p_b.type)
_RETURN_FAIL;
Move Variant::evaluate() switch to computed goto In an effort to make GDScript a little faster replace the double switch() with a computed goto on compilers that set __GNUC__. For compilers that don't support computed goto it will fall back to regular switch/case statements. In addition disable using boolean values in a mathematical context. Now boolean values can only be compared with other booleans. Booleans will also no longer be coerced to integers. This PR replaces #11308 and fixes #11291
2017-09-17 00:32:05 +00:00
const Array &array_a = *reinterpret_cast<const Array *>(p_a._data._mem);
const Array &array_b = *reinterpret_cast<const Array *>(p_b._data._mem);
Array sum;
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_NUM(math, OP_ADD, INT, +, _int);
DEFAULT_OP_NUM(math, OP_ADD, REAL, +, _real);
DEFAULT_OP_STR(math, OP_ADD, STRING, +, String);
DEFAULT_OP_LOCALMEM(math, OP_ADD, VECTOR2, +, Vector2);
DEFAULT_OP_LOCALMEM(math, OP_ADD, VECTOR3, +, Vector3);
DEFAULT_OP_LOCALMEM(math, OP_ADD, QUAT, +, Quat);
DEFAULT_OP_LOCALMEM(math, OP_ADD, COLOR, +, Color);
DEFAULT_OP_ARRAY_ADD(math, OP_ADD, POOL_BYTE_ARRAY, uint8_t);
DEFAULT_OP_ARRAY_ADD(math, OP_ADD, POOL_INT_ARRAY, int);
DEFAULT_OP_ARRAY_ADD(math, OP_ADD, POOL_REAL_ARRAY, real_t);
DEFAULT_OP_ARRAY_ADD(math, OP_ADD, POOL_STRING_ARRAY, String);
DEFAULT_OP_ARRAY_ADD(math, OP_ADD, POOL_VECTOR2_ARRAY, Vector2);
DEFAULT_OP_ARRAY_ADD(math, OP_ADD, POOL_VECTOR3_ARRAY, Vector3);
DEFAULT_OP_ARRAY_ADD(math, OP_ADD, POOL_COLOR_ARRAY, Color);
CASE_TYPE(math, OP_ADD, NIL)
CASE_TYPE(math, OP_ADD, BOOL)
CASE_TYPE(math, OP_ADD, RECT2)
CASE_TYPE(math, OP_ADD, TRANSFORM2D)
CASE_TYPE(math, OP_ADD, PLANE)
Rename Rect3 to AABB. Fixes #12973.
2017-11-17 02:09:00 +00:00
CASE_TYPE(math, OP_ADD, AABB)
Move Variant::evaluate() switch to computed goto In an effort to make GDScript a little faster replace the double switch() with a computed goto on compilers that set __GNUC__. For compilers that don't support computed goto it will fall back to regular switch/case statements. In addition disable using boolean values in a mathematical context. Now boolean values can only be compared with other booleans. Booleans will also no longer be coerced to integers. This PR replaces #11308 and fixes #11291
2017-09-17 00:32:05 +00:00
CASE_TYPE(math, OP_ADD, BASIS)
CASE_TYPE(math, OP_ADD, TRANSFORM)
CASE_TYPE(math, OP_ADD, NODE_PATH)
CASE_TYPE(math, OP_ADD, _RID)
CASE_TYPE(math, OP_ADD, OBJECT)
CASE_TYPE(math, OP_ADD, DICTIONARY)
_RETURN_FAIL;
}
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
Move Variant::evaluate() switch to computed goto In an effort to make GDScript a little faster replace the double switch() with a computed goto on compilers that set __GNUC__. For compilers that don't support computed goto it will fall back to regular switch/case statements. In addition disable using boolean values in a mathematical context. Now boolean values can only be compared with other booleans. Booleans will also no longer be coerced to integers. This PR replaces #11308 and fixes #11291
2017-09-17 00:32:05 +00:00
SWITCH_OP(math, OP_SUBTRACT, p_a.type) {
DEFAULT_OP_NUM(math, OP_SUBTRACT, INT, -, _int);
DEFAULT_OP_NUM(math, OP_SUBTRACT, REAL, -, _real);
DEFAULT_OP_LOCALMEM(math, OP_SUBTRACT, VECTOR2, -, Vector2);
DEFAULT_OP_LOCALMEM(math, OP_SUBTRACT, VECTOR3, -, Vector3);
DEFAULT_OP_LOCALMEM(math, OP_SUBTRACT, QUAT, -, Quat);
DEFAULT_OP_LOCALMEM(math, OP_SUBTRACT, COLOR, -, Color);
CASE_TYPE(math, OP_SUBTRACT, NIL)
CASE_TYPE(math, OP_SUBTRACT, BOOL)
CASE_TYPE(math, OP_SUBTRACT, STRING)
CASE_TYPE(math, OP_SUBTRACT, RECT2)
CASE_TYPE(math, OP_SUBTRACT, TRANSFORM2D)
CASE_TYPE(math, OP_SUBTRACT, PLANE)
Rename Rect3 to AABB. Fixes #12973.
2017-11-17 02:09:00 +00:00
CASE_TYPE(math, OP_SUBTRACT, AABB)
Move Variant::evaluate() switch to computed goto In an effort to make GDScript a little faster replace the double switch() with a computed goto on compilers that set __GNUC__. For compilers that don't support computed goto it will fall back to regular switch/case statements. In addition disable using boolean values in a mathematical context. Now boolean values can only be compared with other booleans. Booleans will also no longer be coerced to integers. This PR replaces #11308 and fixes #11291
2017-09-17 00:32:05 +00:00
CASE_TYPE(math, OP_SUBTRACT, BASIS)
CASE_TYPE(math, OP_SUBTRACT, TRANSFORM)
CASE_TYPE(math, OP_SUBTRACT, NODE_PATH)
CASE_TYPE(math, OP_SUBTRACT, _RID)
CASE_TYPE(math, OP_SUBTRACT, OBJECT)
CASE_TYPE(math, OP_SUBTRACT, DICTIONARY)
CASE_TYPE(math, OP_SUBTRACT, ARRAY)
CASE_TYPE(math, OP_SUBTRACT, POOL_BYTE_ARRAY);
CASE_TYPE(math, OP_SUBTRACT, POOL_INT_ARRAY);
CASE_TYPE(math, OP_SUBTRACT, POOL_REAL_ARRAY);
CASE_TYPE(math, OP_SUBTRACT, POOL_STRING_ARRAY);
CASE_TYPE(math, OP_SUBTRACT, POOL_VECTOR2_ARRAY);
CASE_TYPE(math, OP_SUBTRACT, POOL_VECTOR3_ARRAY);
CASE_TYPE(math, OP_SUBTRACT, POOL_COLOR_ARRAY);
_RETURN_FAIL;
}
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
Move Variant::evaluate() switch to computed goto In an effort to make GDScript a little faster replace the double switch() with a computed goto on compilers that set __GNUC__. For compilers that don't support computed goto it will fall back to regular switch/case statements. In addition disable using boolean values in a mathematical context. Now boolean values can only be compared with other booleans. Booleans will also no longer be coerced to integers. This PR replaces #11308 and fixes #11291
2017-09-17 00:32:05 +00:00
SWITCH_OP(math, OP_MULTIPLY, p_a.type) {
CASE_TYPE(math, OP_MULTIPLY, TRANSFORM2D) {
Be type-strict checking on equality checks After a short discussion with @reduz and @karroffel we decided to make all non number/number comparisons return type errors on comparisons. Now bool == bool is allowed but Vector2 == Vector3 is a type error and no longer 'not equal'. The same has been done for the != operators. In addition I forgot to add some failures to some Object operators meaning that there was a potential for a crasher.
2017-09-18 11:09:06 +00:00
switch (p_b.type) {
case TRANSFORM2D: {
_RETURN(*p_a._data._transform2d * *p_b._data._transform2d);
}
case VECTOR2: {
_RETURN(p_a._data._transform2d->xform(*(const Vector2 *)p_b._data._mem));
}
default: _RETURN_FAIL;
}
Move Variant::evaluate() switch to computed goto In an effort to make GDScript a little faster replace the double switch() with a computed goto on compilers that set __GNUC__. For compilers that don't support computed goto it will fall back to regular switch/case statements. In addition disable using boolean values in a mathematical context. Now boolean values can only be compared with other booleans. Booleans will also no longer be coerced to integers. This PR replaces #11308 and fixes #11291
2017-09-17 00:32:05 +00:00
}
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
Move Variant::evaluate() switch to computed goto In an effort to make GDScript a little faster replace the double switch() with a computed goto on compilers that set __GNUC__. For compilers that don't support computed goto it will fall back to regular switch/case statements. In addition disable using boolean values in a mathematical context. Now boolean values can only be compared with other booleans. Booleans will also no longer be coerced to integers. This PR replaces #11308 and fixes #11291
2017-09-17 00:32:05 +00:00
CASE_TYPE(math, OP_MULTIPLY, QUAT) {
switch (p_b.type) {
case VECTOR3: {
_RETURN(reinterpret_cast<const Quat *>(p_a._data._mem)->xform(*(const Vector3 *)p_b._data._mem));
Be type-strict checking on equality checks After a short discussion with @reduz and @karroffel we decided to make all non number/number comparisons return type errors on comparisons. Now bool == bool is allowed but Vector2 == Vector3 is a type error and no longer 'not equal'. The same has been done for the != operators. In addition I forgot to add some failures to some Object operators meaning that there was a potential for a crasher.
2017-09-18 11:09:06 +00:00
}
Move Variant::evaluate() switch to computed goto In an effort to make GDScript a little faster replace the double switch() with a computed goto on compilers that set __GNUC__. For compilers that don't support computed goto it will fall back to regular switch/case statements. In addition disable using boolean values in a mathematical context. Now boolean values can only be compared with other booleans. Booleans will also no longer be coerced to integers. This PR replaces #11308 and fixes #11291
2017-09-17 00:32:05 +00:00
case QUAT: {
_RETURN(*reinterpret_cast<const Quat *>(p_a._data._mem) * *reinterpret_cast<const Quat *>(p_b._data._mem));
Be type-strict checking on equality checks After a short discussion with @reduz and @karroffel we decided to make all non number/number comparisons return type errors on comparisons. Now bool == bool is allowed but Vector2 == Vector3 is a type error and no longer 'not equal'. The same has been done for the != operators. In addition I forgot to add some failures to some Object operators meaning that there was a potential for a crasher.
2017-09-18 11:09:06 +00:00
}
Move Variant::evaluate() switch to computed goto In an effort to make GDScript a little faster replace the double switch() with a computed goto on compilers that set __GNUC__. For compilers that don't support computed goto it will fall back to regular switch/case statements. In addition disable using boolean values in a mathematical context. Now boolean values can only be compared with other booleans. Booleans will also no longer be coerced to integers. This PR replaces #11308 and fixes #11291
2017-09-17 00:32:05 +00:00
case REAL: {
_RETURN(*reinterpret_cast<const Quat *>(p_a._data._mem) * p_b._data._real);
Be type-strict checking on equality checks After a short discussion with @reduz and @karroffel we decided to make all non number/number comparisons return type errors on comparisons. Now bool == bool is allowed but Vector2 == Vector3 is a type error and no longer 'not equal'. The same has been done for the != operators. In addition I forgot to add some failures to some Object operators meaning that there was a potential for a crasher.
2017-09-18 11:09:06 +00:00
}
default: _RETURN_FAIL;
}
Move Variant::evaluate() switch to computed goto In an effort to make GDScript a little faster replace the double switch() with a computed goto on compilers that set __GNUC__. For compilers that don't support computed goto it will fall back to regular switch/case statements. In addition disable using boolean values in a mathematical context. Now boolean values can only be compared with other booleans. Booleans will also no longer be coerced to integers. This PR replaces #11308 and fixes #11291
2017-09-17 00:32:05 +00:00
}
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
Move Variant::evaluate() switch to computed goto In an effort to make GDScript a little faster replace the double switch() with a computed goto on compilers that set __GNUC__. For compilers that don't support computed goto it will fall back to regular switch/case statements. In addition disable using boolean values in a mathematical context. Now boolean values can only be compared with other booleans. Booleans will also no longer be coerced to integers. This PR replaces #11308 and fixes #11291
2017-09-17 00:32:05 +00:00
CASE_TYPE(math, OP_MULTIPLY, BASIS) {
switch (p_b.type) {
case VECTOR3: {
_RETURN(p_a._data._basis->xform(*(const Vector3 *)p_b._data._mem));
Be type-strict checking on equality checks After a short discussion with @reduz and @karroffel we decided to make all non number/number comparisons return type errors on comparisons. Now bool == bool is allowed but Vector2 == Vector3 is a type error and no longer 'not equal'. The same has been done for the != operators. In addition I forgot to add some failures to some Object operators meaning that there was a potential for a crasher.
2017-09-18 11:09:06 +00:00
}
Move Variant::evaluate() switch to computed goto In an effort to make GDScript a little faster replace the double switch() with a computed goto on compilers that set __GNUC__. For compilers that don't support computed goto it will fall back to regular switch/case statements. In addition disable using boolean values in a mathematical context. Now boolean values can only be compared with other booleans. Booleans will also no longer be coerced to integers. This PR replaces #11308 and fixes #11291
2017-09-17 00:32:05 +00:00
case BASIS: {
_RETURN(*p_a._data._basis * *p_b._data._basis);
Be type-strict checking on equality checks After a short discussion with @reduz and @karroffel we decided to make all non number/number comparisons return type errors on comparisons. Now bool == bool is allowed but Vector2 == Vector3 is a type error and no longer 'not equal'. The same has been done for the != operators. In addition I forgot to add some failures to some Object operators meaning that there was a potential for a crasher.
2017-09-18 11:09:06 +00:00
}
default: _RETURN_FAIL;
}
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
}
Move Variant::evaluate() switch to computed goto In an effort to make GDScript a little faster replace the double switch() with a computed goto on compilers that set __GNUC__. For compilers that don't support computed goto it will fall back to regular switch/case statements. In addition disable using boolean values in a mathematical context. Now boolean values can only be compared with other booleans. Booleans will also no longer be coerced to integers. This PR replaces #11308 and fixes #11291
2017-09-17 00:32:05 +00:00
CASE_TYPE(math, OP_MULTIPLY, TRANSFORM) {
switch (p_b.type) {
case VECTOR3: {
_RETURN(p_a._data._transform->xform(*(const Vector3 *)p_b._data._mem));
Be type-strict checking on equality checks After a short discussion with @reduz and @karroffel we decided to make all non number/number comparisons return type errors on comparisons. Now bool == bool is allowed but Vector2 == Vector3 is a type error and no longer 'not equal'. The same has been done for the != operators. In addition I forgot to add some failures to some Object operators meaning that there was a potential for a crasher.
2017-09-18 11:09:06 +00:00
}
Move Variant::evaluate() switch to computed goto In an effort to make GDScript a little faster replace the double switch() with a computed goto on compilers that set __GNUC__. For compilers that don't support computed goto it will fall back to regular switch/case statements. In addition disable using boolean values in a mathematical context. Now boolean values can only be compared with other booleans. Booleans will also no longer be coerced to integers. This PR replaces #11308 and fixes #11291
2017-09-17 00:32:05 +00:00
case TRANSFORM: {
_RETURN(*p_a._data._transform * *p_b._data._transform);
Be type-strict checking on equality checks After a short discussion with @reduz and @karroffel we decided to make all non number/number comparisons return type errors on comparisons. Now bool == bool is allowed but Vector2 == Vector3 is a type error and no longer 'not equal'. The same has been done for the != operators. In addition I forgot to add some failures to some Object operators meaning that there was a potential for a crasher.
2017-09-18 11:09:06 +00:00
}
default: _RETURN_FAIL;
}
Move Variant::evaluate() switch to computed goto In an effort to make GDScript a little faster replace the double switch() with a computed goto on compilers that set __GNUC__. For compilers that don't support computed goto it will fall back to regular switch/case statements. In addition disable using boolean values in a mathematical context. Now boolean values can only be compared with other booleans. Booleans will also no longer be coerced to integers. This PR replaces #11308 and fixes #11291
2017-09-17 00:32:05 +00:00
}
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
Move Variant::evaluate() switch to computed goto In an effort to make GDScript a little faster replace the double switch() with a computed goto on compilers that set __GNUC__. For compilers that don't support computed goto it will fall back to regular switch/case statements. In addition disable using boolean values in a mathematical context. Now boolean values can only be compared with other booleans. Booleans will also no longer be coerced to integers. This PR replaces #11308 and fixes #11291
2017-09-17 00:32:05 +00:00
DEFAULT_OP_NUM_VEC(math, OP_MULTIPLY, INT, *, _int);
DEFAULT_OP_NUM_VEC(math, OP_MULTIPLY, REAL, *, _real);
DEFAULT_OP_LOCALMEM_NUM(math, OP_MULTIPLY, VECTOR2, *, Vector2);
DEFAULT_OP_LOCALMEM_NUM(math, OP_MULTIPLY, VECTOR3, *, Vector3);
DEFAULT_OP_LOCALMEM_NUM(math, OP_MULTIPLY, COLOR, *, Color);
CASE_TYPE(math, OP_MULTIPLY, NIL)
CASE_TYPE(math, OP_MULTIPLY, BOOL)
CASE_TYPE(math, OP_MULTIPLY, STRING)
CASE_TYPE(math, OP_MULTIPLY, RECT2)
CASE_TYPE(math, OP_MULTIPLY, PLANE)
Rename Rect3 to AABB. Fixes #12973.
2017-11-17 02:09:00 +00:00
CASE_TYPE(math, OP_MULTIPLY, AABB)
Move Variant::evaluate() switch to computed goto In an effort to make GDScript a little faster replace the double switch() with a computed goto on compilers that set __GNUC__. For compilers that don't support computed goto it will fall back to regular switch/case statements. In addition disable using boolean values in a mathematical context. Now boolean values can only be compared with other booleans. Booleans will also no longer be coerced to integers. This PR replaces #11308 and fixes #11291
2017-09-17 00:32:05 +00:00
CASE_TYPE(math, OP_MULTIPLY, NODE_PATH)
CASE_TYPE(math, OP_MULTIPLY, _RID)
CASE_TYPE(math, OP_MULTIPLY, OBJECT)
CASE_TYPE(math, OP_MULTIPLY, DICTIONARY)
CASE_TYPE(math, OP_MULTIPLY, ARRAY)
CASE_TYPE(math, OP_MULTIPLY, POOL_BYTE_ARRAY);
CASE_TYPE(math, OP_MULTIPLY, POOL_INT_ARRAY);
CASE_TYPE(math, OP_MULTIPLY, POOL_REAL_ARRAY);
CASE_TYPE(math, OP_MULTIPLY, POOL_STRING_ARRAY);
CASE_TYPE(math, OP_MULTIPLY, POOL_VECTOR2_ARRAY);
CASE_TYPE(math, OP_MULTIPLY, POOL_VECTOR3_ARRAY);
CASE_TYPE(math, OP_MULTIPLY, POOL_COLOR_ARRAY);
_RETURN_FAIL;
}
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
Move Variant::evaluate() switch to computed goto In an effort to make GDScript a little faster replace the double switch() with a computed goto on compilers that set __GNUC__. For compilers that don't support computed goto it will fall back to regular switch/case statements. In addition disable using boolean values in a mathematical context. Now boolean values can only be compared with other booleans. Booleans will also no longer be coerced to integers. This PR replaces #11308 and fixes #11291
2017-09-17 00:32:05 +00:00
SWITCH_OP(math, OP_DIVIDE, p_a.type) {
CASE_TYPE(math, OP_DIVIDE, QUAT) {
Be type-strict checking on equality checks After a short discussion with @reduz and @karroffel we decided to make all non number/number comparisons return type errors on comparisons. Now bool == bool is allowed but Vector2 == Vector3 is a type error and no longer 'not equal'. The same has been done for the != operators. In addition I forgot to add some failures to some Object operators meaning that there was a potential for a crasher.
2017-09-18 11:09:06 +00:00
if (p_b.type != REAL)
_RETURN_FAIL;
Move Variant::evaluate() switch to computed goto In an effort to make GDScript a little faster replace the double switch() with a computed goto on compilers that set __GNUC__. For compilers that don't support computed goto it will fall back to regular switch/case statements. In addition disable using boolean values in a mathematical context. Now boolean values can only be compared with other booleans. Booleans will also no longer be coerced to integers. This PR replaces #11308 and fixes #11291
2017-09-17 00:32:05 +00:00
#ifdef DEBUG_ENABLED
if (p_b._data._real == 0) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
r_valid = false;
Move Variant::evaluate() switch to computed goto In an effort to make GDScript a little faster replace the double switch() with a computed goto on compilers that set __GNUC__. For compilers that don't support computed goto it will fall back to regular switch/case statements. In addition disable using boolean values in a mathematical context. Now boolean values can only be compared with other booleans. Booleans will also no longer be coerced to integers. This PR replaces #11308 and fixes #11291
2017-09-17 00:32:05 +00:00
_RETURN("Division By Zero");
}
#endif
Be type-strict checking on equality checks After a short discussion with @reduz and @karroffel we decided to make all non number/number comparisons return type errors on comparisons. Now bool == bool is allowed but Vector2 == Vector3 is a type error and no longer 'not equal'. The same has been done for the != operators. In addition I forgot to add some failures to some Object operators meaning that there was a potential for a crasher.
2017-09-18 11:09:06 +00:00
_RETURN(*reinterpret_cast<const Quat *>(p_a._data._mem) / p_b._data._real);
Move Variant::evaluate() switch to computed goto In an effort to make GDScript a little faster replace the double switch() with a computed goto on compilers that set __GNUC__. For compilers that don't support computed goto it will fall back to regular switch/case statements. In addition disable using boolean values in a mathematical context. Now boolean values can only be compared with other booleans. Booleans will also no longer be coerced to integers. This PR replaces #11308 and fixes #11291
2017-09-17 00:32:05 +00:00
}
DEFAULT_OP_NUM_DIV(math, OP_DIVIDE, INT, _int);
DEFAULT_OP_NUM_DIV(math, OP_DIVIDE, REAL, _real);
DEFAULT_OP_LOCALMEM_NUM(math, OP_DIVIDE, VECTOR2, /, Vector2);
DEFAULT_OP_LOCALMEM_NUM(math, OP_DIVIDE, VECTOR3, /, Vector3);
DEFAULT_OP_LOCALMEM_NUM(math, OP_DIVIDE, COLOR, /, Color);
CASE_TYPE(math, OP_DIVIDE, NIL)
CASE_TYPE(math, OP_DIVIDE, BOOL)
CASE_TYPE(math, OP_DIVIDE, STRING)
CASE_TYPE(math, OP_DIVIDE, RECT2)
CASE_TYPE(math, OP_DIVIDE, TRANSFORM2D)
CASE_TYPE(math, OP_DIVIDE, PLANE)
Rename Rect3 to AABB. Fixes #12973.
2017-11-17 02:09:00 +00:00
CASE_TYPE(math, OP_DIVIDE, AABB)
Move Variant::evaluate() switch to computed goto In an effort to make GDScript a little faster replace the double switch() with a computed goto on compilers that set __GNUC__. For compilers that don't support computed goto it will fall back to regular switch/case statements. In addition disable using boolean values in a mathematical context. Now boolean values can only be compared with other booleans. Booleans will also no longer be coerced to integers. This PR replaces #11308 and fixes #11291
2017-09-17 00:32:05 +00:00
CASE_TYPE(math, OP_DIVIDE, BASIS)
CASE_TYPE(math, OP_DIVIDE, TRANSFORM)
CASE_TYPE(math, OP_DIVIDE, NODE_PATH)
CASE_TYPE(math, OP_DIVIDE, _RID)
CASE_TYPE(math, OP_DIVIDE, OBJECT)
CASE_TYPE(math, OP_DIVIDE, DICTIONARY)
CASE_TYPE(math, OP_DIVIDE, ARRAY)
CASE_TYPE(math, OP_DIVIDE, POOL_BYTE_ARRAY);
CASE_TYPE(math, OP_DIVIDE, POOL_INT_ARRAY);
CASE_TYPE(math, OP_DIVIDE, POOL_REAL_ARRAY);
CASE_TYPE(math, OP_DIVIDE, POOL_STRING_ARRAY);
CASE_TYPE(math, OP_DIVIDE, POOL_VECTOR2_ARRAY);
CASE_TYPE(math, OP_DIVIDE, POOL_VECTOR3_ARRAY);
CASE_TYPE(math, OP_DIVIDE, POOL_COLOR_ARRAY);
_RETURN_FAIL;
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
Move Variant::evaluate() switch to computed goto In an effort to make GDScript a little faster replace the double switch() with a computed goto on compilers that set __GNUC__. For compilers that don't support computed goto it will fall back to regular switch/case statements. In addition disable using boolean values in a mathematical context. Now boolean values can only be compared with other booleans. Booleans will also no longer be coerced to integers. This PR replaces #11308 and fixes #11291
2017-09-17 00:32:05 +00:00
SWITCH_OP(math, OP_POSITIVE, p_a.type) {
DEFAULT_OP_NUM_POS(math, OP_POSITIVE, INT, _int);
DEFAULT_OP_NUM_POS(math, OP_POSITIVE, REAL, _real);
DEFAULT_OP_LOCALMEM_POS(math, OP_POSITIVE, VECTOR3, Vector3);
DEFAULT_OP_LOCALMEM_POS(math, OP_POSITIVE, PLANE, Plane);
DEFAULT_OP_LOCALMEM_POS(math, OP_POSITIVE, QUAT, Quat);
DEFAULT_OP_LOCALMEM_POS(math, OP_POSITIVE, VECTOR2, Vector2);
CASE_TYPE(math, OP_POSITIVE, NIL)
CASE_TYPE(math, OP_POSITIVE, BOOL)
CASE_TYPE(math, OP_POSITIVE, STRING)
CASE_TYPE(math, OP_POSITIVE, RECT2)
CASE_TYPE(math, OP_POSITIVE, TRANSFORM2D)
Rename Rect3 to AABB. Fixes #12973.
2017-11-17 02:09:00 +00:00
CASE_TYPE(math, OP_POSITIVE, AABB)
Move Variant::evaluate() switch to computed goto In an effort to make GDScript a little faster replace the double switch() with a computed goto on compilers that set __GNUC__. For compilers that don't support computed goto it will fall back to regular switch/case statements. In addition disable using boolean values in a mathematical context. Now boolean values can only be compared with other booleans. Booleans will also no longer be coerced to integers. This PR replaces #11308 and fixes #11291
2017-09-17 00:32:05 +00:00
CASE_TYPE(math, OP_POSITIVE, BASIS)
CASE_TYPE(math, OP_POSITIVE, TRANSFORM)
CASE_TYPE(math, OP_POSITIVE, COLOR)
CASE_TYPE(math, OP_POSITIVE, NODE_PATH)
CASE_TYPE(math, OP_POSITIVE, _RID)
CASE_TYPE(math, OP_POSITIVE, OBJECT)
CASE_TYPE(math, OP_POSITIVE, DICTIONARY)
CASE_TYPE(math, OP_POSITIVE, ARRAY)
CASE_TYPE(math, OP_POSITIVE, POOL_BYTE_ARRAY)
CASE_TYPE(math, OP_POSITIVE, POOL_INT_ARRAY)
CASE_TYPE(math, OP_POSITIVE, POOL_REAL_ARRAY)
CASE_TYPE(math, OP_POSITIVE, POOL_STRING_ARRAY)
CASE_TYPE(math, OP_POSITIVE, POOL_VECTOR2_ARRAY)
CASE_TYPE(math, OP_POSITIVE, POOL_VECTOR3_ARRAY)
CASE_TYPE(math, OP_POSITIVE, POOL_COLOR_ARRAY)
_RETURN_FAIL;
}
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
Move Variant::evaluate() switch to computed goto In an effort to make GDScript a little faster replace the double switch() with a computed goto on compilers that set __GNUC__. For compilers that don't support computed goto it will fall back to regular switch/case statements. In addition disable using boolean values in a mathematical context. Now boolean values can only be compared with other booleans. Booleans will also no longer be coerced to integers. This PR replaces #11308 and fixes #11291
2017-09-17 00:32:05 +00:00
SWITCH_OP(math, OP_NEGATE, p_a.type) {
DEFAULT_OP_NUM_NEG(math, OP_NEGATE, INT, _int);
DEFAULT_OP_NUM_NEG(math, OP_NEGATE, REAL, _real);
DEFAULT_OP_LOCALMEM_NEG(math, OP_NEGATE, VECTOR2, Vector2);
DEFAULT_OP_LOCALMEM_NEG(math, OP_NEGATE, VECTOR3, Vector3);
DEFAULT_OP_LOCALMEM_NEG(math, OP_NEGATE, PLANE, Plane);
DEFAULT_OP_LOCALMEM_NEG(math, OP_NEGATE, QUAT, Quat);
DEFAULT_OP_LOCALMEM_NEG(math, OP_NEGATE, COLOR, Color);
CASE_TYPE(math, OP_NEGATE, NIL)
CASE_TYPE(math, OP_NEGATE, BOOL)
CASE_TYPE(math, OP_NEGATE, STRING)
CASE_TYPE(math, OP_NEGATE, RECT2)
CASE_TYPE(math, OP_NEGATE, TRANSFORM2D)
Rename Rect3 to AABB. Fixes #12973.
2017-11-17 02:09:00 +00:00
CASE_TYPE(math, OP_NEGATE, AABB)
Move Variant::evaluate() switch to computed goto In an effort to make GDScript a little faster replace the double switch() with a computed goto on compilers that set __GNUC__. For compilers that don't support computed goto it will fall back to regular switch/case statements. In addition disable using boolean values in a mathematical context. Now boolean values can only be compared with other booleans. Booleans will also no longer be coerced to integers. This PR replaces #11308 and fixes #11291
2017-09-17 00:32:05 +00:00
CASE_TYPE(math, OP_NEGATE, BASIS)
CASE_TYPE(math, OP_NEGATE, TRANSFORM)
CASE_TYPE(math, OP_NEGATE, NODE_PATH)
CASE_TYPE(math, OP_NEGATE, _RID)
CASE_TYPE(math, OP_NEGATE, OBJECT)
CASE_TYPE(math, OP_NEGATE, DICTIONARY)
CASE_TYPE(math, OP_NEGATE, ARRAY)
CASE_TYPE(math, OP_NEGATE, POOL_BYTE_ARRAY)
CASE_TYPE(math, OP_NEGATE, POOL_INT_ARRAY)
CASE_TYPE(math, OP_NEGATE, POOL_REAL_ARRAY)
CASE_TYPE(math, OP_NEGATE, POOL_STRING_ARRAY)
CASE_TYPE(math, OP_NEGATE, POOL_VECTOR2_ARRAY)
CASE_TYPE(math, OP_NEGATE, POOL_VECTOR3_ARRAY)
CASE_TYPE(math, OP_NEGATE, POOL_COLOR_ARRAY)
_RETURN_FAIL;
}
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
Move Variant::evaluate() switch to computed goto In an effort to make GDScript a little faster replace the double switch() with a computed goto on compilers that set __GNUC__. For compilers that don't support computed goto it will fall back to regular switch/case statements. In addition disable using boolean values in a mathematical context. Now boolean values can only be compared with other booleans. Booleans will also no longer be coerced to integers. This PR replaces #11308 and fixes #11291
2017-09-17 00:32:05 +00:00
SWITCH_OP(math, OP_MODULE, p_a.type) {
CASE_TYPE(math, OP_MODULE, INT) {
Be type-strict checking on equality checks After a short discussion with @reduz and @karroffel we decided to make all non number/number comparisons return type errors on comparisons. Now bool == bool is allowed but Vector2 == Vector3 is a type error and no longer 'not equal'. The same has been done for the != operators. In addition I forgot to add some failures to some Object operators meaning that there was a potential for a crasher.
2017-09-18 11:09:06 +00:00
if (p_b.type != INT)
Move Variant::evaluate() switch to computed goto In an effort to make GDScript a little faster replace the double switch() with a computed goto on compilers that set __GNUC__. For compilers that don't support computed goto it will fall back to regular switch/case statements. In addition disable using boolean values in a mathematical context. Now boolean values can only be compared with other booleans. Booleans will also no longer be coerced to integers. This PR replaces #11308 and fixes #11291
2017-09-17 00:32:05 +00:00
_RETURN_FAIL;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
#ifdef DEBUG_ENABLED
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
if (p_b._data._int == 0) {
r_valid = false;
_RETURN("Division By Zero");
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
}
#endif
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
_RETURN(p_a._data._int % p_b._data._int);
Move Variant::evaluate() switch to computed goto In an effort to make GDScript a little faster replace the double switch() with a computed goto on compilers that set __GNUC__. For compilers that don't support computed goto it will fall back to regular switch/case statements. In addition disable using boolean values in a mathematical context. Now boolean values can only be compared with other booleans. Booleans will also no longer be coerced to integers. This PR replaces #11308 and fixes #11291
2017-09-17 00:32:05 +00:00
}
remove trailing whitespace
2016-03-08 23:00:52 +00:00
Move Variant::evaluate() switch to computed goto In an effort to make GDScript a little faster replace the double switch() with a computed goto on compilers that set __GNUC__. For compilers that don't support computed goto it will fall back to regular switch/case statements. In addition disable using boolean values in a mathematical context. Now boolean values can only be compared with other booleans. Booleans will also no longer be coerced to integers. This PR replaces #11308 and fixes #11291
2017-09-17 00:32:05 +00:00
CASE_TYPE(math, OP_MODULE, STRING) {
Be type-strict checking on equality checks After a short discussion with @reduz and @karroffel we decided to make all non number/number comparisons return type errors on comparisons. Now bool == bool is allowed but Vector2 == Vector3 is a type error and no longer 'not equal'. The same has been done for the != operators. In addition I forgot to add some failures to some Object operators meaning that there was a potential for a crasher.
2017-09-18 11:09:06 +00: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 20:44:20 +00:00
Correctly halt on error in sprintf parsing (fixes #1393)
2015-02-19 15:45:49 +00:00
String result;
bool error;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
if (p_b.type == ARRAY) {
Added basic sprintf functionality (e.g. "fish %d %s" % [12, Vector2(1, 2)])
2015-01-10 20:44:20 +00:00
// e.g. "frog %s %d" % ["fish", 12]
Be type-strict checking on equality checks After a short discussion with @reduz and @karroffel we decided to make all non number/number comparisons return type errors on comparisons. Now bool == bool is allowed but Vector2 == Vector3 is a type error and no longer 'not equal'. The same has been done for the != operators. In addition I forgot to add some failures to some Object operators meaning that there was a potential for a crasher.
2017-09-18 11:09:06 +00:00
const Array *args = reinterpret_cast<const Array *>(p_b._data._mem);
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
result = format->sprintf(*args, &error);
Added basic sprintf functionality (e.g. "fish %d %s" % [12, Vector2(1, 2)])
2015-01-10 20:44:20 +00:00
} else {
// e.g. "frog %d" % 12
Correctly halt on error in sprintf parsing (fixes #1393)
2015-02-19 15:45:49 +00:00
Array args;
args.push_back(p_b);
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
result = format->sprintf(args, &error);
Added basic sprintf functionality (e.g. "fish %d %s" % [12, Vector2(1, 2)])
2015-01-10 20:44:20 +00:00
}
Correctly halt on error in sprintf parsing (fixes #1393)
2015-02-19 15:45:49 +00:00
r_valid = !error;
_RETURN(result);
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
}
Move Variant::evaluate() switch to computed goto In an effort to make GDScript a little faster replace the double switch() with a computed goto on compilers that set __GNUC__. For compilers that don't support computed goto it will fall back to regular switch/case statements. In addition disable using boolean values in a mathematical context. Now boolean values can only be compared with other booleans. Booleans will also no longer be coerced to integers. This PR replaces #11308 and fixes #11291
2017-09-17 00:32:05 +00:00
CASE_TYPE(math, OP_MODULE, NIL)
CASE_TYPE(math, OP_MODULE, BOOL)
CASE_TYPE(math, OP_MODULE, REAL)
CASE_TYPE(math, OP_MODULE, VECTOR2)
CASE_TYPE(math, OP_MODULE, RECT2)
CASE_TYPE(math, OP_MODULE, VECTOR3)
CASE_TYPE(math, OP_MODULE, TRANSFORM2D)
CASE_TYPE(math, OP_MODULE, PLANE)
CASE_TYPE(math, OP_MODULE, QUAT)
Rename Rect3 to AABB. Fixes #12973.
2017-11-17 02:09:00 +00:00
CASE_TYPE(math, OP_MODULE, AABB)
Move Variant::evaluate() switch to computed goto In an effort to make GDScript a little faster replace the double switch() with a computed goto on compilers that set __GNUC__. For compilers that don't support computed goto it will fall back to regular switch/case statements. In addition disable using boolean values in a mathematical context. Now boolean values can only be compared with other booleans. Booleans will also no longer be coerced to integers. This PR replaces #11308 and fixes #11291
2017-09-17 00:32:05 +00:00
CASE_TYPE(math, OP_MODULE, BASIS)
CASE_TYPE(math, OP_MODULE, TRANSFORM)
CASE_TYPE(math, OP_MODULE, COLOR)
CASE_TYPE(math, OP_MODULE, NODE_PATH)
CASE_TYPE(math, OP_MODULE, _RID)
CASE_TYPE(math, OP_MODULE, OBJECT)
CASE_TYPE(math, OP_MODULE, DICTIONARY)
CASE_TYPE(math, OP_MODULE, ARRAY)
CASE_TYPE(math, OP_MODULE, POOL_BYTE_ARRAY)
CASE_TYPE(math, OP_MODULE, POOL_INT_ARRAY)
CASE_TYPE(math, OP_MODULE, POOL_REAL_ARRAY)
CASE_TYPE(math, OP_MODULE, POOL_STRING_ARRAY)
CASE_TYPE(math, OP_MODULE, POOL_VECTOR2_ARRAY)
CASE_TYPE(math, OP_MODULE, POOL_VECTOR3_ARRAY)
CASE_TYPE(math, OP_MODULE, POOL_COLOR_ARRAY)
_RETURN_FAIL;
}
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
Move Variant::evaluate() switch to computed goto In an effort to make GDScript a little faster replace the double switch() with a computed goto on compilers that set __GNUC__. For compilers that don't support computed goto it will fall back to regular switch/case statements. In addition disable using boolean values in a mathematical context. Now boolean values can only be compared with other booleans. Booleans will also no longer be coerced to integers. This PR replaces #11308 and fixes #11291
2017-09-17 00:32:05 +00:00
SWITCH_OP(math, OP_STRING_CONCAT, p_a.type) {
CASE_TYPE_ALL(math, OP_STRING_CONCAT)
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
_RETURN(p_a.operator String() + p_b.operator String());
Move Variant::evaluate() switch to computed goto In an effort to make GDScript a little faster replace the double switch() with a computed goto on compilers that set __GNUC__. For compilers that don't support computed goto it will fall back to regular switch/case statements. In addition disable using boolean values in a mathematical context. Now boolean values can only be compared with other booleans. Booleans will also no longer be coerced to integers. This PR replaces #11308 and fixes #11291
2017-09-17 00:32:05 +00:00
}
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
Move Variant::evaluate() switch to computed goto In an effort to make GDScript a little faster replace the double switch() with a computed goto on compilers that set __GNUC__. For compilers that don't support computed goto it will fall back to regular switch/case statements. In addition disable using boolean values in a mathematical context. Now boolean values can only be compared with other booleans. Booleans will also no longer be coerced to integers. This PR replaces #11308 and fixes #11291
2017-09-17 00:32:05 +00:00
SWITCH_OP(math, OP_SHIFT_LEFT, p_a.type) {
CASE_TYPE(math, OP_SHIFT_LEFT, INT) {
if (p_b.type != INT)
_RETURN_FAIL;
_RETURN(p_a._data._int << p_b._data._int);
}
Be type-strict checking on equality checks After a short discussion with @reduz and @karroffel we decided to make all non number/number comparisons return type errors on comparisons. Now bool == bool is allowed but Vector2 == Vector3 is a type error and no longer 'not equal'. The same has been done for the != operators. In addition I forgot to add some failures to some Object operators meaning that there was a potential for a crasher.
2017-09-18 11:09:06 +00:00
Move Variant::evaluate() switch to computed goto In an effort to make GDScript a little faster replace the double switch() with a computed goto on compilers that set __GNUC__. For compilers that don't support computed goto it will fall back to regular switch/case statements. In addition disable using boolean values in a mathematical context. Now boolean values can only be compared with other booleans. Booleans will also no longer be coerced to integers. This PR replaces #11308 and fixes #11291
2017-09-17 00:32:05 +00:00
CASE_TYPE_ALL_BUT_INT(math, OP_SHIFT_LEFT)
_RETURN_FAIL;
}
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
Move Variant::evaluate() switch to computed goto In an effort to make GDScript a little faster replace the double switch() with a computed goto on compilers that set __GNUC__. For compilers that don't support computed goto it will fall back to regular switch/case statements. In addition disable using boolean values in a mathematical context. Now boolean values can only be compared with other booleans. Booleans will also no longer be coerced to integers. This PR replaces #11308 and fixes #11291
2017-09-17 00:32:05 +00:00
SWITCH_OP(math, OP_SHIFT_RIGHT, p_a.type) {
CASE_TYPE(math, OP_SHIFT_RIGHT, INT) {
if (p_b.type != INT)
_RETURN_FAIL;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
_RETURN(p_a._data._int >> p_b._data._int);
Move Variant::evaluate() switch to computed goto In an effort to make GDScript a little faster replace the double switch() with a computed goto on compilers that set __GNUC__. For compilers that don't support computed goto it will fall back to regular switch/case statements. In addition disable using boolean values in a mathematical context. Now boolean values can only be compared with other booleans. Booleans will also no longer be coerced to integers. This PR replaces #11308 and fixes #11291
2017-09-17 00:32:05 +00:00
}
Be type-strict checking on equality checks After a short discussion with @reduz and @karroffel we decided to make all non number/number comparisons return type errors on comparisons. Now bool == bool is allowed but Vector2 == Vector3 is a type error and no longer 'not equal'. The same has been done for the != operators. In addition I forgot to add some failures to some Object operators meaning that there was a potential for a crasher.
2017-09-18 11:09:06 +00:00
Move Variant::evaluate() switch to computed goto In an effort to make GDScript a little faster replace the double switch() with a computed goto on compilers that set __GNUC__. For compilers that don't support computed goto it will fall back to regular switch/case statements. In addition disable using boolean values in a mathematical context. Now boolean values can only be compared with other booleans. Booleans will also no longer be coerced to integers. This PR replaces #11308 and fixes #11291
2017-09-17 00:32:05 +00:00
CASE_TYPE_ALL_BUT_INT(math, OP_SHIFT_RIGHT)
_RETURN_FAIL;
}
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
Move Variant::evaluate() switch to computed goto In an effort to make GDScript a little faster replace the double switch() with a computed goto on compilers that set __GNUC__. For compilers that don't support computed goto it will fall back to regular switch/case statements. In addition disable using boolean values in a mathematical context. Now boolean values can only be compared with other booleans. Booleans will also no longer be coerced to integers. This PR replaces #11308 and fixes #11291
2017-09-17 00:32:05 +00:00
SWITCH_OP(math, OP_BIT_AND, p_a.type) {
CASE_TYPE(math, OP_BIT_AND, INT) {
if (p_b.type != INT)
_RETURN_FAIL;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
_RETURN(p_a._data._int & p_b._data._int);
Move Variant::evaluate() switch to computed goto In an effort to make GDScript a little faster replace the double switch() with a computed goto on compilers that set __GNUC__. For compilers that don't support computed goto it will fall back to regular switch/case statements. In addition disable using boolean values in a mathematical context. Now boolean values can only be compared with other booleans. Booleans will also no longer be coerced to integers. This PR replaces #11308 and fixes #11291
2017-09-17 00:32:05 +00:00
}
Be type-strict checking on equality checks After a short discussion with @reduz and @karroffel we decided to make all non number/number comparisons return type errors on comparisons. Now bool == bool is allowed but Vector2 == Vector3 is a type error and no longer 'not equal'. The same has been done for the != operators. In addition I forgot to add some failures to some Object operators meaning that there was a potential for a crasher.
2017-09-18 11:09:06 +00:00
Move Variant::evaluate() switch to computed goto In an effort to make GDScript a little faster replace the double switch() with a computed goto on compilers that set __GNUC__. For compilers that don't support computed goto it will fall back to regular switch/case statements. In addition disable using boolean values in a mathematical context. Now boolean values can only be compared with other booleans. Booleans will also no longer be coerced to integers. This PR replaces #11308 and fixes #11291
2017-09-17 00:32:05 +00:00
CASE_TYPE_ALL_BUT_INT(math, OP_BIT_AND)
_RETURN_FAIL;
}
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
Move Variant::evaluate() switch to computed goto In an effort to make GDScript a little faster replace the double switch() with a computed goto on compilers that set __GNUC__. For compilers that don't support computed goto it will fall back to regular switch/case statements. In addition disable using boolean values in a mathematical context. Now boolean values can only be compared with other booleans. Booleans will also no longer be coerced to integers. This PR replaces #11308 and fixes #11291
2017-09-17 00:32:05 +00:00
SWITCH_OP(math, OP_BIT_OR, p_a.type) {
CASE_TYPE(math, OP_BIT_OR, INT) {
if (p_b.type != INT)
_RETURN_FAIL;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
_RETURN(p_a._data._int | p_b._data._int);
Move Variant::evaluate() switch to computed goto In an effort to make GDScript a little faster replace the double switch() with a computed goto on compilers that set __GNUC__. For compilers that don't support computed goto it will fall back to regular switch/case statements. In addition disable using boolean values in a mathematical context. Now boolean values can only be compared with other booleans. Booleans will also no longer be coerced to integers. This PR replaces #11308 and fixes #11291
2017-09-17 00:32:05 +00:00
}
Be type-strict checking on equality checks After a short discussion with @reduz and @karroffel we decided to make all non number/number comparisons return type errors on comparisons. Now bool == bool is allowed but Vector2 == Vector3 is a type error and no longer 'not equal'. The same has been done for the != operators. In addition I forgot to add some failures to some Object operators meaning that there was a potential for a crasher.
2017-09-18 11:09:06 +00:00
Move Variant::evaluate() switch to computed goto In an effort to make GDScript a little faster replace the double switch() with a computed goto on compilers that set __GNUC__. For compilers that don't support computed goto it will fall back to regular switch/case statements. In addition disable using boolean values in a mathematical context. Now boolean values can only be compared with other booleans. Booleans will also no longer be coerced to integers. This PR replaces #11308 and fixes #11291
2017-09-17 00:32:05 +00:00
CASE_TYPE_ALL_BUT_INT(math, OP_BIT_OR)
_RETURN_FAIL;
}
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
Move Variant::evaluate() switch to computed goto In an effort to make GDScript a little faster replace the double switch() with a computed goto on compilers that set __GNUC__. For compilers that don't support computed goto it will fall back to regular switch/case statements. In addition disable using boolean values in a mathematical context. Now boolean values can only be compared with other booleans. Booleans will also no longer be coerced to integers. This PR replaces #11308 and fixes #11291
2017-09-17 00:32:05 +00:00
SWITCH_OP(math, OP_BIT_XOR, p_a.type) {
CASE_TYPE(math, OP_BIT_XOR, INT) {
if (p_b.type != INT)
_RETURN_FAIL;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
_RETURN(p_a._data._int ^ p_b._data._int);
Move Variant::evaluate() switch to computed goto In an effort to make GDScript a little faster replace the double switch() with a computed goto on compilers that set __GNUC__. For compilers that don't support computed goto it will fall back to regular switch/case statements. In addition disable using boolean values in a mathematical context. Now boolean values can only be compared with other booleans. Booleans will also no longer be coerced to integers. This PR replaces #11308 and fixes #11291
2017-09-17 00:32:05 +00:00
}
Be type-strict checking on equality checks After a short discussion with @reduz and @karroffel we decided to make all non number/number comparisons return type errors on comparisons. Now bool == bool is allowed but Vector2 == Vector3 is a type error and no longer 'not equal'. The same has been done for the != operators. In addition I forgot to add some failures to some Object operators meaning that there was a potential for a crasher.
2017-09-18 11:09:06 +00:00
Move Variant::evaluate() switch to computed goto In an effort to make GDScript a little faster replace the double switch() with a computed goto on compilers that set __GNUC__. For compilers that don't support computed goto it will fall back to regular switch/case statements. In addition disable using boolean values in a mathematical context. Now boolean values can only be compared with other booleans. Booleans will also no longer be coerced to integers. This PR replaces #11308 and fixes #11291
2017-09-17 00:32:05 +00:00
CASE_TYPE_ALL_BUT_INT(math, OP_BIT_XOR)
_RETURN_FAIL;
}
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
Move Variant::evaluate() switch to computed goto In an effort to make GDScript a little faster replace the double switch() with a computed goto on compilers that set __GNUC__. For compilers that don't support computed goto it will fall back to regular switch/case statements. In addition disable using boolean values in a mathematical context. Now boolean values can only be compared with other booleans. Booleans will also no longer be coerced to integers. This PR replaces #11308 and fixes #11291
2017-09-17 00:32:05 +00:00
SWITCH_OP(math, OP_BIT_NEGATE, p_a.type) {
CASE_TYPE(math, OP_BIT_NEGATE, INT) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
_RETURN(~p_a._data._int);
Move Variant::evaluate() switch to computed goto In an effort to make GDScript a little faster replace the double switch() with a computed goto on compilers that set __GNUC__. For compilers that don't support computed goto it will fall back to regular switch/case statements. In addition disable using boolean values in a mathematical context. Now boolean values can only be compared with other booleans. Booleans will also no longer be coerced to integers. This PR replaces #11308 and fixes #11291
2017-09-17 00:32:05 +00:00
}
Be type-strict checking on equality checks After a short discussion with @reduz and @karroffel we decided to make all non number/number comparisons return type errors on comparisons. Now bool == bool is allowed but Vector2 == Vector3 is a type error and no longer 'not equal'. The same has been done for the != operators. In addition I forgot to add some failures to some Object operators meaning that there was a potential for a crasher.
2017-09-18 11:09:06 +00:00
Move Variant::evaluate() switch to computed goto In an effort to make GDScript a little faster replace the double switch() with a computed goto on compilers that set __GNUC__. For compilers that don't support computed goto it will fall back to regular switch/case statements. In addition disable using boolean values in a mathematical context. Now boolean values can only be compared with other booleans. Booleans will also no longer be coerced to integers. This PR replaces #11308 and fixes #11291
2017-09-17 00:32:05 +00:00
CASE_TYPE_ALL_BUT_INT(math, OP_BIT_NEGATE)
_RETURN_FAIL;
}
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
Move Variant::evaluate() switch to computed goto In an effort to make GDScript a little faster replace the double switch() with a computed goto on compilers that set __GNUC__. For compilers that don't support computed goto it will fall back to regular switch/case statements. In addition disable using boolean values in a mathematical context. Now boolean values can only be compared with other booleans. Booleans will also no longer be coerced to integers. This PR replaces #11308 and fixes #11291
2017-09-17 00:32:05 +00:00
SWITCH_OP(math, OP_AND, p_a.type) {
CASE_TYPE_ALL(math, OP_AND) {
Allow booleanization of all types We now allow booleanization of all types. This means that empty versions of all types now evaluate to false. So a Vector2(0,0), Dictionary(), etc. This allows you to write GDScript like: if not Dictionary(): print("Empty dict") Booleanization can now also no longer fail. There is no more valid flag, this changes Variant and GDNative API.
2017-09-18 18:02:47 +00:00
bool l = p_a.booleanize();
bool r = p_b.booleanize();
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
Move Variant::evaluate() switch to computed goto In an effort to make GDScript a little faster replace the double switch() with a computed goto on compilers that set __GNUC__. For compilers that don't support computed goto it will fall back to regular switch/case statements. In addition disable using boolean values in a mathematical context. Now boolean values can only be compared with other booleans. Booleans will also no longer be coerced to integers. This PR replaces #11308 and fixes #11291
2017-09-17 00:32:05 +00:00
_RETURN(l && r);
}
}
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
Move Variant::evaluate() switch to computed goto In an effort to make GDScript a little faster replace the double switch() with a computed goto on compilers that set __GNUC__. For compilers that don't support computed goto it will fall back to regular switch/case statements. In addition disable using boolean values in a mathematical context. Now boolean values can only be compared with other booleans. Booleans will also no longer be coerced to integers. This PR replaces #11308 and fixes #11291
2017-09-17 00:32:05 +00:00
SWITCH_OP(math, OP_OR, p_a.type) {
CASE_TYPE_ALL(math, OP_OR) {
Allow booleanization of all types We now allow booleanization of all types. This means that empty versions of all types now evaluate to false. So a Vector2(0,0), Dictionary(), etc. This allows you to write GDScript like: if not Dictionary(): print("Empty dict") Booleanization can now also no longer fail. There is no more valid flag, this changes Variant and GDNative API.
2017-09-18 18:02:47 +00:00
bool l = p_a.booleanize();
bool r = p_b.booleanize();
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
Move Variant::evaluate() switch to computed goto In an effort to make GDScript a little faster replace the double switch() with a computed goto on compilers that set __GNUC__. For compilers that don't support computed goto it will fall back to regular switch/case statements. In addition disable using boolean values in a mathematical context. Now boolean values can only be compared with other booleans. Booleans will also no longer be coerced to integers. This PR replaces #11308 and fixes #11291
2017-09-17 00:32:05 +00:00
_RETURN(l || r);
}
}
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
Move Variant::evaluate() switch to computed goto In an effort to make GDScript a little faster replace the double switch() with a computed goto on compilers that set __GNUC__. For compilers that don't support computed goto it will fall back to regular switch/case statements. In addition disable using boolean values in a mathematical context. Now boolean values can only be compared with other booleans. Booleans will also no longer be coerced to integers. This PR replaces #11308 and fixes #11291
2017-09-17 00:32:05 +00:00
SWITCH_OP(math, OP_XOR, p_a.type) {
CASE_TYPE_ALL(math, OP_XOR) {
Allow booleanization of all types We now allow booleanization of all types. This means that empty versions of all types now evaluate to false. So a Vector2(0,0), Dictionary(), etc. This allows you to write GDScript like: if not Dictionary(): print("Empty dict") Booleanization can now also no longer fail. There is no more valid flag, this changes Variant and GDNative API.
2017-09-18 18:02:47 +00:00
bool l = p_a.booleanize();
bool r = p_b.booleanize();
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
Move Variant::evaluate() switch to computed goto In an effort to make GDScript a little faster replace the double switch() with a computed goto on compilers that set __GNUC__. For compilers that don't support computed goto it will fall back to regular switch/case statements. In addition disable using boolean values in a mathematical context. Now boolean values can only be compared with other booleans. Booleans will also no longer be coerced to integers. This PR replaces #11308 and fixes #11291
2017-09-17 00:32:05 +00:00
_RETURN((l || r) && !(l && r));
}
}
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
Move Variant::evaluate() switch to computed goto In an effort to make GDScript a little faster replace the double switch() with a computed goto on compilers that set __GNUC__. For compilers that don't support computed goto it will fall back to regular switch/case statements. In addition disable using boolean values in a mathematical context. Now boolean values can only be compared with other booleans. Booleans will also no longer be coerced to integers. This PR replaces #11308 and fixes #11291
2017-09-17 00:32:05 +00:00
SWITCH_OP(math, OP_NOT, p_a.type) {
CASE_TYPE_ALL(math, OP_NOT) {
Allow booleanization of all types We now allow booleanization of all types. This means that empty versions of all types now evaluate to false. So a Vector2(0,0), Dictionary(), etc. This allows you to write GDScript like: if not Dictionary(): print("Empty dict") Booleanization can now also no longer fail. There is no more valid flag, this changes Variant and GDNative API.
2017-09-18 18:02:47 +00:00
bool l = p_a.booleanize();
Move Variant::evaluate() switch to computed goto In an effort to make GDScript a little faster replace the double switch() with a computed goto on compilers that set __GNUC__. For compilers that don't support computed goto it will fall back to regular switch/case statements. In addition disable using boolean values in a mathematical context. Now boolean values can only be compared with other booleans. Booleans will also no longer be coerced to integers. This PR replaces #11308 and fixes #11291
2017-09-17 00:32:05 +00:00
_RETURN(!l);
}
}
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
Move Variant::evaluate() switch to computed goto In an effort to make GDScript a little faster replace the double switch() with a computed goto on compilers that set __GNUC__. For compilers that don't support computed goto it will fall back to regular switch/case statements. In addition disable using boolean values in a mathematical context. Now boolean values can only be compared with other booleans. Booleans will also no longer be coerced to integers. This PR replaces #11308 and fixes #11291
2017-09-17 00:32:05 +00:00
SWITCH_OP(math, OP_IN, p_a.type) {
CASE_TYPE_ALL(math, OP_IN)
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
_RETURN(p_b.in(p_a, &r_valid));
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
}
}
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
void Variant::set_named(const StringName &p_index, const Variant &p_value, bool *r_valid) {
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
Massive optimization to Variant::set_named/get_named. Should give a nice boost to GDScript.
2017-09-24 00:05:35 +00:00
bool valid = false;
switch (type) {
case VECTOR2: {
if (p_value.type == Variant::INT) {
Vector2 *v = reinterpret_cast<Vector2 *>(_data._mem);
if (p_index == CoreStringNames::singleton->x) {
v->x = p_value._data._int;
valid = true;
} else if (p_index == CoreStringNames::singleton->y) {
v->y = p_value._data._int;
valid = true;
}
} else if (p_value.type == Variant::REAL) {
Vector2 *v = reinterpret_cast<Vector2 *>(_data._mem);
if (p_index == CoreStringNames::singleton->x) {
v->x = p_value._data._real;
valid = true;
} else if (p_index == CoreStringNames::singleton->y) {
v->y = p_value._data._real;
valid = true;
}
}
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
Massive optimization to Variant::set_named/get_named. Should give a nice boost to GDScript.
2017-09-24 00:05:35 +00:00
} break;
case RECT2: {
if (p_value.type == Variant::VECTOR2) {
Rect2 *v = reinterpret_cast<Rect2 *>(_data._mem);
//scalar name
if (p_index == CoreStringNames::singleton->position) {
v->position = *reinterpret_cast<const Vector2 *>(p_value._data._mem);
valid = true;
} else if (p_index == CoreStringNames::singleton->size) {
v->size = *reinterpret_cast<const Vector2 *>(p_value._data._mem);
valid = true;
} else if (p_index == CoreStringNames::singleton->end) {
v->size = *reinterpret_cast<const Vector2 *>(p_value._data._mem) - v->position;
valid = true;
}
}
} break;
case TRANSFORM2D: {
if (p_value.type == Variant::VECTOR2) {
Transform2D *v = _data._transform2d;
if (p_index == CoreStringNames::singleton->x) {
v->elements[0] = *reinterpret_cast<const Vector2 *>(p_value._data._mem);
valid = true;
} else if (p_index == CoreStringNames::singleton->y) {
v->elements[1] = *reinterpret_cast<const Vector2 *>(p_value._data._mem);
valid = true;
} else if (p_index == CoreStringNames::singleton->origin) {
v->elements[2] = *reinterpret_cast<const Vector2 *>(p_value._data._mem);
valid = true;
}
}
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
Massive optimization to Variant::set_named/get_named. Should give a nice boost to GDScript.
2017-09-24 00:05:35 +00:00
} break;
case VECTOR3: {
if (p_value.type == Variant::INT) {
Vector3 *v = reinterpret_cast<Vector3 *>(_data._mem);
if (p_index == CoreStringNames::singleton->x) {
v->x = p_value._data._int;
valid = true;
} else if (p_index == CoreStringNames::singleton->y) {
v->y = p_value._data._int;
valid = true;
} else if (p_index == CoreStringNames::singleton->z) {
v->z = p_value._data._int;
valid = true;
}
} else if (p_value.type == Variant::REAL) {
Vector3 *v = reinterpret_cast<Vector3 *>(_data._mem);
if (p_index == CoreStringNames::singleton->x) {
v->x = p_value._data._real;
valid = true;
} else if (p_index == CoreStringNames::singleton->y) {
v->y = p_value._data._real;
valid = true;
} else if (p_index == CoreStringNames::singleton->z) {
v->z = p_value._data._real;
valid = true;
}
}
} break;
case PLANE: {
if (p_value.type == Variant::INT) {
Plane *v = reinterpret_cast<Plane *>(_data._mem);
if (p_index == CoreStringNames::singleton->x) {
v->normal.x = p_value._data._int;
valid = true;
} else if (p_index == CoreStringNames::singleton->y) {
v->normal.y = p_value._data._int;
valid = true;
} else if (p_index == CoreStringNames::singleton->z) {
v->normal.z = p_value._data._int;
valid = true;
} else if (p_index == CoreStringNames::singleton->d) {
v->d = p_value._data._int;
valid = true;
}
} else if (p_value.type == Variant::REAL) {
Plane *v = reinterpret_cast<Plane *>(_data._mem);
if (p_index == CoreStringNames::singleton->x) {
v->normal.x = p_value._data._real;
valid = true;
} else if (p_index == CoreStringNames::singleton->y) {
v->normal.y = p_value._data._real;
valid = true;
} else if (p_index == CoreStringNames::singleton->z) {
v->normal.z = p_value._data._real;
valid = true;
} else if (p_index == CoreStringNames::singleton->d) {
v->d = p_value._data._real;
valid = true;
}
} else if (p_value.type == Variant::VECTOR3) {
Plane *v = reinterpret_cast<Plane *>(_data._mem);
if (p_index == CoreStringNames::singleton->normal) {
v->normal = *reinterpret_cast<const Vector3 *>(p_value._data._mem);
valid = true;
}
}
} break;
case QUAT: {
if (p_value.type == Variant::INT) {
Quat *v = reinterpret_cast<Quat *>(_data._mem);
if (p_index == CoreStringNames::singleton->x) {
v->x = p_value._data._int;
valid = true;
} else if (p_index == CoreStringNames::singleton->y) {
v->y = p_value._data._int;
valid = true;
} else if (p_index == CoreStringNames::singleton->z) {
v->z = p_value._data._int;
valid = true;
} else if (p_index == CoreStringNames::singleton->w) {
v->w = p_value._data._int;
valid = true;
}
} else if (p_value.type == Variant::REAL) {
Quat *v = reinterpret_cast<Quat *>(_data._mem);
if (p_index == CoreStringNames::singleton->x) {
v->x = p_value._data._real;
valid = true;
} else if (p_index == CoreStringNames::singleton->y) {
v->y = p_value._data._real;
valid = true;
} else if (p_index == CoreStringNames::singleton->z) {
v->z = p_value._data._real;
valid = true;
} else if (p_index == CoreStringNames::singleton->w) {
v->w = p_value._data._real;
valid = true;
}
}
} break; // 10
Rename Rect3 to AABB. Fixes #12973.
2017-11-17 02:09:00 +00:00
case AABB: {
Massive optimization to Variant::set_named/get_named. Should give a nice boost to GDScript.
2017-09-24 00:05:35 +00:00
if (p_value.type == Variant::VECTOR3) {
Rename Rect3 to AABB. Fixes #12973.
2017-11-17 02:09:00 +00:00
::AABB *v = _data._aabb;
Massive optimization to Variant::set_named/get_named. Should give a nice boost to GDScript.
2017-09-24 00:05:35 +00:00
//scalar name
if (p_index == CoreStringNames::singleton->position) {
v->position = *reinterpret_cast<const Vector3 *>(p_value._data._mem);
valid = true;
} else if (p_index == CoreStringNames::singleton->size) {
v->size = *reinterpret_cast<const Vector3 *>(p_value._data._mem);
valid = true;
} else if (p_index == CoreStringNames::singleton->end) {
v->size = *reinterpret_cast<const Vector3 *>(p_value._data._mem) - v->position;
valid = true;
}
}
} break;
case BASIS: {
if (p_value.type == Variant::VECTOR3) {
Basis *v = _data._basis;
//scalar name
if (p_index == CoreStringNames::singleton->x) {
v->set_axis(0, *reinterpret_cast<const Vector3 *>(p_value._data._mem));
valid = true;
} else if (p_index == CoreStringNames::singleton->y) {
v->set_axis(1, *reinterpret_cast<const Vector3 *>(p_value._data._mem));
valid = true;
} else if (p_index == CoreStringNames::singleton->z) {
v->set_axis(2, *reinterpret_cast<const Vector3 *>(p_value._data._mem));
valid = true;
}
}
} break;
case TRANSFORM: {
if (p_value.type == Variant::BASIS && p_index == CoreStringNames::singleton->basis) {
_data._transform->basis = *p_value._data._basis;
valid = true;
} else if (p_value.type == Variant::VECTOR3 && p_index == CoreStringNames::singleton->origin) {
_data._transform->origin = *reinterpret_cast<const Vector3 *>(p_value._data._mem);
valid = true;
}
} break;
case COLOR: {
if (p_value.type == Variant::INT) {
Color *v = reinterpret_cast<Color *>(_data._mem);
if (p_index == CoreStringNames::singleton->r) {
v->r = p_value._data._int;
valid = true;
} else if (p_index == CoreStringNames::singleton->g) {
v->g = p_value._data._int;
valid = true;
} else if (p_index == CoreStringNames::singleton->b) {
v->b = p_value._data._int;
valid = true;
} else if (p_index == CoreStringNames::singleton->a) {
v->a = p_value._data._int;
valid = true;
} else if (p_index == CoreStringNames::singleton->r8) {
v->r = p_value._data._int / 255.0;
valid = true;
} else if (p_index == CoreStringNames::singleton->g8) {
v->g = p_value._data._int / 255.0;
valid = true;
} else if (p_index == CoreStringNames::singleton->b8) {
v->b = p_value._data._int / 255.0;
valid = true;
} else if (p_index == CoreStringNames::singleton->a8) {
v->a = p_value._data._int / 255.0;
valid = true;
} else if (p_index == CoreStringNames::singleton->h) {
Keep alpha when changing h, s or v on color When modifying the h, s or v properties of a color in GDScript the alpha value needs to stay unchanged.
2018-04-22 15:00:45 +00:00
v->set_hsv(p_value._data._int, v->get_s(), v->get_v(), v->a);
Massive optimization to Variant::set_named/get_named. Should give a nice boost to GDScript.
2017-09-24 00:05:35 +00:00
valid = true;
} else if (p_index == CoreStringNames::singleton->s) {
Keep alpha when changing h, s or v on color When modifying the h, s or v properties of a color in GDScript the alpha value needs to stay unchanged.
2018-04-22 15:00:45 +00:00
v->set_hsv(v->get_h(), p_value._data._int, v->get_v(), v->a);
Massive optimization to Variant::set_named/get_named. Should give a nice boost to GDScript.
2017-09-24 00:05:35 +00:00
valid = true;
} else if (p_index == CoreStringNames::singleton->v) {
Keep alpha when changing h, s or v on color When modifying the h, s or v properties of a color in GDScript the alpha value needs to stay unchanged.
2018-04-22 15:00:45 +00:00
v->set_hsv(v->get_h(), v->get_v(), p_value._data._int, v->a);
Massive optimization to Variant::set_named/get_named. Should give a nice boost to GDScript.
2017-09-24 00:05:35 +00:00
valid = true;
}
} else if (p_value.type == Variant::REAL) {
Color *v = reinterpret_cast<Color *>(_data._mem);
if (p_index == CoreStringNames::singleton->r) {
v->r = p_value._data._real;
valid = true;
} else if (p_index == CoreStringNames::singleton->g) {
v->g = p_value._data._real;
valid = true;
} else if (p_index == CoreStringNames::singleton->b) {
v->b = p_value._data._real;
valid = true;
} else if (p_index == CoreStringNames::singleton->a) {
v->a = p_value._data._real;
valid = true;
} else if (p_index == CoreStringNames::singleton->r8) {
v->r = p_value._data._real / 255.0;
valid = true;
} else if (p_index == CoreStringNames::singleton->g8) {
v->g = p_value._data._real / 255.0;
valid = true;
} else if (p_index == CoreStringNames::singleton->b8) {
v->b = p_value._data._real / 255.0;
valid = true;
} else if (p_index == CoreStringNames::singleton->a8) {
v->a = p_value._data._real / 255.0;
valid = true;
} else if (p_index == CoreStringNames::singleton->h) {
Keep alpha when changing h, s or v on color When modifying the h, s or v properties of a color in GDScript the alpha value needs to stay unchanged.
2018-04-22 15:00:45 +00:00
v->set_hsv(p_value._data._real, v->get_s(), v->get_v(), v->a);
Massive optimization to Variant::set_named/get_named. Should give a nice boost to GDScript.
2017-09-24 00:05:35 +00:00
valid = true;
} else if (p_index == CoreStringNames::singleton->s) {
Keep alpha when changing h, s or v on color When modifying the h, s or v properties of a color in GDScript the alpha value needs to stay unchanged.
2018-04-22 15:00:45 +00:00
v->set_hsv(v->get_h(), p_value._data._real, v->get_v(), v->a);
Massive optimization to Variant::set_named/get_named. Should give a nice boost to GDScript.
2017-09-24 00:05:35 +00:00
valid = true;
} else if (p_index == CoreStringNames::singleton->v) {
Keep alpha when changing h, s or v on color When modifying the h, s or v properties of a color in GDScript the alpha value needs to stay unchanged.
2018-04-22 15:00:45 +00:00
v->set_hsv(v->get_h(), v->get_s(), p_value._data._real, v->a);
Massive optimization to Variant::set_named/get_named. Should give a nice boost to GDScript.
2017-09-24 00:05:35 +00:00
valid = true;
}
}
} break;
case OBJECT: {
#ifdef DEBUG_ENABLED
if (!_get_obj().obj) {
break;
} else if (ScriptDebugger::get_singleton() && _get_obj().ref.is_null() && !ObjectDB::instance_validate(_get_obj().obj)) {
break;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
}
#endif
Massive optimization to Variant::set_named/get_named. Should give a nice boost to GDScript.
2017-09-24 00:05:35 +00:00
_get_obj().obj->set(p_index, p_value, &valid);
} break;
default: {
Fix Dictionary set_named Reduz optimized field indexing in 3c85703 but the changes didn't apply to dictionary so this code remained untouched. However, the logic for validity checking was changed but not updated for the dictionary case.
2017-09-24 17:44:49 +00:00
set(p_index.operator String(), p_value, &valid);
Massive optimization to Variant::set_named/get_named. Should give a nice boost to GDScript.
2017-09-24 00:05:35 +00:00
} break;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
}
Massive optimization to Variant::set_named/get_named. Should give a nice boost to GDScript.
2017-09-24 00:05:35 +00:00
if (r_valid) {
*r_valid = valid;
}
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
Variant Variant::get_named(const StringName &p_index, bool *r_valid) const {
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
Massive optimization to Variant::set_named/get_named. Should give a nice boost to GDScript.
2017-09-24 00:05:35 +00:00
if (r_valid) {
*r_valid = true;
}
switch (type) {
case VECTOR2: {
const Vector2 *v = reinterpret_cast<const Vector2 *>(_data._mem);
if (p_index == CoreStringNames::singleton->x) {
return v->x;
} else if (p_index == CoreStringNames::singleton->y) {
return v->y;
}
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
Massive optimization to Variant::set_named/get_named. Should give a nice boost to GDScript.
2017-09-24 00:05:35 +00:00
} break;
case RECT2: {
const Rect2 *v = reinterpret_cast<const Rect2 *>(_data._mem);
//scalar name
if (p_index == CoreStringNames::singleton->position) {
return v->position;
} else if (p_index == CoreStringNames::singleton->size) {
return v->size;
} else if (p_index == CoreStringNames::singleton->end) {
return v->size + v->position;
}
} break;
case TRANSFORM2D: {
const Transform2D *v = _data._transform2d;
if (p_index == CoreStringNames::singleton->x) {
return v->elements[0];
} else if (p_index == CoreStringNames::singleton->y) {
return v->elements[1];
} else if (p_index == CoreStringNames::singleton->origin) {
return v->elements[2];
}
} break;
case VECTOR3: {
const Vector3 *v = reinterpret_cast<const Vector3 *>(_data._mem);
if (p_index == CoreStringNames::singleton->x) {
return v->x;
} else if (p_index == CoreStringNames::singleton->y) {
return v->y;
} else if (p_index == CoreStringNames::singleton->z) {
return v->z;
}
} break;
case PLANE: {
const Plane *v = reinterpret_cast<const Plane *>(_data._mem);
if (p_index == CoreStringNames::singleton->x) {
return v->normal.x;
} else if (p_index == CoreStringNames::singleton->y) {
return v->normal.y;
} else if (p_index == CoreStringNames::singleton->z) {
return v->normal.z;
} else if (p_index == CoreStringNames::singleton->d) {
return v->d;
} else if (p_index == CoreStringNames::singleton->normal) {
return v->normal;
}
} break;
case QUAT: {
const Quat *v = reinterpret_cast<const Quat *>(_data._mem);
if (p_index == CoreStringNames::singleton->x) {
return v->x;
} else if (p_index == CoreStringNames::singleton->y) {
return v->y;
} else if (p_index == CoreStringNames::singleton->z) {
return v->z;
} else if (p_index == CoreStringNames::singleton->w) {
return v->w;
}
} break; // 10
Rename Rect3 to AABB. Fixes #12973.
2017-11-17 02:09:00 +00:00
case AABB: {
Massive optimization to Variant::set_named/get_named. Should give a nice boost to GDScript.
2017-09-24 00:05:35 +00:00
Rename Rect3 to AABB. Fixes #12973.
2017-11-17 02:09:00 +00:00
const ::AABB *v = _data._aabb;
Massive optimization to Variant::set_named/get_named. Should give a nice boost to GDScript.
2017-09-24 00:05:35 +00:00
//scalar name
if (p_index == CoreStringNames::singleton->position) {
return v->position;
} else if (p_index == CoreStringNames::singleton->size) {
return v->size;
} else if (p_index == CoreStringNames::singleton->end) {
return v->size + v->position;
}
} break;
case BASIS: {
const Basis *v = _data._basis;
//scalar name
if (p_index == CoreStringNames::singleton->x) {
return v->get_axis(0);
} else if (p_index == CoreStringNames::singleton->y) {
return v->get_axis(1);
} else if (p_index == CoreStringNames::singleton->z) {
return v->get_axis(2);
}
} break;
case TRANSFORM: {
if (p_index == CoreStringNames::singleton->basis) {
return _data._transform->basis;
} else if (p_index == CoreStringNames::singleton->origin) {
return _data._transform->origin;
}
} break;
case COLOR: {
const Color *v = reinterpret_cast<const Color *>(_data._mem);
if (p_index == CoreStringNames::singleton->r) {
return v->r;
} else if (p_index == CoreStringNames::singleton->g) {
return v->g;
} else if (p_index == CoreStringNames::singleton->b) {
return v->b;
} else if (p_index == CoreStringNames::singleton->a) {
return v->a;
} else if (p_index == CoreStringNames::singleton->r8) {
Fix Color.r8/g8/b8/a8 being type float instead of type int
2017-10-19 15:36:06 +00:00
return int(v->r * 255.0);
Massive optimization to Variant::set_named/get_named. Should give a nice boost to GDScript.
2017-09-24 00:05:35 +00:00
} else if (p_index == CoreStringNames::singleton->g8) {
Fix Color.r8/g8/b8/a8 being type float instead of type int
2017-10-19 15:36:06 +00:00
return int(v->g * 255.0);
Massive optimization to Variant::set_named/get_named. Should give a nice boost to GDScript.
2017-09-24 00:05:35 +00:00
} else if (p_index == CoreStringNames::singleton->b8) {
Fix Color.r8/g8/b8/a8 being type float instead of type int
2017-10-19 15:36:06 +00:00
return int(v->b * 255.0);
Massive optimization to Variant::set_named/get_named. Should give a nice boost to GDScript.
2017-09-24 00:05:35 +00:00
} else if (p_index == CoreStringNames::singleton->a8) {
Fix Color.r8/g8/b8/a8 being type float instead of type int
2017-10-19 15:36:06 +00:00
return int(v->a * 255.0);
Massive optimization to Variant::set_named/get_named. Should give a nice boost to GDScript.
2017-09-24 00:05:35 +00:00
} else if (p_index == CoreStringNames::singleton->h) {
return v->get_h();
} else if (p_index == CoreStringNames::singleton->s) {
return v->get_s();
} else if (p_index == CoreStringNames::singleton->v) {
return v->get_v();
}
} break;
case OBJECT: {
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
Massive optimization to Variant::set_named/get_named. Should give a nice boost to GDScript.
2017-09-24 00:05:35 +00:00
#ifdef DEBUG_ENABLED
if (!_get_obj().obj) {
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
if (r_valid)
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
*r_valid = false;
Massive optimization to Variant::set_named/get_named. Should give a nice boost to GDScript.
2017-09-24 00:05:35 +00:00
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.";
}
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
}
#endif
Massive optimization to Variant::set_named/get_named. Should give a nice boost to GDScript.
2017-09-24 00:05:35 +00:00
return _get_obj().obj->get(p_index, r_valid);
} break;
default: {
return get(p_index.operator String(), r_valid);
}
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
}
Massive optimization to Variant::set_named/get_named. Should give a nice boost to GDScript.
2017-09-24 00:05:35 +00:00
if (r_valid) {
*r_valid = false;
}
Fix Variant::get_named return when p_index is invalid
2017-09-24 17:50:51 +00:00
return Variant();
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00: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); \
\
if (index < 0) \
index += arr->size(); \
if (index >= 0 && index < arr->size()) { \
valid = true; \
cmd; \
} \
} \
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 21:35:33 +00:00
} break;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
#define DEFAULT_OP_DVECTOR_SET(m_name, dv_type, skip_cond) \
DEFAULT_OP_ARRAY_CMD(m_name, PoolVector<dv_type>, if (skip_cond) return;, arr->set(index, p_value); return )
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 21:35:33 +00:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
#define DEFAULT_OP_DVECTOR_GET(m_name, dv_type) \
Memory pool vectors (DVector) have been enormously simplified in code, and renamed to PoolVector
2017-01-07 21:25:37 +00:00
DEFAULT_OP_ARRAY_CMD(m_name, const PoolVector<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 21:35:33 +00:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
void Variant::set(const Variant &p_index, const Variant &p_value, bool *r_valid) {
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
static bool _dummy = false;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
bool &valid = r_valid ? *r_valid : _dummy;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
valid = false;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
switch (type) {
case NIL: {
return;
} break;
case BOOL: {
return;
} break;
case INT: {
return;
} break;
case REAL: {
return;
} break;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
case STRING: {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
if (p_index.type != Variant::INT && p_index.type != Variant::REAL)
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00: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 14:12:10 +00:00
int len = str->length();
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
if (idx < 0)
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 14:12:10 +00:00
idx += len;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
if (idx < 0 || idx >= len)
-assignment of ord to string index made valid #1072
2015-01-02 16:17:46 +00:00
return;
String chr;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
if (p_value.type == Variant::INT || p_value.type == Variant::REAL) {
-assignment of ord to string index made valid #1072
2015-01-02 16:17:46 +00:00
chr = String::chr(p_value);
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
} else if (p_value.type == Variant::STRING) {
-assignment of ord to string index made valid #1072
2015-01-02 16:17:46 +00:00
chr = p_value;
} else {
return;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
*str = str->substr(0, idx) + chr + str->substr(idx + 1, len);
valid = true;
-assignment of ord to string index made valid #1072
2015-01-02 16:17:46 +00:00
return;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
} break;
case VECTOR2: {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
if (p_value.type != Variant::INT && p_value.type != Variant::REAL)
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
if (p_index.get_type() == Variant::INT || p_index.get_type() == Variant::REAL) {
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
// scalar index
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
int idx = p_index;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
if (idx < 0)
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 14:12:10 +00:00
idx += 2;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
if (idx >= 0 && idx < 2) {
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
Vector2 *v = reinterpret_cast<Vector2 *>(_data._mem);
valid = true;
(*v)[idx] = p_value;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return;
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
} else if (p_index.get_type() == Variant::STRING) {
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
//scalar name
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
const String *str = reinterpret_cast<const String *>(p_index._data._mem);
Vector2 *v = reinterpret_cast<Vector2 *>(_data._mem);
-Many fixes to VisualScript, fixed property names, etc. -Added ability to set/get a field in GetSet, as well as assignment ops -Added a Select node -Fixed update bugs related to variable list and exported properties, closes #9458
2017-07-01 00:30:17 +00:00
if (*str == "x") {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
valid = true;
v->x = p_value;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return;
-Many fixes to VisualScript, fixed property names, etc. -Added ability to set/get a field in GetSet, as well as assignment ops -Added a Select node -Fixed update bugs related to variable list and exported properties, closes #9458
2017-07-01 00:30:17 +00:00
} else if (*str == "y") {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
valid = true;
v->y = p_value;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return;
}
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
} break; // 5
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
case RECT2: {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
if (p_value.type != Variant::VECTOR2)
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
if (p_index.get_type() == Variant::STRING) {
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
//scalar name
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
const String *str = reinterpret_cast<const String *>(p_index._data._mem);
Rect2 *v = reinterpret_cast<Rect2 *>(_data._mem);
renamed all Rect2.pos to Rect2.position
2017-06-03 22:25:13 +00:00
if (*str == "position") {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
valid = true;
renamed all Rect2.pos to Rect2.position
2017-06-03 22:25:13 +00:00
v->position = p_value;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
} else if (*str == "size") {
valid = true;
v->size = p_value;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
} else if (*str == "end") {
valid = true;
renamed all Rect2.pos to Rect2.position
2017-06-03 22:25:13 +00:00
v->size = Vector2(p_value) - v->position;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return;
}
}
} break;
Type renames: Matrix32 -> Transform2D Matrix3 -> Basis AABB -> Rect3 RawArray -> PoolByteArray IntArray -> PoolIntArray FloatArray -> PoolFloatArray Vector2Array -> PoolVector2Array Vector3Array -> PoolVector3Array ColorArray -> PoolColorArray
2017-01-11 03:52:51 +00:00
case TRANSFORM2D: {
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
if (p_value.type != Variant::VECTOR2)
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
if (p_index.get_type() == Variant::INT || p_index.get_type() == Variant::REAL) {
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
int index = p_index;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
if (index < 0)
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 14:12:10 +00:00
index += 3;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
if (index >= 0 && index < 3) {
Transform2D *v = _data._transform2d;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
valid = true;
v->elements[index] = p_value;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return;
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
} else if (p_index.get_type() == Variant::STRING && p_value.get_type() == Variant::VECTOR2) {
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
//scalar name
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
const String *str = reinterpret_cast<const String *>(p_index._data._mem);
Transform2D *v = _data._transform2d;
if (*str == "x") {
valid = true;
v->elements[0] = p_value;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
} else if (*str == "y") {
valid = true;
v->elements[1] = p_value;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return;
-Many fixes to VisualScript, fixed property names, etc. -Added ability to set/get a field in GetSet, as well as assignment ops -Added a Select node -Fixed update bugs related to variable list and exported properties, closes #9458
2017-07-01 00:30:17 +00:00
} else if (*str == "origin") {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
valid = true;
v->elements[2] = p_value;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return;
}
}
} break;
case VECTOR3: {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
if (p_value.type != Variant::INT && p_value.type != Variant::REAL)
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
if (p_index.get_type() == Variant::INT || p_index.get_type() == Variant::REAL) {
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
//scalar index
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
int idx = p_index;
if (idx < 0)
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 14:12:10 +00:00
idx += 3;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
if (idx >= 0 && idx < 3) {
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
Vector3 *v = reinterpret_cast<Vector3 *>(_data._mem);
valid = true;
(*v)[idx] = p_value;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return;
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
} else if (p_index.get_type() == Variant::STRING) {
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
//scalar name
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
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;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
} else if (*str == "y") {
valid = true;
v->y = p_value;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
} else if (*str == "z") {
valid = true;
v->z = p_value;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return;
}
}
} break;
case PLANE: {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
if (p_index.get_type() == Variant::STRING) {
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
//scalar name
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
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)
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
valid = true;
v->normal.x = p_value;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
} else if (*str == "y") {
if (p_value.type != Variant::INT && p_value.type != Variant::REAL)
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
valid = true;
v->normal.y = p_value;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
} else if (*str == "z") {
if (p_value.type != Variant::INT && p_value.type != Variant::REAL)
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
valid = true;
v->normal.z = p_value;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
} else if (*str == "normal") {
if (p_value.type != Variant::VECTOR3)
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
valid = true;
v->normal = p_value;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
} else if (*str == "d") {
valid = true;
v->d = p_value;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return;
}
}
} break;
case QUAT: {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
if (p_value.type != Variant::INT && p_value.type != Variant::REAL)
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
if (p_index.get_type() == Variant::STRING) {
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
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;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
} else if (*str == "y") {
valid = true;
v->y = p_value;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
} else if (*str == "z") {
valid = true;
v->z = p_value;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
} else if (*str == "w") {
valid = true;
v->w = p_value;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return;
}
}
Fix two typos from previous commit Also cleanup comments on variant types.
2017-05-17 16:45:56 +00:00
} break; // 10
Rename Rect3 to AABB. Fixes #12973.
2017-11-17 02:09:00 +00:00
case AABB: {
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
if (p_value.type != Variant::VECTOR3)
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
if (p_index.get_type() == Variant::STRING) {
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
//scalar name
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
const String *str = reinterpret_cast<const String *>(p_index._data._mem);
Rename Rect3 to AABB. Fixes #12973.
2017-11-17 02:09:00 +00:00
::AABB *v = _data._aabb;
renamed all Rect3.pos to Rect3.position
2017-06-06 18:33:51 +00:00
if (*str == "position") {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
valid = true;
renamed all Rect3.pos to Rect3.position
2017-06-06 18:33:51 +00:00
v->position = p_value;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
} else if (*str == "size") {
valid = true;
v->size = p_value;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
} else if (*str == "end") {
valid = true;
renamed all Rect3.pos to Rect3.position
2017-06-06 18:33:51 +00:00
v->size = Vector3(p_value) - v->position;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return;
}
}
Fix two typos from previous commit Also cleanup comments on variant types.
2017-05-17 16:45:56 +00:00
} break;
Type renames: Matrix32 -> Transform2D Matrix3 -> Basis AABB -> Rect3 RawArray -> PoolByteArray IntArray -> PoolIntArray FloatArray -> PoolFloatArray Vector2Array -> PoolVector2Array Vector3Array -> PoolVector3Array ColorArray -> PoolColorArray
2017-01-11 03:52:51 +00:00
case BASIS: {
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
if (p_value.type != Variant::VECTOR3)
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
if (p_index.get_type() == Variant::INT || p_index.get_type() == Variant::REAL) {
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
int index = p_index;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
if (index < 0)
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 14:12:10 +00:00
index += 3;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
if (index >= 0 && index < 3) {
Basis *v = _data._basis;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
valid = true;
v->set_axis(index, p_value);
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return;
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
} else if (p_index.get_type() == Variant::STRING) {
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 02:13:40 +00:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
const String *str = reinterpret_cast<const String *>(p_index._data._mem);
Basis *v = _data._basis;
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 02:13:40 +00:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
if (*str == "x") {
valid = true;
v->set_axis(0, p_value);
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 02:13:40 +00:00
return;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
} else if (*str == "y") {
valid = true;
v->set_axis(1, p_value);
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 02:13:40 +00:00
return;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
} else if (*str == "z") {
valid = true;
v->set_axis(2, p_value);
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 02:13:40 +00:00
return;
}
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
}
} break;
case TRANSFORM: {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
if (p_index.get_type() == Variant::INT || p_index.get_type() == Variant::REAL) {
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
if (p_value.type != Variant::VECTOR3)
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return;
int index = p_index;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
if (index < 0)
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 14:12:10 +00:00
index += 4;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
if (index >= 0 && index < 4) {
Transform *v = _data._transform;
valid = true;
if (index == 3)
v->origin = p_value;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
else
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
v->basis.set_axis(index, p_value);
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return;
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
} else if (p_index.get_type() == Variant::STRING) {
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
Transform *v = _data._transform;
const String *str = reinterpret_cast<const String *>(p_index._data._mem);
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
if (*str == "basis") {
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
if (p_value.type != Variant::BASIS)
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
valid = true;
v->basis = p_value;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
}
if (*str == "origin") {
if (p_value.type != Variant::VECTOR3)
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
valid = true;
v->origin = p_value;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return;
}
}
} break;
case COLOR: {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
if (p_value.type != Variant::INT && p_value.type != Variant::REAL)
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
if (p_index.get_type() == Variant::STRING) {
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
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;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
} else if (*str == "g") {
valid = true;
v->g = p_value;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
} else if (*str == "b") {
valid = true;
v->b = p_value;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
} else if (*str == "a") {
valid = true;
v->a = p_value;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
} else if (*str == "h") {
valid = true;
Keep alpha when changing h, s or v on color When modifying the h, s or v properties of a color in GDScript the alpha value needs to stay unchanged.
2018-04-22 15:00:45 +00:00
v->set_hsv(p_value, v->get_s(), v->get_v(), v->a);
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
} else if (*str == "s") {
valid = true;
Keep alpha when changing h, s or v on color When modifying the h, s or v properties of a color in GDScript the alpha value needs to stay unchanged.
2018-04-22 15:00:45 +00:00
v->set_hsv(v->get_h(), p_value, v->get_v(), v->a);
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
} else if (*str == "v") {
valid = true;
Keep alpha when changing h, s or v on color When modifying the h, s or v properties of a color in GDScript the alpha value needs to stay unchanged.
2018-04-22 15:00:45 +00:00
v->set_hsv(v->get_h(), v->get_s(), p_value, v->a);
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
} else if (*str == "r8") {
valid = true;
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 21:26:49 +00:00
return;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
} else if (*str == "g8") {
valid = true;
v->g = 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 21:26:49 +00:00
return;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
} else if (*str == "b8") {
valid = true;
v->b = 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 21:26:49 +00:00
return;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
} else if (*str == "a8") {
valid = true;
v->a = 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 21:26:49 +00:00
return;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
} else if (p_index.get_type() == Variant::INT) {
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
int idx = p_index;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
if (idx < 0)
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 14:12:10 +00:00
idx += 4;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
if (idx >= 0 || idx < 4) {
Color *v = reinterpret_cast<Color *>(_data._mem);
(*v)[idx] = p_value;
valid = true;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
}
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
} break;
case NODE_PATH: {
} break; // 15
case _RID: {
} break;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
case OBJECT: {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
Object *obj = _get_obj().obj;
//only if debugging!
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
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.");
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
valid = false;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return;
}
}
#endif
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
if (p_index.get_type() != Variant::STRING) {
obj->setvar(p_index, p_value, r_valid);
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return;
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
return obj->set(p_index, p_value, r_valid);
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
}
} break;
case DICTIONARY: {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
Dictionary *dic = reinterpret_cast<Dictionary *>(_data._mem);
dic->operator[](p_index) = p_value;
valid = true; //always valid, i guess? should this really be ok?
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return;
Fix two typos from previous commit Also cleanup comments on variant types.
2017-05-17 16:45:56 +00:00
} break;
DEFAULT_OP_ARRAY_CMD(ARRAY, Array, ;, (*arr)[index] = p_value; return ) // 20
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
DEFAULT_OP_DVECTOR_SET(POOL_BYTE_ARRAY, uint8_t, p_value.type != Variant::REAL && p_value.type != Variant::INT)
DEFAULT_OP_DVECTOR_SET(POOL_INT_ARRAY, int, p_value.type != Variant::REAL && p_value.type != Variant::INT)
DEFAULT_OP_DVECTOR_SET(POOL_REAL_ARRAY, real_t, p_value.type != Variant::REAL && p_value.type != Variant::INT)
Fix two typos from previous commit Also cleanup comments on variant types.
2017-05-17 16:45:56 +00:00
DEFAULT_OP_DVECTOR_SET(POOL_STRING_ARRAY, String, p_value.type != Variant::STRING)
DEFAULT_OP_DVECTOR_SET(POOL_VECTOR2_ARRAY, Vector2, p_value.type != Variant::VECTOR2) // 25
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
DEFAULT_OP_DVECTOR_SET(POOL_VECTOR3_ARRAY, Vector3, p_value.type != Variant::VECTOR3)
DEFAULT_OP_DVECTOR_SET(POOL_COLOR_ARRAY, Color, p_value.type != Variant::COLOR)
Move Variant::evaluate() switch to computed goto In an effort to make GDScript a little faster replace the double switch() with a computed goto on compilers that set __GNUC__. For compilers that don't support computed goto it will fall back to regular switch/case statements. In addition disable using boolean values in a mathematical context. Now boolean values can only be compared with other booleans. Booleans will also no longer be coerced to integers. This PR replaces #11308 and fixes #11291
2017-09-17 00:32:05 +00:00
default:
return;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
}
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
Variant Variant::get(const Variant &p_index, bool *r_valid) const {
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
static bool _dummy = false;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
bool &valid = r_valid ? *r_valid : _dummy;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
valid = false;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
switch (type) {
case NIL: {
return Variant();
} break;
case BOOL: {
return Variant();
} break;
case INT: {
return Variant();
} break;
case REAL: {
return Variant();
} break;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
case STRING: {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
if (p_index.get_type() == Variant::INT || p_index.get_type() == Variant::REAL) {
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
//string index
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
int idx = p_index;
const String *str = reinterpret_cast<const String *>(_data._mem);
if (idx < 0)
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 14:12:10 +00:00
idx += str->length();
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
if (idx >= 0 && idx < str->length()) {
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
valid = true;
return str->substr(idx, 1);
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
}
}
} break;
case VECTOR2: {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
if (p_index.get_type() == Variant::INT || p_index.get_type() == Variant::REAL) {
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
// scalar index
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
int idx = p_index;
if (idx < 0)
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 14:12:10 +00:00
idx += 2;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
if (idx >= 0 && idx < 2) {
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
const Vector2 *v = reinterpret_cast<const Vector2 *>(_data._mem);
valid = true;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return (*v)[idx];
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
} else if (p_index.get_type() == Variant::STRING) {
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
//scalar name
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
const String *str = reinterpret_cast<const String *>(p_index._data._mem);
const Vector2 *v = reinterpret_cast<const Vector2 *>(_data._mem);
-Many fixes to VisualScript, fixed property names, etc. -Added ability to set/get a field in GetSet, as well as assignment ops -Added a Select node -Fixed update bugs related to variable list and exported properties, closes #9458
2017-07-01 00:30:17 +00:00
if (*str == "x") {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
valid = true;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return v->x;
-Many fixes to VisualScript, fixed property names, etc. -Added ability to set/get a field in GetSet, as well as assignment ops -Added a Select node -Fixed update bugs related to variable list and exported properties, closes #9458
2017-07-01 00:30:17 +00:00
} else if (*str == "y") {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
valid = true;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return v->y;
}
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
} break; // 5
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
case RECT2: {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
if (p_index.get_type() == Variant::STRING) {
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
//scalar name
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
const String *str = reinterpret_cast<const String *>(p_index._data._mem);
const Rect2 *v = reinterpret_cast<const Rect2 *>(_data._mem);
renamed all Rect2.pos to Rect2.position
2017-06-03 22:25:13 +00:00
if (*str == "position") {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
valid = true;
renamed all Rect2.pos to Rect2.position
2017-06-03 22:25:13 +00:00
return v->position;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
} else if (*str == "size") {
valid = true;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return v->size;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
} else if (*str == "end") {
valid = true;
renamed all Rect2.pos to Rect2.position
2017-06-03 22:25:13 +00:00
return v->size + v->position;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
}
}
} break;
case VECTOR3: {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
if (p_index.get_type() == Variant::INT || p_index.get_type() == Variant::REAL) {
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
//scalar index
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
int idx = p_index;
if (idx < 0)
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 14:12:10 +00:00
idx += 3;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
if (idx >= 0 && idx < 3) {
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
const Vector3 *v = reinterpret_cast<const Vector3 *>(_data._mem);
valid = true;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return (*v)[idx];
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
} else if (p_index.get_type() == Variant::STRING) {
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
//scalar name
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
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;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return v->x;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
} else if (*str == "y") {
valid = true;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return v->y;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
} else if (*str == "z") {
valid = true;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return v->z;
}
}
} break;
Type renames: Matrix32 -> Transform2D Matrix3 -> Basis AABB -> Rect3 RawArray -> PoolByteArray IntArray -> PoolIntArray FloatArray -> PoolFloatArray Vector2Array -> PoolVector2Array Vector3Array -> PoolVector3Array ColorArray -> PoolColorArray
2017-01-11 03:52:51 +00:00
case TRANSFORM2D: {
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
if (p_index.get_type() == Variant::INT || p_index.get_type() == Variant::REAL) {
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
int index = p_index;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
if (index < 0)
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 14:12:10 +00:00
index += 3;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
if (index >= 0 && index < 3) {
const Transform2D *v = _data._transform2d;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
valid = true;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return v->elements[index];
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
} else if (p_index.get_type() == Variant::STRING) {
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
//scalar name
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
const String *str = reinterpret_cast<const String *>(p_index._data._mem);
const Transform2D *v = _data._transform2d;
if (*str == "x") {
valid = true;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return v->elements[0];
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
} else if (*str == "y") {
valid = true;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return v->elements[1];
-Many fixes to VisualScript, fixed property names, etc. -Added ability to set/get a field in GetSet, as well as assignment ops -Added a Select node -Fixed update bugs related to variable list and exported properties, closes #9458
2017-07-01 00:30:17 +00:00
} else if (*str == "origin") {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
valid = true;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return v->elements[2];
}
}
} break;
case PLANE: {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
if (p_index.get_type() == Variant::STRING) {
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
//scalar name
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
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;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return v->normal.x;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
} else if (*str == "y") {
valid = true;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return v->normal.y;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
} else if (*str == "z") {
valid = true;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return v->normal.z;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
} else if (*str == "normal") {
valid = true;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return v->normal;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
} else if (*str == "d") {
valid = true;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return v->d;
}
}
} break;
case QUAT: {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
if (p_index.get_type() == Variant::STRING) {
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
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;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return v->x;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
} else if (*str == "y") {
valid = true;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return v->y;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
} else if (*str == "z") {
valid = true;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return v->z;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
} else if (*str == "w") {
valid = true;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return v->w;
}
}
Fix two typos from previous commit Also cleanup comments on variant types.
2017-05-17 16:45:56 +00:00
} break; // 10
Rename Rect3 to AABB. Fixes #12973.
2017-11-17 02:09:00 +00:00
case AABB: {
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
if (p_index.get_type() == Variant::STRING) {
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
//scalar name
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
const String *str = reinterpret_cast<const String *>(p_index._data._mem);
Rename Rect3 to AABB. Fixes #12973.
2017-11-17 02:09:00 +00:00
const ::AABB *v = _data._aabb;
renamed all Rect3.pos to Rect3.position
2017-06-06 18:33:51 +00:00
if (*str == "position") {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
valid = true;
renamed all Rect3.pos to Rect3.position
2017-06-06 18:33:51 +00:00
return v->position;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
} else if (*str == "size") {
valid = true;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return v->size;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
} else if (*str == "end") {
valid = true;
renamed all Rect3.pos to Rect3.position
2017-06-06 18:33:51 +00:00
return v->size + v->position;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
}
}
Fix two typos from previous commit Also cleanup comments on variant types.
2017-05-17 16:45:56 +00:00
} break;
Type renames: Matrix32 -> Transform2D Matrix3 -> Basis AABB -> Rect3 RawArray -> PoolByteArray IntArray -> PoolIntArray FloatArray -> PoolFloatArray Vector2Array -> PoolVector2Array Vector3Array -> PoolVector3Array ColorArray -> PoolColorArray
2017-01-11 03:52:51 +00:00
case BASIS: {
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
if (p_index.get_type() == Variant::INT || p_index.get_type() == Variant::REAL) {
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
int index = p_index;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
if (index < 0)
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 14:12:10 +00:00
index += 3;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
if (index >= 0 && index < 3) {
const Basis *v = _data._basis;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
valid = true;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return v->get_axis(index);
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
} else if (p_index.get_type() == Variant::STRING) {
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 02:13:40 +00:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
const String *str = reinterpret_cast<const String *>(p_index._data._mem);
const Basis *v = _data._basis;
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 02:13:40 +00:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
if (*str == "x") {
valid = true;
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 02:13:40 +00:00
return v->get_axis(0);
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
} else if (*str == "y") {
valid = true;
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 02:13:40 +00:00
return v->get_axis(1);
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
} else if (*str == "z") {
valid = true;
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 02:13:40 +00:00
return v->get_axis(2);
}
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
}
} break;
case TRANSFORM: {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
if (p_index.get_type() == Variant::INT || p_index.get_type() == Variant::REAL) {
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
int index = p_index;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
if (index < 0)
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 14:12:10 +00:00
index += 4;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
if (index >= 0 && index < 4) {
const Transform *v = _data._transform;
valid = true;
return index == 3 ? v->origin : v->basis.get_axis(index);
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
} else if (p_index.get_type() == Variant::STRING) {
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
const Transform *v = _data._transform;
const String *str = reinterpret_cast<const String *>(p_index._data._mem);
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
if (*str == "basis") {
valid = true;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return v->basis;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
}
if (*str == "origin") {
valid = true;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return v->origin;
}
}
} break;
case COLOR: {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
if (p_index.get_type() == Variant::STRING) {
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
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;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return v->r;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
} else if (*str == "g") {
valid = true;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return v->g;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
} else if (*str == "b") {
valid = true;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return v->b;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
} else if (*str == "a") {
valid = true;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return v->a;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
} else if (*str == "h") {
valid = true;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return v->get_h();
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
} else if (*str == "s") {
valid = true;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return v->get_s();
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
} else if (*str == "v") {
valid = true;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return v->get_v();
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
} else if (*str == "r8") {
valid = true;
return (int)Math::round(v->r * 255.0);
} else if (*str == "g8") {
valid = true;
return (int)Math::round(v->g * 255.0);
} else if (*str == "b8") {
valid = true;
return (int)Math::round(v->b * 255.0);
} else if (*str == "a8") {
valid = true;
return (int)Math::round(v->a * 255.0);
}
} else if (p_index.get_type() == Variant::INT) {
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
int idx = p_index;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
if (idx < 0)
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 14:12:10 +00:00
idx += 4;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
if (idx >= 0 || idx < 4) {
const Color *v = reinterpret_cast<const Color *>(_data._mem);
valid = true;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return (*v)[idx];
}
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
} break;
case NODE_PATH: {
} break; // 15
case _RID: {
} break;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
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)) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
valid = false;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return "Attempted get on stray pointer.";
}
}
#endif
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
if (p_index.get_type() != Variant::STRING) {
return obj->getvar(p_index, r_valid);
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
return obj->get(p_index, r_valid);
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
}
} break;
case DICTIONARY: {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
const Dictionary *dic = reinterpret_cast<const Dictionary *>(_data._mem);
const Variant *res = dic->getptr(p_index);
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
if (res) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
valid = true;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return *res;
}
Fix two typos from previous commit Also cleanup comments on variant types.
2017-05-17 16:45:56 +00:00
} break;
DEFAULT_OP_ARRAY_CMD(ARRAY, const Array, ;, return (*arr)[index]) // 20
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
DEFAULT_OP_DVECTOR_GET(POOL_BYTE_ARRAY, uint8_t)
DEFAULT_OP_DVECTOR_GET(POOL_INT_ARRAY, int)
DEFAULT_OP_DVECTOR_GET(POOL_REAL_ARRAY, real_t)
DEFAULT_OP_DVECTOR_GET(POOL_STRING_ARRAY, String)
Fix two typos from previous commit Also cleanup comments on variant types.
2017-05-17 16:45:56 +00:00
DEFAULT_OP_DVECTOR_GET(POOL_VECTOR2_ARRAY, Vector2) // 25
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
DEFAULT_OP_DVECTOR_GET(POOL_VECTOR3_ARRAY, Vector3)
DEFAULT_OP_DVECTOR_GET(POOL_COLOR_ARRAY, Color)
Move Variant::evaluate() switch to computed goto In an effort to make GDScript a little faster replace the double switch() with a computed goto on compilers that set __GNUC__. For compilers that don't support computed goto it will fall back to regular switch/case statements. In addition disable using boolean values in a mathematical context. Now boolean values can only be compared with other booleans. Booleans will also no longer be coerced to integers. This PR replaces #11308 and fixes #11291
2017-09-17 00:32:05 +00:00
default:
return Variant();
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
}
return Variant();
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
bool Variant::in(const Variant &p_index, bool *r_valid) const {
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
if (r_valid)
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
*r_valid = true;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
switch (type) {
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
case STRING: {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
if (p_index.get_type() == Variant::STRING) {
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
//string index
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
String idx = p_index;
const String *str = reinterpret_cast<const String *>(_data._mem);
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
return str->find(idx) != -1;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
}
} break;
case OBJECT: {
Object *obj = _get_obj().obj;
if (obj) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
bool valid = false;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
#ifdef DEBUG_ENABLED
if (ScriptDebugger::get_singleton() && _get_obj().ref.is_null()) {
//only if debugging!
if (!ObjectDB::instance_validate(obj)) {
if (r_valid) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
*r_valid = false;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
}
return "Attempted get on stray pointer.";
}
}
#endif
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
if (p_index.get_type() != Variant::STRING) {
obj->getvar(p_index, &valid);
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
} else {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
obj->get(p_index, &valid);
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
}
return valid;
} else {
if (r_valid)
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
*r_valid = false;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
}
return false;
} break;
case DICTIONARY: {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
const Dictionary *dic = reinterpret_cast<const Dictionary *>(_data._mem);
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return dic->has(p_index);
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
} break; // 20
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
case ARRAY: {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
const Array *arr = reinterpret_cast<const Array *>(_data._mem);
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
int l = arr->size();
if (l) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
for (int i = 0; i < l; i++) {
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
if (evaluate(OP_EQUAL, (*arr)[i], p_index))
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return true;
}
}
return false;
} break;
Type renames: Matrix32 -> Transform2D Matrix3 -> Basis AABB -> Rect3 RawArray -> PoolByteArray IntArray -> PoolIntArray FloatArray -> PoolFloatArray Vector2Array -> PoolVector2Array Vector3Array -> PoolVector3Array ColorArray -> PoolColorArray
2017-01-11 03:52:51 +00:00
case POOL_BYTE_ARRAY: {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
if (p_index.get_type() == Variant::INT || p_index.get_type() == Variant::REAL) {
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
int index = p_index;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
const PoolVector<uint8_t> *arr = reinterpret_cast<const PoolVector<uint8_t> *>(_data._mem);
int l = arr->size();
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
if (l) {
Memory pool vectors (DVector) have been enormously simplified in code, and renamed to PoolVector
2017-01-07 21:25:37 +00:00
PoolVector<uint8_t>::Read r = arr->read();
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
for (int i = 0; i < l; i++) {
if (r[i] == index)
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return true;
}
}
return false;
}
} break;
Type renames: Matrix32 -> Transform2D Matrix3 -> Basis AABB -> Rect3 RawArray -> PoolByteArray IntArray -> PoolIntArray FloatArray -> PoolFloatArray Vector2Array -> PoolVector2Array Vector3Array -> PoolVector3Array ColorArray -> PoolColorArray
2017-01-11 03:52:51 +00:00
case POOL_INT_ARRAY: {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
if (p_index.get_type() == Variant::INT || p_index.get_type() == Variant::REAL) {
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
int index = p_index;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
const PoolVector<int> *arr = reinterpret_cast<const PoolVector<int> *>(_data._mem);
int l = arr->size();
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
if (l) {
Memory pool vectors (DVector) have been enormously simplified in code, and renamed to PoolVector
2017-01-07 21:25:37 +00:00
PoolVector<int>::Read r = arr->read();
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
for (int i = 0; i < l; i++) {
if (r[i] == index)
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return true;
}
}
return false;
}
} break;
Type renames: Matrix32 -> Transform2D Matrix3 -> Basis AABB -> Rect3 RawArray -> PoolByteArray IntArray -> PoolIntArray FloatArray -> PoolFloatArray Vector2Array -> PoolVector2Array Vector3Array -> PoolVector3Array ColorArray -> PoolColorArray
2017-01-11 03:52:51 +00:00
case POOL_REAL_ARRAY: {
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
if (p_index.get_type() == Variant::INT || p_index.get_type() == Variant::REAL) {
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
real_t index = p_index;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
const PoolVector<real_t> *arr = reinterpret_cast<const PoolVector<real_t> *>(_data._mem);
int l = arr->size();
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
if (l) {
Memory pool vectors (DVector) have been enormously simplified in code, and renamed to PoolVector
2017-01-07 21:25:37 +00:00
PoolVector<real_t>::Read r = arr->read();
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
for (int i = 0; i < l; i++) {
if (r[i] == index)
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return true;
}
}
return false;
}
} break;
Type renames: Matrix32 -> Transform2D Matrix3 -> Basis AABB -> Rect3 RawArray -> PoolByteArray IntArray -> PoolIntArray FloatArray -> PoolFloatArray Vector2Array -> PoolVector2Array Vector3Array -> PoolVector3Array ColorArray -> PoolColorArray
2017-01-11 03:52:51 +00:00
case POOL_STRING_ARRAY: {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
if (p_index.get_type() == Variant::STRING) {
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
String index = p_index;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
const PoolVector<String> *arr = reinterpret_cast<const PoolVector<String> *>(_data._mem);
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
int l = arr->size();
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
if (l) {
Memory pool vectors (DVector) have been enormously simplified in code, and renamed to PoolVector
2017-01-07 21:25:37 +00:00
PoolVector<String>::Read r = arr->read();
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
for (int i = 0; i < l; i++) {
if (r[i] == index)
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return true;
}
}
return false;
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
} break; //25
Type renames: Matrix32 -> Transform2D Matrix3 -> Basis AABB -> Rect3 RawArray -> PoolByteArray IntArray -> PoolIntArray FloatArray -> PoolFloatArray Vector2Array -> PoolVector2Array Vector3Array -> PoolVector3Array ColorArray -> PoolColorArray
2017-01-11 03:52:51 +00:00
case POOL_VECTOR2_ARRAY: {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
if (p_index.get_type() == Variant::VECTOR2) {
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
Vector2 index = p_index;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
const PoolVector<Vector2> *arr = reinterpret_cast<const PoolVector<Vector2> *>(_data._mem);
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
int l = arr->size();
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
if (l) {
Memory pool vectors (DVector) have been enormously simplified in code, and renamed to PoolVector
2017-01-07 21:25:37 +00:00
PoolVector<Vector2>::Read r = arr->read();
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
for (int i = 0; i < l; i++) {
if (r[i] == index)
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return true;
}
}
return false;
}
} break;
Type renames: Matrix32 -> Transform2D Matrix3 -> Basis AABB -> Rect3 RawArray -> PoolByteArray IntArray -> PoolIntArray FloatArray -> PoolFloatArray Vector2Array -> PoolVector2Array Vector3Array -> PoolVector3Array ColorArray -> PoolColorArray
2017-01-11 03:52:51 +00:00
case POOL_VECTOR3_ARRAY: {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
if (p_index.get_type() == Variant::VECTOR3) {
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
Vector3 index = p_index;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
const PoolVector<Vector3> *arr = reinterpret_cast<const PoolVector<Vector3> *>(_data._mem);
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
int l = arr->size();
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
if (l) {
Memory pool vectors (DVector) have been enormously simplified in code, and renamed to PoolVector
2017-01-07 21:25:37 +00:00
PoolVector<Vector3>::Read r = arr->read();
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
for (int i = 0; i < l; i++) {
if (r[i] == index)
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return true;
}
}
return false;
}
} break;
Type renames: Matrix32 -> Transform2D Matrix3 -> Basis AABB -> Rect3 RawArray -> PoolByteArray IntArray -> PoolIntArray FloatArray -> PoolFloatArray Vector2Array -> PoolVector2Array Vector3Array -> PoolVector3Array ColorArray -> PoolColorArray
2017-01-11 03:52:51 +00:00
case POOL_COLOR_ARRAY: {
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
if (p_index.get_type() == Variant::COLOR) {
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
Color index = p_index;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
const PoolVector<Color> *arr = reinterpret_cast<const PoolVector<Color> *>(_data._mem);
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
int l = arr->size();
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
if (l) {
Memory pool vectors (DVector) have been enormously simplified in code, and renamed to PoolVector
2017-01-07 21:25:37 +00:00
PoolVector<Color>::Read r = arr->read();
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
for (int i = 0; i < l; i++) {
if (r[i] == index)
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return true;
}
}
return false;
}
} break;
default: {}
}
if (r_valid)
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
*r_valid = false;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return false;
}
void Variant::get_property_list(List<PropertyInfo> *p_list) const {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
switch (type) {
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
case VECTOR2: {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
p_list->push_back(PropertyInfo(Variant::REAL, "x"));
p_list->push_back(PropertyInfo(Variant::REAL, "y"));
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
} break; // 5
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
case RECT2: {
renamed all Rect2.pos to Rect2.position
2017-06-03 22:25:13 +00:00
p_list->push_back(PropertyInfo(Variant::VECTOR2, "position"));
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
p_list->push_back(PropertyInfo(Variant::VECTOR2, "size"));
p_list->push_back(PropertyInfo(Variant::VECTOR2, "end"));
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
} break;
case VECTOR3: {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
p_list->push_back(PropertyInfo(Variant::REAL, "x"));
p_list->push_back(PropertyInfo(Variant::REAL, "y"));
p_list->push_back(PropertyInfo(Variant::REAL, "z"));
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
} break;
Type renames: Matrix32 -> Transform2D Matrix3 -> Basis AABB -> Rect3 RawArray -> PoolByteArray IntArray -> PoolIntArray FloatArray -> PoolFloatArray Vector2Array -> PoolVector2Array Vector3Array -> PoolVector3Array ColorArray -> PoolColorArray
2017-01-11 03:52:51 +00:00
case TRANSFORM2D: {
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
p_list->push_back(PropertyInfo(Variant::VECTOR2, "x"));
p_list->push_back(PropertyInfo(Variant::VECTOR2, "y"));
-Many fixes to VisualScript, fixed property names, etc. -Added ability to set/get a field in GetSet, as well as assignment ops -Added a Select node -Fixed update bugs related to variable list and exported properties, closes #9458
2017-07-01 00:30:17 +00:00
p_list->push_back(PropertyInfo(Variant::VECTOR2, "origin"));
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
} break;
case PLANE: {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
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"));
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
} break;
case QUAT: {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
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"));
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
Fix two typos from previous commit Also cleanup comments on variant types.
2017-05-17 16:45:56 +00:00
} break; // 10
Rename Rect3 to AABB. Fixes #12973.
2017-11-17 02:09:00 +00:00
case AABB: {
Reworked translation system -Label and Button reload translation on the fly -Resources are loaded and reload depending on locale
2017-06-28 20:00:18 +00:00
p_list->push_back(PropertyInfo(Variant::VECTOR3, "position"));
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
p_list->push_back(PropertyInfo(Variant::VECTOR3, "size"));
p_list->push_back(PropertyInfo(Variant::VECTOR3, "end"));
Fix two typos from previous commit Also cleanup comments on variant types.
2017-05-17 16:45:56 +00:00
} break;
Type renames: Matrix32 -> Transform2D Matrix3 -> Basis AABB -> Rect3 RawArray -> PoolByteArray IntArray -> PoolIntArray FloatArray -> PoolFloatArray Vector2Array -> PoolVector2Array Vector3Array -> PoolVector3Array ColorArray -> PoolColorArray
2017-01-11 03:52:51 +00:00
case BASIS: {
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
p_list->push_back(PropertyInfo(Variant::VECTOR3, "x"));
p_list->push_back(PropertyInfo(Variant::VECTOR3, "y"));
p_list->push_back(PropertyInfo(Variant::VECTOR3, "z"));
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
} break;
case TRANSFORM: {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
p_list->push_back(PropertyInfo(Variant::BASIS, "basis"));
p_list->push_back(PropertyInfo(Variant::VECTOR3, "origin"));
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
} break;
case COLOR: {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
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"));
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"));
} break;
case NODE_PATH: {
} break; // 15
case _RID: {
} break;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
case OBJECT: {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
Object *obj = _get_obj().obj;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
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 DICTIONARY: {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
const Dictionary *dic = reinterpret_cast<const Dictionary *>(_data._mem);
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
List<Variant> keys;
dic->get_key_list(&keys);
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
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()));
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
}
}
Fix two typos from previous commit Also cleanup comments on variant types.
2017-05-17 16:45:56 +00:00
} break;
case ARRAY: // 20
Type renames: Matrix32 -> Transform2D Matrix3 -> Basis AABB -> Rect3 RawArray -> PoolByteArray IntArray -> PoolIntArray FloatArray -> PoolFloatArray Vector2Array -> PoolVector2Array Vector3Array -> PoolVector3Array ColorArray -> PoolColorArray
2017-01-11 03:52:51 +00:00
case POOL_BYTE_ARRAY:
case POOL_INT_ARRAY:
case POOL_REAL_ARRAY:
case POOL_STRING_ARRAY:
Fix two typos from previous commit Also cleanup comments on variant types.
2017-05-17 16:45:56 +00:00
case POOL_VECTOR2_ARRAY: // 25
Type renames: Matrix32 -> Transform2D Matrix3 -> Basis AABB -> Rect3 RawArray -> PoolByteArray IntArray -> PoolIntArray FloatArray -> PoolFloatArray Vector2Array -> PoolVector2Array Vector3Array -> PoolVector3Array ColorArray -> PoolColorArray
2017-01-11 03:52:51 +00:00
case POOL_VECTOR3_ARRAY:
case POOL_COLOR_ARRAY: {
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
//nothing
} break;
default: {}
}
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
bool Variant::iter_init(Variant &r_iter, bool &valid) const {
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
valid = true;
switch (type) {
More efficient iteration syntax, and range() is converted behind the scenes to it.
2017-01-11 23:09:45 +00:00
case INT: {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
r_iter = 0;
return _data._int > 0;
More efficient iteration syntax, and range() is converted behind the scenes to it.
2017-01-11 23:09:45 +00:00
} break;
case REAL: {
Reimplement for..in range() so that it always results in ints Fixes #8278, fixup of bfef8de1bc4f7a7b9617a7b181881129033a0b0e
2017-05-16 10:56:49 +00:00
r_iter = 0;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
return _data._real > 0.0;
More efficient iteration syntax, and range() is converted behind the scenes to it.
2017-01-11 23:09:45 +00:00
} break;
case VECTOR2: {
Reimplement for..in range() so that it always results in ints Fixes #8278, fixup of bfef8de1bc4f7a7b9617a7b181881129033a0b0e
2017-05-16 10:56:49 +00:00
int64_t from = reinterpret_cast<const Vector2 *>(_data._mem)->x;
int64_t to = reinterpret_cast<const Vector2 *>(_data._mem)->y;
More efficient iteration syntax, and range() is converted behind the scenes to it.
2017-01-11 23:09:45 +00:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
r_iter = from;
More efficient iteration syntax, and range() is converted behind the scenes to it.
2017-01-11 23:09:45 +00:00
return from < to;
} break;
case VECTOR3: {
Reimplement for..in range() so that it always results in ints Fixes #8278, fixup of bfef8de1bc4f7a7b9617a7b181881129033a0b0e
2017-05-16 10:56:49 +00:00
int64_t from = reinterpret_cast<const Vector3 *>(_data._mem)->x;
int64_t to = reinterpret_cast<const Vector3 *>(_data._mem)->y;
int64_t step = reinterpret_cast<const Vector3 *>(_data._mem)->z;
More efficient iteration syntax, and range() is converted behind the scenes to it.
2017-01-11 23:09:45 +00:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
r_iter = from;
More efficient iteration syntax, and range() is converted behind the scenes to it.
2017-01-11 23:09:45 +00:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
if (from == to) {
More efficient iteration syntax, and range() is converted behind the scenes to it.
2017-01-11 23:09:45 +00:00
return false;
} else if (from < to) {
Reimplement for..in range() so that it always results in ints Fixes #8278, fixup of bfef8de1bc4f7a7b9617a7b181881129033a0b0e
2017-05-16 10:56:49 +00:00
return step > 0;
More efficient iteration syntax, and range() is converted behind the scenes to it.
2017-01-11 23:09:45 +00:00
} else {
Reimplement for..in range() so that it always results in ints Fixes #8278, fixup of bfef8de1bc4f7a7b9617a7b181881129033a0b0e
2017-05-16 10:56:49 +00:00
return step < 0;
More efficient iteration syntax, and range() is converted behind the scenes to it.
2017-01-11 23:09:45 +00:00
}
//return true;
} break;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
case OBJECT: {
#ifdef DEBUG_ENABLED
if (!_get_obj().obj) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
valid = false;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return false;
}
if (ScriptDebugger::get_singleton() && _get_obj().ref.is_null() && !ObjectDB::instance_validate(_get_obj().obj)) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
valid = false;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return false;
}
#endif
Variant::CallError ce;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
ce.error = Variant::CallError::CALL_OK;
Both Array and Dictionary are always in shared mode (removed copy on write).
2017-01-11 11:53:31 +00:00
Array ref;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
ref.push_back(r_iter);
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
Variant vref = ref;
const Variant *refp[] = { &vref };
Variant ret = _get_obj().obj->call(CoreStringNames::get_singleton()->_iter_init, refp, 1, ce);
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
if (ref.size() != 1 || ce.error != Variant::CallError::CALL_OK) {
valid = false;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return false;
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
r_iter = ref[0];
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return ret;
} break;
Add support to String type in gdscript iteration. #5188
2016-06-26 20:03:42 +00:00
case STRING: {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
const String *str = reinterpret_cast<const String *>(_data._mem);
Add support to String type in gdscript iteration. #5188
2016-06-26 20:03:42 +00:00
if (str->empty())
return false;
r_iter = 0;
return true;
} break;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
case DICTIONARY: {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
const Dictionary *dic = reinterpret_cast<const Dictionary *>(_data._mem);
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
if (dic->empty())
return false;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
const Variant *next = dic->next(NULL);
r_iter = *next;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return true;
} break;
case ARRAY: {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
const Array *arr = reinterpret_cast<const Array *>(_data._mem);
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
if (arr->empty())
return false;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
r_iter = 0;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return true;
} break;
Type renames: Matrix32 -> Transform2D Matrix3 -> Basis AABB -> Rect3 RawArray -> PoolByteArray IntArray -> PoolIntArray FloatArray -> PoolFloatArray Vector2Array -> PoolVector2Array Vector3Array -> PoolVector3Array ColorArray -> PoolColorArray
2017-01-11 03:52:51 +00:00
case POOL_BYTE_ARRAY: {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
const PoolVector<uint8_t> *arr = reinterpret_cast<const PoolVector<uint8_t> *>(_data._mem);
if (arr->size() == 0)
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return false;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
r_iter = 0;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return true;
} break;
Type renames: Matrix32 -> Transform2D Matrix3 -> Basis AABB -> Rect3 RawArray -> PoolByteArray IntArray -> PoolIntArray FloatArray -> PoolFloatArray Vector2Array -> PoolVector2Array Vector3Array -> PoolVector3Array ColorArray -> PoolColorArray
2017-01-11 03:52:51 +00:00
case POOL_INT_ARRAY: {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
const PoolVector<int> *arr = reinterpret_cast<const PoolVector<int> *>(_data._mem);
if (arr->size() == 0)
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return false;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
r_iter = 0;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return true;
} break;
Type renames: Matrix32 -> Transform2D Matrix3 -> Basis AABB -> Rect3 RawArray -> PoolByteArray IntArray -> PoolIntArray FloatArray -> PoolFloatArray Vector2Array -> PoolVector2Array Vector3Array -> PoolVector3Array ColorArray -> PoolColorArray
2017-01-11 03:52:51 +00:00
case POOL_REAL_ARRAY: {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
const PoolVector<real_t> *arr = reinterpret_cast<const PoolVector<real_t> *>(_data._mem);
if (arr->size() == 0)
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return false;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
r_iter = 0;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return true;
} break;
Type renames: Matrix32 -> Transform2D Matrix3 -> Basis AABB -> Rect3 RawArray -> PoolByteArray IntArray -> PoolIntArray FloatArray -> PoolFloatArray Vector2Array -> PoolVector2Array Vector3Array -> PoolVector3Array ColorArray -> PoolColorArray
2017-01-11 03:52:51 +00:00
case POOL_STRING_ARRAY: {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
const PoolVector<String> *arr = reinterpret_cast<const PoolVector<String> *>(_data._mem);
if (arr->size() == 0)
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return false;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
r_iter = 0;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return true;
} break;
Type renames: Matrix32 -> Transform2D Matrix3 -> Basis AABB -> Rect3 RawArray -> PoolByteArray IntArray -> PoolIntArray FloatArray -> PoolFloatArray Vector2Array -> PoolVector2Array Vector3Array -> PoolVector3Array ColorArray -> PoolColorArray
2017-01-11 03:52:51 +00:00
case POOL_VECTOR2_ARRAY: {
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
const PoolVector<Vector2> *arr = reinterpret_cast<const PoolVector<Vector2> *>(_data._mem);
if (arr->size() == 0)
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return false;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
r_iter = 0;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return true;
} break;
Type renames: Matrix32 -> Transform2D Matrix3 -> Basis AABB -> Rect3 RawArray -> PoolByteArray IntArray -> PoolIntArray FloatArray -> PoolFloatArray Vector2Array -> PoolVector2Array Vector3Array -> PoolVector3Array ColorArray -> PoolColorArray
2017-01-11 03:52:51 +00:00
case POOL_VECTOR3_ARRAY: {
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
const PoolVector<Vector3> *arr = reinterpret_cast<const PoolVector<Vector3> *>(_data._mem);
if (arr->size() == 0)
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return false;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
r_iter = 0;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return true;
} break;
Type renames: Matrix32 -> Transform2D Matrix3 -> Basis AABB -> Rect3 RawArray -> PoolByteArray IntArray -> PoolIntArray FloatArray -> PoolFloatArray Vector2Array -> PoolVector2Array Vector3Array -> PoolVector3Array ColorArray -> PoolColorArray
2017-01-11 03:52:51 +00:00
case POOL_COLOR_ARRAY: {
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
const PoolVector<Color> *arr = reinterpret_cast<const PoolVector<Color> *>(_data._mem);
if (arr->size() == 0)
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return false;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
r_iter = 0;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return true;
} break;
Move Variant::evaluate() switch to computed goto In an effort to make GDScript a little faster replace the double switch() with a computed goto on compilers that set __GNUC__. For compilers that don't support computed goto it will fall back to regular switch/case statements. In addition disable using boolean values in a mathematical context. Now boolean values can only be compared with other booleans. Booleans will also no longer be coerced to integers. This PR replaces #11308 and fixes #11291
2017-09-17 00:32:05 +00:00
default: {
}
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
valid = false;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return false;
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
bool Variant::iter_next(Variant &r_iter, bool &valid) const {
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
valid = true;
switch (type) {
More efficient iteration syntax, and range() is converted behind the scenes to it.
2017-01-11 23:09:45 +00:00
case INT: {
int64_t idx = r_iter;
idx++;
if (idx >= _data._int)
return false;
r_iter = idx;
return true;
} break;
case REAL: {
Reimplement for..in range() so that it always results in ints Fixes #8278, fixup of bfef8de1bc4f7a7b9617a7b181881129033a0b0e
2017-05-16 10:56:49 +00:00
int64_t idx = r_iter;
idx++;
More efficient iteration syntax, and range() is converted behind the scenes to it.
2017-01-11 23:09:45 +00:00
if (idx >= _data._real)
return false;
r_iter = idx;
return true;
} break;
case VECTOR2: {
Fix accidental cast to Vector3 for Vector2 iter
2017-09-19 12:18:12 +00:00
int64_t to = reinterpret_cast<const Vector2 *>(_data._mem)->y;
Reimplement for..in range() so that it always results in ints Fixes #8278, fixup of bfef8de1bc4f7a7b9617a7b181881129033a0b0e
2017-05-16 10:56:49 +00:00
int64_t idx = r_iter;
idx++;
if (idx >= to)
More efficient iteration syntax, and range() is converted behind the scenes to it.
2017-01-11 23:09:45 +00:00
return false;
Reimplement for..in range() so that it always results in ints Fixes #8278, fixup of bfef8de1bc4f7a7b9617a7b181881129033a0b0e
2017-05-16 10:56:49 +00:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
r_iter = idx;
More efficient iteration syntax, and range() is converted behind the scenes to it.
2017-01-11 23:09:45 +00:00
return true;
} break;
case VECTOR3: {
Reimplement for..in range() so that it always results in ints Fixes #8278, fixup of bfef8de1bc4f7a7b9617a7b181881129033a0b0e
2017-05-16 10:56:49 +00:00
int64_t to = reinterpret_cast<const Vector3 *>(_data._mem)->y;
int64_t step = reinterpret_cast<const Vector3 *>(_data._mem)->z;
More efficient iteration syntax, and range() is converted behind the scenes to it.
2017-01-11 23:09:45 +00:00
Reimplement for..in range() so that it always results in ints Fixes #8278, fixup of bfef8de1bc4f7a7b9617a7b181881129033a0b0e
2017-05-16 10:56:49 +00:00
int64_t idx = r_iter;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
idx += step;
More efficient iteration syntax, and range() is converted behind the scenes to it.
2017-01-11 23:09:45 +00:00
Reimplement for..in range() so that it always results in ints Fixes #8278, fixup of bfef8de1bc4f7a7b9617a7b181881129033a0b0e
2017-05-16 10:56:49 +00:00
if (step < 0 && idx <= to)
More efficient iteration syntax, and range() is converted behind the scenes to it.
2017-01-11 23:09:45 +00:00
return false;
Reimplement for..in range() so that it always results in ints Fixes #8278, fixup of bfef8de1bc4f7a7b9617a7b181881129033a0b0e
2017-05-16 10:56:49 +00:00
if (step > 0 && idx >= to)
More efficient iteration syntax, and range() is converted behind the scenes to it.
2017-01-11 23:09:45 +00:00
return false;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
r_iter = idx;
More efficient iteration syntax, and range() is converted behind the scenes to it.
2017-01-11 23:09:45 +00:00
return true;
} break;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
case OBJECT: {
#ifdef DEBUG_ENABLED
if (!_get_obj().obj) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
valid = false;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return false;
}
if (ScriptDebugger::get_singleton() && _get_obj().ref.is_null() && !ObjectDB::instance_validate(_get_obj().obj)) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
valid = false;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return false;
}
#endif
Variant::CallError ce;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
ce.error = Variant::CallError::CALL_OK;
Both Array and Dictionary are always in shared mode (removed copy on write).
2017-01-11 11:53:31 +00:00
Array ref;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
ref.push_back(r_iter);
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
Variant vref = ref;
const Variant *refp[] = { &vref };
Variant ret = _get_obj().obj->call(CoreStringNames::get_singleton()->_iter_next, refp, 1, ce);
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
if (ref.size() != 1 || ce.error != Variant::CallError::CALL_OK) {
valid = false;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return false;
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
r_iter = ref[0];
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return ret;
} break;
Add support to String type in gdscript iteration. #5188
2016-06-26 20:03:42 +00:00
case STRING: {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
const String *str = reinterpret_cast<const String *>(_data._mem);
Add support to String type in gdscript iteration. #5188
2016-06-26 20:03:42 +00:00
int idx = r_iter;
idx++;
fix string iterator Since strings are null-terminated, size() returns incorrect length, so use length() instead. fixes #6287
2016-08-26 07:42:01 +00:00
if (idx >= str->length())
Add support to String type in gdscript iteration. #5188
2016-06-26 20:03:42 +00:00
return false;
r_iter = idx;
return true;
} break;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
case DICTIONARY: {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
const Dictionary *dic = reinterpret_cast<const Dictionary *>(_data._mem);
const Variant *next = dic->next(&r_iter);
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
if (!next)
return false;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
r_iter = *next;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return true;
} break;
case ARRAY: {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
const Array *arr = reinterpret_cast<const Array *>(_data._mem);
int idx = r_iter;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
idx++;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
if (idx >= arr->size())
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return false;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
r_iter = idx;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return true;
} break;
Type renames: Matrix32 -> Transform2D Matrix3 -> Basis AABB -> Rect3 RawArray -> PoolByteArray IntArray -> PoolIntArray FloatArray -> PoolFloatArray Vector2Array -> PoolVector2Array Vector3Array -> PoolVector3Array ColorArray -> PoolColorArray
2017-01-11 03:52:51 +00:00
case POOL_BYTE_ARRAY: {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
const PoolVector<uint8_t> *arr = reinterpret_cast<const PoolVector<uint8_t> *>(_data._mem);
int idx = r_iter;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
idx++;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
if (idx >= arr->size())
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return false;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
r_iter = idx;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return true;
} break;
Type renames: Matrix32 -> Transform2D Matrix3 -> Basis AABB -> Rect3 RawArray -> PoolByteArray IntArray -> PoolIntArray FloatArray -> PoolFloatArray Vector2Array -> PoolVector2Array Vector3Array -> PoolVector3Array ColorArray -> PoolColorArray
2017-01-11 03:52:51 +00:00
case POOL_INT_ARRAY: {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
const PoolVector<int> *arr = reinterpret_cast<const PoolVector<int> *>(_data._mem);
int idx = r_iter;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
idx++;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
if (idx >= arr->size())
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return false;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
r_iter = idx;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return true;
} break;
Type renames: Matrix32 -> Transform2D Matrix3 -> Basis AABB -> Rect3 RawArray -> PoolByteArray IntArray -> PoolIntArray FloatArray -> PoolFloatArray Vector2Array -> PoolVector2Array Vector3Array -> PoolVector3Array ColorArray -> PoolColorArray
2017-01-11 03:52:51 +00:00
case POOL_REAL_ARRAY: {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
const PoolVector<real_t> *arr = reinterpret_cast<const PoolVector<real_t> *>(_data._mem);
int idx = r_iter;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
idx++;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
if (idx >= arr->size())
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return false;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
r_iter = idx;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return true;
} break;
Type renames: Matrix32 -> Transform2D Matrix3 -> Basis AABB -> Rect3 RawArray -> PoolByteArray IntArray -> PoolIntArray FloatArray -> PoolFloatArray Vector2Array -> PoolVector2Array Vector3Array -> PoolVector3Array ColorArray -> PoolColorArray
2017-01-11 03:52:51 +00:00
case POOL_STRING_ARRAY: {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
const PoolVector<String> *arr = reinterpret_cast<const PoolVector<String> *>(_data._mem);
int idx = r_iter;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
idx++;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
if (idx >= arr->size())
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return false;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
r_iter = idx;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return true;
} break;
Type renames: Matrix32 -> Transform2D Matrix3 -> Basis AABB -> Rect3 RawArray -> PoolByteArray IntArray -> PoolIntArray FloatArray -> PoolFloatArray Vector2Array -> PoolVector2Array Vector3Array -> PoolVector3Array ColorArray -> PoolColorArray
2017-01-11 03:52:51 +00:00
case POOL_VECTOR2_ARRAY: {
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
const PoolVector<Vector2> *arr = reinterpret_cast<const PoolVector<Vector2> *>(_data._mem);
int idx = r_iter;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
idx++;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
if (idx >= arr->size())
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return false;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
r_iter = idx;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return true;
} break;
Type renames: Matrix32 -> Transform2D Matrix3 -> Basis AABB -> Rect3 RawArray -> PoolByteArray IntArray -> PoolIntArray FloatArray -> PoolFloatArray Vector2Array -> PoolVector2Array Vector3Array -> PoolVector3Array ColorArray -> PoolColorArray
2017-01-11 03:52:51 +00:00
case POOL_VECTOR3_ARRAY: {
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
const PoolVector<Vector3> *arr = reinterpret_cast<const PoolVector<Vector3> *>(_data._mem);
int idx = r_iter;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
idx++;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
if (idx >= arr->size())
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return false;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
r_iter = idx;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return true;
} break;
Type renames: Matrix32 -> Transform2D Matrix3 -> Basis AABB -> Rect3 RawArray -> PoolByteArray IntArray -> PoolIntArray FloatArray -> PoolFloatArray Vector2Array -> PoolVector2Array Vector3Array -> PoolVector3Array ColorArray -> PoolColorArray
2017-01-11 03:52:51 +00:00
case POOL_COLOR_ARRAY: {
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
const PoolVector<Color> *arr = reinterpret_cast<const PoolVector<Color> *>(_data._mem);
int idx = r_iter;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
idx++;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
if (idx >= arr->size())
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return false;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
r_iter = idx;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
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 12:47:49 +00:00
default: {}
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
valid = false;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return false;
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
Variant Variant::iter_get(const Variant &r_iter, bool &r_valid) const {
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
r_valid = true;
switch (type) {
More efficient iteration syntax, and range() is converted behind the scenes to it.
2017-01-11 23:09:45 +00:00
case INT: {
return r_iter;
} break;
case REAL: {
return r_iter;
} break;
case VECTOR2: {
return r_iter;
} break;
case VECTOR3: {
return r_iter;
} break;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
case OBJECT: {
#ifdef DEBUG_ENABLED
if (!_get_obj().obj) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
r_valid = false;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return Variant();
}
if (ScriptDebugger::get_singleton() && _get_obj().ref.is_null() && !ObjectDB::instance_validate(_get_obj().obj)) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
r_valid = false;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return Variant();
}
#endif
Variant::CallError ce;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
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);
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
if (ce.error != Variant::CallError::CALL_OK) {
r_valid = false;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return Variant();
}
//r_iter=ref[0];
return ret;
} break;
Add support to String type in gdscript iteration. #5188
2016-06-26 20:03:42 +00:00
case STRING: {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
const String *str = reinterpret_cast<const String *>(_data._mem);
return str->substr(r_iter, 1);
Add support to String type in gdscript iteration. #5188
2016-06-26 20:03:42 +00:00
} break;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
case DICTIONARY: {
return r_iter; //iterator is the same as the key
} break;
case ARRAY: {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
const Array *arr = reinterpret_cast<const Array *>(_data._mem);
int idx = r_iter;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
#ifdef DEBUG_ENABLED
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
if (idx < 0 || idx >= arr->size()) {
r_valid = false;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return Variant();
}
#endif
return arr->get(idx);
} break;
Type renames: Matrix32 -> Transform2D Matrix3 -> Basis AABB -> Rect3 RawArray -> PoolByteArray IntArray -> PoolIntArray FloatArray -> PoolFloatArray Vector2Array -> PoolVector2Array Vector3Array -> PoolVector3Array ColorArray -> PoolColorArray
2017-01-11 03:52:51 +00:00
case POOL_BYTE_ARRAY: {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
const PoolVector<uint8_t> *arr = reinterpret_cast<const PoolVector<uint8_t> *>(_data._mem);
int idx = r_iter;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
#ifdef DEBUG_ENABLED
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
if (idx < 0 || idx >= arr->size()) {
r_valid = false;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return Variant();
}
#endif
return arr->get(idx);
} break;
Type renames: Matrix32 -> Transform2D Matrix3 -> Basis AABB -> Rect3 RawArray -> PoolByteArray IntArray -> PoolIntArray FloatArray -> PoolFloatArray Vector2Array -> PoolVector2Array Vector3Array -> PoolVector3Array ColorArray -> PoolColorArray
2017-01-11 03:52:51 +00:00
case POOL_INT_ARRAY: {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
const PoolVector<int> *arr = reinterpret_cast<const PoolVector<int> *>(_data._mem);
int idx = r_iter;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
#ifdef DEBUG_ENABLED
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
if (idx < 0 || idx >= arr->size()) {
r_valid = false;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return Variant();
}
#endif
return arr->get(idx);
} break;
Type renames: Matrix32 -> Transform2D Matrix3 -> Basis AABB -> Rect3 RawArray -> PoolByteArray IntArray -> PoolIntArray FloatArray -> PoolFloatArray Vector2Array -> PoolVector2Array Vector3Array -> PoolVector3Array ColorArray -> PoolColorArray
2017-01-11 03:52:51 +00:00
case POOL_REAL_ARRAY: {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
const PoolVector<real_t> *arr = reinterpret_cast<const PoolVector<real_t> *>(_data._mem);
int idx = r_iter;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
#ifdef DEBUG_ENABLED
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
if (idx < 0 || idx >= arr->size()) {
r_valid = false;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return Variant();
}
#endif
return arr->get(idx);
} break;
Type renames: Matrix32 -> Transform2D Matrix3 -> Basis AABB -> Rect3 RawArray -> PoolByteArray IntArray -> PoolIntArray FloatArray -> PoolFloatArray Vector2Array -> PoolVector2Array Vector3Array -> PoolVector3Array ColorArray -> PoolColorArray
2017-01-11 03:52:51 +00:00
case POOL_STRING_ARRAY: {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
const PoolVector<String> *arr = reinterpret_cast<const PoolVector<String> *>(_data._mem);
int idx = r_iter;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
#ifdef DEBUG_ENABLED
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
if (idx < 0 || idx >= arr->size()) {
r_valid = false;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return Variant();
}
#endif
return arr->get(idx);
} break;
Type renames: Matrix32 -> Transform2D Matrix3 -> Basis AABB -> Rect3 RawArray -> PoolByteArray IntArray -> PoolIntArray FloatArray -> PoolFloatArray Vector2Array -> PoolVector2Array Vector3Array -> PoolVector3Array ColorArray -> PoolColorArray
2017-01-11 03:52:51 +00:00
case POOL_VECTOR2_ARRAY: {
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
const PoolVector<Vector2> *arr = reinterpret_cast<const PoolVector<Vector2> *>(_data._mem);
int idx = r_iter;
#ifdef DEBUG_ENABLED
if (idx < 0 || idx >= arr->size()) {
r_valid = false;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return Variant();
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
#endif
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return arr->get(idx);
} break;
Type renames: Matrix32 -> Transform2D Matrix3 -> Basis AABB -> Rect3 RawArray -> PoolByteArray IntArray -> PoolIntArray FloatArray -> PoolFloatArray Vector2Array -> PoolVector2Array Vector3Array -> PoolVector3Array ColorArray -> PoolColorArray
2017-01-11 03:52:51 +00:00
case POOL_VECTOR3_ARRAY: {
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
const PoolVector<Vector3> *arr = reinterpret_cast<const PoolVector<Vector3> *>(_data._mem);
int idx = r_iter;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
#ifdef DEBUG_ENABLED
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
if (idx < 0 || idx >= arr->size()) {
r_valid = false;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return Variant();
}
#endif
return arr->get(idx);
} break;
Type renames: Matrix32 -> Transform2D Matrix3 -> Basis AABB -> Rect3 RawArray -> PoolByteArray IntArray -> PoolIntArray FloatArray -> PoolFloatArray Vector2Array -> PoolVector2Array Vector3Array -> PoolVector3Array ColorArray -> PoolColorArray
2017-01-11 03:52:51 +00:00
case POOL_COLOR_ARRAY: {
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
const PoolVector<Color> *arr = reinterpret_cast<const PoolVector<Color> *>(_data._mem);
int idx = r_iter;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
#ifdef DEBUG_ENABLED
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
if (idx < 0 || idx >= arr->size()) {
r_valid = false;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
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 12:47:49 +00:00
default: {}
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
r_valid = false;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return Variant();
}
Duplicate Arrays and Dictionaries when instancing scene in editor Also, add deep (=false) parameter to Array.duplicate and Dictionary.duplicate Fixes #13971
2018-03-09 19:16:08 +00:00
Variant Variant::duplicate(bool deep) const {
switch (type) {
-Fixes to how hashing happened, now StringName and NodePath use default hasher, this was leading to some severe slowdown in scenarios -Fixes to some duplication scenarios for instanced scenes
2018-07-02 18:08:35 +00:00
case OBJECT: {
Hacked around duplication bug. I think duplicate needs to be even smarter, maybe pass two bools? (containers and/or resources)
2018-07-03 11:34:06 +00:00
/* breaks stuff :(
-Fixes to how hashing happened, now StringName and NodePath use default hasher, this was leading to some severe slowdown in scenarios -Fixes to some duplication scenarios for instanced scenes
2018-07-02 18:08:35 +00:00
if (deep && !_get_obj().ref.is_null()) {
Ref<Resource> resource = _get_obj().ref;
if (resource.is_valid()) {
return resource->duplicate(true);
}
}
Hacked around duplication bug. I think duplicate needs to be even smarter, maybe pass two bools? (containers and/or resources)
2018-07-03 11:34:06 +00:00
*/
-Fixes to how hashing happened, now StringName and NodePath use default hasher, this was leading to some severe slowdown in scenarios -Fixes to some duplication scenarios for instanced scenes
2018-07-02 18:08:35 +00:00
return *this;
} break;
Duplicate Arrays and Dictionaries when instancing scene in editor Also, add deep (=false) parameter to Array.duplicate and Dictionary.duplicate Fixes #13971
2018-03-09 19:16:08 +00:00
case DICTIONARY:
return operator Dictionary().duplicate(deep);
case ARRAY:
return operator Array().duplicate(deep);
default:
return *this;
}
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00: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;
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 03:34:49 +00:00
} else {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
r_dst = a;
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 03:34:49 +00:00
}
return;
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
switch (a.type) {
case NIL: {
r_dst = Variant();
}
return;
case INT: {
int64_t va = a._data._int;
int64_t 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);
renamed all Rect2.pos to Rect2.position
2017-06-03 22:25:13 +00:00
r_dst = Rect2(ra->position + rb->position * c, ra->size + rb->size * c);
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
}
return;
case VECTOR3: {
r_dst = *reinterpret_cast<const Vector3 *>(a._data._mem) + *reinterpret_cast<const Vector3 *>(b._data._mem) * c;
}
return;
Rename Rect3 to AABB. Fixes #12973.
2017-11-17 02:09:00 +00: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->position + rb->position * c, ra->size + rb->size * c);
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
}
return;
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;
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;
Move Variant::evaluate() switch to computed goto In an effort to make GDScript a little faster replace the double switch() with a computed goto on compilers that set __GNUC__. For compilers that don't support computed goto it will fall back to regular switch/case statements. In addition disable using boolean values in a mathematical context. Now boolean values can only be compared with other booleans. Booleans will also no longer be coerced to integers. This PR replaces #11308 and fixes #11291
2017-09-17 00:32:05 +00:00
default: {
r_dst = c < 0.5 ? a : b;
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
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 03:34:49 +00:00
}
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
void Variant::interpolate(const Variant &a, const Variant &b, float c, Variant &r_dst) {
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
if (a.type != b.type) {
-Integers and Float should interpolate on animation, maybe fixes #1891, please test
2015-05-16 21:16:11 +00:00
if (a.is_num() && b.is_num()) {
//not as efficient but..
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
real_t va = a;
real_t vb = b;
r_dst = (1.0 - c) * va + vb * c;
-Integers and Float should interpolate on animation, maybe fixes #1891, please test
2015-05-16 21:16:11 +00:00
} else {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
r_dst = a;
-Integers and Float should interpolate on animation, maybe fixes #1891, please test
2015-05-16 21:16:11 +00:00
}
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return;
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
switch (a.type) {
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
case NIL: {
r_dst = Variant();
}
return;
case BOOL: {
r_dst = a;
}
return;
case INT: {
int64_t va = a._data._int;
int64_t vb = b._data._int;
r_dst = int((1.0 - c) * va + vb * c);
}
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: {
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
//this is pretty funny and bizarre, but artists like to use it for typewritter effects
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
String sa = *reinterpret_cast<const String *>(a._data._mem);
String sb = *reinterpret_cast<const String *>(b._data._mem);
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
String dst;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
int csize = sb.length() * c + sa.length() * (1.0 - c);
if (csize == 0) {
r_dst = "";
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return;
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
dst.resize(csize + 1);
dst[csize] = 0;
int split = csize / 2;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
for (int i = 0; i < csize; i++) {
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
CharType chr = ' ';
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
if (i < split) {
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
if (i < sa.length())
chr = sa[i];
else if (i < sb.length())
chr = sb[i];
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
} else {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
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: {
renamed all Rect2.pos to Rect2.position
2017-06-03 22:25:13 +00:00
r_dst = Rect2(reinterpret_cast<const Rect2 *>(a._data._mem)->position.linear_interpolate(reinterpret_cast<const Rect2 *>(b._data._mem)->position, c), reinterpret_cast<const Rect2 *>(a._data._mem)->size.linear_interpolate(reinterpret_cast<const Rect2 *>(b._data._mem)->size, c));
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
}
return;
case VECTOR3: {
r_dst = reinterpret_cast<const Vector3 *>(a._data._mem)->linear_interpolate(*reinterpret_cast<const Vector3 *>(b._data._mem), c);
}
return;
case TRANSFORM2D: {
r_dst = a._data._transform2d->interpolate_with(*b._data._transform2d, 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;
Rename Rect3 to AABB. Fixes #12973.
2017-11-17 02:09:00 +00:00
case AABB: {
r_dst = ::AABB(a._data._aabb->position.linear_interpolate(b._data._aabb->position, c), a._data._aabb->size.linear_interpolate(b._data._aabb->size, c));
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
}
return;
case BASIS: {
r_dst = Transform(*a._data._basis).interpolate_with(Transform(*b._data._basis), 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 NODE_PATH: {
r_dst = a;
}
return;
case _RID: {
r_dst = a;
}
return;
case OBJECT: {
r_dst = a;
}
return;
case DICTIONARY: {
}
return;
case ARRAY: {
r_dst = a;
}
return;
case POOL_BYTE_ARRAY: {
r_dst = a;
}
return;
case POOL_INT_ARRAY: {
r_dst = a;
}
return;
case POOL_REAL_ARRAY: {
r_dst = a;
}
return;
case POOL_STRING_ARRAY: {
r_dst = a;
}
return;
case POOL_VECTOR2_ARRAY: {
const PoolVector<Vector2> *arr_a = reinterpret_cast<const PoolVector<Vector2> *>(a._data._mem);
const PoolVector<Vector2> *arr_b = reinterpret_cast<const PoolVector<Vector2> *>(b._data._mem);
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 20:44:21 +00:00
int sz = arr_a->size();
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
if (sz == 0 || arr_b->size() != sz) {
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 20:44:21 +00:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
r_dst = a;
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 20:44:21 +00:00
} else {
Memory pool vectors (DVector) have been enormously simplified in code, and renamed to PoolVector
2017-01-07 21:25:37 +00:00
PoolVector<Vector2> v;
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 20:44:21 +00:00
v.resize(sz);
{
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
PoolVector<Vector2>::Write vw = v.write();
PoolVector<Vector2>::Read ar = arr_a->read();
PoolVector<Vector2>::Read br = arr_b->read();
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 20:44:21 +00:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
for (int i = 0; i < sz; i++) {
vw[i] = ar[i].linear_interpolate(br[i], c);
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 20:44:21 +00:00
}
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
r_dst = v;
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 20:44:21 +00:00
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
}
return;
case POOL_VECTOR3_ARRAY: {
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 20:44:21 +00:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
const PoolVector<Vector3> *arr_a = reinterpret_cast<const PoolVector<Vector3> *>(a._data._mem);
const PoolVector<Vector3> *arr_b = reinterpret_cast<const PoolVector<Vector3> *>(b._data._mem);
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 20:44:21 +00:00
int sz = arr_a->size();
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
if (sz == 0 || arr_b->size() != sz) {
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 20:44:21 +00:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
r_dst = a;
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 20:44:21 +00:00
} else {
Memory pool vectors (DVector) have been enormously simplified in code, and renamed to PoolVector
2017-01-07 21:25:37 +00:00
PoolVector<Vector3> v;
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 20:44:21 +00:00
v.resize(sz);
{
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
PoolVector<Vector3>::Write vw = v.write();
PoolVector<Vector3>::Read ar = arr_a->read();
PoolVector<Vector3>::Read br = arr_b->read();
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 20:44:21 +00:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
for (int i = 0; i < sz; i++) {
vw[i] = ar[i].linear_interpolate(br[i], c);
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 20:44:21 +00:00
}
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
r_dst = v;
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 20:44:21 +00:00
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
}
return;
case POOL_COLOR_ARRAY: {
r_dst = a;
}
return;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
default: {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
r_dst = a;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
}
}
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
static const char *_op_names[Variant::OP_MAX] = {
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
"==",
"!=",
"<",
"<=",
">",
">=",
"+",
"-",
"*",
"/",
"- (negation)",
Fix names of Variant operators
2018-04-16 17:54:49 +00:00
"+ (positive)",
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
"%",
Fix names of Variant operators
2018-04-16 17:54:49 +00:00
"+ (concatenation)",
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
"<<",
">>",
"&",
"|",
"^",
"~",
"and",
"or",
"xor",
"not",
"in"
};
String Variant::get_operator_name(Operator p_op) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
ERR_FAIL_INDEX_V(p_op, OP_MAX, "");
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return _op_names[p_op];
}