Nixyri/godot
1
0
Fork 0
mirror of https://github.com/godotengine/godot.git synced 2024-11-24 13:12:42 +00:00
Code Issues Actions 1 Packages Projects Releases Wiki Activity

Style: clang-format: Disable AllowShortIfStatementsOnASingleLine

Browse Source 
Part of #33027, also discussed in #29848.

Enforcing the use of brackets even on single line statements would be
preferred, but `clang-format` doesn't have this functionality yet.
This commit is contained in:
Rémi Verschelde 2020-05-10 12:56:01 +02:00
parent 03b13e0c69
commit e956e80c1f
130 changed files with 967 additions and 511 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
.clang-format
View File

@ -15,7 +15,7 @@ AllowAllParametersOfDeclarationOnNextLine: false
# AllowShortBlocksOnASingleLine: false
AllowShortCaseLabelsOnASingleLine: true
AllowShortFunctionsOnASingleLine: Inline
AllowShortIfStatementsOnASingleLine: true
# AllowShortIfStatementsOnASingleLine: false
# AllowShortLoopsOnASingleLine: false
# AlwaysBreakAfterDefinitionReturnType: None
# AlwaysBreakAfterReturnType: None

9
core/class_db.cpp
View File

@ -1456,16 +1456,19 @@ Variant ClassDB::class_get_default_property_value(const StringName &p_class, con
}
if (!default_values.has(p_class)) {
if (r_valid != nullptr) *r_valid = false;
if (r_valid != nullptr)
*r_valid = false;
return Variant();
}
if (!default_values[p_class].has(p_property)) {
if (r_valid != nullptr) *r_valid = false;
if (r_valid != nullptr)
*r_valid = false;
return Variant();
}
if (r_valid != nullptr) *r_valid = true;
if (r_valid != nullptr)
*r_valid = true;
return default_values[p_class][p_property];
}

3
core/color.cpp
View File

@ -406,7 +406,8 @@ bool Color::html_is_valid(const String &p_color) {
}
Color Color::named(const String &p_name) {
if (_named_colors.empty()) _populate_named_colors(); // from color_names.inc
if (_named_colors.empty())
_populate_named_colors(); // from color_names.inc
String name = p_name;
// Normalize name
name = name.replace(" ", "");

3
core/color_names.inc
View File

@ -3,7 +3,8 @@
static Map<String, Color> _named_colors;
static void _populate_named_colors() {
if (!_named_colors.empty()) return;
if (!_named_colors.empty())
return;
_named_colors.insert("aliceblue", Color(0.94, 0.97, 1.00));
_named_colors.insert("antiquewhite", Color(0.98, 0.92, 0.84));
_named_colors.insert("aqua", Color(0.00, 1.00, 1.00));

24
core/command_queue_mt.h
View File

@ -253,7 +253,8 @@
cmd->method = p_method; \
SEMIC_SEP_LIST(CMD_ASSIGN_PARAM, N); \
unlock(); \
if (sync) sync->post(); \
if (sync) \
sync->post(); \
}
#define CMD_RET_TYPE(N) CommandRet##N<T, M, COMMA_SEP_LIST(TYPE_ARG, N) COMMA(N) R>
@ -269,7 +270,8 @@
cmd->ret = r_ret; \
cmd->sync_sem = ss; \
unlock(); \
if (sync) sync->post(); \
if (sync) \
sync->post(); \
ss->sem.wait(); \
ss->in_use = false; \
}
@ -286,7 +288,8 @@
SEMIC_SEP_LIST(CMD_ASSIGN_PARAM, N); \
cmd->sync_sem = ss; \
unlock(); \
if (sync) sync->post(); \
if (sync) \
sync->post(); \
ss->sem.wait(); \
ss->in_use = false; \
}
@ -418,12 +421,14 @@ class CommandQueueMT {
}
bool flush_one(bool p_lock = true) {
if (p_lock) lock();
if (p_lock)
lock();
tryagain:
// tried to read an empty queue
if (read_ptr == write_ptr) {
if (p_lock) unlock();
if (p_lock)
unlock();
return false;
}
@ -442,15 +447,18 @@ class CommandQueueMT {
read_ptr += size;
if (p_lock) unlock();
if (p_lock)
unlock();
cmd->call();
if (p_lock) lock();
if (p_lock)
lock();
cmd->post();
cmd->~CommandBase();
*(uint32_t *)&command_mem[size_ptr] &= ~1;
if (p_lock) unlock();
if (p_lock)
unlock();
return true;
}

6
core/image.cpp
View File

@ -3152,11 +3152,13 @@ void Image::bumpmap_to_normalmap(float bump_scale) {
for (int ty = 0; ty < height; ty++) {
int py = ty + 1;
if (py >= height) py -= height;
if (py >= height)
py -= height;
for (int tx = 0; tx < width; tx++) {
int px = tx + 1;
if (px >= width) px -= width;
if (px >= width)
px -= width;
float here = read_ptr[ty * width + tx];
float to_right = read_ptr[ty * width + px];
float above = read_ptr[py * width + tx];

3
core/io/file_access_pack.cpp
View File

@ -414,7 +414,8 @@ Error DirAccessPack::change_dir(String p_dir) {
nd = nd.simplify_path();
if (nd == "") nd = ".";
if (nd == "")
nd = ".";
if (nd.begins_with("/")) {
nd = nd.replace_first("/", "");

12
core/io/ip_address.h
View File

@ -52,16 +52,20 @@ protected:
public:
//operator Variant() const;
bool operator==(const IP_Address &p_ip) const {
if (p_ip.valid != valid) return false;
if (!valid) return false;
if (p_ip.valid != valid)
return false;
if (!valid)
return false;
for (int i = 0; i < 4; i++)
if (field32[i] != p_ip.field32[i])
return false;
return true;
}
bool operator!=(const IP_Address &p_ip) const {
if (p_ip.valid != valid) return true;
if (!valid) return true;
if (p_ip.valid != valid)
return true;
if (!valid)
return true;
for (int i = 0; i < 4; i++)
if (field32[i] != p_ip.field32[i])
return true;

3
core/io/marshalls.h
View File

@ -121,7 +121,8 @@ static inline int encode_cstring(const char *p_string, uint8_t *p_data) {
len++;
};
if (p_data) *p_data = 0;
if (p_data)
*p_data = 0;
return len + 1;
}

8
core/io/multiplayer_api.cpp
View File

@ -144,7 +144,8 @@ void MultiplayerAPI::set_root_node(Node *p_node) {
void MultiplayerAPI::set_network_peer(const Ref<NetworkedMultiplayerPeer> &p_peer) {
if (p_peer == network_peer) return; // Nothing to do
if (p_peer == network_peer)
return; // Nothing to do
ERR_FAIL_COND_MSG(p_peer.is_valid() && p_peer->get_connection_status() == NetworkedMultiplayerPeer::CONNECTION_DISCONNECTED,
"Supplied NetworkedMultiplayerPeer must be connecting or connected.");
@ -787,8 +788,9 @@ void MultiplayerAPI::_send_rpc(Node *p_from, int p_to, bool p_unreliable, bool p
int ofs = 0;
#define MAKE_ROOM(m_amount) \
if (packet_cache.size() < m_amount) packet_cache.resize(m_amount);
#define MAKE_ROOM(m_amount) \
if (packet_cache.size() < m_amount) \
packet_cache.resize(m_amount);
// Encode meta.
// The meta is composed by a single byte that contains (starting from the least segnificant bit):

6
core/io/resource_loader.h
View File

@ -160,7 +160,8 @@ public:
static bool get_timestamp_on_load() { return timestamp_on_load; }
static void notify_load_error(const String &p_err) {
if (err_notify) err_notify(err_notify_ud, p_err);
if (err_notify)
err_notify(err_notify_ud, p_err);
}
static void set_error_notify_func(void *p_ud, ResourceLoadErrorNotify p_err_notify) {
err_notify = p_err_notify;
@ -168,7 +169,8 @@ public:
}
static void notify_dependency_error(const String &p_path, const String &p_dependency, const String &p_type) {
if (dep_err_notify) dep_err_notify(dep_err_notify_ud, p_path, p_dependency, p_type);
if (dep_err_notify)
dep_err_notify(dep_err_notify_ud, p_path, p_dependency, p_type);
}
static void set_dependency_error_notify_func(void *p_ud, DependencyErrorNotify p_err_notify) {
dep_err_notify = p_err_notify;

3
core/list.h
View File

@ -353,7 +353,8 @@ public:
Element *it = front();
while (it) {
if (it->value == p_val) return it;
if (it->value == p_val)
return it;
it = it->next();
};

24
core/math/a_star.cpp
View File

@ -164,7 +164,8 @@ void AStar::connect_points(int p_id, int p_with_id, bool bidirectional) {
}
Segment s(p_id, p_with_id);
if (bidirectional) s.direction = Segment::BIDIRECTIONAL;
if (bidirectional)
s.direction = Segment::BIDIRECTIONAL;
Set<Segment>::Element *element = segments.find(s);
if (element != nullptr) {
@ -290,7 +291,8 @@ int AStar::get_closest_point(const Vector3 &p_point, bool p_include_disabled) co
for (OAHashMap<int, Point *>::Iterator it = points.iter(); it.valid; it = points.next_iter(it)) {
if (!p_include_disabled && !(*it.value)->enabled) continue; // Disabled points should not be considered.
if (!p_include_disabled && !(*it.value)->enabled)
continue; // Disabled points should not be considered.
real_t d = p_point.distance_squared_to((*it.value)->pos);
if (closest_id < 0 || d < closest_dist) {
@ -340,7 +342,8 @@ bool AStar::_solve(Point *begin_point, Point *end_point) {
pass++;
if (!end_point->enabled) return false;
if (!end_point->enabled)
return false;
bool found_route = false;
@ -451,7 +454,8 @@ Vector<Vector3> AStar::get_point_path(int p_from_id, int p_to_id) {
Point *end_point = b;
bool found_route = _solve(begin_point, end_point);
if (!found_route) return Vector<Vector3>();
if (!found_route)
return Vector<Vector3>();
Point *p = end_point;
int pc = 1; // Begin point
@ -499,7 +503,8 @@ Vector<int> AStar::get_id_path(int p_from_id, int p_to_id) {
Point *end_point = b;
bool found_route = _solve(begin_point, end_point);
if (!found_route) return Vector<int>();
if (!found_route)
return Vector<int>();
Point *p = end_point;
int pc = 1; // Begin point
@ -729,7 +734,8 @@ Vector<Vector2> AStar2D::get_point_path(int p_from_id, int p_to_id) {
AStar::Point *end_point = b;
bool found_route = _solve(begin_point, end_point);
if (!found_route) return Vector<Vector2>();
if (!found_route)
return Vector<Vector2>();
AStar::Point *p = end_point;
int pc = 1; // Begin point
@ -777,7 +783,8 @@ Vector<int> AStar2D::get_id_path(int p_from_id, int p_to_id) {
AStar::Point *end_point = b;
bool found_route = _solve(begin_point, end_point);
if (!found_route) return Vector<int>();
if (!found_route)
return Vector<int>();
AStar::Point *p = end_point;
int pc = 1; // Begin point
@ -809,7 +816,8 @@ bool AStar2D::_solve(AStar::Point *begin_point, AStar::Point *end_point) {
astar.pass++;
if (!end_point->enabled) return false;
if (!end_point->enabled)
return false;
bool found_route = false;

3
core/math/basis.cpp
View File

@ -783,7 +783,8 @@ void Basis::get_axis_angle(Vector3 &r_axis, real_t &r_angle) const {
real_t s = Math::sqrt((elements[1][2] - elements[2][1]) * (elements[1][2] - elements[2][1]) + (elements[2][0] - elements[0][2]) * (elements[2][0] - elements[0][2]) + (elements[0][1] - elements[1][0]) * (elements[0][1] - elements[1][0])); // s=|axis||sin(angle)|, used to normalise
angle = Math::acos((elements[0][0] + elements[1][1] + elements[2][2] - 1) / 2);
if (angle < 0) s = -s;
if (angle < 0)
s = -s;
x = (elements[2][1] - elements[1][2]) / s;
y = (elements[0][2] - elements[2][0]) / s;
z = (elements[1][0] - elements[0][1]) / s;

9
core/math/camera_matrix.cpp
View File

@ -473,20 +473,23 @@ void CameraMatrix::invert() {
/** Divide column by minus pivot value **/
for (i = 0; i < 4; i++) {
if (i != k) matrix[i][k] /= (-pvt_val);
if (i != k)
matrix[i][k] /= (-pvt_val);
}
/** Reduce the matrix **/
for (i = 0; i < 4; i++) {
hold = matrix[i][k];
for (j = 0; j < 4; j++) {
if (i != k && j != k) matrix[i][j] += hold * matrix[k][j];
if (i != k && j != k)
matrix[i][j] += hold * matrix[k][j];
}
}
/** Divide row by pivot **/
for (j = 0; j < 4; j++) {
if (j != k) matrix[k][j] /= pvt_val;
if (j != k)
matrix[k][j] /= pvt_val;
}
/** Replace pivot by reciprocal (at last we can touch it). **/

24
core/math/geometry.h
View File

@ -113,10 +113,14 @@ public:
real_t mub = (d_of(p1, q1, q2, q1) + mua * d_of(q2, q1, p2, p1)) / d_of(q2, q1, q2, q1);
// Clip the value between [0..1] constraining the solution to lie on the original curves.
if (mua < 0) mua = 0;
if (mub < 0) mub = 0;
if (mua > 1) mua = 1;
if (mub > 1) mub = 1;
if (mua < 0)
mua = 0;
if (mub < 0)
mub = 0;
if (mua > 1)
mua = 1;
if (mub > 1)
mub = 1;
c1 = p1.lerp(p2, mua);
c2 = q1.lerp(q2, mub);
}
@ -497,7 +501,8 @@ public:
bool orientation = an.cross(bn) > 0;
if ((bn.cross(cn) > 0) != orientation) return false;
if ((bn.cross(cn) > 0) != orientation)
return false;
return (cn.cross(an) > 0) == orientation;
}
@ -683,7 +688,8 @@ public:
// If the term we intend to square root is less than 0 then the answer won't be real,
// so it definitely won't be t in the range 0 to 1.
if (sqrtterm < 0) return -1;
if (sqrtterm < 0)
return -1;
// If we can assume that the line segment starts outside the circle (e.g. for continuous time collision detection)
// then the following can be skipped and we can just return the equivalent of res1.
@ -691,8 +697,10 @@ public:
real_t res1 = (-b - sqrtterm) / (2 * a);
real_t res2 = (-b + sqrtterm) / (2 * a);
if (res1 >= 0 && res1 <= 1) return res1;
if (res2 >= 0 && res2 <= 1) return res2;
if (res1 >= 0 && res1 <= 1)
return res1;
if (res2 >= 0 && res2 <= 1)
return res2;
return -1;
}

6
core/math/math_funcs.h
View File

@ -233,12 +233,14 @@ public:
static _ALWAYS_INLINE_ float range_lerp(float p_value, float p_istart, float p_istop, float p_ostart, float p_ostop) { return Math::lerp(p_ostart, p_ostop, Math::inverse_lerp(p_istart, p_istop, p_value)); }
static _ALWAYS_INLINE_ double smoothstep(double p_from, double p_to, double p_weight) {
if (is_equal_approx(p_from, p_to)) return p_from;
if (is_equal_approx(p_from, p_to))
return p_from;
double x = CLAMP((p_weight - p_from) / (p_to - p_from), 0.0, 1.0);
return x * x * (3.0 - 2.0 * x);
}
static _ALWAYS_INLINE_ float smoothstep(float p_from, float p_to, float p_weight) {
if (is_equal_approx(p_from, p_to)) return p_from;
if (is_equal_approx(p_from, p_to))
return p_from;
float x = CLAMP((p_weight - p_from) / (p_to - p_from), 0.0f, 1.0f);
return x * x * (3.0f - 2.0f * x);
}

3
core/math/quat.cpp
View File

@ -206,7 +206,8 @@ Quat Quat::slerpni(const Quat &q, const real_t &t) const {
real_t dot = from.dot(q);
if (Math::absf(dot) > 0.9999) return from;
if (Math::absf(dot) > 0.9999)
return from;
real_t theta = Math::acos(dot),
sinT = 1.0 / Math::sin(theta),

15
core/math/triangle_mesh.cpp
View File

@ -558,14 +558,16 @@ bool TriangleMesh::intersect_convex_shape(const Plane *p_planes, int p_plane_cou
if (p.intersects_segment(point, next_point, &res)) {
bool inisde = true;
for (int k = 0; k < p_plane_count; k++) {
if (k == i) continue;
if (k == i)
continue;
const Plane &pp = p_planes[k];
if (pp.is_point_over(res)) {
inisde = false;
break;
}
}
if (inisde) return true;
if (inisde)
return true;
}
if (p.is_point_over(point)) {
@ -573,7 +575,8 @@ bool TriangleMesh::intersect_convex_shape(const Plane *p_planes, int p_plane_cou
break;
}
}
if (over) return true;
if (over)
return true;
}
stack[level] = (VISIT_DONE_BIT << VISITED_BIT_SHIFT) | node;
@ -652,7 +655,8 @@ bool TriangleMesh::inside_convex_shape(const Plane *p_planes, int p_plane_count,
case TEST_AABB_BIT: {
bool intersects = scale.xform(b.aabb).intersects_convex_shape(p_planes, p_plane_count, p_points, p_point_count);
if (!intersects) return false;
if (!intersects)
return false;
bool inside = scale.xform(b.aabb).inside_convex_shape(p_planes, p_plane_count);
if (inside) {
@ -667,7 +671,8 @@ bool TriangleMesh::inside_convex_shape(const Plane *p_planes, int p_plane_count,
Vector3 point = scale.xform(vertexptr[s.indices[j]]);
for (int i = 0; i < p_plane_count; i++) {
const Plane &p = p_planes[i];
if (p.is_point_over(point)) return false;
if (p.is_point_over(point))
return false;
}
}

21
core/math/triangulate.cpp
View File

@ -103,13 +103,16 @@ bool Triangulate::snip(const Vector<Vector2> &p_contour, int u, int v, int w, in
// To avoid that we allow zero-area triangles if all else failed.
float threshold = relaxed ? -CMP_EPSILON : CMP_EPSILON;
if (threshold > (((Bx - Ax) * (Cy - Ay)) - ((By - Ay) * (Cx - Ax)))) return false;
if (threshold > (((Bx - Ax) * (Cy - Ay)) - ((By - Ay) * (Cx - Ax))))
return false;
for (p = 0; p < n; p++) {
if ((p == u) || (p == v) || (p == w)) continue;
if ((p == u) || (p == v) || (p == w))
continue;
Px = contour[V[p]].x;
Py = contour[V[p]].y;
if (is_inside_triangle(Ax, Ay, Bx, By, Cx, Cy, Px, Py, relaxed)) return false;
if (is_inside_triangle(Ax, Ay, Bx, By, Cx, Cy, Px, Py, relaxed))
return false;
}
return true;
@ -119,7 +122,8 @@ bool Triangulate::triangulate(const Vector<Vector2> &contour, Vector<int> &resul
/* allocate and initialize list of Vertices in polygon */
int n = contour.size();
if (n < 3) return false;
if (n < 3)
return false;
Vector<int> V;
V.resize(n);
@ -161,11 +165,14 @@ bool Triangulate::triangulate(const Vector<Vector2> &contour, Vector<int> &resul
/* three consecutive vertices in current polygon, <u,v,w> */
int u = v;
if (nv <= u) u = 0; /* previous */
if (nv <= u)
u = 0; /* previous */
v = u + 1;
if (nv <= v) v = 0; /* new v */
if (nv <= v)
v = 0; /* new v */
int w = v + 1;
if (nv <= w) w = 0; /* next */
if (nv <= w)
w = 0; /* next */
if (snip(contour, u, v, w, nv, V, relaxed)) {
int a, b, c, s, t;

3
core/method_bind.h
View File

@ -165,7 +165,8 @@ struct VariantObjectClassChecker<Control *> {
#define CHECK_NOARG(m_arg) \
{ \
if (p_arg##m_arg.get_type() != Variant::NIL) { \
if (r_argerror) *r_argerror = (m_arg - 1); \
if (r_argerror) \
*r_argerror = (m_arg - 1); \
return CALL_ERROR_EXTRA_ARGUMENT; \
} \
}

3
core/node_path.cpp
View File

@ -373,7 +373,8 @@ NodePath::NodePath(const String &p_path) {
String str = path.substr(from, i - from);
if (str == "") {
if (path[i] == 0) continue; // Allow end-of-path :
if (path[i] == 0)
continue; // Allow end-of-path :
ERR_FAIL_MSG("Invalid NodePath '" + p_path + "'.");
}

3
core/object.cpp
View File

@ -543,7 +543,8 @@ void Object::set_indexed(const Vector<StringName> &p_names, const Variant &p_val
}
bool valid = false;
if (!r_valid) r_valid = &valid;
if (!r_valid)
r_valid = &valid;
List<Variant> value_stack;

3
core/object.h
View File

@ -346,7 +346,8 @@ protected:
return (bool (Object::*)(const StringName &, const Variant &)) & m_class::_set; \
} \
virtual bool _setv(const StringName &p_name, const Variant &p_property) { \
if (m_inherits::_setv(p_name, p_property)) return true; \
if (m_inherits::_setv(p_name, p_property)) \
return true; \
if (m_class::_get_set() != m_inherits::_get_set()) { \
return _set(p_name, p_property); \
} \

3
core/os/dir_access.h
View File

@ -145,7 +145,8 @@ struct DirAccessRef {
DirAccess *f;
DirAccessRef(DirAccess *fa) { f = fa; }
~DirAccessRef() {
if (f) memdelete(f);
if (f)
memdelete(f);
}
};

3
core/os/file_access.h
View File

@ -192,7 +192,8 @@ struct FileAccessRef {
operator FileAccess *() { return f; }
FileAccessRef(FileAccess *fa) { f = fa; }
~FileAccessRef() {
if (f) memdelete(f);
if (f)
memdelete(f);
}
};

7
core/os/memory.h
View File

@ -130,9 +130,10 @@ void memdelete_allocator(T *p_class) {
A::free(p_class);
}
#define memdelete_notnull(m_v) \
{ \
if (m_v) memdelete(m_v); \
#define memdelete_notnull(m_v) \
{ \
if (m_v) \
memdelete(m_v); \
}
#define memnew_arr(m_class, m_count) memnew_arr_template<m_class>(m_count)

12
core/os/rw_lock.h
View File

@ -58,10 +58,12 @@ class RWLockRead {
public:
RWLockRead(const RWLock *p_lock) {
lock = const_cast<RWLock *>(p_lock);
if (lock) lock->read_lock();
if (lock)
lock->read_lock();
}
~RWLockRead() {
if (lock) lock->read_unlock();
if (lock)
lock->read_unlock();
}
};
@ -72,10 +74,12 @@ class RWLockWrite {
public:
RWLockWrite(RWLock *p_lock) {
lock = p_lock;
if (lock) lock->write_lock();
if (lock)
lock->write_lock();
}
~RWLockWrite() {
if (lock) lock->write_unlock();
if (lock)
lock->write_unlock();
}
};

3
core/pool_allocator.cpp
View File

@ -182,7 +182,8 @@ PoolAllocator::ID PoolAllocator::alloc(int p_size) {
ERR_FAIL_COND_V(p_size < 1, POOL_ALLOCATOR_INVALID_ID);
#ifdef DEBUG_ENABLED
if (p_size > free_mem) OS::get_singleton()->debug_break();
if (p_size > free_mem)
OS::get_singleton()->debug_break();
#endif
ERR_FAIL_COND_V(p_size > free_mem, POOL_ALLOCATOR_INVALID_ID);

3
core/self_list.h
View File

@ -121,7 +121,8 @@ private:
public:
_FORCE_INLINE_ bool in_list() const { return _root; }
_FORCE_INLINE_ void remove_from_list() {
if (_root) _root->remove(this);
if (_root)
_root->remove(this);
}
_FORCE_INLINE_ SelfList<T> *next() { return _next; }
_FORCE_INLINE_ SelfList<T> *prev() { return _prev; }

3
core/translation.cpp
View File

@ -989,7 +989,8 @@ String TranslationServer::get_locale() const {
String TranslationServer::get_locale_name(const String &p_locale) const {
if (!locale_name_map.has(p_locale)) return String();
if (!locale_name_map.has(p_locale))
return String();
return locale_name_map[p_locale];
}

3
core/ustring.cpp
View File

@ -1882,7 +1882,8 @@ bool String::is_numeric() const {
};
int s = 0;
if (operator[](0) == '-') ++s;
if (operator[](0) == '-')
++s;
bool dot = false;
for (int i = s; i < length(); i++) {

3
core/variant.h
View File

@ -474,7 +474,8 @@ public:
type = NIL;
}
_FORCE_INLINE_ ~Variant() {
if (type != Variant::NIL) clear();
if (type != Variant::NIL)
clear();
}
};

185
core/variant_op.cpp
View File

@ -181,21 +181,26 @@ bool Variant::booleanize() const {
return; \
}
#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 == FLOAT) _RETURN(p_a._data.m_type m_op p_b._data._float); \
\
_RETURN_FAIL \
#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 == FLOAT) \
_RETURN(p_a._data.m_type m_op p_b._data._float); \
\
_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 == FLOAT) _RETURN(p_a._data.m_type m_op p_b._data._float); \
if (p_b.type == NIL) _RETURN(!(p_b.type m_op NIL)); \
\
_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 == FLOAT) \
_RETURN(p_a._data.m_type m_op p_b._data._float); \
if (p_b.type == NIL) \
_RETURN(!(p_b.type m_op NIL)); \
\
_RETURN_FAIL \
};
#ifdef DEBUG_ENABLED
@ -219,12 +224,14 @@ bool Variant::booleanize() const {
_RETURN_FAIL \
};
#else
#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 == FLOAT) _RETURN(p_a._data.m_type / p_b._data._float); \
\
_RETURN_FAIL \
#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 == FLOAT) \
_RETURN(p_a._data.m_type / p_b._data._float); \
\
_RETURN_FAIL \
};
#endif
@ -238,62 +245,84 @@ bool Variant::booleanize() const {
_RETURN(p_a._data.m_type); \
};
#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 == FLOAT) _RETURN(p_a._data.m_type m_op p_b._data._float); \
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)); \
if (p_b.type == VECTOR2I) _RETURN(p_a._data.m_type m_op *reinterpret_cast<const Vector2 *>(p_b._data._mem)); \
if (p_b.type == VECTOR3I) _RETURN(p_a._data.m_type m_op *reinterpret_cast<const Vector3 *>(p_b._data._mem)); \
\
_RETURN_FAIL \
#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 == FLOAT) \
_RETURN(p_a._data.m_type m_op p_b._data._float); \
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)); \
if (p_b.type == VECTOR2I) \
_RETURN(p_a._data.m_type m_op *reinterpret_cast<const Vector2 *>(p_b._data._mem)); \
if (p_b.type == VECTOR3I) \
_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 == STRING_NAME) _RETURN(*reinterpret_cast<const m_type *>(p_b._data._mem) m_op *reinterpret_cast<const StringName *>(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 \
#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 == STRING_NAME) \
_RETURN(*reinterpret_cast<const m_type *>(p_b._data._mem) m_op *reinterpret_cast<const StringName *>(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 \
};
#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 == STRING_NAME) _RETURN(*reinterpret_cast<const m_type *>(p_a._data._mem) m_op *reinterpret_cast<const StringName *>(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 \
#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 == STRING_NAME) \
_RETURN(*reinterpret_cast<const m_type *>(p_a._data._mem) m_op *reinterpret_cast<const StringName *>(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 \
};
#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 == STRING_NAME) _RETURN(*reinterpret_cast<const m_type *>(p_a._data._mem) m_op *reinterpret_cast<const StringName *>(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)); \
if (p_b.type == NIL) _RETURN(!(p_b.type m_op NIL)); \
\
_RETURN_FAIL \
#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 == STRING_NAME) \
_RETURN(*reinterpret_cast<const m_type *>(p_a._data._mem) m_op *reinterpret_cast<const StringName *>(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)); \
if (p_b.type == NIL) \
_RETURN(!(p_b.type m_op NIL)); \
\
_RETURN_FAIL \
};
#define DEFAULT_OP_STR_NULL_NP(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)); \
if (p_b.type == NIL) _RETURN(!(p_b.type m_op NIL)); \
\
_RETURN_FAIL \
#define DEFAULT_OP_STR_NULL_NP(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)); \
if (p_b.type == NIL) \
_RETURN(!(p_b.type m_op NIL)); \
\
_RETURN_FAIL \
};
#define DEFAULT_OP_STR_NULL_SN(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 == STRING_NAME) _RETURN(*reinterpret_cast<const m_type *>(p_a._data._mem) m_op *reinterpret_cast<const StringName *>(p_b._data._mem)); \
if (p_b.type == NIL) _RETURN(!(p_b.type m_op NIL)); \
\
_RETURN_FAIL \
#define DEFAULT_OP_STR_NULL_SN(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 == STRING_NAME) \
_RETURN(*reinterpret_cast<const m_type *>(p_a._data._mem) m_op *reinterpret_cast<const StringName *>(p_b._data._mem)); \
if (p_b.type == NIL) \
_RETURN(!(p_b.type m_op NIL)); \
\
_RETURN_FAIL \
};
#define DEFAULT_OP_LOCALMEM_REV(m_prefix, m_op_name, m_name, m_op, m_type) \
@ -332,13 +361,16 @@ bool Variant::booleanize() const {
_RETURN(*reinterpret_cast<const m_type *>(p_a._data._mem)); \
}
#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 == FLOAT) _RETURN(*reinterpret_cast<const m_type *>(p_a._data._mem) m_op p_b._data._float); \
\
_RETURN_FAIL \
#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 == FLOAT) \
_RETURN(*reinterpret_cast<const m_type *>(p_a._data._mem) m_op p_b._data._float); \
\
_RETURN_FAIL \
}
#define DEFAULT_OP_PTR(m_op, m_name, m_sub) \
@ -436,7 +468,8 @@ void Variant::evaluate(const Operator &p_op, const Variant &p_a,
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 == NIL)
_RETURN(true);
if (p_b.type == OBJECT)
_RETURN(p_b._get_obj().obj == nullptr);
@ -532,7 +565,8 @@ void Variant::evaluate(const Operator &p_op, const Variant &p_a,
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 == NIL)
_RETURN(false);
if (p_b.type == OBJECT)
_RETURN(p_b._get_obj().obj != nullptr);
@ -1983,7 +2017,8 @@ Variant Variant::get_named(const StringName &p_index, bool *r_valid) const {
#define DEFAULT_OP_DVECTOR_SET(m_name, m_type, skip_cond) \
case m_name: { \
if (skip_cond) return; \
if (skip_cond) \
return; \
\
if (p_index.get_type() == Variant::INT || p_index.get_type() == Variant::FLOAT) { \
int index = p_index; \

3
core/vector.h
View File

@ -69,7 +69,8 @@ public:
void remove(int p_index) { _cowdata.remove(p_index); }
void erase(const T &p_val) {
int idx = find(p_val);
if (idx >= 0) remove(idx);
if (idx >= 0)
remove(idx);
}
void invert();

3
drivers/gles2/shaders/scene.glsl
View File

@ -1128,7 +1128,8 @@ float SchlickFresnel(float u) {
}
float GTR1(float NdotH, float a) {
if (a >= 1.0) return 1.0 / M_PI;
if (a >= 1.0)
return 1.0 / M_PI;
float a2 = a * a;
float t = 1.0 + (a2 - 1.0) * NdotH * NdotH;
return (a2 - 1.0) / (M_PI * log(a2) * t);

3
drivers/unix/ip_unix.cpp
View File

@ -248,7 +248,8 @@ void IP_Unix::get_local_interfaces(Map<String, Interface_Info> *r_interfaces) co
info.ip_addresses.push_front(_sockaddr2ip(ifa->ifa_addr));
}
if (ifAddrStruct != nullptr) freeifaddrs(ifAddrStruct);
if (ifAddrStruct != nullptr)
freeifaddrs(ifAddrStruct);
}
#endif

13
drivers/vulkan/vulkan_context.cpp
View File

@ -601,12 +601,13 @@ Error VulkanContext::_initialize_queues(VkSurfaceKHR surface) {
_create_device();
static PFN_vkGetDeviceProcAddr g_gdpa = nullptr;
#define GET_DEVICE_PROC_ADDR(dev, entrypoint) \
{ \
if (!g_gdpa) g_gdpa = (PFN_vkGetDeviceProcAddr)vkGetInstanceProcAddr(inst, "vkGetDeviceProcAddr"); \
fp##entrypoint = (PFN_vk##entrypoint)g_gdpa(dev, "vk" #entrypoint); \
ERR_FAIL_COND_V_MSG(fp##entrypoint == nullptr, ERR_CANT_CREATE, \
"vkGetDeviceProcAddr failed to find vk" #entrypoint); \
#define GET_DEVICE_PROC_ADDR(dev, entrypoint) \
{ \
if (!g_gdpa) \
g_gdpa = (PFN_vkGetDeviceProcAddr)vkGetInstanceProcAddr(inst, "vkGetDeviceProcAddr"); \
fp##entrypoint = (PFN_vk##entrypoint)g_gdpa(dev, "vk" #entrypoint); \
ERR_FAIL_COND_V_MSG(fp##entrypoint == nullptr, ERR_CANT_CREATE, \
"vkGetDeviceProcAddr failed to find vk" #entrypoint); \
}
GET_DEVICE_PROC_ADDR(device, CreateSwapchainKHR);

6
editor/code_editor.cpp
View File

@ -309,7 +309,8 @@ void FindReplaceBar::_update_results_count() {
results_count = 0;
String searched = get_search_text();
if (searched.empty()) return;
if (searched.empty())
return;
String full_text = text_edit->get_text();
@ -317,7 +318,8 @@ void FindReplaceBar::_update_results_count() {
while (true) {
int pos = is_case_sensitive() ? full_text.find(searched, from_pos) : full_text.findn(searched, from_pos);
if (pos == -1) break;
if (pos == -1)
break;
if (is_whole_words()) {
from_pos++; // Making sure we won't hit the same match next time, if we get out via a continue.

3
editor/debugger/script_editor_debugger.cpp
View File

@ -74,7 +74,8 @@ void ScriptEditorDebugger::_put_msg(String p_message, Array p_data) {
void ScriptEditorDebugger::debug_copy() {
String msg = reason->get_text();
if (msg == "") return;
if (msg == "")
return;
DisplayServer::get_singleton()->clipboard_set(msg);
}

3
editor/editor_file_dialog.cpp
View File

@ -691,7 +691,8 @@ bool EditorFileDialog::_is_open_should_be_disabled() {
void EditorFileDialog::update_file_name() {
int idx = filter->get_selected() - 1;
if ((idx == -1 && filter->get_item_count() == 2) || (filter->get_item_count() > 2 && idx >= 0 && idx < filter->get_item_count() - 2)) {
if (idx == -1) idx += 1;
if (idx == -1)
idx += 1;
String filter_str = filters[idx];
String file_str = file->get_text();
String base_name = file_str.get_basename();

3
editor/editor_help.cpp
View File

@ -1786,7 +1786,8 @@ void FindBar::_update_results_count() {
results_count = 0;
String searched = search_text->get_text();
if (searched.empty()) return;
if (searched.empty())
return;
String full_text = rich_text_label->get_text();

3
editor/editor_node.cpp
View File

@ -3082,7 +3082,8 @@ void EditorNode::_remove_edited_scene(bool p_change_tab) {
ScriptEditor::get_singleton()->close_builtin_scripts_from_scene(editor_data.get_scene_path(old_index));
}
if (p_change_tab) _scene_tab_changed(new_index);
if (p_change_tab)
_scene_tab_changed(new_index);
editor_data.remove_scene(old_index);
editor_data.get_undo_redo().clear_history(false);
_update_title();

15
editor/node_3d_editor_gizmos.cpp
View File

@ -431,7 +431,8 @@ bool EditorNode3DGizmo::intersect_frustum(const Camera3D *p_camera, const Vector
ERR_FAIL_COND_V(!spatial_node, false);
ERR_FAIL_COND_V(!valid, false);
if (hidden && !gizmo_plugin->is_selectable_when_hidden()) return false;
if (hidden && !gizmo_plugin->is_selectable_when_hidden())
return false;
if (selectable_icon_size > 0.0f) {
Vector3 origin = spatial_node->get_global_transform().get_origin();
@ -470,10 +471,12 @@ bool EditorNode3DGizmo::intersect_frustum(const Camera3D *p_camera, const Vector
break;
}
}
if (any_out) break;
if (any_out)
break;
}
if (!any_out) return true;
if (!any_out)
return true;
}
if (collision_mesh.is_valid()) {
@ -504,7 +507,8 @@ bool EditorNode3DGizmo::intersect_ray(Camera3D *p_camera, const Point2 &p_point,
ERR_FAIL_COND_V(!spatial_node, false);
ERR_FAIL_COND_V(!valid, false);
if (hidden && !gizmo_plugin->is_selectable_when_hidden()) return false;
if (hidden && !gizmo_plugin->is_selectable_when_hidden())
return false;
if (r_gizmo_handle && !hidden) {
@ -785,7 +789,8 @@ EditorNode3DGizmo::EditorNode3DGizmo() {
EditorNode3DGizmo::~EditorNode3DGizmo() {
if (gizmo_plugin != nullptr) gizmo_plugin->unregister_gizmo(this);
if (gizmo_plugin != nullptr)
gizmo_plugin->unregister_gizmo(this);
clear();
}

30
editor/plugins/canvas_item_editor_plugin.cpp
View File

@ -1624,20 +1624,28 @@ bool CanvasItemEditor::_gui_input_anchors(const Ref<InputEvent> &p_event) {
switch (drag_type) {
case DRAG_ANCHOR_TOP_LEFT:
if (!use_single_axis || !use_y) control->set_anchor(MARGIN_LEFT, new_anchor.x, false, false);
if (!use_single_axis || use_y) control->set_anchor(MARGIN_TOP, new_anchor.y, false, false);
if (!use_single_axis || !use_y)
control->set_anchor(MARGIN_LEFT, new_anchor.x, false, false);
if (!use_single_axis || use_y)
control->set_anchor(MARGIN_TOP, new_anchor.y, false, false);
break;
case DRAG_ANCHOR_TOP_RIGHT:
if (!use_single_axis || !use_y) control->set_anchor(MARGIN_RIGHT, new_anchor.x, false, false);
if (!use_single_axis || use_y) control->set_anchor(MARGIN_TOP, new_anchor.y, false, false);
if (!use_single_axis || !use_y)
control->set_anchor(MARGIN_RIGHT, new_anchor.x, false, false);
if (!use_single_axis || use_y)
control->set_anchor(MARGIN_TOP, new_anchor.y, false, false);
break;
case DRAG_ANCHOR_BOTTOM_RIGHT:
if (!use_single_axis || !use_y) control->set_anchor(MARGIN_RIGHT, new_anchor.x, false, false);
if (!use_single_axis || use_y) control->set_anchor(MARGIN_BOTTOM, new_anchor.y, false, false);
if (!use_single_axis || !use_y)
control->set_anchor(MARGIN_RIGHT, new_anchor.x, false, false);
if (!use_single_axis || use_y)
control->set_anchor(MARGIN_BOTTOM, new_anchor.y, false, false);
break;
case DRAG_ANCHOR_BOTTOM_LEFT:
if (!use_single_axis || !use_y) control->set_anchor(MARGIN_LEFT, new_anchor.x, false, false);
if (!use_single_axis || use_y) control->set_anchor(MARGIN_BOTTOM, new_anchor.y, false, false);
if (!use_single_axis || !use_y)
control->set_anchor(MARGIN_LEFT, new_anchor.x, false, false);
if (!use_single_axis || use_y)
control->set_anchor(MARGIN_BOTTOM, new_anchor.y, false, false);
break;
case DRAG_ANCHOR_ALL:
if (!use_single_axis || !use_y) {
@ -5037,7 +5045,8 @@ void CanvasItemEditor::_focus_selection(int p_op) {
Map<Node *, Object *> &selection = editor_selection->get_selection();
for (Map<Node *, Object *>::Element *E = selection.front(); E; E = E->next()) {
CanvasItem *canvas_item = Object::cast_to<CanvasItem>(E->key());
if (!canvas_item) continue;
if (!canvas_item)
continue;
if (canvas_item->get_viewport() != EditorNode::get_singleton()->get_scene_root())
continue;
@ -5065,7 +5074,8 @@ void CanvasItemEditor::_focus_selection(int p_op) {
rect = rect.merge(canvas_item_rect);
}
};
if (count == 0) return;
if (count == 0)
return;
if (p_op == VIEW_CENTER_TO_SELECTION) {

18
editor/plugins/debugger_editor_plugin.cpp
View File

@ -179,12 +179,18 @@ void DebuggerEditorPlugin::_update_debug_options() {
bool check_reload_scripts = EditorSettings::get_singleton()->get_project_metadata("debug_options", "run_reload_scripts", false);
int instances = EditorSettings::get_singleton()->get_project_metadata("debug_options", "run_debug_instances", 1);
if (check_deploy_remote) _menu_option(RUN_DEPLOY_REMOTE_DEBUG);
if (check_file_server) _menu_option(RUN_FILE_SERVER);
if (check_debug_collisions) _menu_option(RUN_DEBUG_COLLISONS);
if (check_debug_navigation) _menu_option(RUN_DEBUG_NAVIGATION);
if (check_live_debug) _menu_option(RUN_LIVE_DEBUG);
if (check_reload_scripts) _menu_option(RUN_RELOAD_SCRIPTS);
if (check_deploy_remote)
_menu_option(RUN_DEPLOY_REMOTE_DEBUG);
if (check_file_server)
_menu_option(RUN_FILE_SERVER);
if (check_debug_collisions)
_menu_option(RUN_DEBUG_COLLISONS);
if (check_debug_navigation)
_menu_option(RUN_DEBUG_NAVIGATION);
if (check_live_debug)
_menu_option(RUN_LIVE_DEBUG);
if (check_reload_scripts)
_menu_option(RUN_RELOAD_SCRIPTS);
int len = instances_menu->get_item_count();
for (int idx = 0; idx < len; idx++) {

42
editor/plugins/node_3d_editor_plugin.cpp
View File

@ -718,9 +718,11 @@ void Node3DEditorViewport::_select_region() {
item = sel;
}
if (selected.find(item) != -1) continue;
if (selected.find(item) != -1)
continue;
if (_is_node_locked(item)) continue;
if (_is_node_locked(item))
continue;
Ref<EditorNode3DGizmo> seg = sp->get_gizmo();
@ -1381,7 +1383,8 @@ void Node3DEditorViewport::_sinput(const Ref<InputEvent> &p_event) {
if (cursor.region_select) {
if (!clicked_wants_append) _clear_selected();
if (!clicked_wants_append)
_clear_selected();
_select_region();
cursor.region_select = false;
@ -2076,7 +2079,8 @@ void Node3DEditorViewport::_sinput(const Ref<InputEvent> &p_event) {
}
if (k->get_keycode() == KEY_SPACE) {
if (!k->is_pressed()) emit_signal("toggle_maximize_view", this);
if (!k->is_pressed())
emit_signal("toggle_maximize_view", this);
}
}
@ -4633,7 +4637,8 @@ Dictionary Node3DEditor::get_state() const {
Dictionary gizmos_status;
for (int i = 0; i < gizmo_plugins_by_name.size(); i++) {
if (!gizmo_plugins_by_name[i]->can_be_hidden()) continue;
if (!gizmo_plugins_by_name[i]->can_be_hidden())
continue;
int state = gizmos_menu->get_item_state(gizmos_menu->get_item_index(i));
String name = gizmo_plugins_by_name[i]->get_name();
gizmos_status[name] = state;
@ -4727,7 +4732,8 @@ void Node3DEditor::set_state(const Dictionary &p_state) {
gizmos_status.get_key_list(&keys);
for (int j = 0; j < gizmo_plugins_by_name.size(); ++j) {
if (!gizmo_plugins_by_name[j]->can_be_hidden()) continue;
if (!gizmo_plugins_by_name[j]->can_be_hidden())
continue;
int state = EditorNode3DGizmoPlugin::VISIBLE;
for (int i = 0; i < keys.size(); i++) {
if (gizmo_plugins_by_name.write[j]->get_name() == keys[i]) {
@ -5492,7 +5498,8 @@ void Node3DEditor::_update_gizmos_menu() {
gizmos_menu->clear();
for (int i = 0; i < gizmo_plugins_by_name.size(); ++i) {
if (!gizmo_plugins_by_name[i]->can_be_hidden()) continue;
if (!gizmo_plugins_by_name[i]->can_be_hidden())
continue;
String plugin_name = gizmo_plugins_by_name[i]->get_name();
const int plugin_state = gizmo_plugins_by_name[i]->get_state();
gizmos_menu->add_multistate_item(TTR(plugin_name), 3, plugin_state, i);
@ -5513,7 +5520,8 @@ void Node3DEditor::_update_gizmos_menu() {
void Node3DEditor::_update_gizmos_menu_theme() {
for (int i = 0; i < gizmo_plugins_by_name.size(); ++i) {
if (!gizmo_plugins_by_name[i]->can_be_hidden()) continue;
if (!gizmo_plugins_by_name[i]->can_be_hidden())
continue;
const int plugin_state = gizmo_plugins_by_name[i]->get_state();
const int idx = gizmos_menu->get_item_index(i);
switch (plugin_state) {
@ -5924,9 +5932,11 @@ void Node3DEditor::_request_gizmo(Object *p_obj) {
}
void Node3DEditor::_toggle_maximize_view(Object *p_viewport) {
if (!p_viewport) return;
if (!p_viewport)
return;
Node3DEditorViewport *current_viewport = Object::cast_to<Node3DEditorViewport>(p_viewport);
if (!current_viewport) return;
if (!current_viewport)
return;
int index = -1;
bool maximized = false;
@ -5938,7 +5948,8 @@ void Node3DEditor::_toggle_maximize_view(Object *p_viewport) {
break;
}
}
if (index == -1) return;
if (index == -1)
return;
if (!maximized) {
@ -6655,7 +6666,8 @@ Ref<StandardMaterial3D> EditorNode3DGizmoPlugin::get_material(const String &p_na
ERR_FAIL_COND_V(!materials.has(p_name), Ref<StandardMaterial3D>());
ERR_FAIL_COND_V(materials[p_name].size() == 0, Ref<StandardMaterial3D>());
if (p_gizmo.is_null() || materials[p_name].size() == 1) return materials[p_name][0];
if (p_gizmo.is_null() || materials[p_name].size() == 1)
return materials[p_name][0];
int index = (p_gizmo->is_selected() ? 1 : 0) + (p_gizmo->is_editable() ? 2 : 0);
@ -6692,7 +6704,8 @@ Ref<EditorNode3DGizmo> EditorNode3DGizmoPlugin::get_gizmo(Node3D *p_spatial) {
Ref<EditorNode3DGizmo> ref = create_gizmo(p_spatial);
if (ref.is_null()) return ref;
if (ref.is_null())
return ref;
ref->set_plugin(this);
ref->set_spatial_node(p_spatial);
@ -6751,7 +6764,8 @@ Ref<EditorNode3DGizmo> EditorNode3DGizmoPlugin::create_gizmo(Node3D *p_spatial)
}
Ref<EditorNode3DGizmo> ref;
if (has_gizmo(p_spatial)) ref.instance();
if (has_gizmo(p_spatial))
ref.instance();
return ref;
}

6
editor/plugins/path_2d_editor_plugin.cpp
View File

@ -288,8 +288,10 @@ bool Path2DEditor::forward_gui_input(const Ref<InputEvent> &p_event) {
Vector2 gpoint = mm->get_position();
Ref<Curve2D> curve = node->get_curve();
if (curve == nullptr) return true;
if (curve->get_point_count() < 2) return true;
if (curve == nullptr)
return true;
if (curve->get_point_count() < 2)
return true;
// Find edge
edge_point = xform.xform(curve->get_closest_point(xform.affine_inverse().xform(mm->get_position())));

3
editor/plugins/path_3d_editor_plugin.cpp
View File

@ -631,7 +631,8 @@ Ref<EditorNode3DGizmo> Path3DGizmoPlugin::create_gizmo(Node3D *p_spatial) {
Ref<Path3DGizmo> ref;
Path3D *path = Object::cast_to<Path3D>(p_spatial);
if (path) ref = Ref<Path3DGizmo>(memnew(Path3DGizmo(path)));
if (path)
ref = Ref<Path3DGizmo>(memnew(Path3DGizmo(path)));
return ref;
}

3
editor/plugins/script_text_editor.cpp
View File

@ -822,7 +822,8 @@ void ScriptTextEditor::_code_complete_scripts(void *p_ud, const String &p_code,
void ScriptTextEditor::_code_complete_script(const String &p_code, List<ScriptCodeCompletionOption> *r_options, bool &r_force) {
if (color_panel->is_visible()) return;
if (color_panel->is_visible())
return;
Node *base = get_tree()->get_edited_scene_root();
if (base) {
base = _find_node_for_script(base, base, script);

3
editor/plugins/tile_set_editor_plugin.cpp
View File

@ -126,7 +126,8 @@ void TileSetEditor::_import_node(Node *p_node, Ref<TileSet> p_library) {
sb->get_shape_owners(&shapes);
for (List<uint32_t>::Element *E = shapes.front(); E; E = E->next()) {
if (sb->is_shape_owner_disabled(E->get())) continue;
if (sb->is_shape_owner_disabled(E->get()))
continue;
Transform2D shape_transform = sb->get_transform() * sb->shape_owner_get_transform(E->get());
bool one_way = sb->is_shape_owner_one_way_collision_enabled(E->get());

6
editor/plugins/visual_shader_editor_plugin.cpp
View File

@ -1239,11 +1239,13 @@ void VisualShaderEditor::_port_name_focus_out(Object *line_edit, int p_node_id,
List<String> output_names;
for (int i = 0; i < node->get_input_port_count(); i++) {
if (!p_output && i == p_port_id) continue;
if (!p_output && i == p_port_id)
continue;
input_names.push_back(node->get_input_port_name(i));
}
for (int i = 0; i < node->get_output_port_count(); i++) {
if (p_output && i == p_port_id) continue;
if (p_output && i == p_port_id)
continue;
output_names.push_back(node->get_output_port_name(i));
}

9
editor/project_settings_editor.cpp
View File

@ -446,11 +446,13 @@ void ProjectSettingsEditor::_show_last_added(const Ref<InputEvent> &p_event, con
}
child = child->get_next();
}
if (found) break;
if (found)
break;
r = r->get_next();
}
if (found) input_editor->ensure_cursor_is_visible();
if (found)
input_editor->ensure_cursor_is_visible();
}
void ProjectSettingsEditor::_wait_for_key(const Ref<InputEvent> &p_event) {
@ -1596,7 +1598,8 @@ void ProjectSettingsEditor::_update_translations() {
String n = names[i];
String l = langs[i];
bool is_checked = l_filter.has(l);
if (filter_mode == SHOW_ONLY_SELECTED_LOCALES && !is_checked) continue;
if (filter_mode == SHOW_ONLY_SELECTED_LOCALES && !is_checked)
continue;
TreeItem *t = translation_filter->create_item(root);
t->set_cell_mode(0, TreeItem::CELL_MODE_CHECK);

12
editor/scene_tree_dock.cpp
View File

@ -491,8 +491,10 @@ void SceneTreeDock::_tool_selected(int p_tool, bool p_confirm_override) {
for (List<Node *>::Element *E = selection.front(); E; E = E->next()) {
int index = E->get()->get_index();
if (index > highest_id) highest_id = index;
if (index < lowest_id) lowest_id = index;
if (index > highest_id)
highest_id = index;
if (index < lowest_id)
lowest_id = index;
if (E->get()->get_parent() != common_parent)
common_parent = nullptr;
@ -501,8 +503,10 @@ void SceneTreeDock::_tool_selected(int p_tool, bool p_confirm_override) {
if (!common_parent || (MOVING_DOWN && highest_id >= common_parent->get_child_count() - MOVING_DOWN) || (MOVING_UP && lowest_id == 0))
break; // one or more nodes can not be moved
if (selection.size() == 1) editor_data->get_undo_redo().create_action(TTR("Move Node In Parent"));
if (selection.size() > 1) editor_data->get_undo_redo().create_action(TTR("Move Nodes In Parent"));
if (selection.size() == 1)
editor_data->get_undo_redo().create_action(TTR("Move Node In Parent"));
if (selection.size() > 1)
editor_data->get_undo_redo().create_action(TTR("Move Nodes In Parent"));
for (int i = 0; i < selection.size(); i++) {
Node *top_node = selection[i];

18
editor/script_create_dialog.cpp
View File

@ -167,11 +167,14 @@ String ScriptCreateDialog::_validate_path(const String &p_path, bool p_file_must
String p = p_path.strip_edges();
if (p == "") return TTR("Path is empty.");
if (p.get_file().get_basename() == "") return TTR("Filename is empty.");
if (p == "")
return TTR("Path is empty.");
if (p.get_file().get_basename() == "")
return TTR("Filename is empty.");
p = ProjectSettings::get_singleton()->localize_path(p);
if (!p.begins_with("res://")) return TTR("Path is not local.");
if (!p.begins_with("res://"))
return TTR("Path is not local.");
DirAccess *d = DirAccess::create(DirAccess::ACCESS_RESOURCES);
if (d->change_dir(p.get_base_dir()) != OK) {
@ -216,12 +219,15 @@ String ScriptCreateDialog::_validate_path(const String &p_path, bool p_file_must
index++;
}
if (!found) return TTR("Invalid extension.");
if (!match) return TTR("Wrong extension chosen.");
if (!found)
return TTR("Invalid extension.");
if (!match)
return TTR("Wrong extension chosen.");
/* Let ScriptLanguage do custom validation */
String path_error = ScriptServer::get_language(language_menu->get_selected())->validate_path(p);
if (path_error != "") return path_error;
if (path_error != "")
return path_error;
/* All checks passed */
return "";

3
main/main.cpp
View File

@ -2260,7 +2260,8 @@ bool Main::iteration() {
uint64_t time_step = 1000000L / target_fps;
target_ticks += time_step;
uint64_t current_ticks = OS::get_singleton()->get_ticks_usec();
if (current_ticks < target_ticks) OS::get_singleton()->delay_usec(target_ticks - current_ticks);
if (current_ticks < target_ticks)
OS::get_singleton()->delay_usec(target_ticks - current_ticks);
current_ticks = OS::get_singleton()->get_ticks_usec();
target_ticks = MIN(MAX(target_ticks, current_ticks - time_step), current_ticks + time_step);
}

24
main/tests/test_astar.cpp
View File

@ -173,7 +173,8 @@ bool test_add_remove() {
for (int i = 0; i < 20000; i++) {
int u = Math::rand() % 5;
int v = Math::rand() % 4;
if (u == v) v = 4;
if (u == v)
v = 4;
if (Math::rand() % 2 == 1) {
// Add a (possibly existing) directed edge and confirm connectivity
a.connect_points(u, v, false);
@ -195,7 +196,8 @@ bool test_add_remove() {
for (int j = 0; j < 10; j++) {
int u = Math::rand() % 5;
int v = Math::rand() % 4;
if (u == v) v = 4;
if (u == v)
v = 4;
if (Math::rand() % 2 == 1)
a.connect_points(u, v, false);
else
@ -239,7 +241,8 @@ bool test_solutions() {
int u, v;
u = Math::rand() % N;
v = Math::rand() % (N - 1);
if (u == v) v = N - 1;
if (u == v)
v = N - 1;
// Pick a random operation
int op = Math::rand();
@ -253,14 +256,16 @@ bool test_solutions() {
// Add edge (u, v); possibly bidirectional
a.connect_points(u, v, op % 2);
adj[u][v] = true;
if (op % 2) adj[v][u] = true;
if (op % 2)
adj[v][u] = true;
break;
case 6:
case 7:
// Remove edge (u, v); possibly bidirectional
a.disconnect_points(u, v, op % 2);
adj[u][v] = false;
if (op % 2) adj[v][u] = false;
if (op % 2)
adj[v][u] = false;
break;
case 8:
// Remove point u and add it back; clears adjacent edges and changes coordinates
@ -291,12 +296,14 @@ bool test_solutions() {
int count = 0;
for (int u = 0; u < N; u++)
for (int v = 0; v < N; v++)
if (adj[u][v]) count++;
if (adj[u][v])
count++;
printf("Test #%4d: %3d edges, ", test + 1, count);
count = 0;
for (int u = 0; u < N; u++)
for (int v = 0; v < N; v++)
if (!Math::is_inf(d[u][v])) count++;
if (!Math::is_inf(d[u][v]))
count++;
printf("%3d/%d pairs of reachable points\n", count - N, N * (N - 1));
// Check A*'s output
@ -339,7 +346,8 @@ bool test_solutions() {
}
exit:
if (!match) return false;
if (!match)
return false;
}
return true;
}

12
main/tests/test_string.cpp
View File

@ -972,22 +972,26 @@ bool test_31() {
String a = "";
success = a[0] == 0;
OS::get_singleton()->print("Is 0 String[0]:, %s\n", success ? "OK" : "FAIL");
if (!success) state = false;
if (!success)
state = false;
String b = "Godot";
success = b[b.size()] == 0;
OS::get_singleton()->print("Is 0 String[size()]:, %s\n", success ? "OK" : "FAIL");
if (!success) state = false;
if (!success)
state = false;
const String c = "";
success = c[0] == 0;
OS::get_singleton()->print("Is 0 const String[0]:, %s\n", success ? "OK" : "FAIL");
if (!success) state = false;
if (!success)
state = false;
const String d = "Godot";
success = d[d.size()] == 0;
OS::get_singleton()->print("Is 0 const String[size()]:, %s\n", success ? "OK" : "FAIL");
if (!success) state = false;
if (!success)
state = false;
return state;
};

3
modules/bullet/shape_bullet.cpp
View File

@ -81,7 +81,8 @@ void ShapeBullet::add_owner(ShapeOwnerBullet *p_owner) {
void ShapeBullet::remove_owner(ShapeOwnerBullet *p_owner, bool p_permanentlyFromThisBody) {
Map<ShapeOwnerBullet *, int>::Element *E = owners.find(p_owner);
if (!E) return;
if (!E)
return;
E->get()--;
if (p_permanentlyFromThisBody || 0 >= E->get()) {
owners.erase(E);

3
modules/bullet/space_bullet.h
View File

@ -170,7 +170,8 @@ public:
contactDebugCount = 0;
}
_FORCE_INLINE_ void add_debug_contact(const Vector3 &p_contact) {
if (contactDebugCount < contactDebug.size()) contactDebug.write[contactDebugCount++] = p_contact;
if (contactDebugCount < contactDebug.size())
contactDebug.write[contactDebugCount++] = p_contact;
}
_FORCE_INLINE_ Vector<Vector3> get_debug_contacts() { return contactDebug; }
_FORCE_INLINE_ int get_debug_contact_count() { return contactDebugCount; }

45
modules/csg/csg.cpp
View File

@ -138,10 +138,12 @@ inline bool is_point_in_triangle(const Vector3 &p_point, const Vector3 p_vertice
lambda[2] = p_vertices[0].cross(p_vertices[1]).dot(p_point) / det;
// Point is in the plane if all lambdas sum to 1.
if (!Math::is_equal_approx(lambda[0] + lambda[1] + lambda[2], 1)) return false;
if (!Math::is_equal_approx(lambda[0] + lambda[1] + lambda[2], 1))
return false;
// Point is inside the triangle if all lambdas are positive.
if (lambda[0] < 0 || lambda[1] < 0 || lambda[2] < 0) return false;
if (lambda[0] < 0 || lambda[1] < 0 || lambda[2] < 0)
return false;
return true;
}
@ -524,7 +526,8 @@ void CSGBrushOperation::MeshMerge::_add_distance(List<real_t> &r_intersectionsA,
// Check if distance exists.
for (const List<real_t>::Element *E = intersections.front(); E; E = E->next())
if (Math::abs(**E - p_distance) < vertex_snap) return;
if (Math::abs(**E - p_distance) < vertex_snap)
return;
intersections.push_back(p_distance);
}
@ -790,7 +793,8 @@ int CSGBrushOperation::Build2DFaces::_add_vertex(const Vertex2D &p_vertex) {
// Check if vertex exists.
int vertex_id = _get_point_idx(p_vertex.point);
if (vertex_id != -1) return vertex_id;
if (vertex_id != -1)
return vertex_id;
vertices.push_back(p_vertex);
return vertices.size() - 1;
@ -816,7 +820,8 @@ void CSGBrushOperation::Build2DFaces::_add_vertex_idx_sorted(Vector<int> &r_vert
// Sort along the axis with the greatest difference.
int axis = 0;
if (Math::abs(new_point.x - first_point.x) < Math::abs(new_point.y - first_point.y)) axis = 1;
if (Math::abs(new_point.x - first_point.x) < Math::abs(new_point.y - first_point.y))
axis = 1;
// Add it to the beginning or the end appropriately.
if (new_point[axis] < first_point[axis])
@ -834,7 +839,8 @@ void CSGBrushOperation::Build2DFaces::_add_vertex_idx_sorted(Vector<int> &r_vert
// Determine axis being sorted against i.e. the axis with the greatest difference.
int axis = 0;
if (Math::abs(last_point.x - first_point.x) < Math::abs(last_point.y - first_point.y)) axis = 1;
if (Math::abs(last_point.x - first_point.x) < Math::abs(last_point.y - first_point.y))
axis = 1;
// Insert the point at the appropriate index.
for (int insert_idx = 0; insert_idx < r_vertex_indices.size(); ++insert_idx) {
@ -853,7 +859,8 @@ void CSGBrushOperation::Build2DFaces::_add_vertex_idx_sorted(Vector<int> &r_vert
void CSGBrushOperation::Build2DFaces::_merge_faces(const Vector<int> &p_segment_indices) {
int segments = p_segment_indices.size() - 1;
if (segments < 2) return;
if (segments < 2)
return;
// Faces around an inner vertex are merged by moving the inner vertex to the first vertex.
for (int sorted_idx = 1; sorted_idx < segments; ++sorted_idx) {
@ -893,7 +900,8 @@ void CSGBrushOperation::Build2DFaces::_merge_faces(const Vector<int> &p_segment_
// Skip flattened faces.
if (outer_edge_idx[0] == p_segment_indices[closest_idx] ||
outer_edge_idx[1] == p_segment_indices[closest_idx]) continue;
outer_edge_idx[1] == p_segment_indices[closest_idx])
continue;
//Don't create degenerate triangles.
Vector2 edge1[2] = {
@ -924,7 +932,8 @@ void CSGBrushOperation::Build2DFaces::_merge_faces(const Vector<int> &p_segment_
for (int i = 0; i < merge_faces_idx.size(); ++i)
faces.remove(merge_faces_idx[i]);
if (degenerate_points.size() == 0) continue;
if (degenerate_points.size() == 0)
continue;
// Split faces using degenerate points.
for (int face_idx = 0; face_idx < faces.size(); ++face_idx) {
@ -954,7 +963,8 @@ void CSGBrushOperation::Build2DFaces::_merge_faces(const Vector<int> &p_segment_
break;
}
}
if (existing) continue;
if (existing)
continue;
// Check if point is on an each edge.
for (int face_edge_idx = 0; face_edge_idx < 3; ++face_edge_idx) {
@ -1043,10 +1053,12 @@ void CSGBrushOperation::Build2DFaces::_find_edge_intersections(const Vector2 p_s
// Check if intersection point is an edge point.
if ((intersection_point - edge_points[0]).length_squared() < vertex_snap2 ||
(intersection_point - edge_points[1]).length_squared() < vertex_snap2) continue;
(intersection_point - edge_points[1]).length_squared() < vertex_snap2)
continue;
// Check if edge exists, by checking if the intersecting segment is parallel to the edge.
if (are_segements_parallel(p_segment_points, edge_points, vertex_snap2)) continue;
if (are_segements_parallel(p_segment_points, edge_points, vertex_snap2))
continue;
// Add the intersection point as a new vertex.
Vertex2D new_vertex;
@ -1384,7 +1396,8 @@ void CSGBrushOperation::update_faces(const CSGBrush &p_brush_a, const int p_face
p_collection.build2DFacesB[p_face_idx_b] = Build2DFaces();
has_degenerate = true;
}
if (has_degenerate) return;
if (has_degenerate)
return;
// Ensure B has points either side of or in the plane of A.
int in_plane_count = 0, over_count = 0, under_count = 0;
@ -1400,7 +1413,8 @@ void CSGBrushOperation::update_faces(const CSGBrush &p_brush_a, const int p_face
under_count++;
}
// If all points under or over the plane, there is no intesection.
if (over_count == 3 || under_count == 3) return;
if (over_count == 3 || under_count == 3)
return;
// Ensure A has points either side of or in the plane of B.
in_plane_count = 0;
@ -1418,7 +1432,8 @@ void CSGBrushOperation::update_faces(const CSGBrush &p_brush_a, const int p_face
under_count++;
}
// If all points under or over the plane, there is no intesection.
if (over_count == 3 || under_count == 3) return;
if (over_count == 3 || under_count == 3)
return;
// Check for intersection using the SAT theorem.
{

12
modules/csg/csg_shape.cpp
View File

@ -1783,11 +1783,15 @@ CSGBrush *CSGPolygon3D::_build_brush() {
final_polygon_min = p;
final_polygon_max = final_polygon_min;
} else {
if (p.x < final_polygon_min.x) final_polygon_min.x = p.x;
if (p.y < final_polygon_min.y) final_polygon_min.y = p.y;
if (p.x < final_polygon_min.x)
final_polygon_min.x = p.x;
if (p.y < final_polygon_min.y)
final_polygon_min.y = p.y;
if (p.x > final_polygon_max.x) final_polygon_max.x = p.x;
if (p.y > final_polygon_max.y) final_polygon_max.y = p.y;
if (p.x > final_polygon_max.x)
final_polygon_max.x = p.x;
if (p.y > final_polygon_max.y)
final_polygon_max.y = p.y;
}
}
Vector2 final_polygon_size = final_polygon_max - final_polygon_min;

3
modules/gdnative/gdnative/gdnative.cpp
View File

@ -177,7 +177,8 @@ void *godot_get_class_tag(const godot_string_name *p_class) {
}
godot_object *godot_object_cast_to(const godot_object *p_object, void *p_class_tag) {
if (!p_object) return nullptr;
if (!p_object)
return nullptr;
Object *o = (Object *)p_object;
return o->is_class_ptr(p_class_tag) ? (godot_object *)o : nullptr;

12
modules/gdscript/gdscript.cpp
View File

@ -658,12 +658,14 @@ uint16_t GDScript::get_rpc_method_id(const StringName &p_method) const {
}
StringName GDScript::get_rpc_method(const uint16_t p_rpc_method_id) const {
if (p_rpc_method_id >= rpc_functions.size()) return StringName();
if (p_rpc_method_id >= rpc_functions.size())
return StringName();
return rpc_functions[p_rpc_method_id].name;
}
MultiplayerAPI::RPCMode GDScript::get_rpc_mode_by_id(const uint16_t p_rpc_method_id) const {
if (p_rpc_method_id >= rpc_functions.size()) return MultiplayerAPI::RPC_MODE_DISABLED;
if (p_rpc_method_id >= rpc_functions.size())
return MultiplayerAPI::RPC_MODE_DISABLED;
return rpc_functions[p_rpc_method_id].mode;
}
@ -685,12 +687,14 @@ uint16_t GDScript::get_rset_property_id(const StringName &p_variable) const {
}
StringName GDScript::get_rset_property(const uint16_t p_rset_member_id) const {
if (p_rset_member_id >= rpc_variables.size()) return StringName();
if (p_rset_member_id >= rpc_variables.size())
return StringName();
return rpc_variables[p_rset_member_id].name;
}
MultiplayerAPI::RPCMode GDScript::get_rset_mode_by_id(const uint16_t p_rset_member_id) const {
if (p_rset_member_id >= rpc_variables.size()) return MultiplayerAPI::RPC_MODE_DISABLED;
if (p_rset_member_id >= rpc_variables.size())
return MultiplayerAPI::RPC_MODE_DISABLED;
return rpc_variables[p_rset_member_id].mode;
}

63
modules/gdscript/gdscript_compiler.cpp
View File

@ -861,71 +861,92 @@ int GDScriptCompiler::_parse_expression(CodeGen &codegen, const GDScriptParser::
} break;
//unary operators
case GDScriptParser::OperatorNode::OP_NEG: {
if (!_create_unary_operator(codegen, on, Variant::OP_NEGATE, p_stack_level)) return -1;
if (!_create_unary_operator(codegen, on, Variant::OP_NEGATE, p_stack_level))
return -1;
} break;
case GDScriptParser::OperatorNode::OP_POS: {
if (!_create_unary_operator(codegen, on, Variant::OP_POSITIVE, p_stack_level)) return -1;
if (!_create_unary_operator(codegen, on, Variant::OP_POSITIVE, p_stack_level))
return -1;
} break;
case GDScriptParser::OperatorNode::OP_NOT: {
if (!_create_unary_operator(codegen, on, Variant::OP_NOT, p_stack_level)) return -1;
if (!_create_unary_operator(codegen, on, Variant::OP_NOT, p_stack_level))
return -1;
} break;
case GDScriptParser::OperatorNode::OP_BIT_INVERT: {
if (!_create_unary_operator(codegen, on, Variant::OP_BIT_NEGATE, p_stack_level)) return -1;
if (!_create_unary_operator(codegen, on, Variant::OP_BIT_NEGATE, p_stack_level))
return -1;
} break;
//binary operators (in precedence order)
case GDScriptParser::OperatorNode::OP_IN: {
if (!_create_binary_operator(codegen, on, Variant::OP_IN, p_stack_level)) return -1;
if (!_create_binary_operator(codegen, on, Variant::OP_IN, p_stack_level))
return -1;
} break;
case GDScriptParser::OperatorNode::OP_EQUAL: {
if (!_create_binary_operator(codegen, on, Variant::OP_EQUAL, p_stack_level)) return -1;
if (!_create_binary_operator(codegen, on, Variant::OP_EQUAL, p_stack_level))
return -1;
} break;
case GDScriptParser::OperatorNode::OP_NOT_EQUAL: {
if (!_create_binary_operator(codegen, on, Variant::OP_NOT_EQUAL, p_stack_level)) return -1;
if (!_create_binary_operator(codegen, on, Variant::OP_NOT_EQUAL, p_stack_level))
return -1;
} break;
case GDScriptParser::OperatorNode::OP_LESS: {
if (!_create_binary_operator(codegen, on, Variant::OP_LESS, p_stack_level)) return -1;
if (!_create_binary_operator(codegen, on, Variant::OP_LESS, p_stack_level))
return -1;
} break;
case GDScriptParser::OperatorNode::OP_LESS_EQUAL: {
if (!_create_binary_operator(codegen, on, Variant::OP_LESS_EQUAL, p_stack_level)) return -1;
if (!_create_binary_operator(codegen, on, Variant::OP_LESS_EQUAL, p_stack_level))
return -1;
} break;
case GDScriptParser::OperatorNode::OP_GREATER: {
if (!_create_binary_operator(codegen, on, Variant::OP_GREATER, p_stack_level)) return -1;
if (!_create_binary_operator(codegen, on, Variant::OP_GREATER, p_stack_level))
return -1;
} break;
case GDScriptParser::OperatorNode::OP_GREATER_EQUAL: {
if (!_create_binary_operator(codegen, on, Variant::OP_GREATER_EQUAL, p_stack_level)) return -1;
if (!_create_binary_operator(codegen, on, Variant::OP_GREATER_EQUAL, p_stack_level))
return -1;
} break;
case GDScriptParser::OperatorNode::OP_ADD: {
if (!_create_binary_operator(codegen, on, Variant::OP_ADD, p_stack_level)) return -1;
if (!_create_binary_operator(codegen, on, Variant::OP_ADD, p_stack_level))
return -1;
} break;
case GDScriptParser::OperatorNode::OP_SUB: {
if (!_create_binary_operator(codegen, on, Variant::OP_SUBTRACT, p_stack_level)) return -1;
if (!_create_binary_operator(codegen, on, Variant::OP_SUBTRACT, p_stack_level))
return -1;
} break;
case GDScriptParser::OperatorNode::OP_MUL: {
if (!_create_binary_operator(codegen, on, Variant::OP_MULTIPLY, p_stack_level)) return -1;
if (!_create_binary_operator(codegen, on, Variant::OP_MULTIPLY, p_stack_level))
return -1;
} break;
case GDScriptParser::OperatorNode::OP_DIV: {
if (!_create_binary_operator(codegen, on, Variant::OP_DIVIDE, p_stack_level)) return -1;
if (!_create_binary_operator(codegen, on, Variant::OP_DIVIDE, p_stack_level))
return -1;
} break;
case GDScriptParser::OperatorNode::OP_MOD: {
if (!_create_binary_operator(codegen, on, Variant::OP_MODULE, p_stack_level)) return -1;
if (!_create_binary_operator(codegen, on, Variant::OP_MODULE, p_stack_level))
return -1;
} break;
//case GDScriptParser::OperatorNode::OP_SHIFT_LEFT: { if (!_create_binary_operator(codegen,on,Variant::OP_SHIFT_LEFT,p_stack_level)) return -1;} break;
//case GDScriptParser::OperatorNode::OP_SHIFT_RIGHT: { if (!_create_binary_operator(codegen,on,Variant::OP_SHIFT_RIGHT,p_stack_level)) return -1;} break;
case GDScriptParser::OperatorNode::OP_BIT_AND: {
if (!_create_binary_operator(codegen, on, Variant::OP_BIT_AND, p_stack_level)) return -1;
if (!_create_binary_operator(codegen, on, Variant::OP_BIT_AND, p_stack_level))
return -1;
} break;
case GDScriptParser::OperatorNode::OP_BIT_OR: {
if (!_create_binary_operator(codegen, on, Variant::OP_BIT_OR, p_stack_level)) return -1;
if (!_create_binary_operator(codegen, on, Variant::OP_BIT_OR, p_stack_level))
return -1;
} break;
case GDScriptParser::OperatorNode::OP_BIT_XOR: {
if (!_create_binary_operator(codegen, on, Variant::OP_BIT_XOR, p_stack_level)) return -1;
if (!_create_binary_operator(codegen, on, Variant::OP_BIT_XOR, p_stack_level))
return -1;
} break;
//shift
case GDScriptParser::OperatorNode::OP_SHIFT_LEFT: {
if (!_create_binary_operator(codegen, on, Variant::OP_SHIFT_LEFT, p_stack_level)) return -1;
if (!_create_binary_operator(codegen, on, Variant::OP_SHIFT_LEFT, p_stack_level))
return -1;
} break;
case GDScriptParser::OperatorNode::OP_SHIFT_RIGHT: {
if (!_create_binary_operator(codegen, on, Variant::OP_SHIFT_RIGHT, p_stack_level)) return -1;
if (!_create_binary_operator(codegen, on, Variant::OP_SHIFT_RIGHT, p_stack_level))
return -1;
} break;
//assignment operators
case GDScriptParser::OperatorNode::OP_ASSIGN_ADD:

6
modules/gdscript/gdscript_compiler.h
View File

@ -123,10 +123,12 @@ class GDScriptCompiler {
Vector<int> opcodes;
void alloc_stack(int p_level) {
if (p_level >= stack_max) stack_max = p_level + 1;
if (p_level >= stack_max)
stack_max = p_level + 1;
}
void alloc_call(int p_params) {
if (p_params >= call_max) call_max = p_params;
if (p_params >= call_max)
call_max = p_params;
}
int current_line;

3
modules/gdscript/gdscript_function.h
View File

@ -56,7 +56,8 @@ struct GDScriptDataType {
Ref<Script> script_type;
bool is_type(const Variant &p_variant, bool p_allow_implicit_conversion = false) const {
if (!has_type) return true; // Can't type check
if (!has_type)
return true; // Can't type check
switch (kind) {
case UNINITIALIZED:

81
modules/gdscript/gdscript_parser.cpp
View File

@ -2047,7 +2047,8 @@ bool GDScriptParser::_reduce_export_var_type(Variant &p_value, int p_line) {
if (p_value.get_type() == Variant::ARRAY) {
Array arr = p_value;
for (int i = 0; i < arr.size(); i++) {
if (!_reduce_export_var_type(arr[i], p_line)) return false;
if (!_reduce_export_var_type(arr[i], p_line))
return false;
}
return true;
}
@ -2056,7 +2057,8 @@ bool GDScriptParser::_reduce_export_var_type(Variant &p_value, int p_line) {
Dictionary dict = p_value;
for (int i = 0; i < dict.size(); i++) {
Variant value = dict.get_value_at_index(i);
if (!_reduce_export_var_type(value, p_line)) return false;
if (!_reduce_export_var_type(value, p_line))
return false;
}
return true;
}
@ -3337,7 +3339,8 @@ void GDScriptParser::_parse_block(BlockNode *p_block, bool p_static) {
_parse_pattern_block(compiled_branches, match_node->branches, p_static);
if (error_set) return;
if (error_set)
return;
ControlFlowNode *match_cf_node = alloc_node<ControlFlowNode>();
match_cf_node->cf_type = ControlFlowNode::CF_MATCH;
@ -4934,7 +4937,8 @@ void GDScriptParser::_parse_class(ClassNode *p_class) {
return;
}
if (!_reduce_export_var_type(cn->value, member.line)) return;
if (!_reduce_export_var_type(cn->value, member.line))
return;
member._export.type = cn->value.get_type();
member._export.usage |= PROPERTY_USAGE_SCRIPT_VARIABLE;
@ -5451,8 +5455,10 @@ void GDScriptParser::_determine_inheritance(ClassNode *p_class, bool p_recursive
}
}
if (base_class) break;
if (found) continue;
if (base_class)
break;
if (found)
continue;
if (p->constant_expressions.has(base)) {
if (p->constant_expressions[base].expression->type != Node::TYPE_CONSTANT) {
@ -5554,10 +5560,12 @@ void GDScriptParser::_determine_inheritance(ClassNode *p_class, bool p_recursive
}
String GDScriptParser::DataType::to_string() const {
if (!has_type) return "var";
if (!has_type)
return "var";
switch (kind) {
case BUILTIN: {
if (builtin_type == Variant::NIL) return "null";
if (builtin_type == Variant::NIL)
return "null";
return Variant::get_type_name(builtin_type);
} break;
case NATIVE: {
@ -5721,8 +5729,10 @@ bool GDScriptParser::_parse_type(DataType &r_type, bool p_can_be_void) {
}
GDScriptParser::DataType GDScriptParser::_resolve_type(const DataType &p_source, int p_line) {
if (!p_source.has_type) return p_source;
if (p_source.kind != DataType::UNRESOLVED) return p_source;
if (!p_source.has_type)
return p_source;
if (p_source.kind != DataType::UNRESOLVED)
return p_source;
Vector<String> full_name = p_source.native_type.operator String().split(".", false);
int name_part = 0;
@ -6962,7 +6972,8 @@ bool GDScriptParser::_get_function_signature(DataType &p_base_type, const String
native = "_" + native.operator String();
}
if (!ClassDB::class_exists(native)) {
if (!check_types) return false;
if (!check_types)
return false;
ERR_FAIL_V_MSG(false, "Parser bug: Class '" + String(native) + "' not found.");
}
@ -7053,7 +7064,8 @@ GDScriptParser::DataType GDScriptParser::_reduce_function_call_type(const Operat
par_types.write[i - 1] = _reduce_node_type(p_call->arguments[i]);
}
if (error_set) return DataType();
if (error_set)
return DataType();
// Special case: check copy constructor. Those are defined implicitly in Variant.
if (par_types.size() == 1) {
@ -7121,7 +7133,8 @@ GDScriptParser::DataType GDScriptParser::_reduce_function_call_type(const Operat
err += "' matches the signature '";
err += Variant::get_type_name(tn->vtype) + "(";
for (int i = 0; i < par_types.size(); i++) {
if (i > 0) err += ", ";
if (i > 0)
err += ", ";
err += par_types[i].to_string();
}
err += ")'.";
@ -7479,7 +7492,8 @@ bool GDScriptParser::_get_member_type(const DataType &p_base_type, const StringN
native = "_" + native.operator String();
}
if (!ClassDB::class_exists(native)) {
if (!check_types) return false;
if (!check_types)
return false;
ERR_FAIL_V_MSG(false, "Parser bug: Class \"" + String(native) + "\" not found.");
}
@ -7776,12 +7790,14 @@ void GDScriptParser::_check_class_level_types(ClassNode *p_class) {
// Function declarations
for (int i = 0; i < p_class->static_functions.size(); i++) {
_check_function_types(p_class->static_functions[i]);
if (error_set) return;
if (error_set)
return;
}
for (int i = 0; i < p_class->functions.size(); i++) {
_check_function_types(p_class->functions[i]);
if (error_set) return;
if (error_set)
return;
}
// Class variables
@ -7856,7 +7872,8 @@ void GDScriptParser::_check_class_level_types(ClassNode *p_class) {
}
// Setter and getter
if (v.setter == StringName() && v.getter == StringName()) continue;
if (v.setter == StringName() && v.getter == StringName())
continue;
bool found_getter = false;
bool found_setter = false;
@ -7899,10 +7916,12 @@ void GDScriptParser::_check_class_level_types(ClassNode *p_class) {
return;
}
}
if (found_getter && found_setter) break;
if (found_getter && found_setter)
break;
}
if ((found_getter || v.getter == StringName()) && (found_setter || v.setter == StringName())) continue;
if ((found_getter || v.getter == StringName()) && (found_setter || v.setter == StringName()))
continue;
// Check for static functions
for (int j = 0; j < p_class->static_functions.size(); j++) {
@ -7933,7 +7952,8 @@ void GDScriptParser::_check_class_level_types(ClassNode *p_class) {
for (int i = 0; i < p_class->subclasses.size(); i++) {
current_class = p_class->subclasses[i];
_check_class_level_types(current_class);
if (error_set) return;
if (error_set)
return;
current_class = p_class;
}
}
@ -8081,7 +8101,8 @@ void GDScriptParser::_check_class_blocks_types(ClassNode *p_class) {
_check_block_types(current_block);
current_block = nullptr;
current_function = nullptr;
if (error_set) return;
if (error_set)
return;
}
for (int i = 0; i < p_class->functions.size(); i++) {
@ -8091,7 +8112,8 @@ void GDScriptParser::_check_class_blocks_types(ClassNode *p_class) {
_check_block_types(current_block);
current_block = nullptr;
current_function = nullptr;
if (error_set) return;
if (error_set)
return;
}
#ifdef DEBUG_ENABLED
@ -8112,7 +8134,8 @@ void GDScriptParser::_check_class_blocks_types(ClassNode *p_class) {
for (int i = 0; i < p_class->subclasses.size(); i++) {
current_class = p_class->subclasses[i];
_check_class_blocks_types(current_class);
if (error_set) return;
if (error_set)
return;
current_class = p_class;
}
}
@ -8375,7 +8398,8 @@ void GDScriptParser::_check_block_types(BlockNode *p_block) {
_add_warning(GDScriptWarning::RETURN_VALUE_DISCARDED, op->line, func_name);
}
#endif // DEBUG_ENABLED
if (error_set) return;
if (error_set)
return;
} break;
case OperatorNode::OP_YIELD: {
_mark_line_as_safe(op->line);
@ -8410,7 +8434,8 @@ void GDScriptParser::_check_block_types(BlockNode *p_block) {
}
}
if (!function_type.has_type) break;
if (!function_type.has_type)
break;
if (function_type.kind == DataType::BUILTIN && function_type.builtin_type == Variant::NIL) {
// Return void, should not have arguments
@ -8470,7 +8495,8 @@ void GDScriptParser::_check_block_types(BlockNode *p_block) {
current_block = p_block->sub_blocks[i];
_check_block_types(current_block);
current_block = p_block;
if (error_set) return;
if (error_set)
return;
}
#ifdef DEBUG_ENABLED
@ -8613,7 +8639,8 @@ Error GDScriptParser::_parse(const String &p_base_path) {
current_function = nullptr;
current_block = nullptr;
if (for_completion) check_types = false;
if (for_completion)
check_types = false;
// Resolve all class-level stuff before getting into function blocks
_check_class_level_types(main_class);

6
modules/gdscript/gdscript_parser.h
View File

@ -648,12 +648,14 @@ private:
void _check_block_types(BlockNode *p_block);
_FORCE_INLINE_ void _mark_line_as_safe(int p_line) const {
#ifdef DEBUG_ENABLED
if (safe_lines) safe_lines->insert(p_line);
if (safe_lines)
safe_lines->insert(p_line);
#endif // DEBUG_ENABLED
}
_FORCE_INLINE_ void _mark_line_as_unsafe(int p_line) const {
#ifdef DEBUG_ENABLED
if (safe_lines) safe_lines->erase(p_line);
if (safe_lines)
safe_lines->erase(p_line);
#endif // DEBUG_ENABLED
}

3
modules/gdscript/language_server/gdscript_extend_parser.cpp
View File

@ -385,7 +385,8 @@ String ExtendGDScriptParser::parse_documentation(int p_line, bool p_docs_down) {
int start_line = p_docs_down ? p_line : p_line - 1;
for (int i = start_line; true; i += step) {
if (i < 0 || i >= lines.size()) break;
if (i < 0 || i >= lines.size())
break;
String line_comment = lines[i].strip_edges(true, false);
if (line_comment.begins_with("#")) {

3
modules/gdscript/language_server/gdscript_workspace.cpp
View File

@ -185,7 +185,8 @@ Array GDScriptWorkspace::symbol(const Dictionary &p_params) {
}
Error GDScriptWorkspace::initialize() {
if (initialized) return OK;
if (initialized)
return OK;
DocData *doc = EditorHelp::get_doc_data();
for (Map<String, DocData::ClassDoc>::Element *E = doc->class_list.front(); E; E = E->next()) {

33
modules/gdscript/language_server/lsp.hpp
View File

@ -282,7 +282,8 @@ struct Command {
Dictionary dict;
dict["title"] = title;
dict["command"] = command;
if (arguments.size()) dict["arguments"] = arguments;
if (arguments.size())
dict["arguments"] = arguments;
return dict;
}
};
@ -946,16 +947,20 @@ struct CompletionItem {
dict["preselect"] = preselect;
dict["sortText"] = sortText;
dict["filterText"] = filterText;
if (commitCharacters.size()) dict["commitCharacters"] = commitCharacters;
if (commitCharacters.size())
dict["commitCharacters"] = commitCharacters;
dict["command"] = command.to_json();
}
return dict;
}
void load(const Dictionary &p_dict) {
if (p_dict.has("label")) label = p_dict["label"];
if (p_dict.has("kind")) kind = p_dict["kind"];
if (p_dict.has("detail")) detail = p_dict["detail"];
if (p_dict.has("label"))
label = p_dict["label"];
if (p_dict.has("kind"))
kind = p_dict["kind"];
if (p_dict.has("detail"))
detail = p_dict["detail"];
if (p_dict.has("documentation")) {
Variant doc = p_dict["documentation"];
if (doc.get_type() == Variant::STRING) {
@ -965,12 +970,18 @@ struct CompletionItem {
documentation.value = v["value"];
}
}
if (p_dict.has("deprecated")) deprecated = p_dict["deprecated"];
if (p_dict.has("preselect")) preselect = p_dict["preselect"];
if (p_dict.has("sortText")) sortText = p_dict["sortText"];
if (p_dict.has("filterText")) filterText = p_dict["filterText"];
if (p_dict.has("insertText")) insertText = p_dict["insertText"];
if (p_dict.has("data")) data = p_dict["data"];
if (p_dict.has("deprecated"))
deprecated = p_dict["deprecated"];
if (p_dict.has("preselect"))
preselect = p_dict["preselect"];
if (p_dict.has("sortText"))
sortText = p_dict["sortText"];
if (p_dict.has("filterText"))
filterText = p_dict["filterText"];
if (p_dict.has("insertText"))
insertText = p_dict["insertText"];
if (p_dict.has("data"))
data = p_dict["data"];
}
};

3
modules/jsonrpc/jsonrpc.cpp
View File

@ -148,7 +148,8 @@ Variant JSONRPC::process_action(const Variant &p_action, bool p_process_arr_elem
String JSONRPC::process_string(const String &p_input) {
if (p_input.empty()) return String();
if (p_input.empty())
return String();
Variant ret;
Variant input;

6
modules/mbedtls/packet_peer_mbed_dtls.cpp Executable file → Normal file
View File

@ -36,7 +36,8 @@
int PacketPeerMbedDTLS::bio_send(void *ctx, const unsigned char *buf, size_t len) {
if (buf == nullptr || len <= 0) return 0;
if (buf == nullptr || len <= 0)
return 0;
PacketPeerMbedDTLS *sp = (PacketPeerMbedDTLS *)ctx;
@ -53,7 +54,8 @@ int PacketPeerMbedDTLS::bio_send(void *ctx, const unsigned char *buf, size_t len
int PacketPeerMbedDTLS::bio_recv(void *ctx, unsigned char *buf, size_t len) {
if (buf == nullptr || len <= 0) return 0;
if (buf == nullptr || len <= 0)
return 0;
PacketPeerMbedDTLS *sp = (PacketPeerMbedDTLS *)ctx;

6
modules/mbedtls/stream_peer_mbedtls.cpp Executable file → Normal file
View File

@ -35,7 +35,8 @@
int StreamPeerMbedTLS::bio_send(void *ctx, const unsigned char *buf, size_t len) {
if (buf == nullptr || len <= 0) return 0;
if (buf == nullptr || len <= 0)
return 0;
StreamPeerMbedTLS *sp = (StreamPeerMbedTLS *)ctx;
@ -54,7 +55,8 @@ int StreamPeerMbedTLS::bio_send(void *ctx, const unsigned char *buf, size_t len)
int StreamPeerMbedTLS::bio_recv(void *ctx, unsigned char *buf, size_t len) {
if (buf == nullptr || len <= 0) return 0;
if (buf == nullptr || len <= 0)
return 0;
StreamPeerMbedTLS *sp = (StreamPeerMbedTLS *)ctx;

18
modules/mobile_vr/mobile_vr_interface.cpp
View File

@ -61,13 +61,19 @@ Vector3 MobileVRInterface::scale_magneto(const Vector3 &p_magnetometer) {
};
// adjust our min and max
if (mag_raw.x > mag_next_max.x) mag_next_max.x = mag_raw.x;
if (mag_raw.y > mag_next_max.y) mag_next_max.y = mag_raw.y;
if (mag_raw.z > mag_next_max.z) mag_next_max.z = mag_raw.z;
if (mag_raw.x > mag_next_max.x)
mag_next_max.x = mag_raw.x;
if (mag_raw.y > mag_next_max.y)
mag_next_max.y = mag_raw.y;
if (mag_raw.z > mag_next_max.z)
mag_next_max.z = mag_raw.z;
if (mag_raw.x < mag_next_min.x) mag_next_min.x = mag_raw.x;
if (mag_raw.y < mag_next_min.y) mag_next_min.y = mag_raw.y;
if (mag_raw.z < mag_next_min.z) mag_next_min.z = mag_raw.z;
if (mag_raw.x < mag_next_min.x)
mag_next_min.x = mag_raw.x;
if (mag_raw.y < mag_next_min.y)
mag_next_min.y = mag_raw.y;
if (mag_raw.z < mag_next_min.z)
mag_next_min.z = mag_raw.z;
// scale our x, y and z
if (!(mag_current_max.x - mag_current_min.x)) {

3
modules/mono/editor/bindings_generator.h
View File

@ -619,7 +619,8 @@ class BindingsGenerator {
const List<InternalCall>::Element *find_icall_by_name(const String &p_name, const List<InternalCall> &p_list) {
const List<InternalCall>::Element *it = p_list.front();
while (it) {
if (it->get().name == p_name) return it;
if (it->get().name == p_name)
return it;
it = it->next();
}
return nullptr;

7
modules/mono/mono_gd/gd_mono_utils.cpp
View File

@ -564,9 +564,10 @@ namespace Marshal {
#ifdef MONO_GLUE_ENABLED
#ifdef TOOLS_ENABLED
#define NO_GLUE_RET(m_ret) \
{ \
if (!GDMonoCache::cached_data.godot_api_cache_updated) return m_ret; \
#define NO_GLUE_RET(m_ret) \
{ \
if (!GDMonoCache::cached_data.godot_api_cache_updated) \
return m_ret; \
}
#else
#define NO_GLUE_RET(m_ret) \

15
modules/opensimplex/noise_texture.cpp
View File

@ -202,19 +202,22 @@ Ref<OpenSimplexNoise> NoiseTexture::get_noise() {
}
void NoiseTexture::set_width(int p_width) {
if (p_width == size.x) return;
if (p_width == size.x)
return;
size.x = p_width;
_queue_update();
}
void NoiseTexture::set_height(int p_height) {
if (p_height == size.y) return;
if (p_height == size.y)
return;
size.y = p_height;
_queue_update();
}
void NoiseTexture::set_seamless(bool p_seamless) {
if (p_seamless == seamless) return;
if (p_seamless == seamless)
return;
seamless = p_seamless;
_queue_update();
}
@ -224,7 +227,8 @@ bool NoiseTexture::get_seamless() {
}
void NoiseTexture::set_as_normalmap(bool p_as_normalmap) {
if (p_as_normalmap == as_normalmap) return;
if (p_as_normalmap == as_normalmap)
return;
as_normalmap = p_as_normalmap;
_queue_update();
_change_notify();
@ -236,7 +240,8 @@ bool NoiseTexture::is_normalmap() {
void NoiseTexture::set_bump_strength(float p_bump_strength) {
if (p_bump_strength == bump_strength) return;
if (p_bump_strength == bump_strength)
return;
bump_strength = p_bump_strength;
if (as_normalmap)
_queue_update();

12
modules/opensimplex/open_simplex_noise.cpp
View File

@ -70,7 +70,8 @@ int OpenSimplexNoise::get_seed() {
}
void OpenSimplexNoise::set_octaves(int p_octaves) {
if (p_octaves == octaves) return;
if (p_octaves == octaves)
return;
ERR_FAIL_COND_MSG(p_octaves > MAX_OCTAVES, vformat("The number of OpenSimplexNoise octaves is limited to %d; ignoring the new value.", MAX_OCTAVES));
@ -79,19 +80,22 @@ void OpenSimplexNoise::set_octaves(int p_octaves) {
}
void OpenSimplexNoise::set_period(float p_period) {
if (p_period == period) return;
if (p_period == period)
return;
period = p_period;
emit_changed();
}
void OpenSimplexNoise::set_persistence(float p_persistence) {
if (p_persistence == persistence) return;
if (p_persistence == persistence)
return;
persistence = p_persistence;
emit_changed();
}
void OpenSimplexNoise::set_lacunarity(float p_lacunarity) {
if (p_lacunarity == lacunarity) return;
if (p_lacunarity == lacunarity)
return;
lacunarity = p_lacunarity;
emit_changed();
}

6
modules/theora/video_stream_theora.cpp
View File

@ -209,7 +209,8 @@ void VideoStreamPlaybackTheora::set_file(const String &p_file) {
while (!stateflag) {
int ret = buffer_data();
if (ret == 0) break;
if (ret == 0)
break;
while (ogg_sync_pageout(&oy, &og) > 0) {
ogg_stream_state test;
@ -286,7 +287,8 @@ void VideoStreamPlaybackTheora::set_file(const String &p_file) {
return;
}
vorbis_p++;
if (vorbis_p == 3) break;
if (vorbis_p == 3)
break;
}
/* The header pages/packets will arrive before anything else we

3
modules/webrtc/webrtc_multiplayer.cpp
View File

@ -144,7 +144,8 @@ void WebRTCMultiplayer::poll() {
void WebRTCMultiplayer::_find_next_peer() {
Map<int, Ref<ConnectedPeer>>::Element *E = peer_map.find(next_packet_peer);
if (E) E = E->next();
if (E)
E = E->next();
// After last.
while (E) {
for (List<Ref<WebRTCDataChannel>>::Element *F = E->get()->channels.front(); F; F = F->next()) {

3
platform/android/export/export.cpp
View File

@ -372,7 +372,8 @@ class EditorExportPlatformAndroid : public EditorExportPlatform {
}
d.name = vendor + " " + device;
if (device == String()) continue;
if (device == String())
continue;
}
ndevices.push_back(d);

3
platform/android/java/lib/src/org/godotengine/godot/Godot.java
View File

@ -920,7 +920,8 @@ public abstract class Godot extends FragmentActivity implements SensorEventListe
int cnt = 0;
for (int i = cc.length; --i >= 0; cnt += cc[i] != 0 ? 1 : 0)
;
if (cnt == 0) return super.onKeyMultiple(inKeyCode, repeatCount, event);
if (cnt == 0)
return super.onKeyMultiple(inKeyCode, repeatCount, event);
mRenderView.queueOnRenderThread(new Runnable() {
// This method will be called on the rendering thread:
public void run() {

9
platform/iphone/export/export.cpp
View File

@ -423,7 +423,8 @@ String EditorExportPlatformIOS::_get_linker_flags() {
String result;
for (int i = 0; i < export_plugins.size(); ++i) {
String flags = export_plugins[i]->get_ios_linker_flags();
if (flags.length() == 0) continue;
if (flags.length() == 0)
continue;
if (result.length() > 0) {
result += ' ';
}
@ -456,8 +457,10 @@ void EditorExportPlatformIOS::_blend_and_rotate(Ref<Image> &p_dst, Ref<Image> &p
int xs = (x_pos >= 0) ? 0 : -x_pos;
int ys = (y_pos >= 0) ? 0 : -y_pos;
if (sw + x_pos > p_dst->get_width()) sw = p_dst->get_width() - x_pos;
if (sh + y_pos > p_dst->get_height()) sh = p_dst->get_height() - y_pos;
if (sw + x_pos > p_dst->get_width())
sw = p_dst->get_width() - x_pos;
if (sh + y_pos > p_dst->get_height())
sh = p_dst->get_height() - y_pos;
for (int y = ys; y < sh; y++) {
for (int x = xs; x < sw; x++) {

3
platform/iphone/godot_iphone.cpp
View File

@ -50,7 +50,8 @@ int iphone_main(int width, int height, int argc, char **argv, String data_dir) {
size_t len = strlen(argv[0]);
while (len--) {
if (argv[0][len] == '/') break;
if (argv[0][len] == '/')
break;
}
if (len >= 0) {

3
platform/linuxbsd/detect_prime_x11.cpp
View File

@ -178,7 +178,8 @@ int detect_prime() {
close(fdset[0]);
if (i) setenv("DRI_PRIME", "1", 1);
if (i)
setenv("DRI_PRIME", "1", 1);
create_context();
const char *vendor = (const char *)glGetString(GL_VENDOR);

12
platform/linuxbsd/display_server_x11.cpp
View File

@ -551,7 +551,8 @@ int DisplayServerX11::get_screen_count() const {
// Using Xinerama Extension
int event_base, error_base;
const Bool ext_okay = XineramaQueryExtension(x11_display, &event_base, &error_base);
if (!ext_okay) return 0;
if (!ext_okay)
return 0;
int count;
XineramaScreenInfo *xsi = XineramaQueryScreens(x11_display, &count);
@ -600,11 +601,13 @@ Rect2i DisplayServerX11::screen_get_usable_rect(int p_screen) const {
// Using Xinerama Extension
int event_base, error_base;
const Bool ext_okay = XineramaQueryExtension(x11_display, &event_base, &error_base);
if (!ext_okay) return Rect2i(0, 0, 0, 0);
if (!ext_okay)
return Rect2i(0, 0, 0, 0);
int count;
XineramaScreenInfo *xsi = XineramaQueryScreens(x11_display, &count);
if (p_screen >= count) return Rect2i(0, 0, 0, 0);
if (p_screen >= count)
return Rect2i(0, 0, 0, 0);
Rect2i rect = Rect2i(xsi[p_screen].x_org, xsi[p_screen].y_org, xsi[p_screen].width, xsi[p_screen].height);
XFree(xsi);
@ -827,7 +830,8 @@ void DisplayServerX11::window_set_current_screen(int p_screen, WindowID p_window
WindowData &wd = windows[p_window];
int count = get_screen_count();
if (p_screen >= count) return;
if (p_screen >= count)
return;
if (window_get_mode(p_window) == WINDOW_MODE_FULLSCREEN) {
Point2i position = screen_get_position(p_screen);

3
platform/linuxbsd/joypad_linux.cpp
View File

@ -463,7 +463,8 @@ void JoypadLinux::process_joypads() {
}
for (int i = 0; i < JOYPADS_MAX; i++) {
if (joypads[i].fd == -1) continue;
if (joypads[i].fd == -1)
continue;
input_event events[32];
Joypad *joy = &joypads[i];

6
platform/osx/display_server_osx.mm
View File

@ -1656,7 +1656,8 @@ String DisplayServerOSX::global_menu_get_item_submenu(const String &p_menu_root,
const NSMenu *sub_menu = [menu_item submenu];
if (sub_menu) {
for (Map<String, NSMenu *>::Element *E = submenu.front(); E; E = E->next()) {
if (E->get() == sub_menu) return E->key();
if (E->get() == sub_menu)
return E->key();
}
}
}
@ -2479,7 +2480,8 @@ void DisplayServerOSX::_set_window_per_pixel_transparency_enabled(bool p_enabled
ERR_FAIL_COND(!windows.has(p_window));
WindowData &wd = windows[p_window];
if (!OS_OSX::get_singleton()->is_layered_allowed()) return;
if (!OS_OSX::get_singleton()->is_layered_allowed())
return;
if (wd.layered_window != p_enabled) {
if (p_enabled) {
[wd.window_object setBackgroundColor:[NSColor clearColor]];

9
platform/osx/joypad_osx.cpp
View File

@ -374,7 +374,8 @@ bool joypad::check_ff_features() {
if (ret == FF_OK && (features.supportedEffects & FFCAP_ET_CONSTANTFORCE)) {
uint32_t val;
ret = FFDeviceGetForceFeedbackProperty(ff_device, FFPROP_FFGAIN, &val, sizeof(val));
if (ret != FF_OK) return false;
if (ret != FF_OK)
return false;
int num_axes = features.numFfAxes;
ff_axes = (DWORD *)memalloc(sizeof(DWORD) * num_axes);
ff_directions = (LONG *)memalloc(sizeof(LONG) * num_axes);
@ -509,14 +510,16 @@ void JoypadOSX::joypad_vibration_stop(int p_id, uint64_t p_timestamp) {
int JoypadOSX::get_joy_index(int p_id) const {
for (int i = 0; i < device_list.size(); i++) {
if (device_list[i].id == p_id) return i;
if (device_list[i].id == p_id)
return i;
}
return -1;
}
int JoypadOSX::get_joy_ref(IOHIDDeviceRef p_device) const {
for (int i = 0; i < device_list.size(); i++) {
if (device_list[i].device_ref == p_device) return i;
if (device_list[i].device_ref == p_device)
return i;
}
return -1;
}

39
platform/uwp/export/export.cpp
View File

@ -265,7 +265,8 @@ void AppxPackager::make_content_types(const String &p_path) {
String ext = file_metadata[i].name.get_extension();
if (types.has(ext)) continue;
if (types.has(ext))
continue;
types[ext] = content_type(ext);
@ -664,8 +665,10 @@ class EditorExportPlatformUWP : public EditorExportPlatform {
bool _valid_resource_name(const String &p_name) const {
if (p_name.empty()) return false;
if (p_name.ends_with(".")) return false;
if (p_name.empty())
return false;
if (p_name.ends_with("."))
return false;
static const char *invalid_names[] = {
"CON", "PRN", "AUX", "NUL", "COM1", "COM2", "COM3", "COM4", "COM5", "COM6", "COM7",
@ -675,7 +678,8 @@ class EditorExportPlatformUWP : public EditorExportPlatform {
const char **t = invalid_names;
while (*t) {
if (p_name == *t) return false;
if (p_name == *t)
return false;
t++;
}
@ -686,19 +690,25 @@ class EditorExportPlatformUWP : public EditorExportPlatform {
Vector<String> parts = p_guid.split("-");
if (parts.size() != 5) return false;
if (parts[0].length() != 8) return false;
if (parts.size() != 5)
return false;
if (parts[0].length() != 8)
return false;
for (int i = 1; i < 4; i++)
if (parts[i].length() != 4) return false;
if (parts[4].length() != 12) return false;
if (parts[i].length() != 4)
return false;
if (parts[4].length() != 12)
return false;
return true;
}
bool _valid_bgcolor(const String &p_color) const {
if (p_color.empty()) return true;
if (p_color.begins_with("#") && p_color.is_valid_html_color()) return true;
if (p_color.empty())
return true;
if (p_color.begins_with("#") && p_color.is_valid_html_color())
return true;
// Colors from https://msdn.microsoft.com/en-us/library/windows/apps/dn934817.aspx
static const char *valid_colors[] = {
@ -732,7 +742,8 @@ class EditorExportPlatformUWP : public EditorExportPlatform {
const char **color = valid_colors;
while (*color) {
if (p_color == *color) return true;
if (p_color == *color)
return true;
color++;
}
@ -896,7 +907,8 @@ class EditorExportPlatformUWP : public EditorExportPlatform {
ERR_PRINT("Unable to load logo");
}
if (!image) return data;
if (!image)
return data;
String tmp_path = EditorSettings::get_singleton()->get_cache_dir().plus_file("uwp_tmp_logo.png");
@ -1301,7 +1313,8 @@ public:
path = path.replace(".scale-100", "");
data = _get_image_data(p_preset, path);
if (data.size() > 0) do_read = false;
if (data.size() > 0)
do_read = false;
}
//read

3
platform/uwp/joypad_uwp.cpp
View File

@ -48,7 +48,8 @@ void JoypadUWP::process_controllers() {
ControllerDevice &joy = controllers[i];
if (!joy.connected) break;
if (!joy.connected)
break;
switch (joy.type) {

6
platform/uwp/os_uwp.cpp
View File

@ -123,7 +123,8 @@ bool OS_UWP::is_window_fullscreen() const {
void OS_UWP::set_keep_screen_on(bool p_enabled) {
if (is_keep_screen_on() == p_enabled) return;
if (is_keep_screen_on() == p_enabled)
return;
if (p_enabled)
display_request->RequestActive();
@ -826,7 +827,8 @@ void OS_UWP::run() {
while (!force_quit) {
CoreWindow::GetForCurrentThread()->Dispatcher->ProcessEvents(CoreProcessEventsOption::ProcessAllIfPresent);
if (managed_object->alert_close_handle) continue;
if (managed_object->alert_close_handle)
continue;
process_events(); // get rid of pending events
if (Main::iteration())
break;

12
platform/windows/display_server_windows.cpp
View File

@ -677,7 +677,8 @@ void DisplayServerWindows::window_set_position(const Point2i &p_position, Window
ERR_FAIL_COND(!windows.has(p_window));
WindowData &wd = windows[p_window];
if (wd.fullscreen) return;
if (wd.fullscreen)
return;
#if 0
//wrong needs to account properly for decorations
RECT r;
@ -1474,19 +1475,22 @@ DisplayServer::LatinKeyboardVariant DisplayServerWindows::get_latin_keyboard_var
int i = 0;
while (azerty[i] != 0) {
if (azerty[i] == hex) return LATIN_KEYBOARD_AZERTY;
if (azerty[i] == hex)
return LATIN_KEYBOARD_AZERTY;
i++;
}
i = 0;
while (qwertz[i] != 0) {
if (qwertz[i] == hex) return LATIN_KEYBOARD_QWERTZ;
if (qwertz[i] == hex)
return LATIN_KEYBOARD_QWERTZ;
i++;
}
i = 0;
while (dvorak[i] != 0) {
if (dvorak[i] == hex) return LATIN_KEYBOARD_DVORAK;
if (dvorak[i] == hex)
return LATIN_KEYBOARD_DVORAK;
i++;
}

6
platform/windows/joypad_windows.cpp
View File

@ -112,7 +112,8 @@ bool JoypadWindows::is_xinput_device(const GUID *p_guid) {
return false;
}
dev_list = (PRAWINPUTDEVICELIST)malloc(sizeof(RAWINPUTDEVICELIST) * dev_list_count);
if (!dev_list) return false;
if (!dev_list)
return false;
if (GetRawInputDeviceList(dev_list, &dev_list_count, sizeof(RAWINPUTDEVICELIST)) == (UINT)-1) {
free(dev_list);
@ -267,7 +268,8 @@ void JoypadWindows::close_joypad(int id) {
return;
}
if (!d_joypads[id].attached) return;
if (!d_joypads[id].attached)
return;
d_joypads[id].di_joy->Unacquire();
d_joypads[id].di_joy->Release();

6
scene/2d/cpu_particles_2d.cpp
View File

@ -961,7 +961,8 @@ void CPUParticles2D::_particles_process(float p_delta) {
//scale by scale
float base_scale = tex_scale * Math::lerp(parameters[PARAM_SCALE], 1.0f, p.scale_rand * randomness[PARAM_SCALE]);
if (base_scale < 0.000001) base_scale = 0.000001;
if (base_scale < 0.000001)
base_scale = 0.000001;
p.transform.elements[0] *= base_scale;
p.transform.elements[1] *= base_scale;
@ -1196,7 +1197,8 @@ void CPUParticles2D::convert_from_particles(Node *p_particles) {
set_param(m_param, material->get_param(ParticlesMaterial::m_param)); \
{ \
Ref<CurveTexture> ctex = material->get_param_texture(ParticlesMaterial::m_param); \
if (ctex.is_valid()) set_param_curve(m_param, ctex->get_curve()); \
if (ctex.is_valid()) \
set_param_curve(m_param, ctex->get_curve()); \
} \
set_param_randomness(m_param, material->get_param_randomness(ParticlesMaterial::m_param));

9
scene/2d/navigation_agent_2d.cpp
View File

@ -288,9 +288,12 @@ String NavigationAgent2D::get_configuration_warning() const {
void NavigationAgent2D::update_navigation() {
if (agent_parent == nullptr) return;
if (navigation == nullptr) return;
if (update_frame_id == Engine::get_singleton()->get_physics_frames()) return;
if (agent_parent == nullptr)
return;
if (navigation == nullptr)
return;
if (update_frame_id == Engine::get_singleton()->get_physics_frames())
return;
update_frame_id = Engine::get_singleton()->get_physics_frames();

3
scene/2d/physics_body_2d.cpp
View File

@ -1394,7 +1394,8 @@ Vector2 KinematicCollision2D::get_remainder() const {
return collision.remainder;
}
Object *KinematicCollision2D::get_local_shape() const {
if (!owner) return nullptr;
if (!owner)
return nullptr;
uint32_t ownerid = owner->shape_find_owner(collision.local_shape);
return owner->shape_owner_get_owner(ownerid);
}

3
scene/2d/tile_map.cpp
View File

@ -1355,7 +1355,8 @@ bool TileMap::get_collision_use_parent() const {
void TileMap::set_collision_use_parent(bool p_use_parent) {
if (use_parent == p_use_parent) return;
if (use_parent == p_use_parent)
return;
_clear_quadrants();

Some files were not shown because too many files have changed in this diff Show More