+ GLOBAL_DEF("display/window/energy_saving/keep_screen_on", true);

+ GLOBAL_DEF("display/window/energy_saving/keep_screen_on.editor", false);

+

+Vector2i Image::get_size() const {

+ return Vector2i(width, height);

+ Vector2i get_size() const;

+ <methods>

+ <method name="get_bake_mask_value" qualifiers="const">

+ <return type="bool" />

+ <argument index="0" name="layer_number" type="int" />

+ <description>

+ Returns whether or not the specified layer of the [member bake_mask] is enabled, given a [code]layer_number[/code] between 1 and 32.

+ </description>

+ </method>

+ <method name="set_bake_mask_value">

+ <return type="void" />

+ <argument index="0" name="layer_number" type="int" />

+ <argument index="1" name="value" type="bool" />

+ <description>

+ Based on [code]value[/code], enables or disables the specified layer in the [member bake_mask], given a [code]layer_number[/code] between 1 and 32.

+ </description>

+ </method>

+ </methods>

+ <member name="bake_mask" type="int" setter="set_bake_mask" getter="get_bake_mask" default="4294967295">

+ The visual layers to account for when baking the particle collision SDF. Only [MeshInstance3D]s whose [member VisualInstance3D.layers] match with this [member bake_mask] will be included in the generated particle collision SDF. By default, all objects are taken into account for the particle collision SDF baking.

+ </member>

+ <return type="Vector2i" />

+ For the color to take effect, ensure that [member use_colors] is [code]true[/code] on the [MultiMesh] and [member BaseMaterial3D.vertex_color_use_as_albedo] is [code]true[/code] on the material. If the color doesn't look as expected, make sure the material's albedo color is set to pure white ([code]Color(1, 1, 1)[/code]).

+ The visual layers to account for when baking for occluders. Only [MeshInstance3D]s whose [member VisualInstance3D.layers] match with this [member bake_mask] will be included in the generated occluder mesh. By default, all objects with [i]opaque[/i] materials are taken into account for the occluder baking.

+ <member name="display/window/energy_saving/keep_screen_on.editor" type="bool" setter="" getter="" default="false">

+ Editor-only override for [member display/window/energy_saving/keep_screen_on]. Does not affect exported projects in debug or release mode.

+ </member>

+ [b]Note:[/b] This property will be ignored if the value is lower than [member min_size].

+ [b]Note:[/b] This property will be ignored in favor of [method get_contents_minimum_size] if [member wrap_controls] is enabled and if its size is bigger.

+ If [code]true[/code], the window's size will automatically update when a child node is added or removed, ignoring [member min_size] if the new size is bigger.

+ ref_vec = mix(ref_vec, normal, roughness * roughness);

+ new_size_spin_box->set_value(count);

+ resize_dialog->popup_centered(Size2i(250, 0) * EDSCALE);

+ new_size_spin_box->get_line_edit()->grab_focus();

+ new_size_spin_box->get_line_edit()->select_all();

+void EditorInspectorArray::_resize_dialog_confirmed() {

+ if (int(new_size_spin_box->get_value()) == count) {

+ return;

+

+ resize_dialog->hide();

+ _resize_array(int(new_size_spin_box->get_value()));

+void EditorInspectorArray::_new_size_spin_box_value_changed(float p_value) {

+ resize_dialog->get_ok_button()->set_disabled(int(p_value) == count);

+void EditorInspectorArray::_new_size_spin_box_text_submitted(String p_text) {

+ _resize_dialog_confirmed();

+ new_size_spin_box = memnew(SpinBox);

+ new_size_spin_box->set_max(16384);

+ new_size_spin_box->connect("value_changed", callable_mp(this, &EditorInspectorArray::_new_size_spin_box_value_changed));

+ new_size_spin_box->get_line_edit()->connect("text_submitted", callable_mp(this, &EditorInspectorArray::_new_size_spin_box_text_submitted));

+ resize_dialog_vbox->add_margin_child(TTRC("New Size:"), new_size_spin_box);

+#include "scene/gui/spin_box.h"

+ SpinBox *new_size_spin_box = nullptr;

+ void _new_size_spin_box_value_changed(float p_value);

+ void _new_size_spin_box_text_submitted(String p_text);

+void EditorPropertyLayers::_notification(int p_what) {

+ switch (p_what) {

+ case NOTIFICATION_ENTER_TREE:

+ case NOTIFICATION_THEME_CHANGED: {

+ button->set_normal_texture(get_theme_icon(SNAME("GuiTabMenuHl"), SNAME("EditorIcons")));

+ button->set_pressed_texture(get_theme_icon(SNAME("GuiTabMenuHl"), SNAME("EditorIcons")));

+ button->set_disabled_texture(get_theme_icon(SNAME("GuiTabMenu"), SNAME("EditorIcons")));

+ } break;

+ }

+}

+

+ button = memnew(TextureButton);

+ button->set_stretch_mode(TextureButton::STRETCH_KEEP_CENTERED);

+ TextureButton *button = nullptr;

+ void _notification(int p_what);

+ pre_move_edit = vertices;

+ EditorNode::get_singleton()->show_warning(TTR("No faces detected during GPUParticlesCollisionSDF3D bake.\nCheck whether there are visible meshes matching the bake mask within its extents."));

+ if (is_freelook_active()) {

+ scale_freelook_speed(zoom_factor);

+ scale_cursor_distance(1.0 / zoom_factor);

+ if (is_freelook_active()) {

+ scale_freelook_speed(1.0 / zoom_factor);

+ scale_cursor_distance(zoom_factor);

+ result_type.kind = GDScriptParser::DataType::VARIANT;

+const A := 42

+

+const Constants = preload("gdscript_to_preload.gd")

+

+func test():

+ var a := Constants.A

+ print(a)

+

+GDTEST_OK

+42

+ if (path.IndexOfAny(Path.GetInvalidPathChars()) != -1)

+ return false;

+

+ bool keep_screen_on = bool(GLOBAL_GET("display/window/energy_saving/keep_screen_on"));

+ screen_set_keep_on(GLOBAL_GET("display/window/energy_saving/keep_screen_on"));

+ screen_set_keep_on(GLOBAL_GET("display/window/energy_saving/keep_screen_on"));

+ set_keep_screen_on(GLOBAL_GET("display/window/energy_saving/keep_screen_on"));

+ screen_set_keep_on(GLOBAL_GET("display/window/energy_saving/keep_screen_on"));

+ NavigationServer2D::get_singleton()->region_set_travel_cost(region, travel_cost);

+ if ((mi->get_layer_mask() & bake_mask) == 0) {

+ return;

+ }

+

+ ERR_FAIL_COND_V_MSG(faces.size() <= 1, Ref<Image>(), "No faces detected during GPUParticlesCollisionSDF3D bake. Check whether there are visible meshes matching the bake mask within its extents.");

+TypedArray<String> GPUParticlesCollisionSDF3D::get_configuration_warnings() const {

+ TypedArray<String> warnings = Node::get_configuration_warnings();

+

+ if (bake_mask == 0) {

+ warnings.push_back(RTR("The Bake Mask has no bits enabled, which means baking will not produce any collision for this GPUParticlesCollisionSDF3D.\nTo resolve this, enable at least one bit in the Bake Mask property."));

+ }

+

+ return warnings;

+}

+

+ ClassDB::bind_method(D_METHOD("set_bake_mask", "mask"), &GPUParticlesCollisionSDF3D::set_bake_mask);

+ ClassDB::bind_method(D_METHOD("get_bake_mask"), &GPUParticlesCollisionSDF3D::get_bake_mask);

+ ClassDB::bind_method(D_METHOD("set_bake_mask_value", "layer_number", "value"), &GPUParticlesCollisionSDF3D::set_bake_mask_value);

+ ClassDB::bind_method(D_METHOD("get_bake_mask_value", "layer_number"), &GPUParticlesCollisionSDF3D::get_bake_mask_value);

+

+ ADD_PROPERTY(PropertyInfo(Variant::INT, "bake_mask", PROPERTY_HINT_LAYERS_3D_RENDER), "set_bake_mask", "get_bake_mask");

+void GPUParticlesCollisionSDF3D::set_bake_mask(uint32_t p_mask) {

+ bake_mask = p_mask;

+ update_configuration_warnings();

+}

+

+uint32_t GPUParticlesCollisionSDF3D::get_bake_mask() const {

+ return bake_mask;

+}

+

+void GPUParticlesCollisionSDF3D::set_bake_mask_value(int p_layer_number, bool p_value) {

+ ERR_FAIL_COND_MSG(p_layer_number < 1 || p_layer_number > 20, vformat("The render layer number (%d) must be between 1 and 20 (inclusive).", p_layer_number));

+ uint32_t mask = get_bake_mask();

+ if (p_value) {

+ mask |= 1 << (p_layer_number - 1);

+ } else {

+ mask &= ~(1 << (p_layer_number - 1));

+ }

+ set_bake_mask(mask);

+}

+

+bool GPUParticlesCollisionSDF3D::get_bake_mask_value(int p_layer_number) const {

+ ERR_FAIL_COND_V_MSG(p_layer_number < 1 || p_layer_number > 20, false, vformat("The render layer number (%d) must be between 1 and 20 (inclusive).", p_layer_number));

+ return bake_mask & (1 << (p_layer_number - 1));

+}

+

+ uint32_t bake_mask = 0xFFFFFFFF;

+ virtual TypedArray<String> get_configuration_warnings() const override;

+

+ void set_bake_mask(uint32_t p_mask);

+ uint32_t get_bake_mask() const;

+

+ void set_bake_mask_value(int p_layer_number, bool p_enable);

+ bool get_bake_mask_value(int p_layer_number) const;

+

+ NavigationServer3D::get_singleton()->region_set_travel_cost(region, travel_cost);

+

+ Size2i min_size_adjusted = min_size;

+ min_size_adjusted.x = MAX(cms.x, min_size.x);

+ min_size_adjusted.y = MAX(cms.y, min_size.y);

+

+ min_size_adjusted.x = MAX(min_size_adjusted.x, 1);

+ min_size_adjusted.y = MAX(min_size_adjusted.y, 1);

+ Size2i limit = r.size - min_size_adjusted;

+ Size2i max_size = gui.subwindow_focused->get_max_size();

+ if ((max_size.x > 0 || max_size.y > 0) && (max_size.x >= min_size.x && max_size.y >= min_size.y)) {

+ max_size.x = MAX(max_size.x, 1);

+ max_size.y = MAX(max_size.y, 1);

+

+ if (r.size.x > max_size.x) {

+ r.size.x = max_size.x;

+ }

+ if (r.size.y > max_size.y) {

+ r.size.y = max_size.y;

+ }

+ }

+

+ close_rect.position = Vector2(r.position.x + r.size.x - close_h_ofs, r.position.y - close_v_ofs);

+ DisplayServer::get_singleton()->window_set_max_size(Size2i(), window_id);

+ DisplayServer::get_singleton()->window_set_min_size(Size2i(), window_id);

+ bool reset_min_first = false;

+

+ bool max_size_valid = false;

+ if ((max_size.x > 0 || max_size.y > 0) && (max_size.x >= min_size.x && max_size.y >= min_size.y)) {

+ max_size_valid = true;

+

+ if (size.x > max_size.x) {

+ size.x = max_size.x;

+ }

+ if (size_limit.x > max_size.x) {

+ size_limit.x = max_size.x;

+ reset_min_first = true;

+ }

+ if (size.y > max_size.y) {

+ size.y = max_size.y;

+ }

+ if (size_limit.y > max_size.y) {

+ size_limit.y = max_size.y;

+ reset_min_first = true;

+ }

+ size.x = MAX(size.x, 1);

+ size.y = MAX(size.y, 1);

+

+ if (reset_min_first && wrap_controls) {

+ // Avoid an error if setting max_size to a value between min_size and the previous size_limit.

+ DisplayServer::get_singleton()->window_set_min_size(Size2i(), window_id);

+ }

+

+ DisplayServer::get_singleton()->window_set_max_size(max_size_valid ? max_size : Size2i(), window_id);

+ } else {

+ _update_window_size();

+ info.name = last_group.capitalize();

+ info.name = last_subgroup.capitalize();

+ ref_vec = mix(ref_vec, bent_normal, roughness * roughness);

+ ref_vec = mix(ref_vec, normal, roughness * roughness);

+ ref_vec = mix(ref_vec, n, clearcoat_roughness * clearcoat_roughness);

+ ref_vec = mix(ref_vec, normal, roughness * roughness);

+#ifdef LIGHT_ANISOTROPY_USED

+ // https://google.github.io/filament/Filament.html#lighting/imagebasedlights/anisotropy

+ vec3 anisotropic_direction = anisotropy >= 0.0 ? binormal : tangent;

+ vec3 anisotropic_tangent = cross(anisotropic_direction, view);

+ vec3 anisotropic_normal = cross(anisotropic_tangent, anisotropic_direction);

+ vec3 bent_normal = normalize(mix(normal, anisotropic_normal, abs(anisotropy) * clamp(5.0 * roughness, 0.0, 1.0)));

+#else

+ vec3 bent_normal = normal;

+#endif

+ vec3 ref_vec = normalize(reflect(-view, bent_normal));

+ ref_vec = mix(ref_vec, bent_normal, roughness * roughness);

+

+

+ reflection_process(reflection_index, vertex, ref_vec, normal, roughness, ambient_light, specular_light, ambient_accum, reflection_accum);

+void reflection_process(uint ref_index, vec3 vertex, vec3 ref_vec, vec3 normal, float roughness, vec3 ambient_light, vec3 specular_light, inout vec4 ambient_accum, inout vec4 reflection_accum) {

+ ref_vec = mix(ref_vec, bent_normal, roughness * roughness);

+ ref_vec = mix(ref_vec, normal, roughness * roughness);

+ ref_vec = mix(ref_vec, n, clearcoat_roughness * clearcoat_roughness);

+

+#ifdef LIGHT_ANISOTROPY_USED

+ // https://google.github.io/filament/Filament.html#lighting/imagebasedlights/anisotropy

+ vec3 anisotropic_direction = anisotropy >= 0.0 ? binormal : tangent;

+ vec3 anisotropic_tangent = cross(anisotropic_direction, view);

+ vec3 anisotropic_normal = cross(anisotropic_tangent, anisotropic_direction);

+ vec3 bent_normal = normalize(mix(normal, anisotropic_normal, abs(anisotropy) * clamp(5.0 * roughness, 0.0, 1.0)));

+#else

+ vec3 bent_normal = normal;

+#endif

+ vec3 ref_vec = normalize(reflect(-view, bent_normal));

+ ref_vec = mix(ref_vec, bent_normal, roughness * roughness);

+

+

+ reflection_process(reflection_index, vertex, ref_vec, bent_normal, roughness, ambient_light, specular_light, ambient_accum, reflection_accum);