From 886c7d82d07797344439f09de64811467f5a6300 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?R=C3=A9mi=20Verschelde?= Date: Sun, 27 Aug 2017 14:11:11 +0200 Subject: [PATCH] Re-apply clang-format to all files Some badly formatted code has managed to pass through our CI... --- core/hash_map.h | 40 ++++---- core/hashfuncs.h | 18 ++-- core/io/stream_peer.cpp | 18 ++-- core/io/stream_peer.h | 1 - core/variant.cpp | 139 ++++++++++++++-------------- core/variant.h | 4 +- drivers/gles2/shader_gles2.h | 2 +- modules/gdscript/gd_compiler.h | 4 +- modules/gdscript/gd_tokenizer.cpp | 6 +- scene/io/resource_format_wav.cpp | 2 +- scene/resources/packed_scene.cpp | 14 +-- scene/resources/packed_scene.h | 4 +- servers/visual/rasterizer_dummy.cpp | 1 - 13 files changed, 125 insertions(+), 128 deletions(-) diff --git a/core/hash_map.h b/core/hash_map.h index ea81f9eec46..344fa7b3136 100644 --- a/core/hash_map.h +++ b/core/hash_map.h @@ -30,41 +30,41 @@ #ifndef HASH_MAP_H #define HASH_MAP_H -#include "list.h" #include "hashfuncs.h" +#include "list.h" #include "math_funcs.h" #include "os/memory.h" #include "ustring.h" struct HashMapHasherDefault { - static _FORCE_INLINE_ uint32_t hash(const String &p_string) { return p_string.hash(); } - static _FORCE_INLINE_ uint32_t hash(const char *p_cstr) { return hash_djb2(p_cstr); } - static _FORCE_INLINE_ uint32_t hash(const uint64_t p_int) { return hash_one_uint64(p_int); } + static _FORCE_INLINE_ uint32_t hash(const String &p_string) { return p_string.hash(); } + static _FORCE_INLINE_ uint32_t hash(const char *p_cstr) { return hash_djb2(p_cstr); } + static _FORCE_INLINE_ uint32_t hash(const uint64_t p_int) { return hash_one_uint64(p_int); } - static _FORCE_INLINE_ uint32_t hash(const int64_t p_int) { return hash(uint64_t(p_int)); } - static _FORCE_INLINE_ uint32_t hash(const float p_float) { return hash_djb2_one_float(p_float); } - static _FORCE_INLINE_ uint32_t hash(const double p_double){ return hash_djb2_one_float(p_double); } + static _FORCE_INLINE_ uint32_t hash(const int64_t p_int) { return hash(uint64_t(p_int)); } + static _FORCE_INLINE_ uint32_t hash(const float p_float) { return hash_djb2_one_float(p_float); } + static _FORCE_INLINE_ uint32_t hash(const double p_double) { return hash_djb2_one_float(p_double); } static _FORCE_INLINE_ uint32_t hash(const uint32_t p_int) { return p_int; } - static _FORCE_INLINE_ uint32_t hash(const int32_t p_int) { return (uint32_t)p_int; } + static _FORCE_INLINE_ uint32_t hash(const int32_t p_int) { return (uint32_t)p_int; } static _FORCE_INLINE_ uint32_t hash(const uint16_t p_int) { return p_int; } - static _FORCE_INLINE_ uint32_t hash(const int16_t p_int) { return (uint32_t)p_int; } - static _FORCE_INLINE_ uint32_t hash(const uint8_t p_int) { return p_int; } - static _FORCE_INLINE_ uint32_t hash(const int8_t p_int) { return (uint32_t)p_int; } - static _FORCE_INLINE_ uint32_t hash(const wchar_t p_wchar){ return (uint32_t)p_wchar; } + static _FORCE_INLINE_ uint32_t hash(const int16_t p_int) { return (uint32_t)p_int; } + static _FORCE_INLINE_ uint32_t hash(const uint8_t p_int) { return p_int; } + static _FORCE_INLINE_ uint32_t hash(const int8_t p_int) { return (uint32_t)p_int; } + static _FORCE_INLINE_ uint32_t hash(const wchar_t p_wchar) { return (uint32_t)p_wchar; } //static _FORCE_INLINE_ uint32_t hash(const void* p_ptr) { return uint32_t(uint64_t(p_ptr))*(0x9e3779b1L); } }; template struct HashMapComparatorDefault { - static bool compare(const T& p_lhs, const T& p_rhs) { + static bool compare(const T &p_lhs, const T &p_rhs) { return p_lhs == p_rhs; } - bool compare(const float& p_lhs, const float& p_rhs) { + bool compare(const float &p_lhs, const float &p_rhs) { return (p_lhs == p_rhs) || (Math::is_nan(p_lhs) && Math::is_nan(p_rhs)); } - bool compare(const double& p_lhs, const double& p_rhs) { + bool compare(const double &p_lhs, const double &p_rhs) { return (p_lhs == p_rhs) || (Math::is_nan(p_lhs) && Math::is_nan(p_rhs)); } }; @@ -86,7 +86,7 @@ struct HashMapComparatorDefault { * */ -template , uint8_t MIN_HASH_TABLE_POWER=3,uint8_t RELATIONSHIP=8> +template , uint8_t MIN_HASH_TABLE_POWER = 3, uint8_t RELATIONSHIP = 8> class HashMap { public: struct Pair { @@ -208,7 +208,7 @@ private: while (e) { /* checking hash first avoids comparing key, which may take longer */ - if (e->hash == hash && Comparator::compare(e->pair.key,p_key) ) { + if (e->hash == hash && Comparator::compare(e->pair.key, p_key)) { /* the pair exists in this hashtable, so just update data */ return e; @@ -375,7 +375,7 @@ public: while (e) { /* checking hash first avoids comparing key, which may take longer */ - if (e->hash == hash && Comparator::compare(e->pair.key,p_custom_key) ) { + if (e->hash == hash && Comparator::compare(e->pair.key, p_custom_key)) { /* the pair exists in this hashtable, so just update data */ return &e->pair.data; @@ -401,7 +401,7 @@ public: while (e) { /* checking hash first avoids comparing key, which may take longer */ - if (e->hash == hash && Comparator::compare(e->pair.key,p_custom_key) ) { + if (e->hash == hash && Comparator::compare(e->pair.key, p_custom_key)) { /* the pair exists in this hashtable, so just update data */ return &e->pair.data; @@ -430,7 +430,7 @@ public: while (e) { /* checking hash first avoids comparing key, which may take longer */ - if (e->hash == hash && Comparator::compare(e->pair.key,p_key) ) { + if (e->hash == hash && Comparator::compare(e->pair.key, p_key)) { if (p) { diff --git a/core/hashfuncs.h b/core/hashfuncs.h index 2159563144f..c06b4adb0d7 100644 --- a/core/hashfuncs.h +++ b/core/hashfuncs.h @@ -30,8 +30,8 @@ #ifndef HASHFUNCS_H #define HASHFUNCS_H -#include "math_funcs.h" #include "math_defs.h" +#include "math_funcs.h" #include "typedefs.h" /** @@ -71,14 +71,14 @@ static inline uint32_t hash_djb2_one_32(uint32_t p_in, uint32_t p_prev = 5381) { } static inline uint32_t hash_one_uint64(const uint64_t p_int) { - uint64_t v=p_int; + uint64_t v = p_int; v = (~v) + (v << 18); // v = (v << 18) - v - 1; v = v ^ (v >> 31); v = v * 21; // v = (v + (v << 2)) + (v << 4); v = v ^ (v >> 11); v = v + (v << 6); v = v ^ (v >> 22); - return (int) v; + return (int)v; } static inline uint32_t hash_djb2_one_float(double p_in, uint32_t p_prev = 5381) { @@ -88,17 +88,17 @@ static inline uint32_t hash_djb2_one_float(double p_in, uint32_t p_prev = 5381) } u; // Normalize +/- 0.0 and NaN values so they hash the same. - if (p_in==0.0f) - u.d=0.0; + if (p_in == 0.0f) + u.d = 0.0; else if (Math::is_nan(p_in)) - u.d=NAN; + u.d = NAN; else - u.d=p_in; + u.d = p_in; - return ((p_prev<<5)+p_prev) + hash_one_uint64(u.i); + return ((p_prev << 5) + p_prev) + hash_one_uint64(u.i); } -template +template static inline uint32_t make_uint32_t(T p_in) { union { diff --git a/core/io/stream_peer.cpp b/core/io/stream_peer.cpp index 6f0dba71f4d..e931f049596 100644 --- a/core/io/stream_peer.cpp +++ b/core/io/stream_peer.cpp @@ -412,10 +412,10 @@ void StreamPeerBuffer::_bind_methods() { Error StreamPeerBuffer::put_data(const uint8_t *p_data, int p_bytes) { if (p_bytes <= 0) - return OK; + return OK; if (pointer + p_bytes > data.size()) { - data.resize(pointer + p_bytes); + data.resize(pointer + p_bytes); } DVector::Write w = data.write(); @@ -436,20 +436,20 @@ Error StreamPeerBuffer::get_data(uint8_t *p_buffer, int p_bytes) { int recv; get_partial_data(p_buffer, p_bytes, recv); if (recv != p_bytes) - return ERR_INVALID_PARAMETER; + return ERR_INVALID_PARAMETER; return OK; } Error StreamPeerBuffer::get_partial_data(uint8_t *p_buffer, int p_bytes, int &r_received) { if (pointer + p_bytes > data.size()) { - r_received = data.size() - pointer; - if (r_received <= 0) { - r_received = 0; - return OK; //you got 0 - } + r_received = data.size() - pointer; + if (r_received <= 0) { + r_received = 0; + return OK; //you got 0 + } } else { - r_received = p_bytes; + r_received = p_bytes; } DVector::Read r = data.read(); diff --git a/core/io/stream_peer.h b/core/io/stream_peer.h index d090d23e62c..74372514afc 100644 --- a/core/io/stream_peer.h +++ b/core/io/stream_peer.h @@ -104,7 +104,6 @@ public: Error put_data(const uint8_t *p_data, int p_bytes); Error put_partial_data(const uint8_t *p_data, int p_bytes, int &r_sent); - Error get_data(uint8_t *p_buffer, int p_bytes); Error get_partial_data(uint8_t *p_buffer, int p_bytes, int &r_received); diff --git a/core/variant.cpp b/core/variant.cpp index b4b83397a4a..256562c5625 100644 --- a/core/variant.cpp +++ b/core/variant.cpp @@ -2840,74 +2840,74 @@ uint32_t Variant::hash() const { #define hash_compare_scalar(p_lhs, p_rhs) \ ((p_lhs) == (p_rhs)) || (Math::is_nan(p_lhs) && Math::is_nan(p_rhs)) -#define hash_compare_vector2(p_lhs, p_rhs)\ +#define hash_compare_vector2(p_lhs, p_rhs) \ (hash_compare_scalar((p_lhs).x, (p_rhs).x)) && \ - (hash_compare_scalar((p_lhs).y, (p_rhs).y)) + (hash_compare_scalar((p_lhs).y, (p_rhs).y)) -#define hash_compare_vector3(p_lhs, p_rhs)\ - (hash_compare_scalar((p_lhs).x, (p_rhs).x)) && \ - (hash_compare_scalar((p_lhs).y, (p_rhs).y)) && \ - (hash_compare_scalar((p_lhs).z, (p_rhs).z)) +#define hash_compare_vector3(p_lhs, p_rhs) \ + (hash_compare_scalar((p_lhs).x, (p_rhs).x)) && \ + (hash_compare_scalar((p_lhs).y, (p_rhs).y)) && \ + (hash_compare_scalar((p_lhs).z, (p_rhs).z)) -#define hash_compare_quat(p_lhs, p_rhs)\ - (hash_compare_scalar((p_lhs).x, (p_rhs).x)) && \ - (hash_compare_scalar((p_lhs).y, (p_rhs).y)) && \ - (hash_compare_scalar((p_lhs).z, (p_rhs).z)) && \ - (hash_compare_scalar((p_lhs).w, (p_rhs).w)) +#define hash_compare_quat(p_lhs, p_rhs) \ + (hash_compare_scalar((p_lhs).x, (p_rhs).x)) && \ + (hash_compare_scalar((p_lhs).y, (p_rhs).y)) && \ + (hash_compare_scalar((p_lhs).z, (p_rhs).z)) && \ + (hash_compare_scalar((p_lhs).w, (p_rhs).w)) -#define hash_compare_color(p_lhs, p_rhs)\ - (hash_compare_scalar((p_lhs).r, (p_rhs).r)) && \ - (hash_compare_scalar((p_lhs).g, (p_rhs).g)) && \ - (hash_compare_scalar((p_lhs).b, (p_rhs).b)) && \ - (hash_compare_scalar((p_lhs).a, (p_rhs).a)) +#define hash_compare_color(p_lhs, p_rhs) \ + (hash_compare_scalar((p_lhs).r, (p_rhs).r)) && \ + (hash_compare_scalar((p_lhs).g, (p_rhs).g)) && \ + (hash_compare_scalar((p_lhs).b, (p_rhs).b)) && \ + (hash_compare_scalar((p_lhs).a, (p_rhs).a)) -#define hash_compare_pool_array(p_lhs, p_rhs, p_type, p_compare_func)\ - const DVector& l = *reinterpret_cast*>(p_lhs);\ - const DVector& r = *reinterpret_cast*>(p_rhs);\ - \ - if(l.size() != r.size()) \ - return false; \ - \ - DVector::Read lr = l.read(); \ - DVector::Read rr = r.read(); \ - \ - for(int i = 0; i < l.size(); ++i) { \ - if(! p_compare_func((lr[0]), (rr[0]))) \ - return false; \ - }\ - \ - return true +#define hash_compare_pool_array(p_lhs, p_rhs, p_type, p_compare_func) \ + const DVector &l = *reinterpret_cast *>(p_lhs); \ + const DVector &r = *reinterpret_cast *>(p_rhs); \ + \ + if (l.size() != r.size()) \ + return false; \ + \ + DVector::Read lr = l.read(); \ + DVector::Read rr = r.read(); \ + \ + for (int i = 0; i < l.size(); ++i) { \ + if (!p_compare_func((lr[0]), (rr[0]))) \ + return false; \ + } \ + \ + return true -bool Variant::hash_compare(const Variant& p_variant) const { +bool Variant::hash_compare(const Variant &p_variant) const { if (type != p_variant.type) return false; - switch( type ) { + switch (type) { case REAL: { return hash_compare_scalar(_data._real, p_variant._data._real); } break; case VECTOR2: { - const Vector2* l = reinterpret_cast(_data._mem); - const Vector2* r = reinterpret_cast(p_variant._data._mem); + const Vector2 *l = reinterpret_cast(_data._mem); + const Vector2 *r = reinterpret_cast(p_variant._data._mem); return hash_compare_vector2(*l, *r); } break; case RECT2: { - const Rect2* l = reinterpret_cast(_data._mem); - const Rect2* r = reinterpret_cast(p_variant._data._mem); + const Rect2 *l = reinterpret_cast(_data._mem); + const Rect2 *r = reinterpret_cast(p_variant._data._mem); return (hash_compare_vector2(l->pos, r->pos)) && - (hash_compare_vector2(l->size, r->size)); + (hash_compare_vector2(l->size, r->size)); } break; case MATRIX32: { - Matrix32* l = _data._matrix32; - Matrix32* r = p_variant._data._matrix32; + Matrix32 *l = _data._matrix32; + Matrix32 *r = p_variant._data._matrix32; - for(int i=0;i<3;i++) { - if (! (hash_compare_vector2(l->elements[i], r->elements[i]))) + for (int i = 0; i < 3; i++) { + if (!(hash_compare_vector2(l->elements[i], r->elements[i]))) return false; } @@ -2915,23 +2915,23 @@ bool Variant::hash_compare(const Variant& p_variant) const { } break; case VECTOR3: { - const Vector3* l = reinterpret_cast(_data._mem); - const Vector3* r = reinterpret_cast(p_variant._data._mem); + const Vector3 *l = reinterpret_cast(_data._mem); + const Vector3 *r = reinterpret_cast(p_variant._data._mem); return hash_compare_vector3(*l, *r); } break; case PLANE: { - const Plane* l = reinterpret_cast(_data._mem); - const Plane* r = reinterpret_cast(p_variant._data._mem); + const Plane *l = reinterpret_cast(_data._mem); + const Plane *r = reinterpret_cast(p_variant._data._mem); return (hash_compare_vector3(l->normal, r->normal)) && - (hash_compare_scalar(l->d, r->d)); + (hash_compare_scalar(l->d, r->d)); } break; case _AABB: { - const AABB* l = _data._aabb; - const AABB* r = p_variant._data._aabb; + const AABB *l = _data._aabb; + const AABB *r = p_variant._data._aabb; return (hash_compare_vector3(l->pos, r->pos) && (hash_compare_vector3(l->size, r->size))); @@ -2939,18 +2939,18 @@ bool Variant::hash_compare(const Variant& p_variant) const { } break; case QUAT: { - const Quat* l = reinterpret_cast(_data._mem); - const Quat* r = reinterpret_cast(p_variant._data._mem); + const Quat *l = reinterpret_cast(_data._mem); + const Quat *r = reinterpret_cast(p_variant._data._mem); return hash_compare_quat(*l, *r); } break; case MATRIX3: { - const Matrix3* l = _data._matrix3; - const Matrix3* r = p_variant._data._matrix3; + const Matrix3 *l = _data._matrix3; + const Matrix3 *r = p_variant._data._matrix3; - for(int i=0;i<3;i++) { - if (! (hash_compare_vector3(l->elements[i], r->elements[i]))) + for (int i = 0; i < 3; i++) { + if (!(hash_compare_vector3(l->elements[i], r->elements[i]))) return false; } @@ -2958,11 +2958,11 @@ bool Variant::hash_compare(const Variant& p_variant) const { } break; case TRANSFORM: { - const Transform* l = _data._transform; - const Transform* r = p_variant._data._transform; + const Transform *l = _data._transform; + const Transform *r = p_variant._data._transform; - for(int i=0;i<3;i++) { - if (! (hash_compare_vector3(l->basis.elements[i], r->basis.elements[i]))) + for (int i = 0; i < 3; i++) { + if (!(hash_compare_vector3(l->basis.elements[i], r->basis.elements[i]))) return false; } @@ -2970,21 +2970,21 @@ bool Variant::hash_compare(const Variant& p_variant) const { } break; case COLOR: { - const Color* l = reinterpret_cast(_data._mem); - const Color* r = reinterpret_cast(p_variant._data._mem); + const Color *l = reinterpret_cast(_data._mem); + const Color *r = reinterpret_cast(p_variant._data._mem); return hash_compare_color(*l, *r); } break; case ARRAY: { - const Array& l = *(reinterpret_cast(_data._mem)); - const Array& r = *(reinterpret_cast(p_variant._data._mem)); + const Array &l = *(reinterpret_cast(_data._mem)); + const Array &r = *(reinterpret_cast(p_variant._data._mem)); - if(l.size() != r.size()) + if (l.size() != r.size()) return false; - for(int i = 0; i < l.size(); ++i) { - if(! l[0].hash_compare(r[0])) + for (int i = 0; i < l.size(); ++i) { + if (!l[0].hash_compare(r[0])) return false; } @@ -3010,14 +3010,13 @@ bool Variant::hash_compare(const Variant& p_variant) const { default: bool v; Variant r; - evaluate(OP_EQUAL,*this,p_variant,r,v); + evaluate(OP_EQUAL, *this, p_variant, r, v); return r; - } + } return false; } - bool Variant::is_ref() const { return type == OBJECT && !_get_obj().ref.is_null(); diff --git a/core/variant.h b/core/variant.h index 7663d755f13..c1e682a221c 100644 --- a/core/variant.h +++ b/core/variant.h @@ -401,7 +401,7 @@ public: bool operator<(const Variant &p_variant) const; uint32_t hash() const; - bool hash_compare(const Variant& p_variant) const; + bool hash_compare(const Variant &p_variant) const; bool booleanize(bool &valid) const; void static_assign(const Variant &p_variant); @@ -441,7 +441,7 @@ struct VariantHasher { struct VariantComparator { - static _FORCE_INLINE_ bool compare(const Variant &p_lhs, const Variant &p_rhs) { return p_lhs.hash_compare(p_rhs); } + static _FORCE_INLINE_ bool compare(const Variant &p_lhs, const Variant &p_rhs) { return p_lhs.hash_compare(p_rhs); } }; Variant::ObjData &Variant::_get_obj() { diff --git a/drivers/gles2/shader_gles2.h b/drivers/gles2/shader_gles2.h index 25a90e3f4ae..20a3b9f062b 100644 --- a/drivers/gles2/shader_gles2.h +++ b/drivers/gles2/shader_gles2.h @@ -134,7 +134,7 @@ private: struct VersionKeyHash { - static _FORCE_INLINE_ uint32_t hash( const VersionKey& p_key) { return HashMapHasherDefault::hash(p_key.key); }; + static _FORCE_INLINE_ uint32_t hash(const VersionKey &p_key) { return HashMapHasherDefault::hash(p_key.key); }; }; //this should use a way more cachefriendly version.. diff --git a/modules/gdscript/gd_compiler.h b/modules/gdscript/gd_compiler.h index 507b5d61e95..86e86e54204 100644 --- a/modules/gdscript/gd_compiler.h +++ b/modules/gdscript/gd_compiler.h @@ -91,8 +91,8 @@ class GDCompiler { } //int get_identifier_pos(const StringName& p_dentifier) const; - HashMap constant_map; - Map name_map; + HashMap constant_map; + Map name_map; int get_name_map_pos(const StringName &p_identifier) { int ret; diff --git a/modules/gdscript/gd_tokenizer.cpp b/modules/gdscript/gd_tokenizer.cpp index 09e45a951f9..eea46666697 100644 --- a/modules/gdscript/gd_tokenizer.cpp +++ b/modules/gdscript/gd_tokenizer.cpp @@ -1124,9 +1124,9 @@ Vector GDTokenizerBuffer::parse_code_string(const String &p_code) { Vector buf; - Map identifier_map; - HashMap constant_map; - Map line_map; + Map identifier_map; + HashMap constant_map; + Map line_map; Vector token_array; GDTokenizerText tt; diff --git a/scene/io/resource_format_wav.cpp b/scene/io/resource_format_wav.cpp index e3edf515926..db437332581 100644 --- a/scene/io/resource_format_wav.cpp +++ b/scene/io/resource_format_wav.cpp @@ -173,7 +173,7 @@ RES ResourceFormatLoaderWAV::load(const String &p_path, const String &p_original // 8 bit samples are UNSIGNED uint8_t s = file->get_8(); - data_ptr8[i] = (int8_t)(s-128); + data_ptr8[i] = (int8_t)(s - 128); } } else if (format_bits == 32 && compression_code == 3) { int16_t *data_ptr16 = (int16_t *)data_ptr; diff --git a/scene/resources/packed_scene.cpp b/scene/resources/packed_scene.cpp index 087af48d892..43aad767b8b 100644 --- a/scene/resources/packed_scene.cpp +++ b/scene/resources/packed_scene.cpp @@ -306,7 +306,7 @@ static int _nm_get_string(const String &p_string, Map &name_map return idx; } -static int _vm_get_variant(const Variant& p_variant, HashMap &variant_map) { +static int _vm_get_variant(const Variant &p_variant, HashMap &variant_map) { if (variant_map.has(p_variant)) return variant_map[p_variant]; @@ -316,7 +316,7 @@ static int _vm_get_variant(const Variant& p_variant, HashMap &name_map,HashMap &variant_map,Map &node_map,Map &nodepath_map) { +Error SceneState::_parse_node(Node *p_owner, Node *p_node, int p_parent_idx, Map &name_map, HashMap &variant_map, Map &node_map, Map &nodepath_map) { // this function handles all the work related to properly packing scenes, be it // instanced or inherited. @@ -673,7 +673,7 @@ Error SceneState::_parse_node(Node *p_owner,Node *p_node,int p_parent_idx, Map &name_map,HashMap &variant_map,Map &node_map,Map &nodepath_map) { +Error SceneState::_parse_connections(Node *p_owner, Node *p_node, Map &name_map, HashMap &variant_map, Map &node_map, Map &nodepath_map) { if (p_node != p_owner && p_node->get_owner() && p_node->get_owner() != p_owner && !p_owner->is_editable_instance(p_node->get_owner())) return OK; @@ -860,10 +860,10 @@ Error SceneState::pack(Node *p_scene) { Node *scene = p_scene; - Map name_map; - HashMap variant_map; - Map node_map; - Map nodepath_map; + Map name_map; + HashMap variant_map; + Map node_map; + Map nodepath_map; //if using scene inheritance, pack the scene it inherits from if (scene->get_scene_inherited_state().is_valid()) { diff --git a/scene/resources/packed_scene.h b/scene/resources/packed_scene.h index 7fb407ed986..e9752d36b84 100644 --- a/scene/resources/packed_scene.h +++ b/scene/resources/packed_scene.h @@ -88,8 +88,8 @@ class SceneState : public Reference { Vector connections; - Error _parse_node(Node *p_owner,Node *p_node,int p_parent_idx, Map &name_map,HashMap &variant_map,Map &node_map,Map &nodepath_map); - Error _parse_connections(Node *p_owner,Node *p_node, Map &name_map,HashMap &variant_map,Map &node_map,Map &nodepath_map); + Error _parse_node(Node *p_owner, Node *p_node, int p_parent_idx, Map &name_map, HashMap &variant_map, Map &node_map, Map &nodepath_map); + Error _parse_connections(Node *p_owner, Node *p_node, Map &name_map, HashMap &variant_map, Map &node_map, Map &nodepath_map); String path; diff --git a/servers/visual/rasterizer_dummy.cpp b/servers/visual/rasterizer_dummy.cpp index 89f06d121c4..c75c61ad2b4 100644 --- a/servers/visual/rasterizer_dummy.cpp +++ b/servers/visual/rasterizer_dummy.cpp @@ -1680,7 +1680,6 @@ void RasterizerDummy::custom_shade_model_get_param_info(int p_model, List