godotengine
/
godot
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Make more base nodes thread safe 

Ongoing work to make more of the base nodes thread safe.
This commit is contained in:
Juan Linietsky 2023-05-12 13:53:15 +02:00
parent fd4a06c515
commit 0a9f72d5a8
17 changed files with 965 additions and 133 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

60
core/core_bind.cpp
View File

@ -1301,11 +1301,11 @@ Variant ClassDB::instantiate(const StringName &p_class) const {
}
}
bool ClassDB::has_signal(StringName p_class, StringName p_signal) const {
bool ClassDB::class_has_signal(StringName p_class, StringName p_signal) const {
return ::ClassDB::has_signal(p_class, p_signal);
}
Dictionary ClassDB::get_signal(StringName p_class, StringName p_signal) const {
Dictionary ClassDB::class_get_signal(StringName p_class, StringName p_signal) const {
MethodInfo signal;
if (::ClassDB::get_signal(p_class, p_signal, &signal)) {
return signal.operator Dictionary();
@ -1314,7 +1314,7 @@ Dictionary ClassDB::get_signal(StringName p_class, StringName p_signal) const {
}
}
TypedArray<Dictionary> ClassDB::get_signal_list(StringName p_class, bool p_no_inheritance) const {
TypedArray<Dictionary> ClassDB::class_get_signal_list(StringName p_class, bool p_no_inheritance) const {
List<MethodInfo> signals;
::ClassDB::get_signal_list(p_class, &signals, p_no_inheritance);
TypedArray<Dictionary> ret;
@ -1326,7 +1326,7 @@ TypedArray<Dictionary> ClassDB::get_signal_list(StringName p_class, bool p_no_in
return ret;
}
TypedArray<Dictionary> ClassDB::get_property_list(StringName p_class, bool p_no_inheritance) const {
TypedArray<Dictionary> ClassDB::class_get_property_list(StringName p_class, bool p_no_inheritance) const {
List<PropertyInfo> plist;
::ClassDB::get_property_list(p_class, &plist, p_no_inheritance);
TypedArray<Dictionary> ret;
@ -1337,13 +1337,13 @@ TypedArray<Dictionary> ClassDB::get_property_list(StringName p_class, bool p_no_
return ret;
}
Variant ClassDB::get_property(Object *p_object, const StringName &p_property) const {
Variant ClassDB::class_get_property(Object *p_object, const StringName &p_property) const {
Variant ret;
::ClassDB::get_property(p_object, p_property, ret);
return ret;
}
Error ClassDB::set_property(Object *p_object, const StringName &p_property, const Variant &p_value) const {
Error ClassDB::class_set_property(Object *p_object, const StringName &p_property, const Variant &p_value) const {
Variant ret;
bool valid;
if (!::ClassDB::set_property(p_object, p_property, p_value, &valid)) {
@ -1354,11 +1354,11 @@ Error ClassDB::set_property(Object *p_object, const StringName &p_property, cons
return OK;
}
bool ClassDB::has_method(StringName p_class, StringName p_method, bool p_no_inheritance) const {
bool ClassDB::class_has_method(StringName p_class, StringName p_method, bool p_no_inheritance) const {
return ::ClassDB::has_method(p_class, p_method, p_no_inheritance);
}
TypedArray<Dictionary> ClassDB::get_method_list(StringName p_class, bool p_no_inheritance) const {
TypedArray<Dictionary> ClassDB::class_get_method_list(StringName p_class, bool p_no_inheritance) const {
List<MethodInfo> methods;
::ClassDB::get_method_list(p_class, &methods, p_no_inheritance);
TypedArray<Dictionary> ret;
@ -1376,7 +1376,7 @@ TypedArray<Dictionary> ClassDB::get_method_list(StringName p_class, bool p_no_in
return ret;
}
PackedStringArray ClassDB::get_integer_constant_list(const StringName &p_class, bool p_no_inheritance) const {
PackedStringArray ClassDB::class_get_integer_constant_list(const StringName &p_class, bool p_no_inheritance) const {
List<String> constants;
::ClassDB::get_integer_constant_list(p_class, &constants, p_no_inheritance);
@ -1390,24 +1390,24 @@ PackedStringArray ClassDB::get_integer_constant_list(const StringName &p_class,
return ret;
}
bool ClassDB::has_integer_constant(const StringName &p_class, const StringName &p_name) const {
bool ClassDB::class_has_integer_constant(const StringName &p_class, const StringName &p_name) const {
bool success;
::ClassDB::get_integer_constant(p_class, p_name, &success);
return success;
}
int64_t ClassDB::get_integer_constant(const StringName &p_class, const StringName &p_name) const {
int64_t ClassDB::class_get_integer_constant(const StringName &p_class, const StringName &p_name) const {
bool found;
int64_t c = ::ClassDB::get_integer_constant(p_class, p_name, &found);
ERR_FAIL_COND_V(!found, 0);
return c;
}
bool ClassDB::has_enum(const StringName &p_class, const StringName &p_name, bool p_no_inheritance) const {
bool ClassDB::class_has_enum(const StringName &p_class, const StringName &p_name, bool p_no_inheritance) const {
return ::ClassDB::has_enum(p_class, p_name, p_no_inheritance);
}
PackedStringArray ClassDB::get_enum_list(const StringName &p_class, bool p_no_inheritance) const {
PackedStringArray ClassDB::class_get_enum_list(const StringName &p_class, bool p_no_inheritance) const {
List<StringName> enums;
::ClassDB::get_enum_list(p_class, &enums, p_no_inheritance);
@ -1421,7 +1421,7 @@ PackedStringArray ClassDB::get_enum_list(const StringName &p_class, bool p_no_in
return ret;
}
PackedStringArray ClassDB::get_enum_constants(const StringName &p_class, const StringName &p_enum, bool p_no_inheritance) const {
PackedStringArray ClassDB::class_get_enum_constants(const StringName &p_class, const StringName &p_enum, bool p_no_inheritance) const {
List<StringName> constants;
::ClassDB::get_enum_constants(p_class, p_enum, &constants, p_no_inheritance);
@ -1435,7 +1435,7 @@ PackedStringArray ClassDB::get_enum_constants(const StringName &p_class, const S
return ret;
}
StringName ClassDB::get_integer_constant_enum(const StringName &p_class, const StringName &p_name, bool p_no_inheritance) const {
StringName ClassDB::class_get_integer_constant_enum(const StringName &p_class, const StringName &p_name, bool p_no_inheritance) const {
return ::ClassDB::get_integer_constant_enum(p_class, p_name, p_no_inheritance);
}
@ -1452,27 +1452,27 @@ void ClassDB::_bind_methods() {
::ClassDB::bind_method(D_METHOD("can_instantiate", "class"), &ClassDB::can_instantiate);
::ClassDB::bind_method(D_METHOD("instantiate", "class"), &ClassDB::instantiate);
::ClassDB::bind_method(D_METHOD("class_has_signal", "class", "signal"), &ClassDB::has_signal);
::ClassDB::bind_method(D_METHOD("class_get_signal", "class", "signal"), &ClassDB::get_signal);
::ClassDB::bind_method(D_METHOD("class_get_signal_list", "class", "no_inheritance"), &ClassDB::get_signal_list, DEFVAL(false));
::ClassDB::bind_method(D_METHOD("class_has_signal", "class", "signal"), &ClassDB::class_has_signal);
::ClassDB::bind_method(D_METHOD("class_get_signal", "class", "signal"), &ClassDB::class_get_signal);
::ClassDB::bind_method(D_METHOD("class_get_signal_list", "class", "no_inheritance"), &ClassDB::class_get_signal_list, DEFVAL(false));
::ClassDB::bind_method(D_METHOD("class_get_property_list", "class", "no_inheritance"), &ClassDB::get_property_list, DEFVAL(false));
::ClassDB::bind_method(D_METHOD("class_get_property", "object", "property"), &ClassDB::get_property);
::ClassDB::bind_method(D_METHOD("class_set_property", "object", "property", "value"), &ClassDB::set_property);
::ClassDB::bind_method(D_METHOD("class_get_property_list", "class", "no_inheritance"), &ClassDB::class_get_property_list, DEFVAL(false));
::ClassDB::bind_method(D_METHOD("class_get_property", "object", "property"), &ClassDB::class_get_property);
::ClassDB::bind_method(D_METHOD("class_set_property", "object", "property", "value"), &ClassDB::class_set_property);
::ClassDB::bind_method(D_METHOD("class_has_method", "class", "method", "no_inheritance"), &ClassDB::has_method, DEFVAL(false));
::ClassDB::bind_method(D_METHOD("class_has_method", "class", "method", "no_inheritance"), &ClassDB::class_has_method, DEFVAL(false));
::ClassDB::bind_method(D_METHOD("class_get_method_list", "class", "no_inheritance"), &ClassDB::get_method_list, DEFVAL(false));
::ClassDB::bind_method(D_METHOD("class_get_method_list", "class", "no_inheritance"), &ClassDB::class_get_method_list, DEFVAL(false));
::ClassDB::bind_method(D_METHOD("class_get_integer_constant_list", "class", "no_inheritance"), &ClassDB::get_integer_constant_list, DEFVAL(false));
::ClassDB::bind_method(D_METHOD("class_get_integer_constant_list", "class", "no_inheritance"), &ClassDB::class_get_integer_constant_list, DEFVAL(false));
::ClassDB::bind_method(D_METHOD("class_has_integer_constant", "class", "name"), &ClassDB::has_integer_constant);
::ClassDB::bind_method(D_METHOD("class_get_integer_constant", "class", "name"), &ClassDB::get_integer_constant);
::ClassDB::bind_method(D_METHOD("class_has_integer_constant", "class", "name"), &ClassDB::class_has_integer_constant);
::ClassDB::bind_method(D_METHOD("class_get_integer_constant", "class", "name"), &ClassDB::class_get_integer_constant);
::ClassDB::bind_method(D_METHOD("class_has_enum", "class", "name", "no_inheritance"), &ClassDB::has_enum, DEFVAL(false));
::ClassDB::bind_method(D_METHOD("class_get_enum_list", "class", "no_inheritance"), &ClassDB::get_enum_list, DEFVAL(false));
::ClassDB::bind_method(D_METHOD("class_get_enum_constants", "class", "enum", "no_inheritance"), &ClassDB::get_enum_constants, DEFVAL(false));
::ClassDB::bind_method(D_METHOD("class_get_integer_constant_enum", "class", "name", "no_inheritance"), &ClassDB::get_integer_constant_enum, DEFVAL(false));
::ClassDB::bind_method(D_METHOD("class_has_enum", "class", "name", "no_inheritance"), &ClassDB::class_has_enum, DEFVAL(false));
::ClassDB::bind_method(D_METHOD("class_get_enum_list", "class", "no_inheritance"), &ClassDB::class_get_enum_list, DEFVAL(false));
::ClassDB::bind_method(D_METHOD("class_get_enum_constants", "class", "enum", "no_inheritance"), &ClassDB::class_get_enum_constants, DEFVAL(false));
::ClassDB::bind_method(D_METHOD("class_get_integer_constant_enum", "class", "name", "no_inheritance"), &ClassDB::class_get_integer_constant_enum, DEFVAL(false));
::ClassDB::bind_method(D_METHOD("is_class_enabled", "class"), &ClassDB::is_class_enabled);
}

30
core/core_bind.h
View File

@ -424,26 +424,26 @@ public:
bool can_instantiate(const StringName &p_class) const;
Variant instantiate(const StringName &p_class) const;
bool has_signal(StringName p_class, StringName p_signal) const;
Dictionary get_signal(StringName p_class, StringName p_signal) const;
TypedArray<Dictionary> get_signal_list(StringName p_class, bool p_no_inheritance = false) const;
bool class_has_signal(StringName p_class, StringName p_signal) const;
Dictionary class_get_signal(StringName p_class, StringName p_signal) const;
TypedArray<Dictionary> class_get_signal_list(StringName p_class, bool p_no_inheritance = false) const;
TypedArray<Dictionary> get_property_list(StringName p_class, bool p_no_inheritance = false) const;
Variant get_property(Object *p_object, const StringName &p_property) const;
Error set_property(Object *p_object, const StringName &p_property, const Variant &p_value) const;
TypedArray<Dictionary> class_get_property_list(StringName p_class, bool p_no_inheritance = false) const;
Variant class_get_property(Object *p_object, const StringName &p_property) const;
Error class_set_property(Object *p_object, const StringName &p_property, const Variant &p_value) const;
bool has_method(StringName p_class, StringName p_method, bool p_no_inheritance = false) const;
bool class_has_method(StringName p_class, StringName p_method, bool p_no_inheritance = false) const;
TypedArray<Dictionary> get_method_list(StringName p_class, bool p_no_inheritance = false) const;
TypedArray<Dictionary> class_get_method_list(StringName p_class, bool p_no_inheritance = false) const;
PackedStringArray get_integer_constant_list(const StringName &p_class, bool p_no_inheritance = false) const;
bool has_integer_constant(const StringName &p_class, const StringName &p_name) const;
int64_t get_integer_constant(const StringName &p_class, const StringName &p_name) const;
PackedStringArray class_get_integer_constant_list(const StringName &p_class, bool p_no_inheritance = false) const;
bool class_has_integer_constant(const StringName &p_class, const StringName &p_name) const;
int64_t class_get_integer_constant(const StringName &p_class, const StringName &p_name) const;
bool has_enum(const StringName &p_class, const StringName &p_name, bool p_no_inheritance = false) const;
PackedStringArray get_enum_list(const StringName &p_class, bool p_no_inheritance = false) const;
PackedStringArray get_enum_constants(const StringName &p_class, const StringName &p_enum, bool p_no_inheritance = false) const;
StringName get_integer_constant_enum(const StringName &p_class, const StringName &p_name, bool p_no_inheritance = false) const;
bool class_has_enum(const StringName &p_class, const StringName &p_name, bool p_no_inheritance = false) const;
PackedStringArray class_get_enum_list(const StringName &p_class, bool p_no_inheritance = false) const;
PackedStringArray class_get_enum_constants(const StringName &p_class, const StringName &p_enum, bool p_no_inheritance = false) const;
StringName class_get_integer_constant_enum(const StringName &p_class, const StringName &p_name, bool p_no_inheritance = false) const;
bool is_class_enabled(StringName p_class) const;

41
core/object/object.h
View File

@ -836,14 +836,21 @@ public:
/* SCRIPT */
void set_script(const Variant &p_script);
Variant get_script() const;
// When in debug, some non-virtual functions can be overridden for multithreaded guards.
#ifdef DEBUG_ENABLED
#define MTVIRTUAL virtual
#else
#define MTVIRTUAL
#endif
bool has_meta(const StringName &p_name) const;
void set_meta(const StringName &p_name, const Variant &p_value);
void remove_meta(const StringName &p_name);
Variant get_meta(const StringName &p_name, const Variant &p_default = Variant()) const;
void get_meta_list(List<StringName> *p_list) const;
MTVIRTUAL void set_script(const Variant &p_script);
MTVIRTUAL Variant get_script() const;
MTVIRTUAL bool has_meta(const StringName &p_name) const;
MTVIRTUAL void set_meta(const StringName &p_name, const Variant &p_value);
MTVIRTUAL void remove_meta(const StringName &p_name);
MTVIRTUAL Variant get_meta(const StringName &p_name, const Variant &p_default = Variant()) const;
MTVIRTUAL void get_meta_list(List<StringName> *p_list) const;
#ifdef TOOLS_ENABLED
void set_edited(bool p_edited);
@ -870,17 +877,17 @@ public:
return emit_signalp(p_name, sizeof...(p_args) == 0 ? nullptr : (const Variant **)argptrs, sizeof...(p_args));
}
Error emit_signalp(const StringName &p_name, const Variant **p_args, int p_argcount);
bool has_signal(const StringName &p_name) const;
void get_signal_list(List<MethodInfo> *p_signals) const;
void get_signal_connection_list(const StringName &p_signal, List<Connection> *p_connections) const;
void get_all_signal_connections(List<Connection> *p_connections) const;
int get_persistent_signal_connection_count() const;
void get_signals_connected_to_this(List<Connection> *p_connections) const;
MTVIRTUAL Error emit_signalp(const StringName &p_name, const Variant **p_args, int p_argcount);
MTVIRTUAL bool has_signal(const StringName &p_name) const;
MTVIRTUAL void get_signal_list(List<MethodInfo> *p_signals) const;
MTVIRTUAL void get_signal_connection_list(const StringName &p_signal, List<Connection> *p_connections) const;
MTVIRTUAL void get_all_signal_connections(List<Connection> *p_connections) const;
MTVIRTUAL int get_persistent_signal_connection_count() const;
MTVIRTUAL void get_signals_connected_to_this(List<Connection> *p_connections) const;
Error connect(const StringName &p_signal, const Callable &p_callable, uint32_t p_flags = 0);
void disconnect(const StringName &p_signal, const Callable &p_callable);
bool is_connected(const StringName &p_signal, const Callable &p_callable) const;
MTVIRTUAL Error connect(const StringName &p_signal, const Callable &p_callable, uint32_t p_flags = 0);
MTVIRTUAL void disconnect(const StringName &p_signal, const Callable &p_callable);
MTVIRTUAL bool is_connected(const StringName &p_signal, const Callable &p_callable) const;
template <typename... VarArgs>
void call_deferred(const StringName &p_name, VarArgs... p_args) {

11
core/templates/safe_refcount.h
View File

@ -102,6 +102,17 @@ public:
return value.fetch_sub(p_value, std::memory_order_acq_rel) - p_value;
}
_ALWAYS_INLINE_ T bit_or(T p_value) {
return value.fetch_or(p_value, std::memory_order_acq_rel);
}
_ALWAYS_INLINE_ T bit_and(T p_value) {
return value.fetch_and(p_value, std::memory_order_acq_rel);
}
_ALWAYS_INLINE_ T bit_xor(T p_value) {
return value.fetch_xor(p_value, std::memory_order_acq_rel);
}
// Returns the original value instead of the new one
_ALWAYS_INLINE_ T postsub(T p_value) {
return value.fetch_sub(p_value, std::memory_order_acq_rel);

11
editor/editor_resource_preview.cpp
View File

@ -158,8 +158,6 @@ void EditorResourcePreview::_generate_preview(Ref<ImageTexture> &r_texture, Ref<
}
r_texture = generated;
int small_thumbnail_size = EditorNode::get_singleton()->get_theme_base()->get_theme_icon(SNAME("Object"), SNAME("EditorIcons"))->get_width(); // Kind of a workaround to retrieve the default icon size
if (preview_generators[i]->can_generate_small_preview()) {
Ref<Texture2D> generated_small;
Dictionary d;
@ -340,9 +338,16 @@ void EditorResourcePreview::_thread() {
exited.set();
}
void EditorResourcePreview::_update_thumbnail_sizes() {
if (small_thumbnail_size == -1) {
small_thumbnail_size = EditorNode::get_singleton()->get_theme_base()->get_theme_icon(SNAME("Object"), SNAME("EditorIcons"))->get_width(); // Kind of a workaround to retrieve the default icon size
}
}
void EditorResourcePreview::queue_edited_resource_preview(const Ref<Resource> &p_res, Object *p_receiver, const StringName &p_receiver_func, const Variant &p_userdata) {
ERR_FAIL_NULL(p_receiver);
ERR_FAIL_COND(!p_res.is_valid());
_update_thumbnail_sizes();
{
MutexLock lock(preview_mutex);
@ -370,6 +375,8 @@ void EditorResourcePreview::queue_edited_resource_preview(const Ref<Resource> &p
}
void EditorResourcePreview::queue_resource_preview(const String &p_path, Object *p_receiver, const StringName &p_receiver_func, const Variant &p_userdata) {
_update_thumbnail_sizes();
ERR_FAIL_NULL(p_receiver);
{
MutexLock lock(preview_mutex);

4
editor/editor_resource_preview.h
View File

@ -97,6 +97,8 @@ class EditorResourcePreview : public Node {
void _preview_ready(const String &p_path, int p_hash, const Ref<Texture2D> &p_texture, const Ref<Texture2D> &p_small_texture, ObjectID id, const StringName &p_func, const Variant &p_ud, const Dictionary &p_metadata);
void _generate_preview(Ref<ImageTexture> &r_texture, Ref<ImageTexture> &r_small_texture, const QueueItem &p_item, const String &cache_base, Dictionary &p_metadata);
int small_thumbnail_size = -1;
static void _thread_func(void *ud);
void _thread();
void _iterate();
@ -106,6 +108,8 @@ class EditorResourcePreview : public Node {
Vector<Ref<EditorResourcePreviewGenerator>> preview_generators;
void _update_thumbnail_sizes();
protected:
static void _bind_methods();

61
scene/2d/node_2d.cpp
View File

@ -113,11 +113,11 @@ void Node2D::_edit_set_rect(const Rect2 &p_edit_rect) {
#endif
void Node2D::_update_xform_values() {
position = transform.columns[2];
rotation = transform.get_rotation();
scale = transform.get_scale();
skew = transform.get_skew();
_xform_dirty = false;
position = transform.columns[2];
scale = transform.get_scale();
xform_dirty.clear();
}
void Node2D::_update_transform() {
@ -134,6 +134,7 @@ void Node2D::_update_transform() {
}
void Node2D::reparent(Node *p_parent, bool p_keep_global_transform) {
ERR_THREAD_GUARD;
Transform2D temp = get_global_transform();
Node::reparent(p_parent);
if (p_keep_global_transform) {
@ -142,7 +143,8 @@ void Node2D::reparent(Node *p_parent, bool p_keep_global_transform) {
}
void Node2D::set_position(const Point2 &p_pos) {
if (_xform_dirty) {
ERR_THREAD_GUARD;
if (xform_dirty.is_set()) {
const_cast<Node2D *>(this)->_update_xform_values();
}
position = p_pos;
@ -150,7 +152,8 @@ void Node2D::set_position(const Point2 &p_pos) {
}
void Node2D::set_rotation(real_t p_radians) {
if (_xform_dirty) {
ERR_THREAD_GUARD;
if (xform_dirty.is_set()) {
const_cast<Node2D *>(this)->_update_xform_values();
}
rotation = p_radians;
@ -158,11 +161,13 @@ void Node2D::set_rotation(real_t p_radians) {
}
void Node2D::set_rotation_degrees(real_t p_degrees) {
ERR_THREAD_GUARD;
set_rotation(Math::deg_to_rad(p_degrees));
}
void Node2D::set_skew(real_t p_radians) {
if (_xform_dirty) {
ERR_THREAD_GUARD;
if (xform_dirty.is_set()) {
const_cast<Node2D *>(this)->_update_xform_values();
}
skew = p_radians;
@ -170,7 +175,8 @@ void Node2D::set_skew(real_t p_radians) {
}
void Node2D::set_scale(const Size2 &p_scale) {
if (_xform_dirty) {
ERR_THREAD_GUARD;
if (xform_dirty.is_set()) {
const_cast<Node2D *>(this)->_update_xform_values();
}
scale = p_scale;
@ -185,14 +191,17 @@ void Node2D::set_scale(const Size2 &p_scale) {
}
Point2 Node2D::get_position() const {
if (_xform_dirty) {
ERR_READ_THREAD_GUARD_V(Point2());
if (xform_dirty.is_set()) {
const_cast<Node2D *>(this)->_update_xform_values();
}
return position;
}
real_t Node2D::get_rotation() const {
if (_xform_dirty) {
ERR_READ_THREAD_GUARD_V(0);
if (xform_dirty.is_set()) {
const_cast<Node2D *>(this)->_update_xform_values();
}
@ -200,11 +209,13 @@ real_t Node2D::get_rotation() const {
}
real_t Node2D::get_rotation_degrees() const {
ERR_READ_THREAD_GUARD_V(0);
return Math::rad_to_deg(get_rotation());
}
real_t Node2D::get_skew() const {
if (_xform_dirty) {
ERR_READ_THREAD_GUARD_V(0);
if (xform_dirty.is_set()) {
const_cast<Node2D *>(this)->_update_xform_values();
}
@ -212,7 +223,8 @@ real_t Node2D::get_skew() const {
}
Size2 Node2D::get_scale() const {
if (_xform_dirty) {
ERR_READ_THREAD_GUARD_V(Size2());
if (xform_dirty.is_set()) {
const_cast<Node2D *>(this)->_update_xform_values();
}
@ -220,26 +232,32 @@ Size2 Node2D::get_scale() const {
}
Transform2D Node2D::get_transform() const {
ERR_READ_THREAD_GUARD_V(Transform2D());
return transform;
}
void Node2D::rotate(real_t p_radians) {
ERR_THREAD_GUARD;
set_rotation(get_rotation() + p_radians);
}
void Node2D::translate(const Vector2 &p_amount) {
ERR_THREAD_GUARD;
set_position(get_position() + p_amount);
}
void Node2D::global_translate(const Vector2 &p_amount) {
ERR_THREAD_GUARD;
set_global_position(get_global_position() + p_amount);
}
void Node2D::apply_scale(const Size2 &p_amount) {
ERR_THREAD_GUARD;
set_scale(get_scale() * p_amount);
}
void Node2D::move_x(real_t p_delta, bool p_scaled) {
ERR_THREAD_GUARD;
Transform2D t = get_transform();
Vector2 m = t[0];
if (!p_scaled) {
@ -249,6 +267,7 @@ void Node2D::move_x(real_t p_delta, bool p_scaled) {
}
void Node2D::move_y(real_t p_delta, bool p_scaled) {
ERR_THREAD_GUARD;
Transform2D t = get_transform();
Vector2 m = t[1];
if (!p_scaled) {
@ -258,10 +277,12 @@ void Node2D::move_y(real_t p_delta, bool p_scaled) {
}
Point2 Node2D::get_global_position() const {
ERR_READ_THREAD_GUARD_V(Point2());
return get_global_transform().get_origin();
}
void Node2D::set_global_position(const Point2 &p_pos) {
ERR_THREAD_GUARD;
CanvasItem *parent = get_parent_item();
if (parent) {
Transform2D inv = parent->get_global_transform().affine_inverse();
@ -272,18 +293,22 @@ void Node2D::set_global_position(const Point2 &p_pos) {
}
real_t Node2D::get_global_rotation() const {
ERR_READ_THREAD_GUARD_V(0);
return get_global_transform().get_rotation();
}
real_t Node2D::get_global_rotation_degrees() const {
ERR_READ_THREAD_GUARD_V(0);
return Math::rad_to_deg(get_global_rotation());
}
real_t Node2D::get_global_skew() const {
ERR_READ_THREAD_GUARD_V(0);
return get_global_transform().get_skew();
}
void Node2D::set_global_rotation(const real_t p_radians) {
ERR_THREAD_GUARD;
CanvasItem *parent = get_parent_item();
if (parent) {
Transform2D parent_global_transform = parent->get_global_transform();
@ -297,10 +322,12 @@ void Node2D::set_global_rotation(const real_t p_radians) {
}
void Node2D::set_global_rotation_degrees(const real_t p_degrees) {
ERR_THREAD_GUARD;
set_global_rotation(Math::deg_to_rad(p_degrees));
}
void Node2D::set_global_skew(const real_t p_radians) {
ERR_THREAD_GUARD;
CanvasItem *parent = get_parent_item();
if (parent) {
Transform2D parent_global_transform = parent->get_global_transform();
@ -314,10 +341,12 @@ void Node2D::set_global_skew(const real_t p_radians) {
}
Size2 Node2D::get_global_scale() const {
ERR_READ_THREAD_GUARD_V(Size2());
return get_global_transform().get_scale();
}
void Node2D::set_global_scale(const Size2 &p_scale) {
ERR_THREAD_GUARD;
CanvasItem *parent = get_parent_item();
if (parent) {
Transform2D parent_global_transform = parent->get_global_transform();
@ -331,8 +360,9 @@ void Node2D::set_global_scale(const Size2 &p_scale) {
}
void Node2D::set_transform(const Transform2D &p_transform) {
ERR_THREAD_GUARD;
transform = p_transform;
_xform_dirty = true;
xform_dirty.set();
RenderingServer::get_singleton()->canvas_item_set_transform(get_canvas_item(), transform);
@ -344,6 +374,7 @@ void Node2D::set_transform(const Transform2D &p_transform) {
}
void Node2D::set_global_transform(const Transform2D &p_transform) {
ERR_THREAD_GUARD;
CanvasItem *parent = get_parent_item();
if (parent) {
set_transform(parent->get_global_transform().affine_inverse() * p_transform);
@ -353,6 +384,7 @@ void Node2D::set_global_transform(const Transform2D &p_transform) {
}
Transform2D Node2D::get_relative_transform_to_parent(const Node *p_parent) const {
ERR_READ_THREAD_GUARD_V(Transform2D());
if (p_parent == this) {
return Transform2D();
}
@ -368,22 +400,27 @@ Transform2D Node2D::get_relative_transform_to_parent(const Node *p_parent) const
}
void Node2D::look_at(const Vector2 &p_pos) {
ERR_THREAD_GUARD;
rotate(get_angle_to(p_pos));
}
real_t Node2D::get_angle_to(const Vector2 &p_pos) const {
ERR_READ_THREAD_GUARD_V(0);
return (to_local(p_pos) * get_scale()).angle();
}
Point2 Node2D::to_local(Point2 p_global) const {
ERR_READ_THREAD_GUARD_V(Point2());
return get_global_transform().affine_inverse().xform(p_global);
}
Point2 Node2D::to_global(Point2 p_local) const {
ERR_READ_THREAD_GUARD_V(Point2());
return get_global_transform().xform(p_local);
}
void Node2D::_notification(int p_notification) {
ERR_THREAD_GUARD;
switch (p_notification) {
case NOTIFICATION_ENTER_TREE: {
if (get_viewport()) {

3
scene/2d/node_2d.h
View File

@ -36,6 +36,7 @@
class Node2D : public CanvasItem {
GDCLASS(Node2D, CanvasItem);
SafeFlag xform_dirty;
Point2 position;
real_t rotation = 0.0;
Size2 scale = Vector2(1, 1);
@ -43,8 +44,6 @@ class Node2D : public CanvasItem {
Transform2D transform;
bool _xform_dirty = false;
void _update_transform();
void _update_xform_values();

169
scene/3d/node_3d.cpp
View File

@ -86,10 +86,8 @@ void Node3D::_notify_dirty() {
void Node3D::_update_local_transform() const {
// This function is called when the local transform (data.local_transform) is dirty and the right value is contained in the Euler rotation and scale.
data.local_transform.basis.set_euler_scale(data.euler_rotation, data.scale, data.euler_rotation_order);
data.dirty &= ~DIRTY_LOCAL_TRANSFORM;
data.dirty.bit_and(~DIRTY_LOCAL_TRANSFORM);
}
void Node3D::_update_rotation_and_scale() const {
@ -97,8 +95,13 @@ void Node3D::_update_rotation_and_scale() const {
data.scale = data.local_transform.basis.get_scale();
data.euler_rotation = data.local_transform.basis.get_euler_normalized(data.euler_rotation_order);
data.dirty.bit_and(~DIRTY_EULER_ROTATION_AND_SCALE);
}
data.dirty &= ~DIRTY_EULER_ROTATION_AND_SCALE;
void Node3D::_propagate_transform_changed_deferred() {
if (is_inside_tree() && !xform_change.in_list()) {
get_tree()->xform_change_list.add(&xform_change);
}
}
void Node3D::_propagate_transform_changed(Node3D *p_origin) {
@ -106,8 +109,6 @@ void Node3D::_propagate_transform_changed(Node3D *p_origin) {
return;
}
data.children_lock++;
for (Node3D *&E : data.children) {
if (E->data.top_level_active) {
continue; //don't propagate to a top_level
@ -119,14 +120,19 @@ void Node3D::_propagate_transform_changed(Node3D *p_origin) {
#else
if (data.notify_transform && !data.ignore_notification && !xform_change.in_list()) {
#endif
get_tree()->xform_change_list.add(&xform_change);
if (likely(is_accessible_from_caller_thread())) {
get_tree()->xform_change_list.add(&xform_change);
} else {
// This should very rarely happen, but if it does at least make sure the notification is received eventually.
MessageQueue::get_singleton()->push_callable(callable_mp(this, &Node3D::_propagate_transform_changed_deferred));
}
}
data.dirty |= DIRTY_GLOBAL_TRANSFORM;
data.children_lock--;
data.dirty.bit_or(DIRTY_GLOBAL_TRANSFORM);
}
void Node3D::_notification(int p_what) {
ERR_THREAD_GUARD;
switch (p_what) {
case NOTIFICATION_ENTER_TREE: {
ERR_FAIL_COND(!get_tree());
@ -145,12 +151,12 @@ void Node3D::_notification(int p_what) {
if (data.top_level && !Engine::get_singleton()->is_editor_hint()) {
if (data.parent) {
data.local_transform = data.parent->get_global_transform() * get_transform();
data.dirty = DIRTY_EULER_ROTATION_AND_SCALE; // As local transform was updated, rot/scale should be dirty.
data.dirty.set(DIRTY_EULER_ROTATION_AND_SCALE); // As local transform was updated, rot/scale should be dirty.
}
data.top_level_active = true;
}
data.dirty |= DIRTY_GLOBAL_TRANSFORM; // Global is always dirty upon entering a scene.
data.dirty.bit_or(DIRTY_GLOBAL_TRANSFORM); // Global is always dirty upon entering a scene.
_notify_dirty();
notification(NOTIFICATION_ENTER_WORLD);
@ -217,19 +223,23 @@ void Node3D::_notification(int p_what) {
}
void Node3D::set_basis(const Basis &p_basis) {
ERR_THREAD_GUARD;
set_transform(Transform3D(p_basis, data.local_transform.origin));
}
void Node3D::set_quaternion(const Quaternion &p_quaternion) {
if (data.dirty & DIRTY_EULER_ROTATION_AND_SCALE) {
ERR_THREAD_GUARD;
if (data.dirty.get() & DIRTY_EULER_ROTATION_AND_SCALE) {
// We need the scale part, so if these are dirty, update it
data.scale = data.local_transform.basis.get_scale();
data.dirty &= ~DIRTY_EULER_ROTATION_AND_SCALE;
data.dirty.bit_and(~DIRTY_EULER_ROTATION_AND_SCALE);
}
data.local_transform.basis = Basis(p_quaternion, data.scale);
// Rotscale should not be marked dirty because that would cause precision loss issues with the scale. Instead reconstruct rotation now.
data.euler_rotation = data.local_transform.basis.get_euler_normalized(data.euler_rotation_order);
data.dirty = DIRTY_NONE;
data.dirty.set(DIRTY_NONE);
_propagate_transform_changed(this);
if (data.notify_local_transform) {
@ -238,38 +248,45 @@ void Node3D::set_quaternion(const Quaternion &p_quaternion) {
}
Vector3 Node3D::get_global_position() const {
ERR_READ_THREAD_GUARD_V(Vector3());
return get_global_transform().get_origin();
}
void Node3D::set_global_position(const Vector3 &p_position) {
ERR_THREAD_GUARD;
Transform3D transform = get_global_transform();
transform.set_origin(p_position);
set_global_transform(transform);
}
Vector3 Node3D::get_global_rotation() const {
ERR_READ_THREAD_GUARD_V(Vector3());
return get_global_transform().get_basis().get_euler();
}
Vector3 Node3D::get_global_rotation_degrees() const {
ERR_READ_THREAD_GUARD_V(Vector3());
Vector3 radians = get_global_rotation();
return Vector3(Math::rad_to_deg(radians.x), Math::rad_to_deg(radians.y), Math::rad_to_deg(radians.z));
}
void Node3D::set_global_rotation(const Vector3 &p_euler_rad) {
ERR_THREAD_GUARD;
Transform3D transform = get_global_transform();
transform.basis = Basis::from_euler(p_euler_rad);
set_global_transform(transform);
}
void Node3D::set_global_rotation_degrees(const Vector3 &p_euler_degrees) {
ERR_THREAD_GUARD;
Vector3 radians(Math::deg_to_rad(p_euler_degrees.x), Math::deg_to_rad(p_euler_degrees.y), Math::deg_to_rad(p_euler_degrees.z));
set_global_rotation(radians);
}
void Node3D::set_transform(const Transform3D &p_transform) {
ERR_THREAD_GUARD;
data.local_transform = p_transform;
data.dirty = DIRTY_EULER_ROTATION_AND_SCALE; // Make rot/scale dirty.
data.dirty.set(DIRTY_EULER_ROTATION_AND_SCALE); // Make rot/scale dirty.
_propagate_transform_changed(this);
if (data.notify_local_transform) {
@ -278,18 +295,16 @@ void Node3D::set_transform(const Transform3D &p_transform) {
}
Basis Node3D::get_basis() const {
ERR_READ_THREAD_GUARD_V(Basis());
return get_transform().basis;
}
Quaternion Node3D::get_quaternion() const {
if (data.dirty & DIRTY_LOCAL_TRANSFORM) {
_update_local_transform();
}
return data.local_transform.basis.get_rotation_quaternion();
return get_transform().basis.get_rotation_quaternion();
}
void Node3D::set_global_transform(const Transform3D &p_transform) {
ERR_THREAD_GUARD;
Transform3D xform = (data.parent && !data.top_level_active)
? data.parent->get_global_transform().affine_inverse() * p_transform
: p_transform;
@ -298,31 +313,42 @@ void Node3D::set_global_transform(const Transform3D &p_transform) {
}
Transform3D Node3D::get_transform() const {
if (data.dirty & DIRTY_LOCAL_TRANSFORM) {
ERR_READ_THREAD_GUARD_V(Transform3D());
if (data.dirty.get() & DIRTY_LOCAL_TRANSFORM) {
// This update can happen if needed over multiple threads.
_update_local_transform();
}
return data.local_transform;
}
Transform3D Node3D::get_global_transform() const {
ERR_FAIL_COND_V(!is_inside_tree(), Transform3D());
if (data.dirty & DIRTY_GLOBAL_TRANSFORM) {
if (data.dirty & DIRTY_LOCAL_TRANSFORM) {
_update_local_transform();
/* Due to how threads work at scene level, while this global transform won't be able to be changed from outside a thread,
* it is possible that multiple threads can access it while it's dirty from previous work. Due to this, we must ensure that
* the dirty/update process is thread safe by utilizing atomic copies.
*/
uint32_t dirty = data.dirty.get();
if (dirty & DIRTY_GLOBAL_TRANSFORM) {
if (dirty & DIRTY_LOCAL_TRANSFORM) {
_update_local_transform(); // Update local transform atomically.
}
Transform3D new_global;
if (data.parent && !data.top_level_active) {
data.global_transform = data.parent->get_global_transform() * data.local_transform;
new_global = data.parent->get_global_transform() * data.local_transform;
} else {
data.global_transform = data.local_transform;
new_global = data.local_transform;
}
if (data.disable_scale) {
data.global_transform.basis.orthonormalize();
new_global.basis.orthonormalize();
}
data.dirty &= ~DIRTY_GLOBAL_TRANSFORM;
data.global_transform = new_global;
data.dirty.bit_and(~DIRTY_GLOBAL_TRANSFORM);
}
return data.global_transform;
@ -339,6 +365,7 @@ Transform3D Node3D::get_local_gizmo_transform() const {
#endif
Node3D *Node3D::get_parent_node_3d() const {
ERR_READ_THREAD_GUARD_V(nullptr); // This can't be changed on threads anyway.
if (data.top_level) {
return nullptr;
}
@ -347,6 +374,7 @@ Node3D *Node3D::get_parent_node_3d() const {
}
Transform3D Node3D::get_relative_transform(const Node *p_parent) const {
ERR_READ_THREAD_GUARD_V(Transform3D());
if (p_parent == this) {
return Transform3D();
}
@ -361,6 +389,7 @@ Transform3D Node3D::get_relative_transform(const Node *p_parent) const {
}
void Node3D::set_position(const Vector3 &p_position) {
ERR_THREAD_GUARD;
data.local_transform.origin = p_position;
_propagate_transform_changed(this);
if (data.notify_local_transform) {
@ -369,19 +398,20 @@ void Node3D::set_position(const Vector3 &p_position) {
}
void Node3D::set_rotation_edit_mode(RotationEditMode p_mode) {
ERR_THREAD_GUARD;
if (data.rotation_edit_mode == p_mode) {
return;
}
bool transform_changed = false;
if (data.rotation_edit_mode == ROTATION_EDIT_MODE_BASIS && !(data.dirty & DIRTY_LOCAL_TRANSFORM)) {
if (data.rotation_edit_mode == ROTATION_EDIT_MODE_BASIS && !(data.dirty.get() & DIRTY_LOCAL_TRANSFORM)) {
data.local_transform.orthogonalize();
transform_changed = true;
}
data.rotation_edit_mode = p_mode;
if (p_mode == ROTATION_EDIT_MODE_EULER && (data.dirty & DIRTY_EULER_ROTATION_AND_SCALE)) {
if (p_mode == ROTATION_EDIT_MODE_EULER && (data.dirty.get() & DIRTY_EULER_ROTATION_AND_SCALE)) {
// If going to Euler mode, ensure that vectors are _not_ dirty, else the retrieved value may be wrong.
// Otherwise keep what is there, so switching back and forth between modes does not break the vectors.
@ -399,10 +429,12 @@ void Node3D::set_rotation_edit_mode(RotationEditMode p_mode) {
}
Node3D::RotationEditMode Node3D::get_rotation_edit_mode() const {
ERR_READ_THREAD_GUARD_V(ROTATION_EDIT_MODE_EULER);
return data.rotation_edit_mode;
}
void Node3D::set_rotation_order(EulerOrder p_order) {
ERR_THREAD_GUARD;
if (data.euler_rotation_order == p_order) {
return;
}
@ -410,13 +442,13 @@ void Node3D::set_rotation_order(EulerOrder p_order) {
ERR_FAIL_INDEX(int32_t(p_order), 6);
bool transform_changed = false;
if (data.dirty & DIRTY_EULER_ROTATION_AND_SCALE) {
if (data.dirty.get() & DIRTY_EULER_ROTATION_AND_SCALE) {
_update_rotation_and_scale();
} else if (data.dirty & DIRTY_LOCAL_TRANSFORM) {
} else if (data.dirty.get() & DIRTY_LOCAL_TRANSFORM) {
data.euler_rotation = Basis::from_euler(data.euler_rotation, data.euler_rotation_order).get_euler_normalized(p_order);
transform_changed = true;
} else {
data.dirty |= DIRTY_LOCAL_TRANSFORM;
data.dirty.bit_or(DIRTY_LOCAL_TRANSFORM);
transform_changed = true;
}
@ -432,18 +464,20 @@ void Node3D::set_rotation_order(EulerOrder p_order) {
}
EulerOrder Node3D::get_rotation_order() const {
ERR_READ_THREAD_GUARD_V(EulerOrder::XYZ);
return data.euler_rotation_order;
}
void Node3D::set_rotation(const Vector3 &p_euler_rad) {
if (data.dirty & DIRTY_EULER_ROTATION_AND_SCALE) {
ERR_THREAD_GUARD;
if (data.dirty.get() & DIRTY_EULER_ROTATION_AND_SCALE) {
// Update scale only if rotation and scale are dirty, as rotation will be overridden.
data.scale = data.local_transform.basis.get_scale();
data.dirty &= ~DIRTY_EULER_ROTATION_AND_SCALE;
data.dirty.bit_and(~DIRTY_EULER_ROTATION_AND_SCALE);
}
data.euler_rotation = p_euler_rad;
data.dirty = DIRTY_LOCAL_TRANSFORM;
data.dirty.set(DIRTY_LOCAL_TRANSFORM);
_propagate_transform_changed(this);
if (data.notify_local_transform) {
notification(NOTIFICATION_LOCAL_TRANSFORM_CHANGED);
@ -451,19 +485,21 @@ void Node3D::set_rotation(const Vector3 &p_euler_rad) {
}
void Node3D::set_rotation_degrees(const Vector3 &p_euler_degrees) {
ERR_THREAD_GUARD;
Vector3 radians(Math::deg_to_rad(p_euler_degrees.x), Math::deg_to_rad(p_euler_degrees.y), Math::deg_to_rad(p_euler_degrees.z));
set_rotation(radians);
}
void Node3D::set_scale(const Vector3 &p_scale) {
if (data.dirty & DIRTY_EULER_ROTATION_AND_SCALE) {
ERR_THREAD_GUARD;
if (data.dirty.get() & DIRTY_EULER_ROTATION_AND_SCALE) {
// Update rotation only if rotation and scale are dirty, as scale will be overridden.
data.euler_rotation = data.local_transform.basis.get_euler_normalized(data.euler_rotation_order);
data.dirty &= ~DIRTY_EULER_ROTATION_AND_SCALE;
data.dirty.bit_and(~DIRTY_EULER_ROTATION_AND_SCALE);
}
data.scale = p_scale;
data.dirty = DIRTY_LOCAL_TRANSFORM;
data.dirty.set(DIRTY_LOCAL_TRANSFORM);
_propagate_transform_changed(this);
if (data.notify_local_transform) {
notification(NOTIFICATION_LOCAL_TRANSFORM_CHANGED);
@ -471,11 +507,13 @@ void Node3D::set_scale(const Vector3 &p_scale) {
}
Vector3 Node3D::get_position() const {
ERR_READ_THREAD_GUARD_V(Vector3());
return data.local_transform.origin;
}
Vector3 Node3D::get_rotation() const {
if (data.dirty & DIRTY_EULER_ROTATION_AND_SCALE) {
ERR_READ_THREAD_GUARD_V(Vector3());
if (data.dirty.get() & DIRTY_EULER_ROTATION_AND_SCALE) {
_update_rotation_and_scale();
}
@ -483,12 +521,14 @@ Vector3 Node3D::get_rotation() const {
}
Vector3 Node3D::get_rotation_degrees() const {
ERR_READ_THREAD_GUARD_V(Vector3());
Vector3 radians = get_rotation();
return Vector3(Math::rad_to_deg(radians.x), Math::rad_to_deg(radians.y), Math::rad_to_deg(radians.z));
}
Vector3 Node3D::get_scale() const {
if (data.dirty & DIRTY_EULER_ROTATION_AND_SCALE) {
ERR_READ_THREAD_GUARD_V(Vector3());
if (data.dirty.get() & DIRTY_EULER_ROTATION_AND_SCALE) {
_update_rotation_and_scale();
}
@ -496,6 +536,7 @@ Vector3 Node3D::get_scale() const {
}
void Node3D::update_gizmos() {
ERR_THREAD_GUARD;
#ifdef TOOLS_ENABLED
if (!is_inside_world()) {
return;
@ -514,6 +555,7 @@ void Node3D::update_gizmos() {
}
void Node3D::set_subgizmo_selection(Ref<Node3DGizmo> p_gizmo, int p_id, Transform3D p_transform) {
ERR_THREAD_GUARD;
#ifdef TOOLS_ENABLED
if (!is_inside_world()) {
return;
@ -526,6 +568,7 @@ void Node3D::set_subgizmo_selection(Ref<Node3DGizmo> p_gizmo, int p_id, Transfor
}
void Node3D::clear_subgizmo_selection() {
ERR_THREAD_GUARD;
#ifdef TOOLS_ENABLED
if (!is_inside_world()) {
return;
@ -542,6 +585,7 @@ void Node3D::clear_subgizmo_selection() {
}
void Node3D::add_gizmo(Ref<Node3DGizmo> p_gizmo) {
ERR_THREAD_GUARD;
#ifdef TOOLS_ENABLED
if (data.gizmos_disabled || p_gizmo.is_null()) {
return;
@ -559,6 +603,7 @@ void Node3D::add_gizmo(Ref<Node3DGizmo> p_gizmo) {
}
void Node3D::remove_gizmo(Ref<Node3DGizmo> p_gizmo) {
ERR_THREAD_GUARD;
#ifdef TOOLS_ENABLED
int idx = data.gizmos.find(p_gizmo);
if (idx != -1) {
@ -569,6 +614,7 @@ void Node3D::remove_gizmo(Ref<Node3DGizmo> p_gizmo) {
}
void Node3D::clear_gizmos() {
ERR_THREAD_GUARD;
#ifdef TOOLS_ENABLED
for (int i = 0; i < data.gizmos.size(); i++) {
data.gizmos.write[i]->free();
@ -578,6 +624,7 @@ void Node3D::clear_gizmos() {
}
TypedArray<Node3DGizmo> Node3D::get_gizmos_bind() const {
ERR_THREAD_GUARD_V(TypedArray<Node3DGizmo>());
TypedArray<Node3DGizmo> ret;
#ifdef TOOLS_ENABLED
@ -590,6 +637,7 @@ TypedArray<Node3DGizmo> Node3D::get_gizmos_bind() const {
}
Vector<Ref<Node3DGizmo>> Node3D::get_gizmos() const {
ERR_THREAD_GUARD_V(Vector<Ref<Node3DGizmo>>());
#ifdef TOOLS_ENABLED
return data.gizmos;
#else
@ -615,6 +663,7 @@ void Node3D::_update_gizmos() {
}
void Node3D::set_disable_gizmos(bool p_enabled) {
ERR_THREAD_GUARD;
#ifdef TOOLS_ENABLED
data.gizmos_disabled = p_enabled;
if (!p_enabled) {
@ -624,6 +673,7 @@ void Node3D::set_disable_gizmos(bool p_enabled) {
}
void Node3D::reparent(Node *p_parent, bool p_keep_global_transform) {
ERR_THREAD_GUARD;
Transform3D temp = get_global_transform();
Node::reparent(p_parent);
if (p_keep_global_transform) {
@ -632,14 +682,17 @@ void Node3D::reparent(Node *p_parent, bool p_keep_global_transform) {
}
void Node3D::set_disable_scale(bool p_enabled) {
ERR_THREAD_GUARD;
data.disable_scale = p_enabled;
}
bool Node3D::is_scale_disabled() const {
ERR_READ_THREAD_GUARD_V(false);
return data.disable_scale;
}
void Node3D::set_as_top_level(bool p_enabled) {
ERR_THREAD_GUARD;
if (data.top_level == p_enabled) {
return;
}
@ -658,10 +711,12 @@ void Node3D::set_as_top_level(bool p_enabled) {
}
bool Node3D::is_set_as_top_level() const {
ERR_READ_THREAD_GUARD_V(false);
return data.top_level;
}
Ref<World3D> Node3D::get_world_3d() const {
ERR_READ_THREAD_GUARD_V(Ref<World3D>()); // World3D can only be set from main thread, so it's safe to obtain on threads.
ERR_FAIL_COND_V(!is_inside_world(), Ref<World3D>());
ERR_FAIL_COND_V(!data.viewport, Ref<World3D>());
@ -688,14 +743,17 @@ void Node3D::_propagate_visibility_changed() {
}
void Node3D::show() {
ERR_MAIN_THREAD_GUARD;
set_visible(true);
}
void Node3D::hide() {
ERR_MAIN_THREAD_GUARD;
set_visible(false);
}
void Node3D::set_visible(bool p_visible) {
ERR_MAIN_THREAD_GUARD;
if (data.visible == p_visible) {
return;
}
@ -709,10 +767,12 @@ void Node3D::set_visible(bool p_visible) {
}
bool Node3D::is_visible() const {
ERR_READ_THREAD_GUARD_V(false);
return data.visible;
}
bool Node3D::is_visible_in_tree() const {
ERR_READ_THREAD_GUARD_V(false); // Since visibility can only be changed from main thread, this is safe to call.
const Node3D *s = this;
while (s) {
@ -726,42 +786,49 @@ bool Node3D::is_visible_in_tree() const {
}
void Node3D::rotate_object_local(const Vector3 &p_axis, real_t p_angle) {
ERR_THREAD_GUARD;
Transform3D t = get_transform();
t.basis.rotate_local(p_axis, p_angle);
set_transform(t);
}
void Node3D::rotate(const Vector3 &p_axis, real_t p_angle) {
ERR_THREAD_GUARD;
Transform3D t = get_transform();
t.basis.rotate(p_axis, p_angle);
set_transform(t);
}
void Node3D::rotate_x(real_t p_angle) {
ERR_THREAD_GUARD;
Transform3D t = get_transform();
t.basis.rotate(Vector3(1, 0, 0), p_angle);
set_transform(t);
}
void Node3D::rotate_y(real_t p_angle) {
ERR_THREAD_GUARD;
Transform3D t = get_transform();
t.basis.rotate(Vector3(0, 1, 0), p_angle);
set_transform(t);
}
void Node3D::rotate_z(real_t p_angle) {
ERR_THREAD_GUARD;
Transform3D t = get_transform();
t.basis.rotate(Vector3(0, 0, 1), p_angle);
set_transform(t);
}
void Node3D::translate(const Vector3 &p_offset) {
ERR_THREAD_GUARD;
Transform3D t = get_transform();
t.translate_local(p_offset);
set_transform(t);
}
void Node3D::translate_object_local(const Vector3 &p_offset) {
ERR_THREAD_GUARD;
Transform3D t = get_transform();
Transform3D s;
@ -770,52 +837,61 @@ void Node3D::translate_object_local(const Vector3 &p_offset) {
}
void Node3D::scale(const Vector3 &p_ratio) {
ERR_THREAD_GUARD;
Transform3D t = get_transform();
t.basis.scale(p_ratio);
set_transform(t);
}
void Node3D::scale_object_local(const Vector3 &p_scale) {
ERR_THREAD_GUARD;
Transform3D t = get_transform();
t.basis.scale_local(p_scale);
set_transform(t);
}
void Node3D::global_rotate(const Vector3 &p_axis, real_t p_angle) {
ERR_THREAD_GUARD;
Transform3D t = get_global_transform();
t.basis.rotate(p_axis, p_angle);
set_global_transform(t);
}
void Node3D::global_scale(const Vector3 &p_scale) {
ERR_THREAD_GUARD;
Transform3D t = get_global_transform();
t.basis.scale(p_scale);
set_global_transform(t);
}
void Node3D::global_translate(const Vector3 &p_offset) {
ERR_THREAD_GUARD;
Transform3D t = get_global_transform();
t.origin += p_offset;
set_global_transform(t);
}
void Node3D::orthonormalize() {
ERR_THREAD_GUARD;
Transform3D t = get_transform();
t.orthonormalize();
set_transform(t);
}
void Node3D::set_identity() {
ERR_THREAD_GUARD;
set_transform(Transform3D());
}
void Node3D::look_at(const Vector3 &p_target, const Vector3 &p_up) {
ERR_THREAD_GUARD;
ERR_FAIL_COND_MSG(!is_inside_tree(), "Node not inside tree. Use look_at_from_position() instead.");
Vector3 origin = get_global_transform().origin;
look_at_from_position(origin, p_target, p_up);
}
void Node3D::look_at_from_position(const Vector3 &p_pos, const Vector3 &p_target, const Vector3 &p_up) {
ERR_THREAD_GUARD;
ERR_FAIL_COND_MSG(p_pos.is_equal_approx(p_target), "Node origin and target are in the same position, look_at() failed.");
ERR_FAIL_COND_MSG(p_up.is_zero_approx(), "The up vector can't be zero, look_at() failed.");
ERR_FAIL_COND_MSG(p_up.cross(p_target - p_pos).is_zero_approx(), "Up vector and direction between node origin and target are aligned, look_at() failed.");
@ -827,30 +903,37 @@ void Node3D::look_at_from_position(const Vector3 &p_pos, const Vector3 &p_target
}
Vector3 Node3D::to_local(Vector3 p_global) const {
ERR_READ_THREAD_GUARD_V(Vector3());
return get_global_transform().affine_inverse().xform(p_global);
}
Vector3 Node3D::to_global(Vector3 p_local) const {
ERR_READ_THREAD_GUARD_V(Vector3());
return get_global_transform().xform(p_local);
}
void Node3D::set_notify_transform(bool p_enabled) {
ERR_THREAD_GUARD;
data.notify_transform = p_enabled;
}
bool Node3D::is_transform_notification_enabled() const {
ERR_READ_THREAD_GUARD_V(false);
return data.notify_transform;
}
void Node3D::set_notify_local_transform(bool p_enabled) {
ERR_THREAD_GUARD;
data.notify_local_transform = p_enabled;
}
bool Node3D::is_local_transform_notification_enabled() const {
ERR_READ_THREAD_GUARD_V(false);
return data.notify_local_transform;
}
void Node3D::force_update_transform() {
ERR_THREAD_GUARD;
ERR_FAIL_COND(!is_inside_tree());
if (!xform_change.in_list()) {
return; //nothing to update
@ -894,6 +977,7 @@ void Node3D::_update_visibility_parent(bool p_update_root) {
}
void Node3D::set_visibility_parent(const NodePath &p_path) {
ERR_MAIN_THREAD_GUARD;
visibility_parent_path = p_path;
if (is_inside_tree()) {
_update_visibility_parent(true);
@ -901,6 +985,7 @@ void Node3D::set_visibility_parent(const NodePath &p_path) {
}
NodePath Node3D::get_visibility_parent() const {
ERR_READ_THREAD_GUARD_V(NodePath());
return visibility_parent_path;
}

5
scene/3d/node_3d.h
View File

@ -88,6 +88,7 @@ private:
mutable SelfList<Node> xform_change;
// This Data struct is to avoid namespace pollution in derived classes.
struct Data {
mutable Transform3D global_transform;
mutable Transform3D local_transform;
@ -96,7 +97,7 @@ private:
mutable Vector3 scale = Vector3(1, 1, 1);
mutable RotationEditMode rotation_edit_mode = ROTATION_EDIT_MODE_EULER;
mutable int dirty = DIRTY_NONE;
mutable SafeNumeric<uint32_t> dirty;
Viewport *viewport = nullptr;
@ -106,7 +107,6 @@ private:
RID visibility_parent;
int children_lock = 0;
Node3D *parent = nullptr;
List<Node3D *> children;
List<Node3D *>::Element *C = nullptr;
@ -137,6 +137,7 @@ private:
void _propagate_visibility_parent();
void _update_visibility_parent(bool p_update_root);
void _propagate_transform_changed_deferred();
protected:
_FORCE_INLINE_ void set_ignore_transform_notification(bool p_ignore) { data.ignore_notification = p_ignore; }

157
scene/gui/control.cpp
View File

File diff suppressed because it is too large Load Diff

134
scene/main/canvas_item.cpp
View File

@ -56,6 +56,7 @@ Transform2D CanvasItem::_edit_get_transform() const {
#endif
bool CanvasItem::is_visible_in_tree() const {
ERR_READ_THREAD_GUARD_V(false);
return visible && parent_visible_in_tree;
}
@ -69,6 +70,7 @@ void CanvasItem::_propagate_visibility_changed(bool p_parent_visible_in_tree) {
}
void CanvasItem::set_visible(bool p_visible) {
ERR_MAIN_THREAD_GUARD;
if (visible == p_visible) {
return;
}
@ -105,14 +107,17 @@ void CanvasItem::_handle_visibility_change(bool p_visible) {
}
void CanvasItem::show() {
ERR_MAIN_THREAD_GUARD;
set_visible(true);
}
void CanvasItem::hide() {
ERR_MAIN_THREAD_GUARD;
set_visible(false);
}
bool CanvasItem::is_visible() const {
ERR_READ_THREAD_GUARD_V(false);
return visible;
}
@ -143,10 +148,11 @@ void CanvasItem::_redraw_callback() {
}
void CanvasItem::_invalidate_global_transform() {
global_invalid = true;
global_invalid.set();
}
Transform2D CanvasItem::get_global_transform_with_canvas() const {
ERR_READ_THREAD_GUARD_V(Transform2D());
if (canvas_layer) {
return canvas_layer->get_final_transform() * get_global_transform();
} else if (is_inside_tree()) {
@ -157,20 +163,26 @@ Transform2D CanvasItem::get_global_transform_with_canvas() const {
}
Transform2D CanvasItem::get_screen_transform() const {
ERR_READ_THREAD_GUARD_V(Transform2D());
ERR_FAIL_COND_V(!is_inside_tree(), Transform2D());
return get_viewport()->get_popup_base_transform() * get_global_transform_with_canvas();
}
Transform2D CanvasItem::get_global_transform() const {
if (global_invalid) {
ERR_READ_THREAD_GUARD_V(Transform2D());
if (global_invalid.is_set()) {
// This code can enter multiple times from threads if dirty, this is expected.
const CanvasItem *pi = get_parent_item();
Transform2D new_global;
if (pi) {
global_transform = pi->get_global_transform() * get_transform();
new_global = pi->get_global_transform() * get_transform();
} else {
global_transform = get_transform();
new_global = get_transform();
}
global_invalid = false;
global_transform = new_global;
global_invalid.clear();
}
return global_transform;
@ -253,6 +265,8 @@ void CanvasItem::_exit_canvas() {
}
void CanvasItem::_notification(int p_what) {
ERR_MAIN_THREAD_GUARD;
switch (p_what) {
case NOTIFICATION_ENTER_TREE: {
ERR_FAIL_COND(!is_inside_tree());
@ -294,7 +308,7 @@ void CanvasItem::_notification(int p_what) {
}
}
global_invalid = true;
global_invalid.set();
_enter_canvas();
RenderingServer::get_singleton()->canvas_item_set_visible(canvas_item, is_visible_in_tree()); // The visibility of the parent may change.
@ -327,7 +341,7 @@ void CanvasItem::_notification(int p_what) {
window->disconnect(SceneStringNames::get_singleton()->visibility_changed, callable_mp(this, &CanvasItem::_window_visibility_changed));
window = nullptr;
}
global_invalid = true;
global_invalid.set();
parent_visible_in_tree = false;
if (get_viewport()) {
@ -346,6 +360,8 @@ void CanvasItem::_notification(int p_what) {
}
void CanvasItem::update_draw_order() {
ERR_MAIN_THREAD_GUARD;
if (!is_inside_tree()) {
return;
}
@ -363,6 +379,7 @@ void CanvasItem::_window_visibility_changed() {
}
void CanvasItem::queue_redraw() {
ERR_THREAD_GUARD; // Calling from thread is safe.
if (!is_inside_tree()) {
return;
}
@ -376,6 +393,7 @@ void CanvasItem::queue_redraw() {
}
void CanvasItem::move_to_front() {
ERR_MAIN_THREAD_GUARD;
if (!get_parent()) {
return;
}
@ -383,6 +401,7 @@ void CanvasItem::move_to_front() {
}
void CanvasItem::set_modulate(const Color &p_modulate) {
ERR_THREAD_GUARD;
if (modulate == p_modulate) {
return;
}
@ -392,10 +411,12 @@ void CanvasItem::set_modulate(const Color &p_modulate) {
}
Color CanvasItem::get_modulate() const {
ERR_READ_THREAD_GUARD_V(Color());
return modulate;
}
Color CanvasItem::get_modulate_in_tree() const {
ERR_READ_THREAD_GUARD_V(Color());
Color final_modulate = modulate;
CanvasItem *parent_item = get_parent_item();
while (parent_item) {
@ -406,6 +427,7 @@ Color CanvasItem::get_modulate_in_tree() const {
}
void CanvasItem::set_as_top_level(bool p_top_level) {
ERR_MAIN_THREAD_GUARD;
if (top_level == p_top_level) {
return;
}
@ -445,6 +467,7 @@ bool CanvasItem::is_set_as_top_level() const {
}
CanvasItem *CanvasItem::get_parent_item() const {
ERR_READ_THREAD_GUARD_V(nullptr);
if (top_level) {
return nullptr;
}
@ -453,6 +476,7 @@ CanvasItem *CanvasItem::get_parent_item() const {
}
void CanvasItem::set_self_modulate(const Color &p_self_modulate) {
ERR_THREAD_GUARD;
if (self_modulate == p_self_modulate) {
return;
}
@ -462,10 +486,12 @@ void CanvasItem::set_self_modulate(const Color &p_self_modulate) {
}
Color CanvasItem::get_self_modulate() const {
ERR_READ_THREAD_GUARD_V(Color());
return self_modulate;
}
void CanvasItem::set_light_mask(int p_light_mask) {
ERR_THREAD_GUARD;
if (light_mask == p_light_mask) {
return;
}
@ -475,10 +501,12 @@ void CanvasItem::set_light_mask(int p_light_mask) {
}
int CanvasItem::get_light_mask() const {
ERR_READ_THREAD_GUARD_V(0);
return light_mask;
}
void CanvasItem::item_rect_changed(bool p_size_changed) {
ERR_MAIN_THREAD_GUARD;
if (p_size_changed) {
queue_redraw();
}
@ -486,6 +514,7 @@ void CanvasItem::item_rect_changed(bool p_size_changed) {
}
void CanvasItem::set_z_index(int p_z) {
ERR_THREAD_GUARD;
ERR_FAIL_COND(p_z < RS::CANVAS_ITEM_Z_MIN);
ERR_FAIL_COND(p_z > RS::CANVAS_ITEM_Z_MAX);
z_index = p_z;
@ -494,6 +523,7 @@ void CanvasItem::set_z_index(int p_z) {
}
void CanvasItem::set_z_as_relative(bool p_enabled) {
ERR_THREAD_GUARD;
if (z_relative == p_enabled) {
return;
}
@ -502,14 +532,17 @@ void CanvasItem::set_z_as_relative(bool p_enabled) {
}
bool CanvasItem::is_z_relative() const {
ERR_READ_THREAD_GUARD_V(false);
return z_relative;
}
int CanvasItem::get_z_index() const {
ERR_READ_THREAD_GUARD_V(0);
return z_index;
}
int CanvasItem::get_effective_z_index() const {
ERR_READ_THREAD_GUARD_V(0);
int effective_z_index = z_index;
if (is_z_relative()) {
CanvasItem *p = get_parent_item();
@ -521,15 +554,18 @@ int CanvasItem::get_effective_z_index() const {
}
void CanvasItem::set_y_sort_enabled(bool p_enabled) {
ERR_THREAD_GUARD;
y_sort_enabled = p_enabled;
RS::get_singleton()->canvas_item_set_sort_children_by_y(canvas_item, y_sort_enabled);
}
bool CanvasItem::is_y_sort_enabled() const {
ERR_READ_THREAD_GUARD_V(false);
return y_sort_enabled;
}
void CanvasItem::draw_dashed_line(const Point2 &p_from, const Point2 &p_to, const Color &p_color, real_t p_width, real_t p_dash, bool p_aligned) {
ERR_THREAD_GUARD;
ERR_FAIL_COND_MSG(!drawing, "Drawing is only allowed inside NOTIFICATION_DRAW, _draw() function or 'draw' signal.");
ERR_FAIL_COND(p_dash <= 0.0);
@ -565,12 +601,14 @@ void CanvasItem::draw_dashed_line(const Point2 &p_from, const Point2 &p_to, cons
}
void CanvasItem::draw_line(const Point2 &p_from, const Point2 &p_to, const Color &p_color, real_t p_width, bool p_antialiased) {
ERR_THREAD_GUARD;
ERR_FAIL_COND_MSG(!drawing, "Drawing is only allowed inside NOTIFICATION_DRAW, _draw() function or 'draw' signal.");
RenderingServer::get_singleton()->canvas_item_add_line(canvas_item, p_from, p_to, p_color, p_width, p_antialiased);
}
void CanvasItem::draw_polyline(const Vector<Point2> &p_points, const Color &p_color, real_t p_width, bool p_antialiased) {
ERR_THREAD_GUARD;
ERR_FAIL_COND_MSG(!drawing, "Drawing is only allowed inside NOTIFICATION_DRAW, _draw() function or 'draw' signal.");
Vector<Color> colors = { p_color };
@ -578,12 +616,14 @@ void CanvasItem::draw_polyline(const Vector<Point2> &p_points, const Color &p_co
}
void CanvasItem::draw_polyline_colors(const Vector<Point2> &p_points, const Vector<Color> &p_colors, real_t p_width, bool p_antialiased) {
ERR_THREAD_GUARD;
ERR_FAIL_COND_MSG(!drawing, "Drawing is only allowed inside NOTIFICATION_DRAW, _draw() function or 'draw' signal.");
RenderingServer::get_singleton()->canvas_item_add_polyline(canvas_item, p_points, p_colors, p_width, p_antialiased);
}
void CanvasItem::draw_arc(const Vector2 &p_center, real_t p_radius, real_t p_start_angle, real_t p_end_angle, int p_point_count, const Color &p_color, real_t p_width, bool p_antialiased) {
ERR_THREAD_GUARD;
Vector<Point2> points;
points.resize(p_point_count);
Point2 *points_ptr = points.ptrw();
@ -599,6 +639,7 @@ void CanvasItem::draw_arc(const Vector2 &p_center, real_t p_radius, real_t p_sta
}
void CanvasItem::draw_multiline(const Vector<Point2> &p_points, const Color &p_color, real_t p_width) {
ERR_THREAD_GUARD;
ERR_FAIL_COND_MSG(!drawing, "Drawing is only allowed inside NOTIFICATION_DRAW, _draw() function or 'draw' signal.");
Vector<Color> colors = { p_color };
@ -606,12 +647,14 @@ void CanvasItem::draw_multiline(const Vector<Point2> &p_points, const Color &p_c
}
void CanvasItem::draw_multiline_colors(const Vector<Point2> &p_points, const Vector<Color> &p_colors, real_t p_width) {
ERR_THREAD_GUARD;
ERR_FAIL_COND_MSG(!drawing, "Drawing is only allowed inside NOTIFICATION_DRAW, _draw() function or 'draw' signal.");
RenderingServer::get_singleton()->canvas_item_add_multiline(canvas_item, p_points, p_colors, p_width);
}
void CanvasItem::draw_rect(const Rect2 &p_rect, const Color &p_color, bool p_filled, real_t p_width) {
ERR_THREAD_GUARD;
ERR_FAIL_COND_MSG(!drawing, "Drawing is only allowed inside NOTIFICATION_DRAW, _draw() function or 'draw' signal.");
Rect2 rect = p_rect.abs();
@ -640,12 +683,14 @@ void CanvasItem::draw_rect(const Rect2 &p_rect, const Color &p_color, bool p_fil
}
void CanvasItem::draw_circle(const Point2 &p_pos, real_t p_radius, const Color &p_color) {
ERR_THREAD_GUARD;
ERR_FAIL_COND_MSG(!drawing, "Drawing is only allowed inside NOTIFICATION_DRAW, _draw() function or 'draw' signal.");
RenderingServer::get_singleton()->canvas_item_add_circle(canvas_item, p_pos, p_radius, p_color);
}
void CanvasItem::draw_texture(const Ref<Texture2D> &p_texture, const Point2 &p_pos, const Color &p_modulate) {
ERR_THREAD_GUARD;
ERR_FAIL_COND_MSG(!drawing, "Drawing is only allowed inside NOTIFICATION_DRAW, _draw() function or 'draw' signal.");
ERR_FAIL_COND(p_texture.is_null());
@ -654,6 +699,7 @@ void CanvasItem::draw_texture(const Ref<Texture2D> &p_texture, const Point2 &p_p
}
void CanvasItem::draw_texture_rect(const Ref<Texture2D> &p_texture, const Rect2 &p_rect, bool p_tile, const Color &p_modulate, bool p_transpose) {
ERR_THREAD_GUARD;
ERR_FAIL_COND_MSG(!drawing, "Drawing is only allowed inside NOTIFICATION_DRAW, _draw() function or 'draw' signal.");
ERR_FAIL_COND(p_texture.is_null());
@ -661,24 +707,28 @@ void CanvasItem::draw_texture_rect(const Ref<Texture2D> &p_texture, const Rect2
}
void CanvasItem::draw_texture_rect_region(const Ref<Texture2D> &p_texture, const Rect2 &p_rect, const Rect2 &p_src_rect, const Color &p_modulate, bool p_transpose, bool p_clip_uv) {
ERR_THREAD_GUARD;
ERR_FAIL_COND_MSG(!drawing, "Drawing is only allowed inside NOTIFICATION_DRAW, _draw() function or 'draw' signal.");
ERR_FAIL_COND(p_texture.is_null());
p_texture->draw_rect_region(canvas_item, p_rect, p_src_rect, p_modulate, p_transpose, p_clip_uv);
}
void CanvasItem::draw_msdf_texture_rect_region(const Ref<Texture2D> &p_texture, const Rect2 &p_rect, const Rect2 &p_src_rect, const Color &p_modulate, double p_outline, double p_pixel_range, double p_scale) {
ERR_THREAD_GUARD;
ERR_FAIL_COND_MSG(!drawing, "Drawing is only allowed inside NOTIFICATION_DRAW, _draw() function or 'draw' signal.");
ERR_FAIL_COND(p_texture.is_null());
RenderingServer::get_singleton()->canvas_item_add_msdf_texture_rect_region(canvas_item, p_rect, p_texture->get_rid(), p_src_rect, p_modulate, p_outline, p_pixel_range, p_scale);
}
void CanvasItem::draw_lcd_texture_rect_region(const Ref<Texture2D> &p_texture, const Rect2 &p_rect, const Rect2 &p_src_rect, const Color &p_modulate) {
ERR_THREAD_GUARD;
ERR_FAIL_COND_MSG(!drawing, "Drawing is only allowed inside NOTIFICATION_DRAW, _draw() function or 'draw' signal.");
ERR_FAIL_COND(p_texture.is_null());
RenderingServer::get_singleton()->canvas_item_add_lcd_texture_rect_region(canvas_item, p_rect, p_texture->get_rid(), p_src_rect, p_modulate);
}
void CanvasItem::draw_style_box(const Ref<StyleBox> &p_style_box, const Rect2 &p_rect) {
ERR_THREAD_GUARD;
ERR_FAIL_COND_MSG(!drawing, "Drawing is only allowed inside NOTIFICATION_DRAW, _draw() function or 'draw' signal.");
ERR_FAIL_COND(p_style_box.is_null());
@ -687,6 +737,7 @@ void CanvasItem::draw_style_box(const Ref<StyleBox> &p_style_box, const Rect2 &p
}
void CanvasItem::draw_primitive(const Vector<Point2> &p_points, const Vector<Color> &p_colors, const Vector<Point2> &p_uvs, Ref<Texture2D> p_texture) {
ERR_THREAD_GUARD;
ERR_FAIL_COND_MSG(!drawing, "Drawing is only allowed inside NOTIFICATION_DRAW, _draw() function or 'draw' signal.");
RID rid = p_texture.is_valid() ? p_texture->get_rid() : RID();
@ -694,6 +745,7 @@ void CanvasItem::draw_primitive(const Vector<Point2> &p_points, const Vector<Col
}
void CanvasItem::draw_set_transform(const Point2 &p_offset, real_t p_rot, const Size2 &p_scale) {
ERR_THREAD_GUARD;
ERR_FAIL_COND_MSG(!drawing, "Drawing is only allowed inside NOTIFICATION_DRAW, _draw() function or 'draw' signal.");
Transform2D xform(p_rot, p_offset);
@ -702,23 +754,27 @@ void CanvasItem::draw_set_transform(const Point2 &p_offset, real_t p_rot, const
}
void CanvasItem::draw_set_transform_matrix(const Transform2D &p_matrix) {
ERR_THREAD_GUARD;
ERR_FAIL_COND_MSG(!drawing, "Drawing is only allowed inside NOTIFICATION_DRAW, _draw() function or 'draw' signal.");
RenderingServer::get_singleton()->canvas_item_add_set_transform(canvas_item, p_matrix);
}
void CanvasItem::draw_animation_slice(double p_animation_length, double p_slice_begin, double p_slice_end, double p_offset) {
ERR_THREAD_GUARD;
ERR_FAIL_COND_MSG(!drawing, "Drawing is only allowed inside NOTIFICATION_DRAW, _draw() function or 'draw' signal.");
RenderingServer::get_singleton()->canvas_item_add_animation_slice(canvas_item, p_animation_length, p_slice_begin, p_slice_end, p_offset);
}
void CanvasItem::draw_end_animation() {
ERR_THREAD_GUARD;
ERR_FAIL_COND_MSG(!drawing, "Drawing is only allowed inside NOTIFICATION_DRAW, _draw() function or 'draw' signal.");
RenderingServer::get_singleton()->canvas_item_add_animation_slice(canvas_item, 1, 0, 2, 0);
}
void CanvasItem::draw_polygon(const Vector<Point2> &p_points, const Vector<Color> &p_colors, const Vector<Point2> &p_uvs, Ref<Texture2D> p_texture) {
ERR_THREAD_GUARD;
ERR_FAIL_COND_MSG(!drawing, "Drawing is only allowed inside NOTIFICATION_DRAW, _draw() function or 'draw' signal.");
RID rid = p_texture.is_valid() ? p_texture->get_rid() : RID();
@ -727,6 +783,7 @@ void CanvasItem::draw_polygon(const Vector<Point2> &p_points, const Vector<Color
}
void CanvasItem::draw_colored_polygon(const Vector<Point2> &p_points, const Color &p_color, const Vector<Point2> &p_uvs, Ref<Texture2D> p_texture) {
ERR_THREAD_GUARD;
ERR_FAIL_COND_MSG(!drawing, "Drawing is only allowed inside NOTIFICATION_DRAW, _draw() function or 'draw' signal.");
Vector<Color> colors = { p_color };
@ -735,6 +792,7 @@ void CanvasItem::draw_colored_polygon(const Vector<Point2> &p_points, const Colo
}
void CanvasItem::draw_mesh(const Ref<Mesh> &p_mesh, const Ref<Texture2D> &p_texture, const Transform2D &p_transform, const Color &p_modulate) {
ERR_THREAD_GUARD;
ERR_FAIL_COND(p_mesh.is_null());
RID texture_rid = p_texture.is_valid() ? p_texture->get_rid() : RID();
@ -742,12 +800,14 @@ void CanvasItem::draw_mesh(const Ref<Mesh> &p_mesh, const Ref<Texture2D> &p_text
}
void CanvasItem::draw_multimesh(const Ref<MultiMesh> &p_multimesh, const Ref<Texture2D> &p_texture) {
ERR_THREAD_GUARD;
ERR_FAIL_COND(p_multimesh.is_null());
RID texture_rid = p_texture.is_valid() ? p_texture->get_rid() : RID();
RenderingServer::get_singleton()->canvas_item_add_multimesh(canvas_item, p_multimesh->get_rid(), texture_rid);
}
void CanvasItem::draw_string(const Ref<Font> &p_font, const Point2 &p_pos, const String &p_text, HorizontalAlignment p_alignment, float p_width, int p_font_size, const Color &p_modulate, BitField<TextServer::JustificationFlag> p_jst_flags, TextServer::Direction p_direction, TextServer::Orientation p_orientation) const {
ERR_THREAD_GUARD;
ERR_FAIL_COND_MSG(!drawing, "Drawing is only allowed inside NOTIFICATION_DRAW, _draw() function or 'draw' signal.");
ERR_FAIL_COND(p_font.is_null());
@ -755,6 +815,7 @@ void CanvasItem::draw_string(const Ref<Font> &p_font, const Point2 &p_pos, const
}
void CanvasItem::draw_multiline_string(const Ref<Font> &p_font, const Point2 &p_pos, const String &p_text, HorizontalAlignment p_alignment, float p_width, int p_font_size, int p_max_lines, const Color &p_modulate, BitField<TextServer::LineBreakFlag> p_brk_flags, BitField<TextServer::JustificationFlag> p_jst_flags, TextServer::Direction p_direction, TextServer::Orientation p_orientation) const {
ERR_THREAD_GUARD;
ERR_FAIL_COND_MSG(!drawing, "Drawing is only allowed inside NOTIFICATION_DRAW, _draw() function or 'draw' signal.");
ERR_FAIL_COND(p_font.is_null());
@ -762,6 +823,7 @@ void CanvasItem::draw_multiline_string(const Ref<Font> &p_font, const Point2 &p_
}
void CanvasItem::draw_string_outline(const Ref<Font> &p_font, const Point2 &p_pos, const String &p_text, HorizontalAlignment p_alignment, float p_width, int p_font_size, int p_size, const Color &p_modulate, BitField<TextServer::JustificationFlag> p_jst_flags, TextServer::Direction p_direction, TextServer::Orientation p_orientation) const {
ERR_THREAD_GUARD;
ERR_FAIL_COND_MSG(!drawing, "Drawing is only allowed inside NOTIFICATION_DRAW, _draw() function or 'draw' signal.");
ERR_FAIL_COND(p_font.is_null());
@ -769,6 +831,7 @@ void CanvasItem::draw_string_outline(const Ref<Font> &p_font, const Point2 &p_po
}
void CanvasItem::draw_multiline_string_outline(const Ref<Font> &p_font, const Point2 &p_pos, const String &p_text, HorizontalAlignment p_alignment, float p_width, int p_font_size, int p_max_lines, int p_size, const Color &p_modulate, BitField<TextServer::LineBreakFlag> p_brk_flags, BitField<TextServer::JustificationFlag> p_jst_flags, TextServer::Direction p_direction, TextServer::Orientation p_orientation) const {
ERR_THREAD_GUARD;
ERR_FAIL_COND_MSG(!drawing, "Drawing is only allowed inside NOTIFICATION_DRAW, _draw() function or 'draw' signal.");
ERR_FAIL_COND(p_font.is_null());
@ -776,6 +839,7 @@ void CanvasItem::draw_multiline_string_outline(const Ref<Font> &p_font, const Po
}
void CanvasItem::draw_char(const Ref<Font> &p_font, const Point2 &p_pos, const String &p_char, int p_font_size, const Color &p_modulate) const {
ERR_THREAD_GUARD;
ERR_FAIL_COND_MSG(!drawing, "Drawing is only allowed inside NOTIFICATION_DRAW, _draw() function or 'draw' signal.");
ERR_FAIL_COND(p_char.length() != 1);
ERR_FAIL_COND(p_font.is_null());
@ -784,6 +848,7 @@ void CanvasItem::draw_char(const Ref<Font> &p_font, const Point2 &p_pos, const S
}
void CanvasItem::draw_char_outline(const Ref<Font> &p_font, const Point2 &p_pos, const String &p_char, int p_font_size, int p_size, const Color &p_modulate) const {
ERR_THREAD_GUARD;
ERR_FAIL_COND_MSG(!drawing, "Drawing is only allowed inside NOTIFICATION_DRAW, _draw() function or 'draw' signal.");
ERR_FAIL_COND(p_char.length() != 1);
ERR_FAIL_COND(p_font.is_null());
@ -791,6 +856,12 @@ void CanvasItem::draw_char_outline(const Ref<Font> &p_font, const Point2 &p_pos,
p_font->draw_char_outline(canvas_item, p_pos, p_char[0], p_font_size, p_size, p_modulate);
}
void CanvasItem::_notify_transform_deferred() {
if (is_inside_tree() && notify_transform && !xform_change.in_list()) {
get_tree()->xform_change_list.add(&xform_change);
}
}
void CanvasItem::_notify_transform(CanvasItem *p_node) {
/* This check exists to avoid re-propagating the transform
* notification down the tree on dirty nodes. It provides
@ -798,16 +869,21 @@ void CanvasItem::_notify_transform(CanvasItem *p_node) {
* notification anyway).
*/
if (/*p_node->xform_change.in_list() &&*/ p_node->global_invalid) {
if (/*p_node->xform_change.in_list() &&*/ p_node->global_invalid.is_set()) {
return; //nothing to do
}
p_node->global_invalid = true;
p_node->global_invalid.set();
if (p_node->notify_transform && !p_node->xform_change.in_list()) {
if (!p_node->block_transform_notify) {
if (p_node->is_inside_tree()) {
get_tree()->xform_change_list.add(&p_node->xform_change);
if (is_accessible_from_caller_thread()) {
get_tree()->xform_change_list.add(&p_node->xform_change);
} else {
// Should be rare, but still needs to be handled.
MessageQueue::get_singleton()->push_callable(callable_mp(p_node, &CanvasItem::_notify_transform_deferred));
}
}
}
}
@ -821,11 +897,13 @@ void CanvasItem::_notify_transform(CanvasItem *p_node) {
}
Rect2 CanvasItem::get_viewport_rect() const {
ERR_READ_THREAD_GUARD_V(Rect2());
ERR_FAIL_COND_V(!is_inside_tree(), Rect2());
return get_viewport()->get_visible_rect();
}
RID CanvasItem::get_canvas() const {
ERR_READ_THREAD_GUARD_V(RID());
ERR_FAIL_COND_V(!is_inside_tree(), RID());
if (canvas_layer) {
@ -836,6 +914,7 @@ RID CanvasItem::get_canvas() const {
}
ObjectID CanvasItem::get_canvas_layer_instance_id() const {
ERR_READ_THREAD_GUARD_V(ObjectID());
if (canvas_layer) {
return canvas_layer->get_instance_id();
} else {
@ -844,6 +923,7 @@ ObjectID CanvasItem::get_canvas_layer_instance_id() const {
}
CanvasItem *CanvasItem::get_top_level() const {
ERR_READ_THREAD_GUARD_V(nullptr);
CanvasItem *ci = const_cast<CanvasItem *>(this);
while (!ci->top_level && Object::cast_to<CanvasItem>(ci->get_parent())) {
ci = Object::cast_to<CanvasItem>(ci->get_parent());
@ -853,6 +933,7 @@ CanvasItem *CanvasItem::get_top_level() const {
}
Ref<World2D> CanvasItem::get_world_2d() const {
ERR_READ_THREAD_GUARD_V(Ref<World2D>());
ERR_FAIL_COND_V(!is_inside_tree(), Ref<World2D>());
CanvasItem *tl = get_top_level();
@ -865,19 +946,23 @@ Ref<World2D> CanvasItem::get_world_2d() const {
}
RID CanvasItem::get_viewport_rid() const {
ERR_READ_THREAD_GUARD_V(RID());
ERR_FAIL_COND_V(!is_inside_tree(), RID());
return get_viewport()->get_viewport_rid();
}
void CanvasItem::set_block_transform_notify(bool p_enable) {
ERR_THREAD_GUARD;
block_transform_notify = p_enable;
}
bool CanvasItem::is_block_transform_notify_enabled() const {
ERR_READ_THREAD_GUARD_V(false);
return block_transform_notify;
}
void CanvasItem::set_draw_behind_parent(bool p_enable) {
ERR_THREAD_GUARD;
if (behind == p_enable) {
return;
}
@ -886,10 +971,12 @@ void CanvasItem::set_draw_behind_parent(bool p_enable) {
}
bool CanvasItem::is_draw_behind_parent_enabled() const {
ERR_READ_THREAD_GUARD_V(false);
return behind;
}
void CanvasItem::set_material(const Ref<Material> &p_material) {
ERR_THREAD_GUARD;
material = p_material;
RID rid;
if (material.is_valid()) {
@ -900,19 +987,23 @@ void CanvasItem::set_material(const Ref<Material> &p_material) {
}
void CanvasItem::set_use_parent_material(bool p_use_parent_material) {
ERR_THREAD_GUARD;
use_parent_material = p_use_parent_material;
RS::get_singleton()->canvas_item_set_use_parent_material(canvas_item, p_use_parent_material);
}
bool CanvasItem::get_use_parent_material() const {
ERR_READ_THREAD_GUARD_V(false);
return use_parent_material;
}
Ref<Material> CanvasItem::get_material() const {
ERR_READ_THREAD_GUARD_V(Ref<Material>());
return material;
}
Vector2 CanvasItem::make_canvas_position_local(const Vector2 &screen_point) const {
ERR_READ_THREAD_GUARD_V(Vector2());
ERR_FAIL_COND_V(!is_inside_tree(), screen_point);
Transform2D local_matrix = (get_canvas_transform() * get_global_transform()).affine_inverse();
@ -921,6 +1012,7 @@ Vector2 CanvasItem::make_canvas_position_local(const Vector2 &screen_point) cons
}
Ref<InputEvent> CanvasItem::make_input_local(const Ref<InputEvent> &p_event) const {
ERR_READ_THREAD_GUARD_V(Ref<InputEvent>());
ERR_FAIL_COND_V(p_event.is_null(), p_event);
ERR_FAIL_COND_V(!is_inside_tree(), p_event);
@ -928,17 +1020,20 @@ Ref<InputEvent> CanvasItem::make_input_local(const Ref<InputEvent> &p_event) con
}
Vector2 CanvasItem::get_global_mouse_position() const {
ERR_READ_THREAD_GUARD_V(Vector2());
ERR_FAIL_COND_V(!get_viewport(), Vector2());
return get_canvas_transform().affine_inverse().xform(get_viewport()->get_mouse_position());
}
Vector2 CanvasItem::get_local_mouse_position() const {
ERR_READ_THREAD_GUARD_V(Vector2());
ERR_FAIL_COND_V(!get_viewport(), Vector2());
return get_global_transform().affine_inverse().xform(get_global_mouse_position());
}
void CanvasItem::force_update_transform() {
ERR_THREAD_GUARD;
ERR_FAIL_COND(!is_inside_tree());
if (!xform_change.in_list()) {
return;
@ -1148,6 +1243,7 @@ void CanvasItem::_bind_methods() {
}
Transform2D CanvasItem::get_canvas_transform() const {
ERR_READ_THREAD_GUARD_V(Transform2D());
ERR_FAIL_COND_V(!is_inside_tree(), Transform2D());
if (canvas_layer) {
@ -1160,6 +1256,7 @@ Transform2D CanvasItem::get_canvas_transform() const {
}
Transform2D CanvasItem::get_viewport_transform() const {
ERR_READ_THREAD_GUARD_V(Transform2D());
ERR_FAIL_COND_V(!is_inside_tree(), Transform2D());
if (canvas_layer) {
@ -1170,14 +1267,17 @@ Transform2D CanvasItem::get_viewport_transform() const {
}
void CanvasItem::set_notify_local_transform(bool p_enable) {
ERR_THREAD_GUARD;
notify_local_transform = p_enable;
}
bool CanvasItem::is_local_transform_notification_enabled() const {
ERR_READ_THREAD_GUARD_V(false);
return notify_local_transform;
}
void CanvasItem::set_notify_transform(bool p_enable) {
ERR_THREAD_GUARD;
if (notify_transform == p_enable) {
return;
}
@ -1191,10 +1291,12 @@ void CanvasItem::set_notify_transform(bool p_enable) {
}
bool CanvasItem::is_transform_notification_enabled() const {
ERR_READ_THREAD_GUARD_V(false);
return notify_transform;
}
int CanvasItem::get_canvas_layer() const {
ERR_READ_THREAD_GUARD_V(0);
if (canvas_layer) {
return canvas_layer->get_layer();
} else {
@ -1203,15 +1305,18 @@ int CanvasItem::get_canvas_layer() const {
}
void CanvasItem::set_visibility_layer(uint32_t p_visibility_layer) {
ERR_THREAD_GUARD;
visibility_layer = p_visibility_layer;
RenderingServer::get_singleton()->canvas_item_set_visibility_layer(canvas_item, p_visibility_layer);
}
uint32_t CanvasItem::get_visibility_layer() const {
ERR_READ_THREAD_GUARD_V(0);
return visibility_layer;
}
void CanvasItem::set_visibility_layer_bit(uint32_t p_visibility_layer, bool p_enable) {
ERR_THREAD_GUARD;
ERR_FAIL_UNSIGNED_INDEX(p_visibility_layer, 32);
if (p_enable) {
set_visibility_layer(visibility_layer | (1 << p_visibility_layer));
@ -1221,6 +1326,7 @@ void CanvasItem::set_visibility_layer_bit(uint32_t p_visibility_layer, bool p_en
}
bool CanvasItem::get_visibility_layer_bit(uint32_t p_visibility_layer) const {
ERR_READ_THREAD_GUARD_V(0);
ERR_FAIL_UNSIGNED_INDEX_V(p_visibility_layer, 32, false);
return (visibility_layer & (1 << p_visibility_layer));
}
@ -1261,6 +1367,7 @@ void CanvasItem::_update_texture_filter_changed(bool p_propagate) {
}
void CanvasItem::set_texture_filter(TextureFilter p_texture_filter) {
ERR_MAIN_THREAD_GUARD; // Goes down in the tree, so only main thread can set.
ERR_FAIL_INDEX(p_texture_filter, TEXTURE_FILTER_MAX);
if (texture_filter == p_texture_filter) {
return;
@ -1271,6 +1378,7 @@ void CanvasItem::set_texture_filter(TextureFilter p_texture_filter) {
}
CanvasItem::TextureFilter CanvasItem::get_texture_filter() const {
ERR_READ_THREAD_GUARD_V(TEXTURE_FILTER_NEAREST);
return texture_filter;
}
@ -1309,6 +1417,7 @@ void CanvasItem::_update_texture_repeat_changed(bool p_propagate) {
}
void CanvasItem::set_texture_repeat(TextureRepeat p_texture_repeat) {
ERR_MAIN_THREAD_GUARD; // Goes down in the tree, so only main thread can set.
ERR_FAIL_INDEX(p_texture_repeat, TEXTURE_REPEAT_MAX);
if (texture_repeat == p_texture_repeat) {
return;
@ -1319,6 +1428,7 @@ void CanvasItem::set_texture_repeat(TextureRepeat p_texture_repeat) {
}
void CanvasItem::set_clip_children_mode(ClipChildrenMode p_clip_mode) {
ERR_THREAD_GUARD;
ERR_FAIL_COND(p_clip_mode >= CLIP_CHILDREN_MAX);
if (clip_children_mode == p_clip_mode) {
@ -1334,19 +1444,23 @@ void CanvasItem::set_clip_children_mode(ClipChildrenMode p_clip_mode) {
RS::get_singleton()->canvas_item_set_canvas_group_mode(get_canvas_item(), RS::CanvasGroupMode(clip_children_mode));
}
CanvasItem::ClipChildrenMode CanvasItem::get_clip_children_mode() const {
ERR_READ_THREAD_GUARD_V(CLIP_CHILDREN_DISABLED);
return clip_children_mode;
}
CanvasItem::TextureRepeat CanvasItem::get_texture_repeat() const {
ERR_READ_THREAD_GUARD_V(TEXTURE_REPEAT_DISABLED);
return texture_repeat;
}
CanvasItem::TextureFilter CanvasItem::get_texture_filter_in_tree() {
ERR_READ_THREAD_GUARD_V(TEXTURE_FILTER_NEAREST);
_refresh_texture_filter_cache();
return (TextureFilter)texture_filter_cache;
}
CanvasItem::TextureRepeat CanvasItem::get_texture_repeat_in_tree() {
ERR_READ_THREAD_GUARD_V(TEXTURE_REPEAT_DISABLED);
_refresh_texture_repeat_cache();
return (TextureRepeat)texture_repeat_cache;
}

4
scene/main/canvas_item.h
View File

@ -118,7 +118,7 @@ private:
Ref<Material> material;
mutable Transform2D global_transform;
mutable bool global_invalid = true;
mutable SafeFlag global_invalid;
void _top_level_raise_self();
@ -145,6 +145,8 @@ private:
void _refresh_texture_filter_cache();
void _update_texture_filter_changed(bool p_propagate);
void _notify_transform_deferred();
protected:
_FORCE_INLINE_ void _notify_transform() {
if (!is_inside_tree()) {

90
scene/main/node.cpp
View File

@ -3505,3 +3505,93 @@ Node::~Node() {
}
////////////////////////////////
// Multithreaded locked version of Object functions.
#ifdef DEBUG_ENABLED
void Node::set_script(const Variant &p_script) {
ERR_THREAD_GUARD;
Object::set_script(p_script);
}
Variant Node::get_script() const {
ERR_THREAD_GUARD_V(Variant());
return Object::get_script();
}
bool Node::has_meta(const StringName &p_name) const {
ERR_THREAD_GUARD_V(false);
return Object::has_meta(p_name);
}
void Node::set_meta(const StringName &p_name, const Variant &p_value) {
ERR_THREAD_GUARD;
Object::set_meta(p_name, p_value);
}
void Node::remove_meta(const StringName &p_name) {
ERR_THREAD_GUARD;
Object::remove_meta(p_name);
}
Variant Node::get_meta(const StringName &p_name, const Variant &p_default) const {
ERR_THREAD_GUARD_V(Variant());
return Object::get_meta(p_name, p_default);
}
void Node::get_meta_list(List<StringName> *p_list) const {
ERR_THREAD_GUARD;
Object::get_meta_list(p_list);
}
Error Node::emit_signalp(const StringName &p_name, const Variant **p_args, int p_argcount) {
ERR_THREAD_GUARD_V(ERR_INVALID_PARAMETER);
return Object::emit_signalp(p_name, p_args, p_argcount);
}
bool Node::has_signal(const StringName &p_name) const {
ERR_THREAD_GUARD_V(false);
return Object::has_signal(p_name);
}
void Node::get_signal_list(List<MethodInfo> *p_signals) const {
ERR_THREAD_GUARD;
Object::get_signal_list(p_signals);
}
void Node::get_signal_connection_list(const StringName &p_signal, List<Connection> *p_connections) const {
ERR_THREAD_GUARD;
Object::get_signal_connection_list(p_signal, p_connections);
}
void Node::get_all_signal_connections(List<Connection> *p_connections) const {
ERR_THREAD_GUARD;
Object::get_all_signal_connections(p_connections);
}
int Node::get_persistent_signal_connection_count() const {
ERR_THREAD_GUARD_V(0);
return Object::get_persistent_signal_connection_count();
}
void Node::get_signals_connected_to_this(List<Connection> *p_connections) const {
ERR_THREAD_GUARD;
Object::get_signals_connected_to_this(p_connections);
}
Error Node::connect(const StringName &p_signal, const Callable &p_callable, uint32_t p_flags) {
ERR_THREAD_GUARD_V(ERR_INVALID_PARAMETER);
return Object::connect(p_signal, p_callable, p_flags);
}
void Node::disconnect(const StringName &p_signal, const Callable &p_callable) {
ERR_THREAD_GUARD;
Object::disconnect(p_signal, p_callable);
}
bool Node::is_connected(const StringName &p_signal, const Callable &p_callable) const {
ERR_THREAD_GUARD_V(false);
return Object::is_connected(p_signal, p_callable);
}
#endif

36
scene/main/node.h
View File

@ -527,6 +527,14 @@ public:
}
}
_FORCE_INLINE_ bool is_readable_from_caller_thread() const {
if (current_process_thread_group == nullptr) {
return Thread::is_main_thread();
} else {
return true;
}
}
void set_process_thread_messages(BitField<ProcessThreadMessages> p_flags);
BitField<ProcessThreadMessages> get_process_thread_messages() const;
@ -645,6 +653,30 @@ public:
void set_thread_safe(const StringName &p_property, const Variant &p_value);
void notify_thread_safe(int p_notification);
// These inherited functions need proper multithread locking when overridden in Node.
#ifdef DEBUG_ENABLED
virtual void set_script(const Variant &p_script) override;
virtual Variant get_script() const override;
virtual bool has_meta(const StringName &p_name) const override;
virtual void set_meta(const StringName &p_name, const Variant &p_value) override;
virtual void remove_meta(const StringName &p_name) override;
virtual Variant get_meta(const StringName &p_name, const Variant &p_default = Variant()) const override;
virtual void get_meta_list(List<StringName> *p_list) const override;
virtual Error emit_signalp(const StringName &p_name, const Variant **p_args, int p_argcount) override;
virtual bool has_signal(const StringName &p_name) const override;
virtual void get_signal_list(List<MethodInfo> *p_signals) const override;
virtual void get_signal_connection_list(const StringName &p_signal, List<Connection> *p_connections) const override;
virtual void get_all_signal_connections(List<Connection> *p_connections) const override;
virtual int get_persistent_signal_connection_count() const override;
virtual void get_signals_connected_to_this(List<Connection> *p_connections) const override;
virtual Error connect(const StringName &p_signal, const Callable &p_callable, uint32_t p_flags = 0) override;
virtual void disconnect(const StringName &p_signal, const Callable &p_callable) override;
virtual bool is_connected(const StringName &p_signal, const Callable &p_callable) const override;
#endif
Node();
~Node();
};
@ -676,11 +708,15 @@ Error Node::rpc_id(int p_peer_id, const StringName &p_method, VarArgs... p_args)
#define ERR_THREAD_GUARD_V(m_ret) ERR_FAIL_COND_V_MSG(!is_accessible_from_caller_thread(), (m_ret), "Caller thread can't call this function in this node. Use call_deferred() or call_thread_group() instead.")
#define ERR_MAIN_THREAD_GUARD ERR_FAIL_COND_MSG(is_inside_tree() && !Thread::is_main_thread(), "This function in this node can only be accessed from the main thread. Use call_deferred() instead.");
#define ERR_MAIN_THREAD_GUARD_V(m_ret) ERR_FAIL_COND_V_MSG(is_inside_tree() && !Thread::is_main_thread(), (m_ret), "This function in this node can only be accessed from the main thread. Use call_deferred() instead.")
#define ERR_READ_THREAD_GUARD ERR_FAIL_COND_MSG(!is_readable_from_caller_thread(), "This function in this node can only be accessed from either the main thread or a thread group. Use call_deferred() instead.")
#define ERR_READ_THREAD_GUARD_V(m_ret) ERR_FAIL_COND_V_MSG(!is_readable_from_caller_thread(), (m_ret), "This function in this node can only be accessed from either the main thread or a thread group. Use call_deferred() instead.")
#else
#define ERR_THREAD_GUARD
#define ERR_THREAD_GUARD_V(m_ret)
#define ERR_MAIN_THREAD_GUARD
#define ERR_MAIN_THREAD_GUARD_V(m_ret)
#define ERR_READ_THREAD_GUARD
#define ERR_READ_THREAD_GUARD_V(m_ret)
#endif
// Add these macro to your class's 'get_configuration_warnings' function to have warnings show up in the scene tree inspector.

148
scene/main/viewport.cpp
View File

@ -468,6 +468,8 @@ void Viewport::_update_viewport_path() {
}
void Viewport::_notification(int p_what) {
ERR_MAIN_THREAD_GUARD;
switch (p_what) {
case NOTIFICATION_ENTER_TREE: {
_update_viewport_path();
@ -922,10 +924,12 @@ void Viewport::_process_picking() {
}
RID Viewport::get_viewport_rid() const {
ERR_READ_THREAD_GUARD_V(RID());
return viewport;
}
void Viewport::update_canvas_items() {
ERR_MAIN_THREAD_GUARD;
if (!is_inside_tree()) {
return;
}
@ -1013,6 +1017,7 @@ bool Viewport::_is_size_allocated() const {
}
Rect2 Viewport::get_visible_rect() const {
ERR_READ_THREAD_GUARD_V(Rect2());
Rect2 r;
if (size == Size2()) {
@ -1029,6 +1034,7 @@ Rect2 Viewport::get_visible_rect() const {
}
void Viewport::canvas_parent_mark_dirty(Node *p_node) {
ERR_MAIN_THREAD_GUARD;
bool request_update = gui.canvas_parents_with_dirty_order.is_empty();
gui.canvas_parents_with_dirty_order.insert(p_node->get_instance_id());
if (request_update) {
@ -1043,6 +1049,7 @@ void Viewport::_update_audio_listener_2d() {
}
void Viewport::set_as_audio_listener_2d(bool p_enable) {
ERR_MAIN_THREAD_GUARD;
if (p_enable == is_audio_listener_2d_enabled) {
return;
}
@ -1052,14 +1059,17 @@ void Viewport::set_as_audio_listener_2d(bool p_enable) {
}
bool Viewport::is_audio_listener_2d() const {
ERR_READ_THREAD_GUARD_V(false);
return is_audio_listener_2d_enabled;
}
AudioListener2D *Viewport::get_audio_listener_2d() const {
ERR_READ_THREAD_GUARD_V(nullptr);
return audio_listener_2d;
}
void Viewport::enable_canvas_transform_override(bool p_enable) {
ERR_MAIN_THREAD_GUARD;
if (override_canvas_transform == p_enable) {
return;
}
@ -1073,10 +1083,12 @@ void Viewport::enable_canvas_transform_override(bool p_enable) {
}
bool Viewport::is_canvas_transform_override_enbled() const {
ERR_READ_THREAD_GUARD_V(false);
return override_canvas_transform;
}
void Viewport::set_canvas_transform_override(const Transform2D &p_transform) {
ERR_MAIN_THREAD_GUARD;
if (canvas_transform_override == p_transform) {
return;
}
@ -1088,10 +1100,12 @@ void Viewport::set_canvas_transform_override(const Transform2D &p_transform) {
}
Transform2D Viewport::get_canvas_transform_override() const {
ERR_READ_THREAD_GUARD_V(Transform2D());
return canvas_transform_override;
}
void Viewport::set_canvas_transform(const Transform2D &p_transform) {
ERR_MAIN_THREAD_GUARD;
canvas_transform = p_transform;
if (!override_canvas_transform) {
@ -1100,6 +1114,7 @@ void Viewport::set_canvas_transform(const Transform2D &p_transform) {
}
Transform2D Viewport::get_canvas_transform() const {
ERR_READ_THREAD_GUARD_V(Transform2D());
return canvas_transform;
}
@ -1110,12 +1125,14 @@ void Viewport::_update_global_transform() {
}
void Viewport::set_global_canvas_transform(const Transform2D &p_transform) {
ERR_MAIN_THREAD_GUARD;
global_canvas_transform = p_transform;
_update_global_transform();
}
Transform2D Viewport::get_global_canvas_transform() const {
ERR_READ_THREAD_GUARD_V(Transform2D());
return global_canvas_transform;
}
@ -1147,15 +1164,18 @@ void Viewport::_canvas_layer_remove(CanvasLayer *p_canvas_layer) {
}
void Viewport::set_transparent_background(bool p_enable) {
ERR_MAIN_THREAD_GUARD;
transparent_bg = p_enable;
RS::get_singleton()->viewport_set_transparent_background(viewport, p_enable);
}
bool Viewport::has_transparent_background() const {
ERR_READ_THREAD_GUARD_V(false);
return transparent_bg;
}
void Viewport::set_world_2d(const Ref<World2D> &p_world_2d) {
ERR_MAIN_THREAD_GUARD;
if (world_2d == p_world_2d) {
return;
}
@ -1184,6 +1204,7 @@ void Viewport::set_world_2d(const Ref<World2D> &p_world_2d) {
}
Ref<World2D> Viewport::find_world_2d() const {
ERR_READ_THREAD_GUARD_V(Ref<World2D>());
if (world_2d.is_valid()) {
return world_2d;
} else if (parent) {
@ -1205,18 +1226,22 @@ void Viewport::_propagate_viewport_notification(Node *p_node, int p_what) {
}
Ref<World2D> Viewport::get_world_2d() const {
ERR_READ_THREAD_GUARD_V(Ref<World2D>());
return world_2d;
}
Camera2D *Viewport::get_camera_2d() const {
ERR_READ_THREAD_GUARD_V(nullptr);
return camera_2d;
}
Transform2D Viewport::get_final_transform() const {
ERR_READ_THREAD_GUARD_V(Transform2D());
return stretch_transform * global_canvas_transform;
}
void Viewport::assign_next_enabled_camera_2d(const StringName &p_camera_group) {
ERR_MAIN_THREAD_GUARD;
List<Node *> camera_list;
get_tree()->get_nodes_in_group(p_camera_group, &camera_list);
@ -1260,19 +1285,23 @@ void Viewport::_update_canvas_items(Node *p_node) {
}
Ref<ViewportTexture> Viewport::get_texture() const {
ERR_READ_THREAD_GUARD_V(Ref<ViewportTexture>());
return default_texture;
}
void Viewport::set_positional_shadow_atlas_size(int p_size) {
ERR_MAIN_THREAD_GUARD;
positional_shadow_atlas_size = p_size;
RS::get_singleton()->viewport_set_positional_shadow_atlas_size(viewport, p_size, positional_shadow_atlas_16_bits);
}
int Viewport::get_positional_shadow_atlas_size() const {
ERR_READ_THREAD_GUARD_V(0);
return positional_shadow_atlas_size;
}
void Viewport::set_positional_shadow_atlas_16_bits(bool p_16_bits) {
ERR_MAIN_THREAD_GUARD;
if (positional_shadow_atlas_16_bits == p_16_bits) {
return;
}
@ -1282,9 +1311,11 @@ void Viewport::set_positional_shadow_atlas_16_bits(bool p_16_bits) {
}
bool Viewport::get_positional_shadow_atlas_16_bits() const {
ERR_READ_THREAD_GUARD_V(false);
return positional_shadow_atlas_16_bits;
}
void Viewport::set_positional_shadow_atlas_quadrant_subdiv(int p_quadrant, PositionalShadowAtlasQuadrantSubdiv p_subdiv) {
ERR_MAIN_THREAD_GUARD;
ERR_FAIL_INDEX(p_quadrant, 4);
ERR_FAIL_INDEX(p_subdiv, SHADOW_ATLAS_QUADRANT_SUBDIV_MAX);
@ -1299,6 +1330,7 @@ void Viewport::set_positional_shadow_atlas_quadrant_subdiv(int p_quadrant, Posit
}
Viewport::PositionalShadowAtlasQuadrantSubdiv Viewport::get_positional_shadow_atlas_quadrant_subdiv(int p_quadrant) const {
ERR_READ_THREAD_GUARD_V(SHADOW_ATLAS_QUADRANT_SUBDIV_DISABLED);
ERR_FAIL_INDEX_V(p_quadrant, 4, SHADOW_ATLAS_QUADRANT_SUBDIV_DISABLED);
return positional_shadow_atlas_quadrant_subdiv[p_quadrant];
}
@ -1313,6 +1345,7 @@ Ref<InputEvent> Viewport::_make_input_local(const Ref<InputEvent> &ev) {
}
Vector2 Viewport::get_mouse_position() const {
ERR_READ_THREAD_GUARD_V(Vector2());
if (DisplayServer::get_singleton()->has_feature(DisplayServer::FEATURE_MOUSE)) {
return get_screen_transform_internal(true).affine_inverse().xform(DisplayServer::get_singleton()->mouse_get_position());
} else {
@ -1322,6 +1355,7 @@ Vector2 Viewport::get_mouse_position() const {
}
void Viewport::warp_mouse(const Vector2 &p_position) {
ERR_MAIN_THREAD_GUARD;
Transform2D xform = get_screen_transform_internal();
Vector2 gpos = xform.xform(p_position);
Input::get_singleton()->warp_mouse(gpos);
@ -1565,6 +1599,7 @@ void Viewport::_gui_call_notification(Control *p_control, int p_what) {
}
Control *Viewport::gui_find_control(const Point2 &p_global) {
ERR_MAIN_THREAD_GUARD_V(nullptr);
// Handle subwindows.
_gui_sort_roots();
@ -2274,6 +2309,7 @@ List<Control *>::Element *Viewport::_gui_add_root_control(Control *p_control) {
}
void Viewport::gui_set_root_order_dirty() {
ERR_MAIN_THREAD_GUARD;
gui.roots_order_dirty = true;
}
@ -2374,6 +2410,7 @@ void Viewport::_gui_remove_control(Control *p_control) {
}
Window *Viewport::get_base_window() const {
ERR_READ_THREAD_GUARD_V(nullptr);
ERR_FAIL_COND_V(!is_inside_tree(), nullptr);
Viewport *v = const_cast<Viewport *>(this);
@ -2576,6 +2613,7 @@ void Viewport::_post_gui_grab_click_focus() {
///////////////////////////////
void Viewport::push_text_input(const String &p_text) {
ERR_MAIN_THREAD_GUARD;
if (gui.subwindow_focused) {
gui.subwindow_focused->push_text_input(p_text);
return;
@ -2903,6 +2941,7 @@ bool Viewport::_sub_windows_forward_input(const Ref<InputEvent> &p_event) {
}
void Viewport::push_input(const Ref<InputEvent> &p_event, bool p_local_coords) {
ERR_MAIN_THREAD_GUARD;
ERR_FAIL_COND(!is_inside_tree());
if (disable_input) {
@ -2955,6 +2994,7 @@ void Viewport::push_input(const Ref<InputEvent> &p_event, bool p_local_coords) {
}
void Viewport::push_unhandled_input(const Ref<InputEvent> &p_event, bool p_local_coords) {
ERR_MAIN_THREAD_GUARD;
ERR_FAIL_COND(p_event.is_null());
ERR_FAIL_COND(!is_inside_tree());
local_input_handled = false;
@ -3004,6 +3044,7 @@ void Viewport::push_unhandled_input(const Ref<InputEvent> &p_event, bool p_local
}
void Viewport::set_physics_object_picking(bool p_enable) {
ERR_MAIN_THREAD_GUARD;
physics_object_picking = p_enable;
if (physics_object_picking) {
add_to_group("_picking_viewports");
@ -3016,27 +3057,33 @@ void Viewport::set_physics_object_picking(bool p_enable) {
}
bool Viewport::get_physics_object_picking() {
ERR_READ_THREAD_GUARD_V(false);
return physics_object_picking;
}
void Viewport::set_physics_object_picking_sort(bool p_enable) {
ERR_MAIN_THREAD_GUARD;
physics_object_picking_sort = p_enable;
}
bool Viewport::get_physics_object_picking_sort() {
ERR_READ_THREAD_GUARD_V(false);
return physics_object_picking_sort;
}
Vector2 Viewport::get_camera_coords(const Vector2 &p_viewport_coords) const {
ERR_READ_THREAD_GUARD_V(Vector2());
Transform2D xf = stretch_transform * global_canvas_transform;
return xf.xform(p_viewport_coords);
}
Vector2 Viewport::get_camera_rect_size() const {
ERR_READ_THREAD_GUARD_V(Vector2());
return size;
}
void Viewport::set_disable_input(bool p_disable) {
ERR_MAIN_THREAD_GUARD;
if (p_disable == disable_input) {
return;
}
@ -3049,14 +3096,17 @@ void Viewport::set_disable_input(bool p_disable) {
}
bool Viewport::is_input_disabled() const {
ERR_READ_THREAD_GUARD_V(false);
return disable_input;
}
Variant Viewport::gui_get_drag_data() const {
ERR_READ_THREAD_GUARD_V(Variant());
return gui.drag_data;
}
PackedStringArray Viewport::get_configuration_warnings() const {
ERR_MAIN_THREAD_GUARD_V(PackedStringArray());
PackedStringArray warnings = Node::get_configuration_warnings();
if (size.x <= 1 || size.y <= 1) {
@ -3066,14 +3116,17 @@ PackedStringArray Viewport::get_configuration_warnings() const {
}
void Viewport::gui_reset_canvas_sort_index() {
ERR_MAIN_THREAD_GUARD;
gui.canvas_sort_index = 0;
}
int Viewport::gui_get_canvas_sort_index() {
ERR_MAIN_THREAD_GUARD_V(0);
return gui.canvas_sort_index++;
}
void Viewport::gui_release_focus() {
ERR_MAIN_THREAD_GUARD;
if (gui.key_focus) {
Control *f = gui.key_focus;
gui.key_focus = nullptr;
@ -3083,10 +3136,12 @@ void Viewport::gui_release_focus() {
}
Control *Viewport::gui_get_focus_owner() {
ERR_READ_THREAD_GUARD_V(nullptr);
return gui.key_focus;
}
void Viewport::set_msaa_2d(MSAA p_msaa) {
ERR_MAIN_THREAD_GUARD;
ERR_FAIL_INDEX(p_msaa, MSAA_MAX);
if (msaa_2d == p_msaa) {
return;
@ -3096,10 +3151,12 @@ void Viewport::set_msaa_2d(MSAA p_msaa) {
}
Viewport::MSAA Viewport::get_msaa_2d() const {
ERR_READ_THREAD_GUARD_V(MSAA_DISABLED);
return msaa_2d;
}
void Viewport::set_msaa_3d(MSAA p_msaa) {
ERR_MAIN_THREAD_GUARD;
ERR_FAIL_INDEX(p_msaa, MSAA_MAX);
if (msaa_3d == p_msaa) {
return;
@ -3109,10 +3166,12 @@ void Viewport::set_msaa_3d(MSAA p_msaa) {
}
Viewport::MSAA Viewport::get_msaa_3d() const {
ERR_READ_THREAD_GUARD_V(MSAA_DISABLED);
return msaa_3d;
}
void Viewport::set_screen_space_aa(ScreenSpaceAA p_screen_space_aa) {
ERR_MAIN_THREAD_GUARD;
ERR_FAIL_INDEX(p_screen_space_aa, SCREEN_SPACE_AA_MAX);
if (screen_space_aa == p_screen_space_aa) {
return;
@ -3122,10 +3181,12 @@ void Viewport::set_screen_space_aa(ScreenSpaceAA p_screen_space_aa) {
}
Viewport::ScreenSpaceAA Viewport::get_screen_space_aa() const {
ERR_READ_THREAD_GUARD_V(SCREEN_SPACE_AA_DISABLED);
return screen_space_aa;
}
void Viewport::set_use_taa(bool p_use_taa) {
ERR_MAIN_THREAD_GUARD;
if (use_taa == p_use_taa) {
return;
}
@ -3134,10 +3195,12 @@ void Viewport::set_use_taa(bool p_use_taa) {
}
bool Viewport::is_using_taa() const {
ERR_READ_THREAD_GUARD_V(false);
return use_taa;
}
void Viewport::set_use_debanding(bool p_use_debanding) {
ERR_MAIN_THREAD_GUARD;
if (use_debanding == p_use_debanding) {
return;
}
@ -3146,19 +3209,23 @@ void Viewport::set_use_debanding(bool p_use_debanding) {
}
bool Viewport::is_using_debanding() const {
ERR_READ_THREAD_GUARD_V(false);
return use_debanding;
}
void Viewport::set_mesh_lod_threshold(float p_pixels) {
ERR_MAIN_THREAD_GUARD;
mesh_lod_threshold = p_pixels;
RS::get_singleton()->viewport_set_mesh_lod_threshold(viewport, mesh_lod_threshold);
}
float Viewport::get_mesh_lod_threshold() const {
ERR_READ_THREAD_GUARD_V(0);
return mesh_lod_threshold;
}
void Viewport::set_use_occlusion_culling(bool p_use_occlusion_culling) {
ERR_MAIN_THREAD_GUARD;
if (use_occlusion_culling == p_use_occlusion_culling) {
return;
}
@ -3170,57 +3237,70 @@ void Viewport::set_use_occlusion_culling(bool p_use_occlusion_culling) {
}
bool Viewport::is_using_occlusion_culling() const {
ERR_READ_THREAD_GUARD_V(false);
return use_occlusion_culling;
}
void Viewport::set_debug_draw(DebugDraw p_debug_draw) {
ERR_MAIN_THREAD_GUARD;
debug_draw = p_debug_draw;
RS::get_singleton()->viewport_set_debug_draw(viewport, RS::ViewportDebugDraw(p_debug_draw));
}
Viewport::DebugDraw Viewport::get_debug_draw() const {
ERR_READ_THREAD_GUARD_V(DEBUG_DRAW_DISABLED);
return debug_draw;
}
int Viewport::get_render_info(RenderInfoType p_type, RenderInfo p_info) {
ERR_READ_THREAD_GUARD_V(0);
return RS::get_singleton()->viewport_get_render_info(viewport, RS::ViewportRenderInfoType(p_type), RS::ViewportRenderInfo(p_info));
}
void Viewport::set_snap_controls_to_pixels(bool p_enable) {
ERR_MAIN_THREAD_GUARD;
snap_controls_to_pixels = p_enable;
}
bool Viewport::is_snap_controls_to_pixels_enabled() const {
ERR_READ_THREAD_GUARD_V(false);
return snap_controls_to_pixels;
}
void Viewport::set_snap_2d_transforms_to_pixel(bool p_enable) {
ERR_MAIN_THREAD_GUARD;
snap_2d_transforms_to_pixel = p_enable;
RS::get_singleton()->viewport_set_snap_2d_transforms_to_pixel(viewport, snap_2d_transforms_to_pixel);
}
bool Viewport::is_snap_2d_transforms_to_pixel_enabled() const {
ERR_READ_THREAD_GUARD_V(false);
return snap_2d_transforms_to_pixel;
}
void Viewport::set_snap_2d_vertices_to_pixel(bool p_enable) {
ERR_MAIN_THREAD_GUARD;
snap_2d_vertices_to_pixel = p_enable;
RS::get_singleton()->viewport_set_snap_2d_vertices_to_pixel(viewport, snap_2d_vertices_to_pixel);
}
bool Viewport::is_snap_2d_vertices_to_pixel_enabled() const {
ERR_READ_THREAD_GUARD_V(false);
return snap_2d_vertices_to_pixel;
}
bool Viewport::gui_is_dragging() const {
ERR_READ_THREAD_GUARD_V(false);
return gui.dragging;
}
bool Viewport::gui_is_drag_successful() const {
ERR_READ_THREAD_GUARD_V(false);
return gui.drag_successful;
}
void Viewport::set_input_as_handled() {
ERR_MAIN_THREAD_GUARD;
if (!handle_input_locally) {
ERR_FAIL_COND(!is_inside_tree());
Viewport *vp = this;
@ -3243,6 +3323,7 @@ void Viewport::set_input_as_handled() {
}
bool Viewport::is_input_handled() const {
ERR_READ_THREAD_GUARD_V(false);
if (!handle_input_locally) {
ERR_FAIL_COND_V(!is_inside_tree(), false);
const Viewport *vp = this;
@ -3263,14 +3344,17 @@ bool Viewport::is_input_handled() const {
}
void Viewport::set_handle_input_locally(bool p_enable) {
ERR_MAIN_THREAD_GUARD;
handle_input_locally = p_enable;
}
bool Viewport::is_handling_input_locally() const {
ERR_READ_THREAD_GUARD_V(false);
return handle_input_locally;
}
void Viewport::set_default_canvas_item_texture_filter(DefaultCanvasItemTextureFilter p_filter) {
ERR_MAIN_THREAD_GUARD;
ERR_FAIL_INDEX(p_filter, DEFAULT_CANVAS_ITEM_TEXTURE_FILTER_MAX);
if (default_canvas_item_texture_filter == p_filter) {
@ -3296,10 +3380,12 @@ void Viewport::set_default_canvas_item_texture_filter(DefaultCanvasItemTextureFi
}
Viewport::DefaultCanvasItemTextureFilter Viewport::get_default_canvas_item_texture_filter() const {
ERR_READ_THREAD_GUARD_V(DEFAULT_CANVAS_ITEM_TEXTURE_FILTER_NEAREST);
return default_canvas_item_texture_filter;
}
void Viewport::set_default_canvas_item_texture_repeat(DefaultCanvasItemTextureRepeat p_repeat) {
ERR_MAIN_THREAD_GUARD;
ERR_FAIL_INDEX(p_repeat, DEFAULT_CANVAS_ITEM_TEXTURE_REPEAT_MAX);
if (default_canvas_item_texture_repeat == p_repeat) {
@ -3324,10 +3410,12 @@ void Viewport::set_default_canvas_item_texture_repeat(DefaultCanvasItemTextureRe
}
Viewport::DefaultCanvasItemTextureRepeat Viewport::get_default_canvas_item_texture_repeat() const {
ERR_READ_THREAD_GUARD_V(DEFAULT_CANVAS_ITEM_TEXTURE_REPEAT_DISABLED);
return default_canvas_item_texture_repeat;
}
void Viewport::set_vrs_mode(Viewport::VRSMode p_vrs_mode) {
ERR_MAIN_THREAD_GUARD;
// Note, set this even if not supported on this hardware, it will only be used if it is but we want to save the value as set by the user.
vrs_mode = p_vrs_mode;
@ -3347,10 +3435,12 @@ void Viewport::set_vrs_mode(Viewport::VRSMode p_vrs_mode) {
}
Viewport::VRSMode Viewport::get_vrs_mode() const {
ERR_READ_THREAD_GUARD_V(VRS_DISABLED);
return vrs_mode;
}
void Viewport::set_vrs_texture(Ref<Texture2D> p_texture) {
ERR_MAIN_THREAD_GUARD;
vrs_texture = p_texture;
// TODO need to add something here in case the RID changes
@ -3359,14 +3449,17 @@ void Viewport::set_vrs_texture(Ref<Texture2D> p_texture) {
}
Ref<Texture2D> Viewport::get_vrs_texture() const {
ERR_READ_THREAD_GUARD_V(Ref<Texture2D>());
return vrs_texture;
}
DisplayServer::WindowID Viewport::get_window_id() const {
ERR_READ_THREAD_GUARD_V(DisplayServer::INVALID_WINDOW_ID);
return DisplayServer::MAIN_WINDOW_ID;
}
Viewport *Viewport::get_parent_viewport() const {
ERR_READ_THREAD_GUARD_V(nullptr);
ERR_FAIL_COND_V(!is_inside_tree(), nullptr);
if (!get_parent()) {
return nullptr; //root viewport
@ -3376,14 +3469,17 @@ Viewport *Viewport::get_parent_viewport() const {
}
void Viewport::set_embedding_subwindows(bool p_embed) {
ERR_THREAD_GUARD;
gui.embed_subwindows_hint = p_embed;
}
bool Viewport::is_embedding_subwindows() const {
ERR_READ_THREAD_GUARD_V(false);
return gui.embed_subwindows_hint;
}
void Viewport::pass_mouse_focus_to(Viewport *p_viewport, Control *p_control) {
ERR_MAIN_THREAD_GUARD;
ERR_FAIL_NULL(p_viewport);
ERR_FAIL_NULL(p_control);
@ -3400,43 +3496,52 @@ void Viewport::pass_mouse_focus_to(Viewport *p_viewport, Control *p_control) {
}
void Viewport::set_sdf_oversize(SDFOversize p_sdf_oversize) {
ERR_MAIN_THREAD_GUARD;
ERR_FAIL_INDEX(p_sdf_oversize, SDF_OVERSIZE_MAX);
sdf_oversize = p_sdf_oversize;
RS::get_singleton()->viewport_set_sdf_oversize_and_scale(viewport, RS::ViewportSDFOversize(sdf_oversize), RS::ViewportSDFScale(sdf_scale));
}
Viewport::SDFOversize Viewport::get_sdf_oversize() const {
ERR_READ_THREAD_GUARD_V(SDF_OVERSIZE_100_PERCENT);
return sdf_oversize;
}
void Viewport::set_sdf_scale(SDFScale p_sdf_scale) {
ERR_MAIN_THREAD_GUARD;
ERR_FAIL_INDEX(p_sdf_scale, SDF_SCALE_MAX);
sdf_scale = p_sdf_scale;
RS::get_singleton()->viewport_set_sdf_oversize_and_scale(viewport, RS::ViewportSDFOversize(sdf_oversize), RS::ViewportSDFScale(sdf_scale));
}
Viewport::SDFScale Viewport::get_sdf_scale() const {
ERR_READ_THREAD_GUARD_V(SDF_SCALE_100_PERCENT);
return sdf_scale;
}
Transform2D Viewport::get_screen_transform() const {
ERR_READ_THREAD_GUARD_V(Transform2D());
return get_screen_transform_internal();
}
Transform2D Viewport::get_screen_transform_internal(bool p_absolute_position) const {
ERR_READ_THREAD_GUARD_V(Transform2D());
return get_final_transform();
}
void Viewport::set_canvas_cull_mask(uint32_t p_canvas_cull_mask) {
ERR_MAIN_THREAD_GUARD;
canvas_cull_mask = p_canvas_cull_mask;
RenderingServer::get_singleton()->viewport_set_canvas_cull_mask(viewport, canvas_cull_mask);
}
uint32_t Viewport::get_canvas_cull_mask() const {
ERR_READ_THREAD_GUARD_V(0);
return canvas_cull_mask;
}
void Viewport::set_canvas_cull_mask_bit(uint32_t p_layer, bool p_enable) {
ERR_MAIN_THREAD_GUARD;
ERR_FAIL_UNSIGNED_INDEX(p_layer, 32);
if (p_enable) {
set_canvas_cull_mask(canvas_cull_mask | (1 << p_layer));
@ -3446,16 +3551,19 @@ void Viewport::set_canvas_cull_mask_bit(uint32_t p_layer, bool p_enable) {
}
bool Viewport::get_canvas_cull_mask_bit(uint32_t p_layer) const {
ERR_READ_THREAD_GUARD_V(false);
ERR_FAIL_UNSIGNED_INDEX_V(p_layer, 32, false);
return (canvas_cull_mask & (1 << p_layer));
}
#ifndef _3D_DISABLED
AudioListener3D *Viewport::get_audio_listener_3d() const {
ERR_READ_THREAD_GUARD_V(nullptr);
return audio_listener_3d;
}
void Viewport::set_as_audio_listener_3d(bool p_enable) {
ERR_MAIN_THREAD_GUARD;
if (p_enable == is_audio_listener_3d_enabled) {
return;
}
@ -3465,6 +3573,7 @@ void Viewport::set_as_audio_listener_3d(bool p_enable) {
}
bool Viewport::is_audio_listener_3d() const {
ERR_READ_THREAD_GUARD_V(false);
return is_audio_listener_3d_enabled;
}
@ -3543,6 +3652,7 @@ void Viewport::_collision_object_3d_input_event(CollisionObject3D *p_object, Cam
}
Camera3D *Viewport::get_camera_3d() const {
ERR_READ_THREAD_GUARD_V(nullptr);
return camera_3d;
}
@ -3606,6 +3716,7 @@ void Viewport::_camera_3d_make_next_current(Camera3D *p_exclude) {
}
void Viewport::enable_camera_3d_override(bool p_enable) {
ERR_MAIN_THREAD_GUARD;
if (p_enable == camera_3d_override) {
return;
}
@ -3627,6 +3738,7 @@ void Viewport::enable_camera_3d_override(bool p_enable) {
}
void Viewport::set_camera_3d_override_perspective(real_t p_fovy_degrees, real_t p_z_near, real_t p_z_far) {
ERR_MAIN_THREAD_GUARD;
if (camera_3d_override) {
if (camera_3d_override.fov == p_fovy_degrees && camera_3d_override.z_near == p_z_near &&
camera_3d_override.z_far == p_z_far && camera_3d_override.projection == Camera3DOverrideData::PROJECTION_PERSPECTIVE) {
@ -3643,6 +3755,7 @@ void Viewport::set_camera_3d_override_perspective(real_t p_fovy_degrees, real_t
}
void Viewport::set_camera_3d_override_orthogonal(real_t p_size, real_t p_z_near, real_t p_z_far) {
ERR_MAIN_THREAD_GUARD;
if (camera_3d_override) {
if (camera_3d_override.size == p_size && camera_3d_override.z_near == p_z_near &&
camera_3d_override.z_far == p_z_far && camera_3d_override.projection == Camera3DOverrideData::PROJECTION_ORTHOGONAL) {
@ -3659,19 +3772,23 @@ void Viewport::set_camera_3d_override_orthogonal(real_t p_size, real_t p_z_near,
}
void Viewport::set_disable_3d(bool p_disable) {
ERR_MAIN_THREAD_GUARD;
disable_3d = p_disable;
RenderingServer::get_singleton()->viewport_set_disable_3d(viewport, disable_3d);
}
bool Viewport::is_3d_disabled() const {
ERR_READ_THREAD_GUARD_V(false);
return disable_3d;
}
bool Viewport::is_camera_3d_override_enabled() const {
ERR_READ_THREAD_GUARD_V(false);
return camera_3d_override;
}
void Viewport::set_camera_3d_override_transform(const Transform3D &p_transform) {
ERR_MAIN_THREAD_GUARD;
if (camera_3d_override) {
camera_3d_override.transform = p_transform;
RenderingServer::get_singleton()->camera_set_transform(camera_3d_override.rid, p_transform);
@ -3679,6 +3796,7 @@ void Viewport::set_camera_3d_override_transform(const Transform3D &p_transform)
}
Transform3D Viewport::get_camera_3d_override_transform() const {
ERR_READ_THREAD_GUARD_V(Transform3D());
if (camera_3d_override) {
return camera_3d_override.transform;
}
@ -3687,10 +3805,12 @@ Transform3D Viewport::get_camera_3d_override_transform() const {
}
Ref<World3D> Viewport::get_world_3d() const {
ERR_READ_THREAD_GUARD_V(Ref<World3D>());
return world_3d;
}
Ref<World3D> Viewport::find_world_3d() const {
ERR_READ_THREAD_GUARD_V(Ref<World3D>());
if (own_world_3d.is_valid()) {
return own_world_3d;
} else if (world_3d.is_valid()) {
@ -3703,6 +3823,7 @@ Ref<World3D> Viewport::find_world_3d() const {
}
void Viewport::set_world_3d(const Ref<World3D> &p_world_3d) {
ERR_MAIN_THREAD_GUARD;
if (world_3d == p_world_3d) {
return;
}
@ -3759,6 +3880,7 @@ void Viewport::_own_world_3d_changed() {
}
void Viewport::set_use_own_world_3d(bool p_use_own_world_3d) {
ERR_MAIN_THREAD_GUARD;
if (p_use_own_world_3d == own_world_3d.is_valid()) {
return;
}
@ -3793,6 +3915,7 @@ void Viewport::set_use_own_world_3d(bool p_use_own_world_3d) {
}
bool Viewport::is_using_own_world_3d() const {
ERR_READ_THREAD_GUARD_V(false);
return own_world_3d.is_valid();
}
@ -3843,6 +3966,7 @@ void Viewport::_propagate_exit_world_3d(Node *p_node) {
}
void Viewport::set_use_xr(bool p_use_xr) {
ERR_MAIN_THREAD_GUARD;
if (use_xr != p_use_xr) {
use_xr = p_use_xr;
@ -3860,10 +3984,12 @@ void Viewport::set_use_xr(bool p_use_xr) {
}
bool Viewport::is_using_xr() {
ERR_READ_THREAD_GUARD_V(false);
return use_xr;
}
void Viewport::set_scaling_3d_mode(Scaling3DMode p_scaling_3d_mode) {
ERR_MAIN_THREAD_GUARD;
if (scaling_3d_mode == p_scaling_3d_mode) {
return;
}
@ -3873,10 +3999,12 @@ void Viewport::set_scaling_3d_mode(Scaling3DMode p_scaling_3d_mode) {
}
Viewport::Scaling3DMode Viewport::get_scaling_3d_mode() const {
ERR_READ_THREAD_GUARD_V(SCALING_3D_MODE_BILINEAR);
return scaling_3d_mode;
}
void Viewport::set_scaling_3d_scale(float p_scaling_3d_scale) {
ERR_MAIN_THREAD_GUARD;
// Clamp to reasonable values that are actually useful.
// Values above 2.0 don't serve a practical purpose since the viewport
// isn't displayed with mipmaps.
@ -3886,10 +4014,12 @@ void Viewport::set_scaling_3d_scale(float p_scaling_3d_scale) {
}
float Viewport::get_scaling_3d_scale() const {
ERR_READ_THREAD_GUARD_V(0);
return scaling_3d_scale;
}
void Viewport::set_fsr_sharpness(float p_fsr_sharpness) {
ERR_MAIN_THREAD_GUARD;
if (fsr_sharpness == p_fsr_sharpness) {
return;
}
@ -3903,10 +4033,12 @@ void Viewport::set_fsr_sharpness(float p_fsr_sharpness) {
}
float Viewport::get_fsr_sharpness() const {
ERR_READ_THREAD_GUARD_V(0);
return fsr_sharpness;
}
void Viewport::set_texture_mipmap_bias(float p_texture_mipmap_bias) {
ERR_MAIN_THREAD_GUARD;
if (texture_mipmap_bias == p_texture_mipmap_bias) {
return;
}
@ -3916,6 +4048,7 @@ void Viewport::set_texture_mipmap_bias(float p_texture_mipmap_bias) {
}
float Viewport::get_texture_mipmap_bias() const {
ERR_READ_THREAD_GUARD_V(0);
return texture_mipmap_bias;
}
@ -4309,10 +4442,12 @@ Viewport::~Viewport() {
/////////////////////////////////
void SubViewport::set_size(const Size2i &p_size) {
ERR_MAIN_THREAD_GUARD;
_internal_set_size(p_size);
}
void SubViewport::set_size_force(const Size2i &p_size) {
ERR_MAIN_THREAD_GUARD;
// Use only for setting the size from the parent SubViewportContainer with enabled stretch mode.
// Don't expose function to scripting.
_internal_set_size(p_size, true);
@ -4335,18 +4470,22 @@ void SubViewport::_internal_set_size(const Size2i &p_size, bool p_force) {
}
Size2i SubViewport::get_size() const {
ERR_READ_THREAD_GUARD_V(Size2());
return _get_size();
}
void SubViewport::set_size_2d_override(const Size2i &p_size) {
ERR_MAIN_THREAD_GUARD;
_set_size(_get_size(), p_size, true);
}
Size2i SubViewport::get_size_2d_override() const {
ERR_READ_THREAD_GUARD_V(Size2i());
return _get_size_2d_override();
}
void SubViewport::set_size_2d_override_stretch(bool p_enable) {
ERR_MAIN_THREAD_GUARD;
if (p_enable == size_2d_override_stretch) {
return;
}
@ -4356,32 +4495,39 @@ void SubViewport::set_size_2d_override_stretch(bool p_enable) {
}
bool SubViewport::is_size_2d_override_stretch_enabled() const {
ERR_READ_THREAD_GUARD_V(false);
return size_2d_override_stretch;
}
void SubViewport::set_update_mode(UpdateMode p_mode) {
ERR_MAIN_THREAD_GUARD;
update_mode = p_mode;
RS::get_singleton()->viewport_set_update_mode(get_viewport_rid(), RS::ViewportUpdateMode(p_mode));
}
SubViewport::UpdateMode SubViewport::get_update_mode() const {
ERR_READ_THREAD_GUARD_V(UPDATE_DISABLED);
return update_mode;
}
void SubViewport::set_clear_mode(ClearMode p_mode) {
ERR_MAIN_THREAD_GUARD;
clear_mode = p_mode;
RS::get_singleton()->viewport_set_clear_mode(get_viewport_rid(), RS::ViewportClearMode(p_mode));
}
SubViewport::ClearMode SubViewport::get_clear_mode() const {
ERR_READ_THREAD_GUARD_V(CLEAR_MODE_ALWAYS);
return clear_mode;
}
DisplayServer::WindowID SubViewport::get_window_id() const {
ERR_READ_THREAD_GUARD_V(DisplayServer::INVALID_WINDOW_ID);
return DisplayServer::INVALID_WINDOW_ID;
}
Transform2D SubViewport::get_screen_transform_internal(bool p_absolute_position) const {
ERR_READ_THREAD_GUARD_V(Transform2D());
Transform2D container_transform;
SubViewportContainer *c = Object::cast_to<SubViewportContainer>(get_parent());
if (c) {
@ -4396,6 +4542,7 @@ Transform2D SubViewport::get_screen_transform_internal(bool p_absolute_position)
}
Transform2D SubViewport::get_popup_base_transform() const {
ERR_READ_THREAD_GUARD_V(Transform2D());
if (is_embedding_subwindows()) {
return Transform2D();
}
@ -4411,6 +4558,7 @@ Transform2D SubViewport::get_popup_base_transform() const {
}
void SubViewport::_notification(int p_what) {
ERR_MAIN_THREAD_GUARD;
switch (p_what) {
case NOTIFICATION_ENTER_TREE: {
RS::get_singleton()->viewport_set_active(get_viewport_rid(), true);

134
scene/main/window.cpp
View File

@ -43,6 +43,8 @@
// Dynamic properties.
bool Window::_set(const StringName &p_name, const Variant &p_value) {
ERR_MAIN_THREAD_GUARD_V(false);
String name = p_name;
if (!name.begins_with("theme_override")) {
return false;
@ -113,6 +115,8 @@ bool Window::_set(const StringName &p_name, const Variant &p_value) {
}
bool Window::_get(const StringName &p_name, Variant &r_ret) const {
ERR_READ_THREAD_GUARD_V(false);
String sname = p_name;
if (!sname.begins_with("theme_override")) {
return false;
@ -144,6 +148,8 @@ bool Window::_get(const StringName &p_name, Variant &r_ret) const {
}
void Window::_get_property_list(List<PropertyInfo> *p_list) const {
ERR_READ_THREAD_GUARD;
Ref<Theme> default_theme = ThemeDB::get_singleton()->get_default_theme();
p_list->push_back(PropertyInfo(Variant::NIL, GNAME("Theme Overrides", "theme_override_"), PROPERTY_HINT_NONE, "theme_override_", PROPERTY_USAGE_GROUP));
@ -261,6 +267,8 @@ void Window::_validate_property(PropertyInfo &p_property) const {
//
void Window::set_title(const String &p_title) {
ERR_MAIN_THREAD_GUARD;
title = p_title;
if (embedder) {
@ -280,19 +288,25 @@ void Window::set_title(const String &p_title) {
}
String Window::get_title() const {
ERR_READ_THREAD_GUARD_V(String());
return title;
}
void Window::set_initial_position(Window::WindowInitialPosition p_initial_position) {
ERR_MAIN_THREAD_GUARD;
initial_position = p_initial_position;
notify_property_list_changed();
}
Window::WindowInitialPosition Window::get_initial_position() const {
ERR_READ_THREAD_GUARD_V(WINDOW_INITIAL_POSITION_ABSOLUTE);
return initial_position;
}
void Window::set_current_screen(int p_screen) {
ERR_MAIN_THREAD_GUARD;
current_screen = p_screen;
if (window_id == DisplayServer::INVALID_WINDOW_ID) {
return;
@ -301,6 +315,8 @@ void Window::set_current_screen(int p_screen) {
}
int Window::get_current_screen() const {
ERR_READ_THREAD_GUARD_V(0);
if (window_id != DisplayServer::INVALID_WINDOW_ID) {
current_screen = DisplayServer::get_singleton()->window_get_current_screen(window_id);
}
@ -308,6 +324,8 @@ int Window::get_current_screen() const {
}
void Window::set_position(const Point2i &p_position) {
ERR_MAIN_THREAD_GUARD;
position = p_position;
if (embedder) {
@ -319,23 +337,30 @@ void Window::set_position(const Point2i &p_position) {
}
Point2i Window::get_position() const {
ERR_READ_THREAD_GUARD_V(Point2i());
return position;
}
void Window::set_size(const Size2i &p_size) {
ERR_MAIN_THREAD_GUARD;
size = p_size;
_update_window_size();
}
Size2i Window::get_size() const {
ERR_READ_THREAD_GUARD_V(Size2i());
return size;
}
void Window::reset_size() {
ERR_MAIN_THREAD_GUARD;
set_size(Size2i());
}
Point2i Window::get_position_with_decorations() const {
ERR_READ_THREAD_GUARD_V(Point2i());
if (window_id != DisplayServer::INVALID_WINDOW_ID) {
return DisplayServer::get_singleton()->window_get_position_with_decorations(window_id);
}
@ -343,6 +368,7 @@ Point2i Window::get_position_with_decorations() const {
}
Size2i Window::get_size_with_decorations() const {
ERR_READ_THREAD_GUARD_V(Size2i());
if (window_id != DisplayServer::INVALID_WINDOW_ID) {
return DisplayServer::get_singleton()->window_get_size_with_decorations(window_id);
}
@ -366,6 +392,7 @@ void Window::_validate_limit_size() {
}
void Window::set_max_size(const Size2i &p_max_size) {
ERR_MAIN_THREAD_GUARD;
Size2i max_size_clamped = _clamp_limit_size(p_max_size);
if (max_size == max_size_clamped) {
return;
@ -377,10 +404,12 @@ void Window::set_max_size(const Size2i &p_max_size) {
}
Size2i Window::get_max_size() const {
ERR_READ_THREAD_GUARD_V(Size2i());
return max_size;
}
void Window::set_min_size(const Size2i &p_min_size) {
ERR_MAIN_THREAD_GUARD;
Size2i min_size_clamped = _clamp_limit_size(p_min_size);
if (min_size == min_size_clamped) {
return;
@ -392,10 +421,12 @@ void Window::set_min_size(const Size2i &p_min_size) {
}
Size2i Window::get_min_size() const {
ERR_READ_THREAD_GUARD_V(Size2i());
return min_size;
}
void Window::set_mode(Mode p_mode) {
ERR_MAIN_THREAD_GUARD;
mode = p_mode;
if (embedder) {
@ -407,6 +438,7 @@ void Window::set_mode(Mode p_mode) {
}
Window::Mode Window::get_mode() const {
ERR_READ_THREAD_GUARD_V(MODE_WINDOWED);
if (window_id != DisplayServer::INVALID_WINDOW_ID) {
mode = (Mode)DisplayServer::get_singleton()->window_get_mode(window_id);
}
@ -414,6 +446,7 @@ Window::Mode Window::get_mode() const {
}
void Window::set_flag(Flags p_flag, bool p_enabled) {
ERR_MAIN_THREAD_GUARD;
ERR_FAIL_INDEX(p_flag, FLAG_MAX);
flags[p_flag] = p_enabled;
@ -428,6 +461,7 @@ void Window::set_flag(Flags p_flag, bool p_enabled) {
}
bool Window::get_flag(Flags p_flag) const {
ERR_READ_THREAD_GUARD_V(false);
ERR_FAIL_INDEX_V(p_flag, FLAG_MAX, false);
if (window_id != DisplayServer::INVALID_WINDOW_ID) {
if (!is_in_edited_scene_root()) {
@ -438,6 +472,7 @@ bool Window::get_flag(Flags p_flag) const {
}
bool Window::is_maximize_allowed() const {
ERR_READ_THREAD_GUARD_V(false);
if (window_id != DisplayServer::INVALID_WINDOW_ID) {
return DisplayServer::get_singleton()->window_is_maximize_allowed(window_id);
}
@ -445,12 +480,14 @@ bool Window::is_maximize_allowed() const {
}
void Window::request_attention() {
ERR_MAIN_THREAD_GUARD;
if (window_id != DisplayServer::INVALID_WINDOW_ID) {
DisplayServer::get_singleton()->window_request_attention(window_id);
}
}
void Window::move_to_foreground() {
ERR_MAIN_THREAD_GUARD;
if (embedder) {
embedder->_sub_window_grab_focus(this);
@ -460,6 +497,7 @@ void Window::move_to_foreground() {
}
bool Window::can_draw() const {
ERR_READ_THREAD_GUARD_V(false);
if (!is_inside_tree()) {
return false;
}
@ -471,24 +509,28 @@ bool Window::can_draw() const {
}
void Window::set_ime_active(bool p_active) {
ERR_MAIN_THREAD_GUARD;
if (window_id != DisplayServer::INVALID_WINDOW_ID) {
DisplayServer::get_singleton()->window_set_ime_active(p_active, window_id);
}
}
void Window::set_ime_position(const Point2i &p_pos) {
ERR_MAIN_THREAD_GUARD;
if (window_id != DisplayServer::INVALID_WINDOW_ID) {
DisplayServer::get_singleton()->window_set_ime_position(p_pos, window_id);
}
}
bool Window::is_embedded() const {
ERR_READ_THREAD_GUARD_V(false);
ERR_FAIL_COND_V(!is_inside_tree(), false);
return get_embedder() != nullptr;
}
bool Window::is_in_edited_scene_root() const {
ERR_READ_THREAD_GUARD_V(false);
#ifdef TOOLS_ENABLED
return is_part_of_edited_scene();
#else
@ -680,6 +722,7 @@ void Window::_event_callback(DisplayServer::WindowEvent p_event) {
}
void Window::update_mouse_cursor_shape() {
ERR_MAIN_THREAD_GUARD;
// The default shape is set in Viewport::_gui_input_event. To instantly
// see the shape in the viewport we need to trigger a mouse motion event.
Ref<InputEventMouseMotion> mm;
@ -693,14 +736,17 @@ void Window::update_mouse_cursor_shape() {
}
void Window::show() {
ERR_MAIN_THREAD_GUARD;
set_visible(true);
}
void Window::hide() {
ERR_MAIN_THREAD_GUARD;
set_visible(false);
}
void Window::set_visible(bool p_visible) {
ERR_MAIN_THREAD_GUARD;
if (visible == p_visible) {
return;
}
@ -816,6 +862,7 @@ void Window::_make_transient() {
}
void Window::set_transient(bool p_transient) {
ERR_MAIN_THREAD_GUARD;
if (transient == p_transient) {
return;
}
@ -834,10 +881,12 @@ void Window::set_transient(bool p_transient) {
}
bool Window::is_transient() const {
ERR_READ_THREAD_GUARD_V(false);
return transient;
}
void Window::set_exclusive(bool p_exclusive) {
ERR_MAIN_THREAD_GUARD;
if (exclusive == p_exclusive) {
return;
}
@ -867,10 +916,12 @@ void Window::set_exclusive(bool p_exclusive) {
}
bool Window::is_exclusive() const {
ERR_READ_THREAD_GUARD_V(false);
return exclusive;
}
bool Window::is_visible() const {
ERR_READ_THREAD_GUARD_V(false);
return visible;
}
@ -1061,6 +1112,7 @@ void Window::_update_window_callbacks() {
}
Viewport *Window::get_embedder() const {
ERR_READ_THREAD_GUARD_V(nullptr);
Viewport *vp = get_parent_viewport();
while (vp) {
@ -1078,6 +1130,7 @@ Viewport *Window::get_embedder() const {
}
void Window::_notification(int p_what) {
ERR_MAIN_THREAD_GUARD;
switch (p_what) {
case NOTIFICATION_POSTINITIALIZE: {
initialized = true;
@ -1215,6 +1268,7 @@ void Window::_notification(int p_what) {
}
void Window::set_content_scale_size(const Size2i &p_size) {
ERR_MAIN_THREAD_GUARD;
ERR_FAIL_COND(p_size.x < 0);
ERR_FAIL_COND(p_size.y < 0);
content_scale_size = p_size;
@ -1222,38 +1276,46 @@ void Window::set_content_scale_size(const Size2i &p_size) {
}
Size2i Window::get_content_scale_size() const {
ERR_READ_THREAD_GUARD_V(Size2i());
return content_scale_size;
}
void Window::set_content_scale_mode(ContentScaleMode p_mode) {
ERR_MAIN_THREAD_GUARD;
content_scale_mode = p_mode;
_update_viewport_size();
}
Window::ContentScaleMode Window::get_content_scale_mode() const {
ERR_READ_THREAD_GUARD_V(CONTENT_SCALE_MODE_DISABLED);
return content_scale_mode;
}
void Window::set_content_scale_aspect(ContentScaleAspect p_aspect) {
ERR_MAIN_THREAD_GUARD;
content_scale_aspect = p_aspect;
_update_viewport_size();
}
Window::ContentScaleAspect Window::get_content_scale_aspect() const {
ERR_READ_THREAD_GUARD_V(CONTENT_SCALE_ASPECT_IGNORE);
return content_scale_aspect;
}
void Window::set_content_scale_factor(real_t p_factor) {
ERR_MAIN_THREAD_GUARD;
ERR_FAIL_COND(p_factor <= 0);
content_scale_factor = p_factor;
_update_viewport_size();
}
real_t Window::get_content_scale_factor() const {
ERR_READ_THREAD_GUARD_V(0);
return content_scale_factor;
}
void Window::set_use_font_oversampling(bool p_oversampling) {
ERR_MAIN_THREAD_GUARD;
if (is_inside_tree() && window_id != DisplayServer::MAIN_WINDOW_ID) {
ERR_FAIL_MSG("Only the root window can set and use font oversampling.");
}
@ -1262,10 +1324,12 @@ void Window::set_use_font_oversampling(bool p_oversampling) {
}
bool Window::is_using_font_oversampling() const {
ERR_READ_THREAD_GUARD_V(false);
return use_font_oversampling;
}
DisplayServer::WindowID Window::get_window_id() const {
ERR_READ_THREAD_GUARD_V(DisplayServer::INVALID_WINDOW_ID);
if (embedder) {
return parent->get_window_id();
}
@ -1273,6 +1337,7 @@ DisplayServer::WindowID Window::get_window_id() const {
}
void Window::set_mouse_passthrough_polygon(const Vector<Vector2> &p_region) {
ERR_MAIN_THREAD_GUARD;
mpath = p_region;
if (window_id == DisplayServer::INVALID_WINDOW_ID) {
return;
@ -1285,6 +1350,7 @@ Vector<Vector2> Window::get_mouse_passthrough_polygon() const {
}
void Window::set_wrap_controls(bool p_enable) {
ERR_MAIN_THREAD_GUARD;
wrap_controls = p_enable;
if (!is_inside_tree()) {
@ -1299,6 +1365,7 @@ void Window::set_wrap_controls(bool p_enable) {
}
bool Window::is_wrapping_controls() const {
ERR_READ_THREAD_GUARD_V(false);
return wrap_controls;
}
@ -1320,6 +1387,7 @@ Size2 Window::_get_contents_minimum_size() const {
}
void Window::child_controls_changed() {
ERR_MAIN_THREAD_GUARD;
if (!is_inside_tree() || !visible || updating_child_controls) {
return;
}
@ -1397,6 +1465,7 @@ void Window::_window_drop_files(const Vector<String> &p_files) {
}
Viewport *Window::get_parent_viewport() const {
ERR_READ_THREAD_GUARD_V(nullptr);
if (get_parent()) {
return get_parent()->get_viewport();
} else {
@ -1405,6 +1474,7 @@ Viewport *Window::get_parent_viewport() const {
}
Window *Window::get_parent_visible_window() const {
ERR_READ_THREAD_GUARD_V(nullptr);
Viewport *vp = get_parent_viewport();
Window *window = nullptr;
while (vp) {
@ -1422,6 +1492,7 @@ Window *Window::get_parent_visible_window() const {
}
void Window::popup_on_parent(const Rect2i &p_parent_rect) {
ERR_MAIN_THREAD_GUARD;
ERR_FAIL_COND(!is_inside_tree());
ERR_FAIL_COND_MSG(window_id == DisplayServer::MAIN_WINDOW_ID, "Can't popup the main window.");
@ -1439,6 +1510,7 @@ void Window::popup_on_parent(const Rect2i &p_parent_rect) {
}
void Window::popup_centered_clamped(const Size2i &p_size, float p_fallback_ratio) {
ERR_MAIN_THREAD_GUARD;
ERR_FAIL_COND(!is_inside_tree());
ERR_FAIL_COND_MSG(window_id == DisplayServer::MAIN_WINDOW_ID, "Can't popup the main window.");
@ -1470,6 +1542,7 @@ void Window::popup_centered_clamped(const Size2i &p_size, float p_fallback_ratio
}
void Window::popup_centered(const Size2i &p_minsize) {
ERR_MAIN_THREAD_GUARD;
ERR_FAIL_COND(!is_inside_tree());
ERR_FAIL_COND_MSG(window_id == DisplayServer::MAIN_WINDOW_ID, "Can't popup the main window.");
@ -1498,6 +1571,7 @@ void Window::popup_centered(const Size2i &p_minsize) {
}
void Window::popup_centered_ratio(float p_ratio) {
ERR_MAIN_THREAD_GUARD;
ERR_FAIL_COND(!is_inside_tree());
ERR_FAIL_COND_MSG(window_id == DisplayServer::MAIN_WINDOW_ID, "Can't popup the main window.");
ERR_FAIL_COND_MSG(p_ratio <= 0.0 || p_ratio > 1.0, "Ratio must be between 0.0 and 1.0!");
@ -1524,6 +1598,7 @@ void Window::popup_centered_ratio(float p_ratio) {
}
void Window::popup(const Rect2i &p_screen_rect) {
ERR_MAIN_THREAD_GUARD;
emit_signal(SNAME("about_to_popup"));
if (!get_embedder() && get_flag(FLAG_POPUP)) {
@ -1582,6 +1657,7 @@ void Window::popup(const Rect2i &p_screen_rect) {
}
Rect2i Window::fit_rect_in_parent(Rect2i p_rect, const Rect2i &p_parent_rect) const {
ERR_READ_THREAD_GUARD_V(Rect2i());
Size2i limit = p_parent_rect.size;
if (p_rect.position.x + p_rect.size.x > limit.x) {
p_rect.position.x = limit.x - p_rect.size.x;
@ -1604,10 +1680,12 @@ Rect2i Window::fit_rect_in_parent(Rect2i p_rect, const Rect2i &p_parent_rect) co
}
Size2 Window::get_contents_minimum_size() const {
ERR_READ_THREAD_GUARD_V(Size2());
return _get_contents_minimum_size();
}
Size2 Window::get_clamped_minimum_size() const {
ERR_READ_THREAD_GUARD_V(Size2());
if (!wrap_controls) {
return min_size;
}
@ -1616,6 +1694,7 @@ Size2 Window::get_clamped_minimum_size() const {
}
void Window::grab_focus() {
ERR_MAIN_THREAD_GUARD;
if (embedder) {
embedder->_sub_window_grab_focus(this);
} else if (window_id != DisplayServer::INVALID_WINDOW_ID) {
@ -1624,10 +1703,12 @@ void Window::grab_focus() {
}
bool Window::has_focus() const {
ERR_READ_THREAD_GUARD_V(false);
return focused;
}
Rect2i Window::get_usable_parent_rect() const {
ERR_READ_THREAD_GUARD_V(Rect2i());
ERR_FAIL_COND_V(!is_inside_tree(), Rect2());
Rect2i parent_rect;
if (is_embedded()) {
@ -1657,18 +1738,22 @@ void Window::remove_child_notify(Node *p_child) {
// Theming.
void Window::set_theme_owner_node(Node *p_node) {
ERR_MAIN_THREAD_GUARD;
theme_owner->set_owner_node(p_node);
}
Node *Window::get_theme_owner_node() const {
ERR_READ_THREAD_GUARD_V(nullptr);
return theme_owner->get_owner_node();
}
bool Window::has_theme_owner_node() const {
ERR_READ_THREAD_GUARD_V(false);
return theme_owner->has_owner_node();
}
void Window::set_theme(const Ref<Theme> &p_theme) {
ERR_MAIN_THREAD_GUARD;
if (theme == p_theme) {
return;
}
@ -1700,6 +1785,7 @@ void Window::set_theme(const Ref<Theme> &p_theme) {
}
Ref<Theme> Window::get_theme() const {
ERR_READ_THREAD_GUARD_V(Ref<Theme>());
return theme;
}
@ -1748,6 +1834,7 @@ void Window::_update_embedded_window() {
}
void Window::set_theme_type_variation(const StringName &p_theme_type) {
ERR_MAIN_THREAD_GUARD;
theme_type_variation = p_theme_type;
if (is_inside_tree()) {
notification(NOTIFICATION_THEME_CHANGED);
@ -1755,12 +1842,14 @@ void Window::set_theme_type_variation(const StringName &p_theme_type) {
}
StringName Window::get_theme_type_variation() const {
ERR_READ_THREAD_GUARD_V(StringName());
return theme_type_variation;
}
/// Theme property lookup.
Ref<Texture2D> Window::get_theme_icon(const StringName &p_name, const StringName &p_theme_type) const {
ERR_READ_THREAD_GUARD_V(Ref<Texture2D>());
if (!initialized) {
WARN_PRINT_ONCE("Attempting to access theme items too early; prefer NOTIFICATION_POSTINITIALIZE and NOTIFICATION_THEME_CHANGED");
}
@ -1784,6 +1873,7 @@ Ref<Texture2D> Window::get_theme_icon(const StringName &p_name, const StringName
}
Ref<StyleBox> Window::get_theme_stylebox(const StringName &p_name, const StringName &p_theme_type) const {
ERR_READ_THREAD_GUARD_V(Ref<StyleBox>());
if (!initialized) {
WARN_PRINT_ONCE("Attempting to access theme items too early; prefer NOTIFICATION_POSTINITIALIZE and NOTIFICATION_THEME_CHANGED");
}
@ -1807,6 +1897,7 @@ Ref<StyleBox> Window::get_theme_stylebox(const StringName &p_name, const StringN
}
Ref<Font> Window::get_theme_font(const StringName &p_name, const StringName &p_theme_type) const {
ERR_READ_THREAD_GUARD_V(Ref<Font>());
if (!initialized) {
WARN_PRINT_ONCE("Attempting to access theme items too early; prefer NOTIFICATION_POSTINITIALIZE and NOTIFICATION_THEME_CHANGED");
}
@ -1830,6 +1921,7 @@ Ref<Font> Window::get_theme_font(const StringName &p_name, const StringName &p_t
}
int Window::get_theme_font_size(const StringName &p_name, const StringName &p_theme_type) const {
ERR_READ_THREAD_GUARD_V(0);
if (!initialized) {
WARN_PRINT_ONCE("Attempting to access theme items too early; prefer NOTIFICATION_POSTINITIALIZE and NOTIFICATION_THEME_CHANGED");
}
@ -1853,6 +1945,7 @@ int Window::get_theme_font_size(const StringName &p_name, const StringName &p_th
}
Color Window::get_theme_color(const StringName &p_name, const StringName &p_theme_type) const {
ERR_READ_THREAD_GUARD_V(Color());
if (!initialized) {
WARN_PRINT_ONCE("Attempting to access theme items too early; prefer NOTIFICATION_POSTINITIALIZE and NOTIFICATION_THEME_CHANGED");
}
@ -1876,6 +1969,7 @@ Color Window::get_theme_color(const StringName &p_name, const StringName &p_them
}
int Window::get_theme_constant(const StringName &p_name, const StringName &p_theme_type) const {
ERR_READ_THREAD_GUARD_V(0);
if (!initialized) {
WARN_PRINT_ONCE("Attempting to access theme items too early; prefer NOTIFICATION_POSTINITIALIZE and NOTIFICATION_THEME_CHANGED");
}
@ -1899,6 +1993,7 @@ int Window::get_theme_constant(const StringName &p_name, const StringName &p_the
}
bool Window::has_theme_icon(const StringName &p_name, const StringName &p_theme_type) const {
ERR_READ_THREAD_GUARD_V(false);
if (!initialized) {
WARN_PRINT_ONCE("Attempting to access theme items too early; prefer NOTIFICATION_POSTINITIALIZE and NOTIFICATION_THEME_CHANGED");
}
@ -1915,6 +2010,7 @@ bool Window::has_theme_icon(const StringName &p_name, const StringName &p_theme_
}
bool Window::has_theme_stylebox(const StringName &p_name, const StringName &p_theme_type) const {
ERR_READ_THREAD_GUARD_V(false);
if (!initialized) {
WARN_PRINT_ONCE("Attempting to access theme items too early; prefer NOTIFICATION_POSTINITIALIZE and NOTIFICATION_THEME_CHANGED");
}
@ -1931,6 +2027,7 @@ bool Window::has_theme_stylebox(const StringName &p_name, const StringName &p_th
}
bool Window::has_theme_font(const StringName &p_name, const StringName &p_theme_type) const {
ERR_READ_THREAD_GUARD_V(false);
if (!initialized) {
WARN_PRINT_ONCE("Attempting to access theme items too early; prefer NOTIFICATION_POSTINITIALIZE and NOTIFICATION_THEME_CHANGED");
}
@ -1947,6 +2044,7 @@ bool Window::has_theme_font(const StringName &p_name, const StringName &p_theme_
}
bool Window::has_theme_font_size(const StringName &p_name, const StringName &p_theme_type) const {
ERR_READ_THREAD_GUARD_V(false);
if (!initialized) {
WARN_PRINT_ONCE("Attempting to access theme items too early; prefer NOTIFICATION_POSTINITIALIZE and NOTIFICATION_THEME_CHANGED");
}
@ -1963,6 +2061,7 @@ bool Window::has_theme_font_size(const StringName &p_name, const StringName &p_t
}
bool Window::has_theme_color(const StringName &p_name, const StringName &p_theme_type) const {
ERR_READ_THREAD_GUARD_V(false);
if (!initialized) {
WARN_PRINT_ONCE("Attempting to access theme items too early; prefer NOTIFICATION_POSTINITIALIZE and NOTIFICATION_THEME_CHANGED");
}
@ -1979,6 +2078,7 @@ bool Window::has_theme_color(const StringName &p_name, const StringName &p_theme
}
bool Window::has_theme_constant(const StringName &p_name, const StringName &p_theme_type) const {
ERR_READ_THREAD_GUARD_V(false);
if (!initialized) {
WARN_PRINT_ONCE("Attempting to access theme items too early; prefer NOTIFICATION_POSTINITIALIZE and NOTIFICATION_THEME_CHANGED");
}
@ -1997,6 +2097,7 @@ bool Window::has_theme_constant(const StringName &p_name, const StringName &p_th
/// Local property overrides.
void Window::add_theme_icon_override(const StringName &p_name, const Ref<Texture2D> &p_icon) {
ERR_MAIN_THREAD_GUARD;
ERR_FAIL_COND(!p_icon.is_valid());
if (theme_icon_override.has(p_name)) {
@ -2009,6 +2110,7 @@ void Window::add_theme_icon_override(const StringName &p_name, const Ref<Texture
}
void Window::add_theme_style_override(const StringName &p_name, const Ref<StyleBox> &p_style) {
ERR_MAIN_THREAD_GUARD;
ERR_FAIL_COND(!p_style.is_valid());
if (theme_style_override.has(p_name)) {
@ -2021,6 +2123,7 @@ void Window::add_theme_style_override(const StringName &p_name, const Ref<StyleB
}
void Window::add_theme_font_override(const StringName &p_name, const Ref<Font> &p_font) {
ERR_MAIN_THREAD_GUARD;
ERR_FAIL_COND(!p_font.is_valid());
if (theme_font_override.has(p_name)) {
@ -2033,21 +2136,25 @@ void Window::add_theme_font_override(const StringName &p_name, const Ref<Font> &
}
void Window::add_theme_font_size_override(const StringName &p_name, int p_font_size) {
ERR_MAIN_THREAD_GUARD;
theme_font_size_override[p_name] = p_font_size;
_notify_theme_override_changed();
}
void Window::add_theme_color_override(const StringName &p_name, const Color &p_color) {
ERR_MAIN_THREAD_GUARD;
theme_color_override[p_name] = p_color;
_notify_theme_override_changed();
}
void Window::add_theme_constant_override(const StringName &p_name, int p_constant) {
ERR_MAIN_THREAD_GUARD;
theme_constant_override[p_name] = p_constant;
_notify_theme_override_changed();
}
void Window::remove_theme_icon_override(const StringName &p_name) {
ERR_MAIN_THREAD_GUARD;
if (theme_icon_override.has(p_name)) {
theme_icon_override[p_name]->disconnect("changed", callable_mp(this, &Window::_notify_theme_override_changed));
}
@ -2057,6 +2164,7 @@ void Window::remove_theme_icon_override(const StringName &p_name) {
}
void Window::remove_theme_style_override(const StringName &p_name) {
ERR_MAIN_THREAD_GUARD;
if (theme_style_override.has(p_name)) {
theme_style_override[p_name]->disconnect("changed", callable_mp(this, &Window::_notify_theme_override_changed));
}
@ -2066,6 +2174,7 @@ void Window::remove_theme_style_override(const StringName &p_name) {
}
void Window::remove_theme_font_override(const StringName &p_name) {
ERR_MAIN_THREAD_GUARD;
if (theme_font_override.has(p_name)) {
theme_font_override[p_name]->disconnect("changed", callable_mp(this, &Window::_notify_theme_override_changed));
}
@ -2075,46 +2184,55 @@ void Window::remove_theme_font_override(const StringName &p_name) {
}
void Window::remove_theme_font_size_override(const StringName &p_name) {
ERR_MAIN_THREAD_GUARD;
theme_font_size_override.erase(p_name);
_notify_theme_override_changed();
}
void Window::remove_theme_color_override(const StringName &p_name) {
ERR_MAIN_THREAD_GUARD;
theme_color_override.erase(p_name);
_notify_theme_override_changed();
}
void Window::remove_theme_constant_override(const StringName &p_name) {
ERR_MAIN_THREAD_GUARD;
theme_constant_override.erase(p_name);
_notify_theme_override_changed();
}
bool Window::has_theme_icon_override(const StringName &p_name) const {
ERR_READ_THREAD_GUARD_V(false);
const Ref<Texture2D> *tex = theme_icon_override.getptr(p_name);
return tex != nullptr;
}
bool Window::has_theme_stylebox_override(const StringName &p_name) const {
ERR_READ_THREAD_GUARD_V(false);
const Ref<StyleBox> *style = theme_style_override.getptr(p_name);
return style != nullptr;
}
bool Window::has_theme_font_override(const StringName &p_name) const {
ERR_READ_THREAD_GUARD_V(false);
const Ref<Font> *font = theme_font_override.getptr(p_name);
return font != nullptr;
}
bool Window::has_theme_font_size_override(const StringName &p_name) const {
ERR_READ_THREAD_GUARD_V(false);
const int *font_size = theme_font_size_override.getptr(p_name);
return font_size != nullptr;
}
bool Window::has_theme_color_override(const StringName &p_name) const {
ERR_READ_THREAD_GUARD_V(false);
const Color *color = theme_color_override.getptr(p_name);
return color != nullptr;
}
bool Window::has_theme_constant_override(const StringName &p_name) const {
ERR_READ_THREAD_GUARD_V(false);
const int *constant = theme_constant_override.getptr(p_name);
return constant != nullptr;
}
@ -2122,24 +2240,29 @@ bool Window::has_theme_constant_override(const StringName &p_name) const {
/// Default theme properties.
float Window::get_theme_default_base_scale() const {
ERR_READ_THREAD_GUARD_V(0);
return theme_owner->get_theme_default_base_scale();
}
Ref<Font> Window::get_theme_default_font() const {
ERR_READ_THREAD_GUARD_V(Ref<Font>());
return theme_owner->get_theme_default_font();
}
int Window::get_theme_default_font_size() const {
ERR_READ_THREAD_GUARD_V(0);
return theme_owner->get_theme_default_font_size();
}
/// Bulk actions.
void Window::begin_bulk_theme_override() {
ERR_MAIN_THREAD_GUARD;
bulk_theme_override = true;
}
void Window::end_bulk_theme_override() {
ERR_MAIN_THREAD_GUARD;
ERR_FAIL_COND(!bulk_theme_override);
bulk_theme_override = false;
@ -2149,6 +2272,7 @@ void Window::end_bulk_theme_override() {
//
Rect2i Window::get_parent_rect() const {
ERR_READ_THREAD_GUARD_V(Rect2i());
ERR_FAIL_COND_V(!is_inside_tree(), Rect2i());
if (is_embedded()) {
//viewport
@ -2185,14 +2309,17 @@ Rect2i Window::get_parent_rect() const {
}
void Window::set_clamp_to_embedder(bool p_enable) {
ERR_MAIN_THREAD_GUARD;
clamp_to_embedder = p_enable;
}
bool Window::is_clamped_to_embedder() const {
ERR_READ_THREAD_GUARD_V(false);
return clamp_to_embedder;
}
void Window::set_layout_direction(Window::LayoutDirection p_direction) {
ERR_MAIN_THREAD_GUARD;
ERR_FAIL_INDEX((int)p_direction, 4);
layout_dir = p_direction;
@ -2200,10 +2327,12 @@ void Window::set_layout_direction(Window::LayoutDirection p_direction) {
}
Window::LayoutDirection Window::get_layout_direction() const {
ERR_READ_THREAD_GUARD_V(LAYOUT_DIRECTION_INHERITED);
return layout_dir;
}
bool Window::is_layout_rtl() const {
ERR_READ_THREAD_GUARD_V(false);
if (layout_dir == LAYOUT_DIRECTION_INHERITED) {
if (GLOBAL_GET(SNAME("internationalization/rendering/force_right_to_left_layout_direction"))) {
return true;
@ -2244,6 +2373,7 @@ bool Window::is_layout_rtl() const {
}
void Window::set_auto_translate(bool p_enable) {
ERR_MAIN_THREAD_GUARD;
if (p_enable == auto_translate) {
return;
}
@ -2254,14 +2384,17 @@ void Window::set_auto_translate(bool p_enable) {
}
bool Window::is_auto_translating() const {
ERR_READ_THREAD_GUARD_V(false);
return auto_translate;
}
Transform2D Window::get_final_transform() const {
ERR_READ_THREAD_GUARD_V(Transform2D());
return window_transform * stretch_transform * global_canvas_transform;
}
Transform2D Window::get_screen_transform_internal(bool p_absolute_position) const {
ERR_READ_THREAD_GUARD_V(Transform2D());
Transform2D embedder_transform;
if (get_embedder()) {
embedder_transform.translate_local(get_position());
@ -2273,6 +2406,7 @@ Transform2D Window::get_screen_transform_internal(bool p_absolute_position) cons
}
Transform2D Window::get_popup_base_transform() const {
ERR_READ_THREAD_GUARD_V(Transform2D());
if (is_embedding_subwindows()) {
return Transform2D();
}