GLOBAL_DEF(PropertyInfo(Variant::INT, "audio/general/ios/session_category", PROPERTY_HINT_ENUM, "Ambient,Multi Route,Play and Record,Playback,Record,Solo Ambient"), 0);

GLOBAL_DEF("audio/general/ios/mix_with_others", false);

_add_builtin_input_map();

// Keep the enum values in sync with the `DisplayServer::ScreenOrientation` enum.

return ret;

}

Variant ClassDB::class_get_property(Object *p_object, const StringName &p_property) const {

Variant ret;

::ClassDB::get_property(p_object, p_property, ret);

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

TypedArray<Dictionary> class_get_signal_list(const StringName &p_class, bool p_no_inheritance = false) const;

TypedArray<Dictionary> class_get_property_list(const 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;

Default Android Gamepad,Default Controller,leftx:a0,lefty:a1,dpdown:h0.4,rightstick:b8,rightshoulder:b10,rightx:a2,start:b6,righty:a3,dpleft:h0.8,lefttrigger:a4,x:b2,dpup:h0.1,back:b4,leftstick:b7,leftshoulder:b9,y:b3,a:b0,dpright:h0.2,righttrigger:a5,b:b1,platform:Android,

# Web

Linux24c6581a,PowerA Xbox One Cabled,a:b0,b:b1,y:b3,x:b2,start:b7,guide:b8,back:b6,leftstick:b9,rightstick:b10,leftshoulder:b4,rightshoulder:b5,dpup:-a7,dpleft:-a6,dpdown:+a7,dpright:+a6,leftx:a0,lefty:a1,rightx:a3,righty:a4,lefttrigger:a2,righttrigger:a5,platform:Web,

Linux0e6f0301,Logic 3 Controller (xbox compatible),a:b0,b:b1,y:b3,x:b2,start:b7,guide:b8,back:b6,leftstick:b9,rightstick:b10,leftshoulder:b4,rightshoulder:b5,dpup:-a7,dpleft:-a6,dpdown:+a7,dpright:+a6,leftx:a0,lefty:a1,rightx:a3,righty:a4,lefttrigger:a2,righttrigger:a5,platform:Web,

Linux045e028e,Microsoft X-Box 360 pad,a:b0,b:b1,y:b3,x:b2,start:b7,guide:b8,back:b6,leftstick:b9,rightstick:b10,leftshoulder:b4,rightshoulder:b5,dpup:-a7,dpleft:-a6,dpdown:+a7,dpright:+a6,leftx:a0,lefty:a1,rightx:a3,righty:a4,lefttrigger:a2,righttrigger:a5,platform:Web,

#include "core/os/os.h"

#include "core/os/safe_binary_mutex.h"

#include "core/string/print_string.h"

#include "core/variant/variant_parser.h"

#include "servers/rendering_server.h"

#include "core/object/script_language.h"

#include "core/os/os.h"

#include "core/string/print_string.h"

#include "core/templates/local_vector.h"

#include "core/variant/typed_array.h"

#include "core/os/time.h"

#include "core/string/optimized_translation.h"

#include "core/string/translation.h"

static Ref<ResourceFormatSaverBinary> resource_saver_binary;

static Ref<ResourceFormatLoaderBinary> resource_loader_binary;

ClassDB::bind_compatibility_method(D_METHOD("erase_message", "src_message", "context"), &Translation::erase_message, DEFVAL(""));

}

#endif

#include "translation.h"

#include "translation.compat.inc"

#include "core/os/os.h"

Dictionary Translation::_get_messages() const {

Dictionary d;

ADD_PROPERTY(PropertyInfo(Variant::DICTIONARY, "messages", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NO_EDITOR | PROPERTY_USAGE_INTERNAL), "_set_messages", "_get_messages");

ADD_PROPERTY(PropertyInfo(Variant::STRING, "locale"), "set_locale", "get_locale");

}

Translation() {}

};

#endif // TRANSLATION_H

#include "core/os/memory.h"

#include "core/string/print_string.h"

#include "core/string/string_name.h"

#include "core/string/ucaps.h"

#include "core/variant/variant.h"

#include "core/version_generated.gen.h"

Returns the default value of [param property] of [param class] or its ancestor classes.

</description>

</method>

<method name="class_get_property_list" qualifiers="const">

<return type="Dictionary[]" />

<param index="0" name="class" type="StringName" />

Returns an array with all the properties of [param class] or its ancestry if [param no_inheritance] is [code]false[/code].

</description>

</method>

<method name="class_get_signal" qualifiers="const">

<return type="Dictionary" />

<param index="0" name="class" type="StringName" />

The compositor resource stores attributes used to customize how a [Viewport] is rendered.

</description>

<tutorials>

</tutorials>

<members>

<member name="compositor_effects" type="CompositorEffect[]" setter="set_compositor_effects" getter="get_compositor_effects" default="[]">

This resource defines a custom rendering effect that can be applied to [Viewport]s through the viewports' [Environment]. You can implement a callback that is called during rendering at a given stage of the rendering pipeline and allows you to insert additional passes. Note that this callback happens on the rendering thread. CompositorEffect is an abstract base class and must be extended to implement specific rendering logic.

</description>

<tutorials>

</tutorials>

<methods>

<method name="_render_callback" qualifiers="virtual">

The grid size in units. Higher values prevent the grid from appearing "cut off" at certain angles, but make the grid more demanding to render. Depending on the camera's position, the grid may not be fully visible since a shader is used to fade it progressively.

</member>

<member name="editors/3d/grid_xy_plane" type="bool" setter="" getter="">

</member>

<member name="editors/3d/grid_xz_plane" type="bool" setter="" getter="">

</member>

<member name="editors/3d/grid_yz_plane" type="bool" setter="" getter="">

</member>

<member name="editors/3d/navigation/emulate_3_button_mouse" type="bool" setter="" getter="">

If [code]true[/code], enables 3-button mouse emulation mode. This is useful on laptops when using a trackpad.

Expanding main editor window content to the title, if supported by [DisplayServer]. See [constant DisplayServer.WINDOW_FLAG_EXTEND_TO_TITLE].

Specific to the macOS platform.

</member>

<member name="interface/editor/font_antialiasing" type="int" setter="" getter="">

FreeType's font anti-aliasing mode used to render the editor fonts. Most fonts are not designed to look good with anti-aliasing disabled, so it's recommended to leave this enabled unless you're using a pixel art font.

</member>

<param index="2" name="from_b" type="Vector2" />

<param index="3" name="dir_b" type="Vector2" />

<description>

</description>

</method>

<method name="make_atlas">

Returns whether or not the specified layer of the [member navigation_layers] bitmask is enabled, given a [param layer_number] between 1 and 32.

</description>

</method>

<method name="get_rid" qualifiers="const">

<return type="RID" />

<description>

Based on [param value], enables or disables the specified layer in the [member navigation_layers] bitmask, given a [param layer_number] between 1 and 32.

</description>

</method>

</methods>

<members>

<member name="bidirectional" type="bool" setter="set_bidirectional" getter="is_bidirectional" default="true">

Returns whether or not the specified layer of the [member navigation_layers] bitmask is enabled, given a [param layer_number] between 1 and 32.

</description>

</method>

<method name="get_rid" qualifiers="const">

<return type="RID" />

<description>

Based on [param value], enables or disables the specified layer in the [member navigation_layers] bitmask, given a [param layer_number] between 1 and 32.

</description>

</method>

</methods>

<members>

<member name="bidirectional" type="bool" setter="set_bidirectional" getter="is_bidirectional" default="true">

<member name="antialiased" type="bool" setter="set_antialiased" getter="get_antialiased" default="false">

If [code]true[/code], polygon edges will be anti-aliased.

</member>

<member name="color" type="Color" setter="set_color" getter="get_color" default="Color(1, 1, 1, 1)" keywords="colour">

The polygon's fill color. If [member texture] is set, it will be multiplied by this color. It will also be the default color for vertices not set in [member vertex_colors].

</member>

prime-run %command%

[/codeblock]

</member>

Text-based file extensions to include in the script editor's "Find in Files" feature. You can add e.g. [code]tscn[/code] if you wish to also parse your scene files, especially if you use built-in scripts which are serialized in the scene files.

</member>

<member name="editor/script/templates_search_path" type="String" setter="" getter="" default="&quot;res://script_templates&quot;">

<member name="script_support" type="Dictionary" setter="" getter="" default="{}">

Override the list of language scripts supported by this font. If left empty, this is supplied by the font metadata. There is usually no need to change this. See also [member language_support].

</member>

Subpixel positioning improves font rendering appearance, especially at smaller font sizes. The downside is that it takes more time to initially render the font, which can cause stuttering during gameplay, especially if used with large font sizes. This should be set to [b]Disabled[/b] for fonts with a pixel art appearance.

[b]Disabled:[/b] No subpixel positioning. Lowest quality, fastest rendering.

[b]Auto:[/b] Use subpixel positioning at small font sizes (the chosen quality varies depending on font size). Large fonts will not use subpixel positioning. This is a good tradeoff between performance and quality.

[b]One Half of a Pixel:[/b] Always perform intermediate subpixel positioning regardless of font size. High quality, slow rendering.

[b]One Quarter of a Pixel:[/b] Always perform precise subpixel positioning regardless of font size. Highest quality, slowest rendering.

</member>

</members>

</class>

Returns a string containing all the characters available in the font.

</description>

</method>

<method name="font_get_texture_count" qualifiers="const">

<return type="int" />

<param index="0" name="font_rid" type="RID" />

Returns a string containing all the characters available in the font.

</description>

</method>

<method name="_font_get_texture_count" qualifiers="virtual const">

<return type="int" />

<param index="0" name="font_rid" type="RID" />

Returns a rectangle enclosing the used (non-empty) tiles of the map, including all layers.

</description>

</method>

<method name="is_layer_enabled" qualifiers="const">

<return type="bool" />

<param index="0" name="layer" type="int" />

Returns whether the provided [param body] [RID] belongs to one of this [TileMapLayer]'s cells.

</description>

</method>

<method name="local_to_map" qualifiers="const">

<return type="Vector2i" />

<param index="0" name="local_position" type="Vector2" />

<return type="void" />

<param index="0" name="time_sec" type="float" default="-1" />

<description>

[b]Note:[/b] This method does not resume a paused timer. See [member paused].

</description>

</method>

alpha = min(alpha, clamp(length(ambient_light), 0.0, 1.0));

#if defined(ALPHA_SCISSOR_USED)

discard;

}

#endif // !ALPHA_SCISSOR_USED

id = p_object->get_instance_id();

}

AnimationTrackEditAudio::AnimationTrackEditAudio() {

AudioStreamPreviewGenerator::get_singleton()->connect("preview_updated", callable_mp(this, &AnimationTrackEditAudio::_preview_changed));

}

}

}

AnimationTrackEditTypeAudio::AnimationTrackEditTypeAudio() {

AudioStreamPreviewGenerator::get_singleton()->connect("preview_updated", callable_mp(this, &AnimationTrackEditTypeAudio::_preview_changed));

}

void _preview_changed(ObjectID p_which);

public:

virtual int get_key_height() const override;

virtual Rect2 get_key_rect(int p_index, float p_pixels_sec) override;

float len_resizing_rel = 0.0f;

bool over_drag_position = false;

public:

virtual void gui_input(const Ref<InputEvent> &p_event) override;

}

}

DependencyEditor::DependencyEditor() {

VBoxContainer *vb = memnew(VBoxContainer);

vb->set_name(TTR("Dependencies"));

}

}

void DependencyEditorOwners::_fill_owners(EditorFileSystemDirectory *efsd) {

if (!efsd) {

return;

dep_edit->edit(path);

}

OrphanResourcesDialog::OrphanResourcesDialog() {

set_title(TTR("Orphan Resource Explorer"));

delete_confirm = memnew(ConfirmationDialog);

void _update_file();

public:

void edit(const String &p_path);

DependencyEditor();

void _fill_owners(EditorFileSystemDirectory *efsd);

void _list_rmb_clicked(int p_item, const Vector2 &p_pos, MouseButton p_mouse_button_index);

void _select_file(int p_idx);

void _empty_clicked(const Vector2 &p_pos, MouseButton p_mouse_button_index);

void _button_pressed(Object *p_item, int p_column, int p_id, MouseButton p_button);

void refresh();

public:

void show();

#include "core/io/marshalls.h"

#include "core/io/resource_importer.h"

#include "core/object/script_language.h"

#include "editor/editor_settings.h"

#include "editor/export/editor_export.h"

#include "scene/resources/theme.h"

}

}

EditorAssetInstaller::EditorAssetInstaller() {

VBoxContainer *vb = memnew(VBoxContainer);

add_child(vb);

protected:

void _notification(int p_what);

public:

void open_asset(const String &p_path, bool p_autoskip_toplevel = false);

void EditorFileSystem::_update_file_icon_path(EditorFileSystemDirectory::FileInfo *file_info) {

String icon_path;

const String &script_dep = file_info->deps[0]; // Assuming the first dependency is a script.

const String &script_path = script_dep.contains("::") ? script_dep.get_slice("::", 2) : script_dep;

if (!script_path.is_empty()) {

#include "editor_locale_dialog.h"

#include "core/config/project_settings.h"

#include "editor/editor_undo_redo_manager.h"

#include "editor/themes/editor_scale.h"

#include "scene/gui/check_button.h"

#ifndef EDITOR_LOCALE_DIALOG_H

#define EDITOR_LOCALE_DIALOG_H

#include "scene/gui/dialogs.h"

class Button;

#include "core/os/os.h"

#include "core/os/time.h"

#include "core/string/print_string.h"

#include "core/version.h"

#include "editor/editor_string_names.h"

#include "main/main.h"

text->set_placeholder(p_string);

}

EditorPropertyText::EditorPropertyText() {

HBoxContainer *hb = memnew(HBoxContainer);

add_child(hb);

}

}

EditorPropertyMultilineText::EditorPropertyMultilineText(bool p_expression) {

HBoxContainer *hb = memnew(HBoxContainer);

hb->add_theme_constant_override("separation", 0);

}

}

void EditorPropertyTextEnum::_notification(int p_what) {

switch (p_what) {

case NOTIFICATION_ENTER_TREE:

_locale_selected(locale->get_text());

}

EditorPropertyLocale::EditorPropertyLocale() {

HBoxContainer *locale_hb = memnew(HBoxContainer);

add_child(locale_hb);

return false;

}

EditorPropertyPath::EditorPropertyPath() {

HBoxContainer *path_hb = memnew(HBoxContainer);

add_child(path_hb);

update_property();

}

EditorPropertyClassName::EditorPropertyClassName() {

property = memnew(Button);

property->set_clip_text(true);

checkbox->set_disabled(is_read_only());

}

EditorPropertyCheck::EditorPropertyCheck() {

checkbox = memnew(CheckBox);

checkbox->set_text(TTR("On"));

options->set_clip_text(p_enable);

}

EditorPropertyEnum::EditorPropertyEnum() {

options = memnew(OptionButton);

options->set_clip_text(true);

}

}

EditorPropertyFlags::EditorPropertyFlags() {

vbox = memnew(VBoxContainer);

add_child(vbox);

setup(layer_type);

}

EditorPropertyLayers::EditorPropertyLayers() {

HBoxContainer *hb = memnew(HBoxContainer);

hb->set_clip_contents(true);

#endif

}

void EditorPropertyInteger::setup(int64_t p_min, int64_t p_max, int64_t p_step, bool p_hide_slider, bool p_allow_greater, bool p_allow_lesser, const String &p_suffix) {

spin->set_min(p_min);

spin->set_max(p_max);

base_type = p_base_type;

}

EditorPropertyObjectID::EditorPropertyObjectID() {

edit = memnew(Button);

add_child(edit);

edit->set_icon(get_editor_theme_icon(SNAME("Signals")));

}

EditorPropertySignal::EditorPropertySignal() {

edit = memnew(Button);

add_child(edit);

edit->set_icon(get_editor_theme_icon(SNAME("Callable")));

}

EditorPropertyCallable::EditorPropertyCallable() {

edit = memnew(Button);

add_child(edit);

spin->set_value_no_signal(val);

}

void EditorPropertyFloat::setup(double p_min, double p_max, double p_step, bool p_hide_slider, bool p_exp_range, bool p_greater, bool p_lesser, const String &p_suffix, bool p_radians_as_degrees) {

radians_as_degrees = p_radians_as_degrees;

spin->set_min(p_min);

}

}

EditorPropertyEasing::EditorPropertyEasing() {

easing_draw = memnew(Control);

easing_draw->connect(SceneStringName(draw), callable_mp(this, &EditorPropertyEasing::_draw_easing));

}

}

void EditorPropertyRect2::setup(double p_min, double p_max, double p_step, bool p_hide_slider, const String &p_suffix) {

for (int i = 0; i < 4; i++) {

spin[i]->set_min(p_min);

}

}

void EditorPropertyRect2i::setup(int p_min, int p_max, const String &p_suffix) {

for (int i = 0; i < 4; i++) {

spin[i]->set_min(p_min);

}

}

void EditorPropertyPlane::setup(double p_min, double p_max, double p_step, bool p_hide_slider, const String &p_suffix) {

for (int i = 0; i < 4; i++) {

spin[i]->set_min(p_min);

}

}

void EditorPropertyQuaternion::setup(double p_min, double p_max, double p_step, bool p_hide_slider, const String &p_suffix, bool p_hide_editor) {

for (int i = 0; i < 4; i++) {

spin[i]->set_min(p_min);

}

}

void EditorPropertyAABB::setup(double p_min, double p_max, double p_step, bool p_hide_slider, const String &p_suffix) {

for (int i = 0; i < 6; i++) {

spin[i]->set_min(p_min);

}

}

void EditorPropertyTransform2D::setup(double p_min, double p_max, double p_step, bool p_hide_slider, const String &p_suffix) {

for (int i = 0; i < 6; i++) {

spin[i]->set_min(p_min);

}

}

void EditorPropertyBasis::setup(double p_min, double p_max, double p_step, bool p_hide_slider, const String &p_suffix) {

for (int i = 0; i < 9; i++) {

spin[i]->set_min(p_min);

}

}

void EditorPropertyTransform3D::setup(double p_min, double p_max, double p_step, bool p_hide_slider, const String &p_suffix) {

for (int i = 0; i < 12; i++) {

spin[i]->set_min(p_min);

}

}

void EditorPropertyProjection::setup(double p_min, double p_max, double p_step, bool p_hide_slider, const String &p_suffix) {

for (int i = 0; i < 16; i++) {

spin[i]->set_min(p_min);

protected:

virtual void _set_read_only(bool p_read_only) override;

public:

void set_string_name(bool p_enabled);

protected:

virtual void _set_read_only(bool p_read_only) override;

void _notification(int p_what);

public:

virtual void update_property() override;

protected:

virtual void _set_read_only(bool p_read_only) override;

void _notification(int p_what);

public:

protected:

virtual void _set_read_only(bool p_read_only) override;

void _notification(int p_what);

public:

void _locale_focus_exited();

protected:

void _notification(int p_what);

public:

protected:

virtual void _set_read_only(bool p_read_only) override;

public:

void setup(const String &p_base_type, const String &p_selected_type);

protected:

virtual void _set_read_only(bool p_read_only) override;

public:

virtual void update_property() override;

protected:

virtual void _set_read_only(bool p_read_only) override;

public:

void setup(const Vector<String> &p_options);

protected:

virtual void _set_read_only(bool p_read_only) override;

public:

void setup(const Vector<String> &p_options);

protected:

void _notification(int p_what);

virtual void _set_read_only(bool p_read_only) override;

public:

void setup(LayerType p_layer_type);

protected:

virtual void _set_read_only(bool p_read_only) override;

public:

virtual void update_property() override;

protected:

virtual void _set_read_only(bool p_read_only) override;

public:

virtual void update_property() override;

String base_type;

void _edit_pressed();

public:

virtual void update_property() override;

EditorPropertySignal();

Button *edit = nullptr;

String base_type;

public:

virtual void update_property() override;

EditorPropertyCallable();

protected:

virtual void _set_read_only(bool p_read_only) override;

public:

virtual void update_property() override;

protected:

virtual void _set_read_only(bool p_read_only) override;

public:

virtual void update_property() override;

protected:

virtual void _set_read_only(bool p_read_only) override;

void _notification(int p_what);

public:

virtual void update_property() override;

protected:

virtual void _set_read_only(bool p_read_only) override;

void _notification(int p_what);

public:

virtual void update_property() override;

protected:

virtual void _set_read_only(bool p_read_only) override;

void _notification(int p_what);

public:

virtual void update_property() override;

protected:

virtual void _set_read_only(bool p_read_only) override;

void _notification(int p_what);

public:

virtual void update_property() override;

protected:

virtual void _set_read_only(bool p_read_only) override;

void _notification(int p_what);

public:

virtual void update_property() override;

protected:

virtual void _set_read_only(bool p_read_only) override;

void _notification(int p_what);

public:

virtual void update_property() override;

protected:

virtual void _set_read_only(bool p_read_only) override;

void _notification(int p_what);

public:

virtual void update_property() override;

protected:

virtual void _set_read_only(bool p_read_only) override;

void _notification(int p_what);

public:

virtual void update_property() override;

protected:

virtual void _set_read_only(bool p_read_only) override;

void _notification(int p_what);

public:

virtual void update_property() override;

return p_mode == COLORATION_CONTAINER_RESOURCE;

}

EditorPropertyArray::EditorPropertyArray() {

object.instantiate();

page_length = int(EDITOR_GET("interface/inspector/max_array_dictionary_items_per_page"));

update_property();

}

bool EditorPropertyDictionary::is_colored(ColorationMode p_mode) {

return p_mode == COLORATION_CONTAINER_RESOURCE;

}

update_property();

}

EditorPropertyLocalizableString::EditorPropertyLocalizableString() {

object.instantiate();

page_length = int(EDITOR_GET("interface/inspector/max_array_dictionary_items_per_page"));

bool updating = false;

bool dropping = false;

void _notification(int p_what);

virtual void _add_element();

void _object_id_selected(const StringName &p_property, ObjectID p_id);

protected:

void _notification(int p_what);

public:

void _object_id_selected(const StringName &p_property, ObjectID p_id);

protected:

void _notification(int p_what);

public:

#include "editor_property_name_processor.h"

#include "editor_settings.h"

EditorPropertyNameProcessor *EditorPropertyNameProcessor::singleton = nullptr;

#include "core/object/class_db.h"

#include "core/os/keyboard.h"

#include "core/os/os.h"

#include "core/version.h"

#include "editor/editor_node.h"

#include "editor/editor_paths.h"

#endif

EDITOR_SETTING(Variant::INT, PROPERTY_HINT_ENUM, "interface/editor/font_subpixel_positioning", 1, "Disabled,Auto,One Half of a Pixel,One Quarter of a Pixel")

EDITOR_SETTING(Variant::BOOL, PROPERTY_HINT_NONE, "interface/editor/font_disable_embedded_bitmaps", true, "");

EDITOR_SETTING(Variant::STRING, PROPERTY_HINT_GLOBAL_FILE, "interface/editor/main_font", "", "*.ttf,*.otf,*.woff,*.woff2,*.pfb,*.pfm")

EDITOR_SETTING(Variant::STRING, PROPERTY_HINT_GLOBAL_FILE, "interface/editor/main_font_bold", "", "*.ttf,*.otf,*.woff,*.woff2,*.pfb,*.pfm")

#include "core/io/compression.h"

#include "core/io/file_access_memory.h"

#include "core/io/translation_loader_po.h"

#include "editor/doc_translations.gen.h"

#include "editor/editor_translations.gen.h"

#include "editor/extractable_translations.gen.h"

}

}

ExportTemplateManager::ExportTemplateManager() {

set_title(TTR("Export Template Manager"));

set_hide_on_ok(false);

protected:

void _notification(int p_what);

public:

static String get_android_build_directory(const Ref<EditorExportPreset> &p_preset);

files->set_max_columns(1);

files->set_max_text_lines(1);

files->set_fixed_column_width(0);

}

Ref<Texture2D> folder_icon = (use_thumbnails) ? folder_thumbnail : get_theme_icon(SNAME("folder"), SNAME("FileDialog"));

}

}

EditorObjectSelector::EditorObjectSelector(EditorSelectionHistory *p_history) {

history = p_history;

protected:

void _notification(int p_what);

public:

virtual Size2 get_minimum_size() const override;

// -> TAB was pressed

// -> modal_close was not called

// -> need to close/hide manually

if (value_input_popup) {

value_input_popup->hide();

}

} else {

grab_focus();

}

ERR_FAIL_NULL(settings);

if (r_option.name == "rest_pose/load_pose") {

if (!settings->has("rest_pose/load_pose") || int((*settings)["rest_pose/load_pose"]) != 2) {

}

}

if (r_option.name == "rest_pose/selected_animation") {

}

} break;

case 2: {

Ref<Animation> anim(res);

Ref<AnimationLibrary> library(res);

if (anim.is_valid()) {

#include "dynamic_font_import_settings.h"

#include "core/config/project_settings.h"

#include "editor/editor_file_system.h"

#include "editor/editor_inspector.h"

#include "editor/editor_locale_dialog.h"

#include "core/io/file_access.h"

#include "core/io/resource_saver.h"

#include "core/string/optimized_translation.h"

String ResourceImporterCSVTranslation::get_importer_name() const {

return "csv_translation";

r_options->push_back(ImportOption(PropertyInfo(Variant::BOOL, "allow_system_fallback"), true));

r_options->push_back(ImportOption(PropertyInfo(Variant::BOOL, "force_autohinter"), false));

r_options->push_back(ImportOption(PropertyInfo(Variant::INT, "hinting", PROPERTY_HINT_ENUM, "None,Light,Normal"), 1));

r_options->push_back(ImportOption(PropertyInfo(Variant::FLOAT, "oversampling", PROPERTY_HINT_RANGE, "0,10,0.1"), 0.0));

r_options->push_back(ImportOption(PropertyInfo(Variant::NIL, "Fallbacks", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_GROUP), Variant()));

font->set_fixed_size(0);

font->set_force_autohinter(autohinter);

font->set_allow_system_fallback(allow_system_fallback);

font->set_hinting((TextServer::Hinting)hinting);

font->set_oversampling(oversampling);

font->set_fallbacks(fallbacks);

Dictionary langs = p_options["language_support"];

for (int i = 0; i < langs.size(); i++) {

String key = langs.get_key_at_index(i);

#include "localization_editor.h"

#include "core/config/project_settings.h"

#include "editor/editor_translation_parser.h"

#include "editor/editor_undo_redo_manager.h"

#include "editor/filesystem_dock.h"

connections->show();

}

void NodeDock::_notification(int p_what) {

switch (p_what) {

case NOTIFICATION_ENTER_TREE:

static NodeDock *get_singleton() { return singleton; }

protected:

void _notification(int p_what);

public:

canvas_item_editor->update_viewport();

}

void AbstractPolygon2DEditor::remove_point(const Vertex &p_vertex) {

EditorUndoRedoManager *undo_redo = EditorUndoRedoManager::get_singleton();

Vector<Vector2> vertices = _get_polygon(p_vertex.polygon);

void _notification(int p_what);

void _node_removed(Node *p_node);

void remove_point(const Vertex &p_vertex);

Vertex get_active_point() const;

}

}

AnimationTreeEditor *AnimationTreeEditor::singleton = nullptr;

void AnimationTreeEditor::add_plugin(AnimationTreeNodeEditorPlugin *p_editor) {

protected:

void _notification(int p_what);

void _node_removed(Node *p_node);

static AnimationTreeEditor *singleton;

return selected->get_text(0);

}

void BonePicker::_notification(int p_what) {

switch (p_what) {

case NOTIFICATION_ENTER_TREE: {

protected:

void _notification(int p_what);

void _confirm();

private:

Node3DEditor::get_singleton()->set_custom_camera(sn);

}

void Camera3DEditor::edit(Node *p_camera) {

node = p_camera;

protected:

void _node_removed(Node *p_node);

public:

void edit(Node *p_camera);

}

}

CPUParticles2DEditorPlugin::CPUParticles2DEditorPlugin() {

particles = nullptr;

protected:

void _notification(int p_what);

public:

virtual String get_name() const override { return "CPUParticles2D"; }

}

}

CPUParticles3DEditor::CPUParticles3DEditor() {

particles_editor_hb = memnew(HBoxContainer);

Node3DEditor::get_singleton()->add_control_to_menu_panel(particles_editor_hb);

protected:

void _notification(int p_notification);

void _node_removed(Node *p_node);

public:

void edit(CPUParticles3D *p_particles);

return plugins;

}

EditorPluginSettings::EditorPluginSettings() {

ProjectSettings::get_singleton()->add_hidden_prefix("editor_plugins/");

protected:

void _notification(int p_what);

public:

void update_plugins();

#include "font_config_plugin.h"

#include "editor/editor_settings.h"

#include "editor/import/dynamic_font_import_settings.h"

#include "editor/themes/editor_scale.h"

return false;

}

void EditorPropertyFontMetaObject::set_dict(const Dictionary &p_dict) {

dict = p_dict;

}

protected:

bool _set(const StringName &p_name, const Variant &p_value);

bool _get(const StringName &p_name, Variant &r_ret) const;

public:

void set_dict(const Dictionary &p_dict);

}

}

GPUParticles2DEditorPlugin::GPUParticles2DEditorPlugin() {

particles = nullptr;

protected:

void _notification(int p_what);

public:

virtual String get_name() const override { return "GPUParticles2D"; }

emission_dialog->popup_centered(Size2(300, 130));

}

GPUParticles3DEditorBase::GPUParticles3DEditorBase() {

emission_dialog = memnew(ConfirmationDialog);

emission_dialog->set_title(TTR("Create Emitter"));

}

}

GPUParticles3DEditor::GPUParticles3DEditor() {

node = nullptr;

particles_editor_hb = memnew(HBoxContainer);

virtual void _generate_emission_points(){};

void _node_selected(const NodePath &p_path);

public:

GPUParticles3DEditorBase();

};

protected:

void _notification(int p_notification);

void _node_removed(Node *p_node);

public:

void edit(GPUParticles3D *p_particles);

}

}

GPUParticlesCollisionSDF3DEditorPlugin::GPUParticlesCollisionSDF3DEditorPlugin() {

bake_hb = memnew(HBoxContainer);

bake_hb->set_h_size_flags(Control::SIZE_EXPAND_FILL);

void _sdf_save_path_and_bake(const String &p_path);

protected:

void _notification(int p_what);

public:

#include "editor/event_listener_line_edit.h"

#include "editor/input_event_configuration_dialog.h"

void InputEventConfigContainer::_notification(int p_what) {

switch (p_what) {

case NOTIFICATION_ENTER_TREE:

protected:

void _notification(int p_what);

public:

void set_event(const Ref<InputEvent> &p_event);

}

}

MeshLibraryEditor::MeshLibraryEditor() {

file = memnew(EditorFileDialog);

file->set_file_mode(EditorFileDialog::FILE_MODE_OPEN_FILE);

static void _import_scene(Node *p_scene, Ref<MeshLibrary> p_library, bool p_merge, bool p_apply_xforms);

static void _import_scene_parse_node(Ref<MeshLibrary> p_library, HashMap<int, MeshInstance3D *> &p_mesh_instances, Node *p_node, bool p_merge, bool p_apply_xforms);

public:

MenuButton *get_menu_button() const { return menu; }

std->popup_scenetree_dialog(browsed_node);

}

MultiMeshEditor::MultiMeshEditor() {

options = memnew(MenuButton);

options->set_switch_on_hover(true);

protected:

void _node_removed(Node *p_node);

public:

void edit(MultiMeshInstance3D *p_multimesh);

if (found_nodes.has(sp)) {

continue;

}

found_nodes.insert(sp);

Node *node = Object::cast_to<Node>(sp);

if (node != edited_scene) {

node = edited_scene->get_deepest_editable_node(node);

}

}

// Replace the node by the group if grouped

int primary_grid_steps = EDITOR_GET("editors/3d/primary_grid_steps");

// Which grid planes are enabled? Which should we generate?

// Offsets division_level for bigger or smaller grids.

// Default value is -0.2. -1.0 gives Blender-like behavior, 0.5 gives huge grids.

int idx_last = atr_owners.size() - 1;

if (idx_last > 0 && !parent_path.begins_with(atr_owners[idx_last].first)) {

atr_owners.remove_at(idx_last);

}

if (property == "auto_translate_mode") {

// If `auto_translate_mode` wasn't found, that means it is set to its default value (`AUTO_TRANSLATE_MODE_INHERIT`).

if (!auto_translate_mode_found) {

int idx_last = atr_owners.size() - 1;

auto_translating = atr_owners[idx_last].second;

} else {

atr_owners.push_back(Pair(state->get_node_path(i), true));

#include "scene/3d/physics/physical_bone_3d.h"

#include "scene/gui/separator.h"

void PhysicalBone3DEditor::_on_toggle_button_transform_joint(bool p_is_pressed) {

_set_move_joint();

}

PhysicalBone3D *selected = nullptr;

private:

void _on_toggle_button_transform_joint(bool p_is_pressed);

void _set_move_joint();

}

}

EditorPropertyRootMotion::EditorPropertyRootMotion() {

HBoxContainer *hbc = memnew(HBoxContainer);

add_child(hbc);

void _node_clear();

protected:

void _notification(int p_what);

public:

}

}

void ShaderFileEditor::edit(const Ref<RDShaderFile> &p_shader) {

if (p_shader.is_null()) {

if (shader_file.is_valid()) {

protected:

void _notification(int p_what);

public:

static ShaderFileEditor *singleton;

}

}

Skeleton2DEditor::Skeleton2DEditor() {

options = memnew(MenuButton);

protected:

void _node_removed(Node *p_node);

public:

void edit(Skeleton2D *p_sprite);

}

}

SkeletonIK3DEditorPlugin::SkeletonIK3DEditorPlugin() {

play_btn = memnew(Button);

play_btn->set_icon(EditorNode::get_singleton()->get_editor_theme()->get_icon(SNAME("Play"), EditorStringName(EditorIcons)));

void _play();

public:

virtual String get_name() const override { return "SkeletonIK3D"; }

bool has_main_screen() const override { return false; }

for (int i = 0; i < tile_set_atlas_source->get_tiles_count(); i++) {

Vector2i tile_id = tile_set_atlas_source->get_tile_id(i);

Vector2 in_tile_base_offset = tile_set_atlas_source->get_tile_data(tile_id, 0)->get_texture_origin();

for (int frame = 0; frame < tile_set_atlas_source->get_tile_animation_frames_count(tile_id); frame++) {

Color color = grid_color;

if (frame > 0) {

base_control->draw_set_transform_matrix(xform);

// Draw fill rect under texture region.

if (tile_data) {

texture_rect.position -= tile_data->get_texture_origin();

}

base_control->draw_rect(texture_rect, Color(1, 1, 1, 0.3));

// Draw the background.

if (tile_data->get_flip_v()) {

region_size.y = -region_size.y;

}

}

// Compute and draw the grid area.

Rect2 grid_area = Rect2(-base_tile_size / 2, base_tile_size);

base_control->draw_rect(grid_area, Color(1, 1, 1, 0.3), false);

// Draw grid.

xform.set_origin(base_control->get_size() / 2 + panning);

xform.set_scale(Vector2(editor_zoom_widget->get_zoom(), editor_zoom_widget->get_zoom()));

Ref<InputEventMouseMotion> mm = p_event;

if (mm.is_valid()) {

if (drag_type == DRAG_TYPE_DRAG_POINT) {

TileSetSource *source = *(tile_set->get_source(p_cell.source_id));

TileSetAtlasSource *atlas_source = Object::cast_to<TileSetAtlasSource>(source);

}

if (atlas_source->is_position_in_tile_texture_region(p_cell.get_atlas_coords(), p_cell.alternative_tile, Vector2())) {

tiles_bottom_panel->set_name(TTR("Tiles"));

missing_source_label = memnew(Label);

missing_source_label->set_h_size_flags(Control::SIZE_EXPAND_FILL);

missing_source_label->set_v_size_flags(Control::SIZE_EXPAND_FILL);

missing_source_label->set_horizontal_alignment(HORIZONTAL_ALIGNMENT_CENTER);

tabs_bar = memnew(TabBar);

tabs_bar->set_tab_alignment(TabBar::ALIGNMENT_CENTER);

tabs_bar->set_clip_tabs(false);

tabs_bar->add_tab(TTR("Patterns"));

tabs_bar->connect("tab_changed", callable_mp(this, &TileSetEditor::_tab_changed));

options->set_clip_text(p_enable);

}

EditorPropertyVisualShaderMode::EditorPropertyVisualShaderMode() {

options = memnew(OptionButton);

options->set_clip_text(true);

}

}

//////////////////////////////////

String VisualShaderConversionPlugin::converts_to() const {

void _option_selected(int p_which);

public:

void setup(const Vector<String> &p_options);

virtual void update_property() override;

void _shader_changed(); //must regen

protected:

void _notification(int p_what);

public:

virtual Size2 get_minimum_size() const override;

}

}

VoxelGIEditorPlugin::VoxelGIEditorPlugin() {

bake_hb = memnew(HBoxContainer);

bake_hb->set_h_size_flags(Control::SIZE_EXPAND_FILL);

void _voxel_gi_save_path_and_bake(const String &p_path);

protected:

void _notification(int p_what);

public:

#include "quick_settings_dialog.h"

#include "core/config/project_settings.h"

#include "editor/editor_settings.h"

#include "editor/editor_string_names.h"

#include "editor/themes/editor_scale.h"

TreeItem *category = nullptr;

bool found = false;

for (const PropertyInfo &E : props) {

if (E.usage == PROPERTY_USAGE_CATEGORY) {

if (category && category->get_first_child() == nullptr) {

continue;

}

continue;

}

TreeItem *item = search_options->create_item(category ? category : root);

item->set_text(0, E.name);

item->set_metadata(0, E.name);

if (!found && !search_box->get_text().is_empty() && E.name.containsn(search_text)) {

item->select(0);

}

item->set_selectable(0, true);

}

if (category && category->get_first_child() == nullptr) {

_cancel_pressed(); // From AcceptDialog.

}

void PropertySelector::_notification(int p_what) {

switch (p_what) {

case NOTIFICATION_ENTER_TREE: {

search_options->connect("item_activated", callable_mp(this, &PropertySelector::_confirmed));

search_options->connect("cell_selected", callable_mp(this, &PropertySelector::_item_selected));

search_options->set_hide_root(true);

help_bit = memnew(EditorHelpBit);

help_bit->set_content_height_limits(80 * EDSCALE, 80 * EDSCALE);

class EditorHelpBit;

class LineEdit;

class Tree;

class PropertySelector : public ConfirmationDialog {

GDCLASS(PropertySelector, ConfirmationDialog);

Vector<Variant::Type> type_filter;

protected:

void _notification(int p_what);

static void _bind_methods();

int font_hinting_setting = (int)EDITOR_GET("interface/editor/font_hinting");

TextServer::SubpixelPositioning font_subpixel_positioning = (TextServer::SubpixelPositioning)(int)EDITOR_GET("interface/editor/font_subpixel_positioning");

bool font_disable_embedded_bitmaps = (bool)EDITOR_GET("interface/editor/font_disable_embedded_bitmaps");

TextServer::Hinting font_hinting;

TextServer::Hinting font_mono_hinting;

const float embolden_strength = 0.6;

Ref<Font> default_font = load_internal_font(_font_NotoSans_Regular, _font_NotoSans_Regular_size, font_hinting, font_antialiasing, true, font_subpixel_positioning, font_disable_embedded_bitmaps, false);

TypedArray<Font> fallbacks;

Ref<FontFile> arabic_font = load_internal_font(_font_NotoNaskhArabicUI_Regular, _font_NotoNaskhArabicUI_Regular_size, font_hinting, font_antialiasing, true, font_subpixel_positioning, font_disable_embedded_bitmaps, false, &fallbacks);

default_font_msdf->set_fallbacks(fallbacks);

Ref<FontFile> default_font_bold = load_internal_font(_font_NotoSans_Bold, _font_NotoSans_Bold_size, font_hinting, font_antialiasing, true, font_subpixel_positioning, font_disable_embedded_bitmaps, false);

TypedArray<Font> fallbacks_bold;

Ref<FontFile> arabic_font_bold = load_internal_font(_font_NotoNaskhArabicUI_Bold, _font_NotoNaskhArabicUI_Bold_size, font_hinting, font_antialiasing, true, font_subpixel_positioning, font_disable_embedded_bitmaps, false, &fallbacks_bold);

Ref<FontVariation> default_fc_msdf;

default_fc_msdf.instantiate();

if (custom_font_path.length() > 0 && dir->file_exists(custom_font_path)) {

{

TypedArray<Font> fallback_custom;

fallback_custom.push_back(default_font_msdf);

Ref<FontVariation> bold_fc_msdf;

bold_fc_msdf.instantiate();

if (custom_font_path_bold.length() > 0 && dir->file_exists(custom_font_path_bold)) {

{

TypedArray<Font> fallback_custom;

fallback_custom.push_back(default_font_bold_msdf);

}

bold_fc_msdf->set_base_font(custom_font);

} else if (custom_font_path.length() > 0 && dir->file_exists(custom_font_path)) {

{

TypedArray<Font> fallback_custom;

fallback_custom.push_back(default_font_bold_msdf);

#include "core/os/os.h"

#include "core/os/time.h"

#include "core/register_core_types.h"

#include "core/version.h"

#include "drivers/register_driver_types.h"

#include "main/app_icon.gen.h"

OS::get_singleton()->benchmark_end_measure("Startup", "Main::Setup");

if (p_second_phase) {

}

return OK;

if (err != OK || display_server == nullptr) {

ERR_PRINT("Unable to create DisplayServer, all display drivers failed.\nUse \"--headless\" command line argument to run the engine in headless mode if this is desired (e.g. for continuous integration).");

return err;

}

OS::get_singleton()->benchmark_end_measure("Scene", "Modules and Extensions");

}

OS::get_singleton()->benchmark_end_measure("Startup", "Scene");

#ifdef TOOLS_ENABLED

return EtcpakType::ETCPAK_TYPE_ETC2;

case Image::USED_CHANNELS_RGBA:

return EtcpakType::ETCPAK_TYPE_ETC2_ALPHA;

default:

return EtcpakType::ETCPAK_TYPE_ETC2_ALPHA;

}

return EtcpakType::ETCPAK_TYPE_DXT1;

case Image::USED_CHANNELS_RGBA:

return EtcpakType::ETCPAK_TYPE_DXT5;

default:

return EtcpakType::ETCPAK_TYPE_DXT5;

}

}

void _compress_etc2(Image *r_img, Image::UsedChannels p_channels) {

}

void _compress_bc(Image *r_img, Image::UsedChannels p_channels) {

}

uint64_t start_time = OS::get_singleton()->get_ticks_msec();

return;

}

// Determine output format based on Etcpak type.

Image::Format target_format = Image::FORMAT_RGBA8;