Nixyri/godot
1
0
Fork 0
mirror of https://github.com/godotengine/godot.git synced 2024-10-23 05:31:54 +00:00
Code Issues Actions 1 Packages Projects Releases Wiki Activity

Re-apply clang-format to all files

Browse Source 
Some badly formatted code has managed to pass through our CI...
This commit is contained in:
Rémi Verschelde 2017-08-27 14:11:11 +02:00
parent f3e302c07c
commit 886c7d82d0
13 changed files with 125 additions and 128 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

40
core/hash_map.h
View File

@ -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 <typename T>
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 <class TKey, class TData, class Hasher = HashMapHasherDefault, class Comparator=HashMapComparatorDefault<TKey>, uint8_t MIN_HASH_TABLE_POWER=3,uint8_t RELATIONSHIP=8>
template <class TKey, class TData, class Hasher = HashMapHasherDefault, class Comparator = HashMapComparatorDefault<TKey>, 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) {

18
core/hashfuncs.h
View File

@ -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<class T>
template <class T>
static inline uint32_t make_uint32_t(T p_in) {
union {

18
core/io/stream_peer.cpp
View File

@ -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<uint8_t>::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<uint8_t>::Read r = data.read();

1
core/io/stream_peer.h
View File

@ -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);

139
core/variant.cpp
View File

@ -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<p_type>& l = *reinterpret_cast<const DVector<p_type>*>(p_lhs);\
const DVector<p_type>& r = *reinterpret_cast<const DVector<p_type>*>(p_rhs);\
\
if(l.size() != r.size()) \
return false; \
\
DVector<p_type>::Read lr = l.read(); \
DVector<p_type>::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<p_type> &l = *reinterpret_cast<const DVector<p_type> *>(p_lhs); \
const DVector<p_type> &r = *reinterpret_cast<const DVector<p_type> *>(p_rhs); \
\
if (l.size() != r.size()) \
return false; \
\
DVector<p_type>::Read lr = l.read(); \
DVector<p_type>::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<const Vector2*>(_data._mem);
const Vector2* r = reinterpret_cast<const Vector2*>(p_variant._data._mem);
const Vector2 *l = reinterpret_cast<const Vector2 *>(_data._mem);
const Vector2 *r = reinterpret_cast<const Vector2 *>(p_variant._data._mem);
return hash_compare_vector2(*l, *r);
} break;
case RECT2: {
const Rect2* l = reinterpret_cast<const Rect2*>(_data._mem);
const Rect2* r = reinterpret_cast<const Rect2*>(p_variant._data._mem);
const Rect2 *l = reinterpret_cast<const Rect2 *>(_data._mem);
const Rect2 *r = reinterpret_cast<const Rect2 *>(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<const Vector3*>(_data._mem);
const Vector3* r = reinterpret_cast<const Vector3*>(p_variant._data._mem);
const Vector3 *l = reinterpret_cast<const Vector3 *>(_data._mem);
const Vector3 *r = reinterpret_cast<const Vector3 *>(p_variant._data._mem);
return hash_compare_vector3(*l, *r);
} break;
case PLANE: {
const Plane* l = reinterpret_cast<const Plane*>(_data._mem);
const Plane* r = reinterpret_cast<const Plane*>(p_variant._data._mem);
const Plane *l = reinterpret_cast<const Plane *>(_data._mem);
const Plane *r = reinterpret_cast<const Plane *>(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<const Quat*>(_data._mem);
const Quat* r = reinterpret_cast<const Quat*>(p_variant._data._mem);
const Quat *l = reinterpret_cast<const Quat *>(_data._mem);
const Quat *r = reinterpret_cast<const Quat *>(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<const Color*>(_data._mem);
const Color* r = reinterpret_cast<const Color*>(p_variant._data._mem);
const Color *l = reinterpret_cast<const Color *>(_data._mem);
const Color *r = reinterpret_cast<const Color *>(p_variant._data._mem);
return hash_compare_color(*l, *r);
} break;
case ARRAY: {
const Array& l = *(reinterpret_cast<const Array*>(_data._mem));
const Array& r = *(reinterpret_cast<const Array*>(p_variant._data._mem));
const Array &l = *(reinterpret_cast<const Array *>(_data._mem));
const Array &r = *(reinterpret_cast<const Array *>(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();

4
core/variant.h
View File

@ -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() {

2
drivers/gles2/shader_gles2.h
View File

@ -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..

4
modules/gdscript/gd_compiler.h
View File

@ -91,8 +91,8 @@ class GDCompiler {
}
//int get_identifier_pos(const StringName& p_dentifier) const;
HashMap<Variant,int,VariantHasher,VariantComparator> constant_map;
Map<StringName,int> name_map;
HashMap<Variant, int, VariantHasher, VariantComparator> constant_map;
Map<StringName, int> name_map;
int get_name_map_pos(const StringName &p_identifier) {
int ret;

6
modules/gdscript/gd_tokenizer.cpp
View File

@ -1124,9 +1124,9 @@ Vector<uint8_t> GDTokenizerBuffer::parse_code_string(const String &p_code) {
Vector<uint8_t> buf;
Map<StringName,int> identifier_map;
HashMap<Variant,int,VariantHasher,VariantComparator> constant_map;
Map<uint32_t,int> line_map;
Map<StringName, int> identifier_map;
HashMap<Variant, int, VariantHasher, VariantComparator> constant_map;
Map<uint32_t, int> line_map;
Vector<uint32_t> token_array;
GDTokenizerText tt;

2
scene/io/resource_format_wav.cpp
View File

@ -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;

14
scene/resources/packed_scene.cpp
View File

@ -306,7 +306,7 @@ static int _nm_get_string(const String &p_string, Map<StringName, int> &name_map
return idx;
}
static int _vm_get_variant(const Variant& p_variant, HashMap<Variant,int,VariantHasher,VariantComparator> &variant_map) {
static int _vm_get_variant(const Variant &p_variant, HashMap<Variant, int, VariantHasher, VariantComparator> &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<Variant,int,Variant
return idx;
}
Error SceneState::_parse_node(Node *p_owner,Node *p_node,int p_parent_idx, Map<StringName,int> &name_map,HashMap<Variant,int,VariantHasher,VariantComparator> &variant_map,Map<Node*,int> &node_map,Map<Node*,int> &nodepath_map) {
Error SceneState::_parse_node(Node *p_owner, Node *p_node, int p_parent_idx, Map<StringName, int> &name_map, HashMap<Variant, int, VariantHasher, VariantComparator> &variant_map, Map<Node *, int> &node_map, Map<Node *, int> &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<S
return OK;
}
Error SceneState::_parse_connections(Node *p_owner,Node *p_node, Map<StringName,int> &name_map,HashMap<Variant,int,VariantHasher,VariantComparator> &variant_map,Map<Node*,int> &node_map,Map<Node*,int> &nodepath_map) {
Error SceneState::_parse_connections(Node *p_owner, Node *p_node, Map<StringName, int> &name_map, HashMap<Variant, int, VariantHasher, VariantComparator> &variant_map, Map<Node *, int> &node_map, Map<Node *, int> &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<StringName,int> name_map;
HashMap<Variant,int,VariantHasher,VariantComparator> variant_map;
Map<Node*,int> node_map;
Map<Node*,int> nodepath_map;
Map<StringName, int> name_map;
HashMap<Variant, int, VariantHasher, VariantComparator> variant_map;
Map<Node *, int> node_map;
Map<Node *, int> nodepath_map;
//if using scene inheritance, pack the scene it inherits from
if (scene->get_scene_inherited_state().is_valid()) {

4
scene/resources/packed_scene.h
View File

@ -88,8 +88,8 @@ class SceneState : public Reference {
Vector<ConnectionData> connections;
Error _parse_node(Node *p_owner,Node *p_node,int p_parent_idx, Map<StringName,int> &name_map,HashMap<Variant,int,VariantHasher,VariantComparator> &variant_map,Map<Node*,int> &node_map,Map<Node*,int> &nodepath_map);
Error _parse_connections(Node *p_owner,Node *p_node, Map<StringName,int> &name_map,HashMap<Variant,int,VariantHasher,VariantComparator> &variant_map,Map<Node*,int> &node_map,Map<Node*,int> &nodepath_map);
Error _parse_node(Node *p_owner, Node *p_node, int p_parent_idx, Map<StringName, int> &name_map, HashMap<Variant, int, VariantHasher, VariantComparator> &variant_map, Map<Node *, int> &node_map, Map<Node *, int> &nodepath_map);
Error _parse_connections(Node *p_owner, Node *p_node, Map<StringName, int> &name_map, HashMap<Variant, int, VariantHasher, VariantComparator> &variant_map, Map<Node *, int> &node_map, Map<Node *, int> &nodepath_map);
String path;

1
servers/visual/rasterizer_dummy.cpp
View File

@ -1680,7 +1680,6 @@ void RasterizerDummy::custom_shade_model_get_param_info(int p_model, List<Proper
};
void RasterizerDummy::set_time_scale(float p_scale) {
}
void RasterizerDummy::init() {