+# Hints for improving IntelliSense, created together with VS project

+cpp.hint

+

+ Andrea Catania (AndreaCatania)

+ Ben Brookshire (sheepandshepherd)

+ Bernard Liebl (poke1024)

+ Дмитрий Сальников (DmitriySalnikov)

+ Ian (ianb96)

+ Matthias Hölzl (hoelzl)

+ Max Hilbrunner (mhilbrunner)

+ Przemysław Gołąb (n-pigeon)

+ GameDev.TV <https://www.gamedev.tv>

+ Christoph Woinke

+ Pascal Julien

+ 3Dexplorer

+ Andy Meier

+ Jahn Johansen

+ Ranoller

+ Zaq Poi

+ Andres Cuevas

+ Arnaud Verstuyf

+ Giovanni Solimeno

+ Ryan Estes

+ Blair Allen

+ Daniel Kaplan

+ David Cravens

+ David May

+ Diego Moreira Guimarães

+ Eric Martini

+ Frank C. Simmons

+ Gustav Dahlström

+ HardRound

+ Jaime Ruiz-Borau Vizárraga

+ Jeff Hungerford

+ Jesse Liles

+ joe513

+ Juan Negrier

+ Linus Lind Lundgren

+ mhilbrunner

+ Michael Tintiuc

+ Oleg Tyshchenko

+ Pat LaBine

+ Roman Tinkov

+ Thomas Norman

+platform_apis = []

+ if (os.path.exists(x + "/api/api.cpp")):

+ platform_apis.append(x[9:])

+env_base.platform_apis = platform_apis

+ SConscript("platform/SCsub")

+ methods.generate_cpp_hint_file("cpp.hint")

+template <typename Less>

+_FORCE_INLINE_ int bisect(const Vector<Variant> &p_array, const Variant &p_value, bool p_before, const Less &p_less) {

+

+ int lo = 0;

+ int hi = p_array.size();

+ if (p_before) {

+ while (lo < hi) {

+ const int mid = (lo + hi) / 2;

+ if (p_less(p_array.get(mid), p_value)) {

+ lo = mid + 1;

+ } else {

+ hi = mid;

+ }

+ }

+ } else {

+ while (lo < hi) {

+ const int mid = (lo + hi) / 2;

+ if (p_less(p_value, p_array.get(mid))) {

+ hi = mid;

+ } else {

+ lo = mid + 1;

+ }

+ }

+ }

+ return lo;

+}

+

+int Array::bsearch(const Variant &p_value, bool p_before) {

+

+ return bisect(_p->array, p_value, p_before, _ArrayVariantSort());

+}

+

+int Array::bsearch_custom(const Variant &p_value, Object *p_obj, const StringName &p_function, bool p_before) {

+

+ ERR_FAIL_NULL_V(p_obj, 0);

+

+ _ArrayVariantSortCustom less;

+ less.obj = p_obj;

+ less.func = p_function;

+

+ return bisect(_p->array, p_value, p_before, less);

+}

+

+ int bsearch(const Variant &p_value, bool p_before = true);

+ int bsearch_custom(const Variant &p_value, Object *p_obj, const StringName &p_function, bool p_before = true);

+String _OS::get_user_data_dir() const {

+ return OS::get_singleton()->get_user_data_dir();

+ ClassDB::bind_method(D_METHOD("get_user_data_dir"), &_OS::get_user_data_dir);

+ String get_user_data_dir() const;

+ dict["status"] = VERSION_STATUS;

+ dict["build"] = VERSION_BUILD;

+ String hash = VERSION_HASH;

+ stringver += "-" + String(dict["status"]) + " (" + String(dict["build"]) + ")";

+void Image::crop_from_point(int p_x, int p_y, int p_width, int p_height) {

+ ERR_FAIL_COND(p_x < 0);

+ ERR_FAIL_COND(p_y < 0);

+ ERR_FAIL_COND(p_x + p_width > MAX_WIDTH);

+ ERR_FAIL_COND(p_y + p_height > MAX_HEIGHT);

+ if (p_width == width && p_height == height && p_x == 0 && p_y == 0)

+ int m_h = p_y + p_height;

+ int m_w = p_x + p_width;

+ for (int y = p_y; y < m_h; y++) {

+ for (int x = p_x; x < m_w; x++) {

+ dst._put_pixelb(x - p_x, y - p_y, pixel_size, w.ptr(), pdata);

+void Image::crop(int p_width, int p_height) {

+

+ crop_from_point(0, 0, p_width, p_height);

+}

+

+ void crop_from_point(int p_x, int p_y, int p_width, int p_height);

+

+void CompositeLogger::add_logger(Logger *p_logger) {

+ loggers.push_back(p_logger);

+}

+

+ void add_logger(Logger *p_logger);

+

+ case ACCESS_USERDATA: return OS::get_singleton()->get_user_data_dir();

+ da->change_dir("..");

+ String data_dir = OS::get_singleton()->get_user_data_dir();

+// Changes dir for the current scope, returning back to the original dir

+// when scope exits

+class DirChanger {

+ DirAccess *da;

+ String original_dir;

+

+public:

+ DirChanger(DirAccess *p_da, String p_dir) {

+ da = p_da;

+ original_dir = p_da->get_current_dir();

+ p_da->change_dir(p_dir);

+ }

+

+ ~DirChanger() {

+ da->change_dir(original_dir);

+ }

+};

+

+Error DirAccess::_copy_dir(DirAccess *p_target_da, String p_to, int p_chmod_flags) {

+ List<String> dirs;

+

+ String curdir = get_current_dir();

+ list_dir_begin();

+ String n = get_next();

+ while (n != String()) {

+

+ if (n != "." && n != "..") {

+

+ if (current_is_dir())

+ dirs.push_back(n);

+ else {

+ String rel_path = n;

+ if (!n.is_rel_path()) {

+ list_dir_end();

+ return ERR_BUG;

+ }

+ Error err = copy(get_current_dir() + "/" + n, p_to + rel_path, p_chmod_flags);

+ if (err) {

+ list_dir_end();

+ return err;

+ }

+ }

+ }

+

+ n = get_next();

+ }

+

+ list_dir_end();

+

+ for (List<String>::Element *E = dirs.front(); E; E = E->next()) {

+ String rel_path = E->get();

+ String target_dir = p_to + rel_path;

+ if (!p_target_da->dir_exists(target_dir)) {

+ Error err = p_target_da->make_dir(target_dir);

+ ERR_FAIL_COND_V(err, err);

+ }

+

+ Error err = change_dir(E->get());

+ ERR_FAIL_COND_V(err, err);

+ err = _copy_dir(p_target_da, p_to + rel_path + "/", p_chmod_flags);

+ if (err) {

+ change_dir("..");

+ ERR_PRINT("Failed to copy recursively");

+ return err;

+ }

+ err = change_dir("..");

+ if (err) {

+ ERR_PRINT("Failed to go back");

+ return err;

+ }

+ }

+

+ return OK;

+}

+

+Error DirAccess::copy_dir(String p_from, String p_to, int p_chmod_flags) {

+ ERR_FAIL_COND_V(!dir_exists(p_from), ERR_FILE_NOT_FOUND);

+

+ DirAccess *target_da = DirAccess::create_for_path(p_to);

+ ERR_FAIL_COND_V(!target_da, ERR_CANT_CREATE);

+

+ if (!target_da->dir_exists(p_to)) {

+ Error err = target_da->make_dir_recursive(p_to);

+ if (err) {

+ memdelete(target_da);

+ }

+ ERR_FAIL_COND_V(err, err);

+ }

+

+ DirChanger dir_changer(this, p_from);

+ Error err = _copy_dir(target_da, p_to + "/", p_chmod_flags);

+ memdelete(target_da);

+

+ return err;

+}

+

+

+ Error _copy_dir(DirAccess *p_target_da, String p_to, int p_chmod_flags);

+

+ Error copy_dir(String p_from, String p_to, int chmod_flags = -1);

+ String data_dir = OS::get_singleton()->get_user_data_dir();

+void InputEventWithModifiers::set_modifiers_from_event(const InputEventWithModifiers *event) {

+

+ set_alt(event->get_alt());

+ set_shift(event->get_shift());

+ set_control(event->get_control());

+ set_metakey(event->get_metakey());

+}

+

+ kc = find_keycode_name(KEY_META) + ("+" + kc);

+ kc = find_keycode_name(KEY_ALT) + ("+" + kc);

+ kc = find_keycode_name(KEY_SHIFT) + ("+" + kc);

+ kc = find_keycode_name(KEY_CONTROL) + ("+" + kc);

+ mb->set_modifiers_from_event(this);

+ mm->set_modifiers_from_event(this);

+/////////////////////////////

+

+void InputEventGesture::set_position(const Vector2 &p_pos) {

+

+ pos = p_pos;

+}

+

+Vector2 InputEventGesture::get_position() const {

+

+ return pos;

+}

+/////////////////////////////

+

+void InputEventMagnifyGesture::set_factor(real_t p_factor) {

+

+ factor = p_factor;

+}

+

+real_t InputEventMagnifyGesture::get_factor() const {

+

+ return factor;

+}

+

+Ref<InputEvent> InputEventMagnifyGesture::xformed_by(const Transform2D &p_xform, const Vector2 &p_local_ofs) const {

+

+ Ref<InputEventMagnifyGesture> ev;

+ ev.instance();

+

+ ev->set_id(get_id());

+ ev->set_device(get_device());

+ ev->set_modifiers_from_event(this);

+

+ ev->set_position(p_xform.xform(get_position() + p_local_ofs));

+ ev->set_factor(get_factor());

+

+ return ev;

+}

+

+InputEventMagnifyGesture::InputEventMagnifyGesture() {

+

+ factor = 1.0;

+}

+/////////////////////////////

+

+void InputEventPanGesture::set_delta(const Vector2 &p_delta) {

+

+ delta = p_delta;

+}

+

+Vector2 InputEventPanGesture::get_delta() const {

+ return delta;

+}

+

+Ref<InputEvent> InputEventPanGesture::xformed_by(const Transform2D &p_xform, const Vector2 &p_local_ofs) const {

+

+ Ref<InputEventPanGesture> ev;

+ ev.instance();

+

+ ev->set_id(get_id());

+ ev->set_device(get_device());

+ ev->set_modifiers_from_event(this);

+

+ ev->set_position(p_xform.xform(get_position() + p_local_ofs));

+ ev->set_delta(get_delta());

+

+ return ev;

+}

+

+InputEventPanGesture::InputEventPanGesture() {

+

+ delta = Vector2(0, 0);

+}

+ void set_modifiers_from_event(const InputEventWithModifiers *event);

+

+class InputEventGesture : public InputEventWithModifiers {

+

+ GDCLASS(InputEventGesture, InputEventWithModifiers)

+

+ Vector2 pos;

+

+public:

+ void set_position(const Vector2 &p_pos);

+ Vector2 get_position() const;

+};

+

+class InputEventMagnifyGesture : public InputEventGesture {

+

+ GDCLASS(InputEventMagnifyGesture, InputEventGesture)

+ real_t factor;

+

+public:

+ void set_factor(real_t p_factor);

+ real_t get_factor() const;

+

+ virtual Ref<InputEvent> xformed_by(const Transform2D &p_xform, const Vector2 &p_local_ofs = Vector2()) const;

+

+ InputEventMagnifyGesture();

+};

+

+class InputEventPanGesture : public InputEventGesture {

+

+ GDCLASS(InputEventPanGesture, InputEventGesture)

+ Vector2 delta;

+

+public:

+ void set_delta(const Vector2 &p_delta);

+ Vector2 get_delta() const;

+

+ virtual Ref<InputEvent> xformed_by(const Transform2D &p_xform, const Vector2 &p_local_ofs = Vector2()) const;

+

+ InputEventPanGesture();

+};

+#ifdef OSX_ENABLED

+ {KEY_META ,"Command"},

+#else

+#endif

+ if (p_code & KEY_MASK_SHIFT) {

+ codestr += find_keycode_name(KEY_SHIFT);

+ codestr += "+";

+ }

+ if (p_code & KEY_MASK_ALT) {

+ codestr += find_keycode_name(KEY_ALT);

+ codestr += "+";

+ }

+ if (p_code & KEY_MASK_CTRL) {

+ codestr += find_keycode_name(KEY_CONTROL);

+ codestr += "+";

+ }

+ if (p_code & KEY_MASK_META) {

+ codestr += find_keycode_name(KEY_META);

+ codestr += "+";

+ }

+const char *find_keycode_name(int p_keycode) {

+

+ const _KeyCodeText *kct = &_keycodes[0];

+

+ while (kct->text) {

+

+ if (kct->code == p_keycode) {

+ return kct->text;

+ }

+ kct++;

+ }

+

+ return "";

+}

+

+const char *find_keycode_name(int p_keycode);

+#ifdef _MSC_VER

+void operator delete(void *p_mem, const char *p_description) {

+

+ ERR_EXPLAINC("Call to placement delete should not happen.");

+ CRASH_NOW();

+}

+

+void operator delete(void *p_mem, void *(*p_allocfunc)(size_t p_size)) {

+

+ ERR_EXPLAINC("Call to placement delete should not happen.");

+ CRASH_NOW();

+}

+

+void operator delete(void *p_mem, void *p_pointer, size_t check, const char *p_description) {

+

+ ERR_EXPLAINC("Call to placement delete should not happen.");

+ CRASH_NOW();

+}

+#endif

+

+#ifdef _MSC_VER

+// When compiling with VC++ 2017, the above declarations of placement new generate many irrelevant warnings (C4291).

+// The purpose of the following definitions is to muffle these warnings, not to provide a usable implementation of placement delete.

+void operator delete(void *p_mem, const char *p_description);

+void operator delete(void *p_mem, void *(*p_allocfunc)(size_t p_size));

+void operator delete(void *p_mem, void *p_pointer, size_t check, const char *p_description);

+#endif

+

+#include "version_generated.gen.h"

+void OS::_set_logger(CompositeLogger *p_logger) {

+void OS::add_logger(Logger *p_logger) {

+ if (!_logger) {

+ Vector<Logger *> loggers;

+ loggers.push_back(p_logger);

+ _logger = memnew(CompositeLogger(loggers));

+ } else {

+ _logger->add_logger(p_logger);

+ }

+// Helper function used by OS_Unix and OS_Windows

+// Path to data, config, cache, etc. OS-specific folders

+

+// Get properly capitalized engine name for system paths

+String OS::get_godot_dir_name() const {

+

+ // Default to lowercase, so only override when different case is needed

+ return String(VERSION_SHORT_NAME).to_lower();

+}

+

+// OS equivalent of XDG_DATA_HOME

+String OS::get_data_path() const {

+

+ return ".";

+}

+

+// OS equivalent of XDG_CONFIG_HOME

+String OS::get_config_path() const {

+

+ return ".";

+}

+

+// OS equivalent of XDG_CACHE_HOME

+String OS::get_cache_path() const {

+

+ return ".";

+}

+

+// OS specific path for user://

+String OS::get_user_data_dir() const {

+// Absolute path to res://

+String OS::get_resource_dir() const {

+

+ return ProjectSettings::get_singleton()->get_resource_path();

+}

+

+// Access system-specific dirs like Documents, Downloads, etc.

+String OS::get_system_dir(SystemDir p_dir) const {

+

+ return ".";

+}

+

+void OS::_ensure_user_data_dir() {

+ String dd = get_user_data_dir();

+#if defined(__x86_64) || defined(__x86_64__)

+ if (p_feature == "x86_64") {

+ return true;

+ }

+#elif (defined(__i386) || defined(__i386__))

+ if (p_feature == "x86") {

+ return true;

+ }

+#elif defined(__aarch64__)

+ if (p_feature == "arm64") {

+ return true;

+ }

+#elif defined(__arm__)

+#if defined(__ARM_ARCH_7A__)

+ if (p_feature == "armv7a" || p_feature == "armv7") {

+ return true;

+ }

+#endif

+#if defined(__ARM_ARCH_7S__)

+ if (p_feature == "armv7s" || p_feature == "armv7") {

+ return true;

+ }

+#endif

+ if (p_feature == "arm") {

+ return true;

+ }

+#endif

+

+ Vector<Logger *> loggers;

+ loggers.push_back(memnew(StdLogger));

+ _set_logger(memnew(CompositeLogger(loggers)));

+ CompositeLogger *_logger;

+ void _set_logger(CompositeLogger *p_logger);

+ bool maximized;

+ VideoMode(int p_width = 1024, int p_height = 600, bool p_fullscreen = false, bool p_resizable = true, bool p_borderless_window = false, bool p_maximized = false) {

+ maximized = p_maximized;

+ void add_logger(Logger *p_logger);

+

+ void _ensure_user_data_dir();

+ virtual String get_godot_dir_name() const;

+ virtual String get_data_path() const;

+ virtual String get_config_path() const;

+ virtual String get_cache_path() const;

+

+ virtual String get_user_data_dir() const;

+ virtual String get_resource_dir() const;

+ virtual Error move_to_trash(const String &p_path) { return FAILED; }

+

+ String data_dir = OS::get_singleton()->get_user_data_dir();

+#include "scene/main/node.h"

+

+ if (ScriptInstance *inst = p_script->debug_get_stack_level_instance(lv)) {

+ members.push_back("self");

+ member_vals.push_back(inst->get_owner());

+ }

+ List<String> globals;

+ List<Variant> globals_vals;

+ p_script->debug_get_globals(&globals, &globals_vals);

+ ERR_CONTINUE(globals.size() != globals_vals.size());

+

+ packet_peer_stream->put_var(3 + (locals.size() + members.size() + globals.size()) * 2);

+

+ { //locals

+ packet_peer_stream->put_var(locals.size());

+

+ List<String>::Element *E = locals.front();

+ List<Variant>::Element *F = local_vals.front();

+

+ while (E) {

+ _put_variable(E->get(), F->get());

+

+ E = E->next();

+ F = F->next();

+ }

+ }

+ { //globals

+ packet_peer_stream->put_var(globals.size());

+ List<String>::Element *E = globals.front();

+ List<Variant>::Element *F = globals_vals.front();

+ typedef Pair<PropertyInfo, Variant> PropertyDesc;

+ List<PropertyDesc> properties;

+ if (ScriptInstance *si = obj->get_script_instance()) {

+ if (!si->get_script().is_null()) {

+ Set<StringName> members;

+ si->get_script()->get_members(&members);

+ for (Set<StringName>::Element *E = members.front(); E; E = E->next()) {

+ Variant m;

+ if (si->get(E->get(), m)) {

+ PropertyInfo pi(m.get_type(), String("Members/") + E->get());

+ properties.push_back(PropertyDesc(pi, m));

+ }

+ }

+ Map<StringName, Variant> constants;

+ si->get_script()->get_constants(&constants);

+ for (Map<StringName, Variant>::Element *E = constants.front(); E; E = E->next()) {

+ PropertyInfo pi(E->value().get_type(), (String("Constants/") + E->key()));

+ properties.push_back(PropertyDesc(pi, E->value()));

+ }

+ }

+ }

+ if (Node *node = Object::cast_to<Node>(obj)) {

+ PropertyInfo pi(Variant::NODE_PATH, String("Node/path"));

+ properties.push_front(PropertyDesc(pi, node->get_path()));

+ } else if (Resource *res = Object::cast_to<Resource>(obj)) {

+ if (Script *s = Object::cast_to<Script>(res)) {

+ Map<StringName, Variant> constants;

+ s->get_constants(&constants);

+ for (Map<StringName, Variant>::Element *E = constants.front(); E; E = E->next()) {

+ PropertyInfo pi(E->value().get_type(), String("Constants/") + E->key());

+ properties.push_front(PropertyDesc(pi, E->value()));

+ }

+ }

+ }

+ List<PropertyInfo> pinfo;

+ obj->get_property_list(&pinfo, true);

+ properties.push_back(PropertyDesc(E->get(), obj->get(E->get().name)));

+ }

+ }

+ Array send_props;

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

+ const PropertyInfo &pi = properties[i].first;

+ const Variant &var = properties[i].second;

+ RES res = var;

+

+ Array prop;

+ prop.push_back(pi.name);

+ prop.push_back(pi.type);

+

+ //only send information that can be sent..

+ int len = 0; //test how big is this to encode

+ encode_variant(var, NULL, len);

+ if (len > packet_peer_stream->get_output_buffer_max_size()) { //limit to max size

+ prop.push_back(PROPERTY_HINT_OBJECT_TOO_BIG);

+ prop.push_back("");

+ prop.push_back(pi.usage);

+ prop.push_back(Variant());

+ } else {

+ prop.push_back(pi.hint);

+ if (res.is_null())

+ prop.push_back(pi.hint_string);

+ else

+ prop.push_back(String("RES:") + res->get_path());

+ prop.push_back(pi.usage);

+ prop.push_back(var);

+ send_props.push_back(prop);

+

+ packet_peer_stream->put_var("message:inspect_object");

+ packet_peer_stream->put_var(3);

+ packet_peer_stream->put_var(p_id);

+ packet_peer_stream->put_var(obj->get_class());

+ packet_peer_stream->put_var(send_props);

+ String prop_name = p_property;

+ if (p_property.begins_with("Members/"))

+ prop_name = p_property.substr(8, p_property.length());

+

+ obj->set(prop_name, p_value);

+ virtual void get_constants(Map<StringName, Variant> *p_constants) {}

+ virtual void get_members(Set<StringName> *p_constants) {}

+

+ virtual Object *get_owner() { return NULL; }

+ virtual ScriptInstance *debug_get_stack_level_instance(int p_level) { return NULL; }

+ virtual void debug_get_globals(List<String> *p_globals, List<Variant> *p_values, int p_max_subitems = -1, int p_max_depth = -1) = 0;

+String String::join(Vector<String> parts) {

+ String ret;

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

+ if (i > 0) {

+ ret += *this;

+ }

+ ret += parts[i];

+ }

+ return ret;

+}

+

+ String join(Vector<String> parts);

+

+ VECTOR3,

+ VCALL_LOCALMEM2R(Array, bsearch);

+ VCALL_LOCALMEM4R(Array, bsearch_custom);

+ ADDFUNC2R(ARRAY, INT, Array, bsearch, NIL, "value", BOOL, "before", varray(true));

+ ADDFUNC4R(ARRAY, INT, Array, bsearch_custom, NIL, "value", OBJECT, "obj", STRING, "func", BOOL, "before", varray(true));

+ } else if (id == "AABB" || id == "Rect3") {

+#define VERSION_MKSTRING "" _MKSTR(VERSION_MAJOR) "." _MKSTR(VERSION_MINOR) "." _MKSTR(VERSION_PATCH) "." VERSION_STATUS "." VERSION_BUILD VERSION_MODULE_CONFIG

+#define VERSION_MKSTRING "" _MKSTR(VERSION_MAJOR) "." _MKSTR(VERSION_MINOR) "." VERSION_STATUS "." VERSION_BUILD VERSION_MODULE_CONFIG

+#define VERSION_FULL_NAME "" VERSION_NAME " v" VERSION_MKSTRING

+ <method name="cartesian2polar">

+ <return type="Vector2">

+ </return>

+ <argument index="0" name="x" type="float">

+ </argument>

+ <argument index="1" name="y" type="float">

+ </argument>

+ <description>

+ Converts a 2D point expressed in the cartesian coordinate system (x and y axis) to the polar coordinate system (a distance from the origin and an angle).

+ </description>

+ </method>

+ <method name="polar2cartesian">

+ <return type="Vector2">

+ </return>

+ <argument index="0" name="r" type="float">

+ </argument>

+ <argument index="1" name="th" type="float">

+ </argument>

+ <description>

+ Converts a 2D point expressed in the polar coordinate system (a distance from the origin [code]r[/code] and an angle [code]th[/code]) to the cartesian coordinate system (x and y axis).

+ </description>

+ </method>

+ <member name="JavaScript" type="JavaScript" setter="" getter="">

+ </member>

+ <method name="bsearch">

+ <return type="int">

+ </return>

+ <argument index="0" name="value" type="var">

+ </argument>

+ <argument index="1" name="before" type="bool" default="true">

+ </argument>

+ <description>

+ Finds the index of an existing value (or the insertion index that maintains sorting order, if the value is not yet present in the array) using binary search. Optionally, a before specifier can be passed. If false, the returned index comes after all existing entries of the value in the array. Note that calling bsearch on an unsorted array results in unexpected behavior.

+ </description>

+ </method>

+ <method name="bsearch_custom">

+ <return type="int">

+ </return>

+ <argument index="0" name="value" type="var">

+ </argument>

+ <argument index="1" name="obj" type="Object">

+ </argument>

+ <argument index="2" name="func" type="String">

+ </argument>

+ <argument index="3" name="before" type="bool" default="true">

+ </argument>

+ <description>

+ Finds the index of an existing value (or the insertion index that maintains sorting order, if the value is not yet present in the array) using binary search and a custom comparison method. Optionally, a before specifier can be passed. If false, the returned index comes after all existing entries of the value in the array. The custom method receives two arguments (an element from the array and the value searched for) and must return true if the first argument is less than the second, and return false otherwise. Note that calling bsearch on an unsorted array results in unexpected behavior.

+ </description>

+ </method>

+ Connects the output of the bus at [code]bus_idx[/code] to the bus named [code]send[/code].

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

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

+ Overrides an integer constant in the [Theme] resource the node uses. If the [code]constant[/code] is invalid, Godot clears the override. See [member Theme.INVALID_CONSTANT] for more information.

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

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

+ "build" - Holds the build name (e.g. "custom-build") as a String

+ "string" - major + minor + patch + status + build in a single String

+ [codeblock]

+ [/codeblock]

+ Returns [code]true[/code] if this event matches [code]event[/code].

+ Contains a generic action which can be targeted from several type of inputs. Actions can be created from the project settings menu [code]Project &gt; Project Settings &gt; Input Map[/code]. See [method Node._input].

+ Manages all [InputEventAction] which can be created/modified from the project settings menu [code]Project &gt; Project Settings &gt; Input Map[/code] or in code with [method add_action] and [method action_add_event]. See [method Node._input].

+<?xml version="1.0" encoding="UTF-8" ?>

+<class name="JavaScript" inherits="Object" category="Core" version="3.0-alpha">

+ <brief_description>

+ Singleton that connects the engine with the browser's JavaScript context in HTML5 export.

+ </brief_description>

+ <description>

+ The JavaScript singleton is implemented only in HTML5 export. It's used to access the browser's JavaScript context. This allows interaction with embedding pages or calling third-party JavaScript APIs.

+ </description>

+ <tutorials>

+ http://docs.godotengine.org/en/stable/learning/workflow/export/exporting_for_web.html#calling-javascript-from-script

+ </tutorials>

+ <demos>

+ </demos>

+ <methods>

+ <method name="eval">

+ <return type="Variant">

+ </return>

+ <argument index="0" name="code" type="String">

+ </argument>

+ <argument index="1" name="use_global_execution_context" type="bool" default="false">

+ </argument>

+ <description>

+ Execute the string [code]code[/code] as JavaScript code within the browser window. This is a call to the actual global JavaScript function [code]eval()[/code].

+ If [code]use_global_execution_context[/code] is [code]true[/code], the code will be evaluated in the global execution context. Otherwise, it is evaluated in the execution context of a function within the engine's runtime environment.

+ </description>

+ </method>

+ </methods>

+ <constants>

+ </constants>

+</class>

+ Returns a [KinematicCollision], which contains information about a collision that occured during the last [method move_and_slide] call. Since the body can collide several times in a single call to [method move_and_slide], you must specify the index of the collision in the range 0 to ([method get_slide_count] - 1).

+ Returns a [KinematicCollision2D], which contains information about a collision that occured during the last [method move_and_slide] call. Since the body can collide several times in a single call to [method move_and_slide], you must specify the index of the collision in the range 0 to ([method get_slide_count] - 1).

+ Returns point [code]i[/code]'s position.

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

+ Returns the absolute directory path where user data is written ([code]user://[/code]).

+ <signal name="meta_hover_started">

+ <argument index="0" name="meta" type="Nil">

+ </argument>

+ <description>

+ Triggers when the mouse enters a meta tag.

+ </description>

+ </signal>

+ <signal name="meta_hover_ended">

+ <argument index="0" name="meta" type="Nil">

+ </argument>

+ <description>

+ Triggers when the mouse exits a meta tag.

+ </description>

+ </signal>

+cur_file = ""

+ escape_post = True

+ ss = param.split('.')

+ if len(ss) > 2:

+ sys.exit("Bad reference: '" + param + "' in file: " + cur_file)

+ (class_param, method_param) = ss

+for cur_file in file_list:

+ tree = ET.parse(cur_file)

+ import os

+ path = os.getcwd()

+ # Change directory so the path resolves correctly in the function call.

+ os.chdir("..")

+ os.chdir(path)

+#if defined(OPENGL_ENABLED) || defined(GLES_ENABLED)

+#if defined(OPENGL_ENABLED) || defined(GLES_ENABLED)

+#ifdef GLAD_ENABLED

+ if (!gladLoadGL()) {

+ ERR_PRINT("Error initializing GLAD");

+// GLVersion seems to be used for both GL and GL ES, so we need different version checks for them

+#ifdef OPENGL_ENABLED // OpenGL 3.3 Core Profile required

+ if (GLVersion.major < 3 && GLVersion.minor < 3) {

+#else // OpenGL ES 3.0

+ if (GLVersion.major < 3) {

+#endif

+ ERR_PRINT("Your system's graphic drivers seem not to support OpenGL 3.3 / OpenGL ES 3.0, sorry :(\n"

+ OS::get_singleton()->alert("Your system's graphic drivers seem not to support OpenGL 3.3 / OpenGL ES 3.0, sorry :(\n"

+ "Fatal error: Insufficient OpenGL / GLES driver support");

+#endif // GLAD_ENABLED

+ /* // For debugging

+ glDebugMessageControlARB(GL_DEBUG_SOURCE_API_ARB,GL_DEBUG_TYPE_ERROR_ARB,GL_DEBUG_SEVERITY_HIGH_ARB,0,NULL,GL_TRUE);

+ */

+ light->param[VS::LIGHT_PARAM_INDIRECT_ENERGY] = 1.0;

+String OS_Unix::get_user_data_dir() const {

+ String appname = get_safe_application_name();

+ if (appname != "") {

+ bool use_godot_dir = ProjectSettings::get_singleton()->get("application/config/use_shared_user_dir");

+ if (use_godot_dir) {

+ return get_data_path().plus_file(get_godot_dir_name()).plus_file("app_userdata").plus_file(appname);

+ } else {

+ return get_data_path().plus_file(appname);

+OS_Unix::OS_Unix() {

+ Vector<Logger *> loggers;

+ loggers.push_back(memnew(UnixTerminalLogger));

+ _set_logger(memnew(CompositeLogger(loggers)));

+}

+

+ OS_Unix();

+

+ virtual String get_user_data_dir() const;

+ track_ofs[0] = size.width - icon_ofs.x + ofs.x;

+ track_ofs[1] = size.width - icon_ofs.x + ofs.x;

+ track_ofs[2] = size.width - icon_ofs.x + ofs.x;

+ track_ofs[3] = size.width - icon_ofs.x + ofs.x;

+ track_ofs[4] = size.width - icon_ofs.x + ofs.x;

+ if (mpos.x < name_limit - (type_icon[0]->get_width() / 2.0)) {

+

+ Ref<InputEventMagnifyGesture> magnify_gesture = p_input;

+ if (magnify_gesture.is_valid()) {

+ zoom->set_value(zoom->get_value() * magnify_gesture->get_factor());

+ }

+

+ Ref<InputEventPanGesture> pan_gesture = p_input;

+ if (pan_gesture.is_valid()) {

+

+ h_scroll->set_value(h_scroll->get_value() - h_scroll->get_page() * pan_gesture->get_delta().x / 8);

+ v_scroll->set_value(v_scroll->get_value() - v_scroll->get_page() * pan_gesture->get_delta().y / 8);

+ }

+ text_editor->unfold_line(get_line() - 1);

+ text_edit->unfold_line(line);

+ text_edit->unfold_line(result_line);

+ text_edit->unfold_line(result_line);

+ text_edit->unfold_line(line);

+ Ref<InputEventMagnifyGesture> magnify_gesture = p_event;

+ if (magnify_gesture.is_valid()) {

+

+ Ref<DynamicFont> font = text_editor->get_font("font");

+

+ if (font.is_valid()) {

+ if (font->get_size() != (int)font_size) {

+ font_size = font->get_size();

+ }

+

+ font_size *= powf(magnify_gesture->get_factor(), 0.25);

+

+ _add_font_size((int)font_size - font->get_size());

+ }

+ return;

+ }

+

+ _zoom_changed();

+ _zoom_changed();

+}

+void CodeTextEditor::_zoom_changed() {

+ if (_add_font_size(font_resize_val)) {

+ font_resize_val = 0;

+ }

+}

+

+bool CodeTextEditor::_add_font_size(int p_delta) {

+

+ int new_size = CLAMP(font->get_size() + p_delta, 8 * EDSCALE, 96 * EDSCALE);

+ return true;

+ } else {

+ return false;

+ text_editor->set_hiding_enabled(EditorSettings::get_singleton()->get("text_editor/line_numbers/code_folding"));

+ text_editor->set_draw_fold_gutter(EditorSettings::get_singleton()->get("text_editor/line_numbers/code_folding"));

+ font_size = -1;

+ real_t font_size;

+ bool _add_font_size(int p_delta);

+ void _zoom_changed();

+ FileAccess *f = FileAccess::open(EditorSettings::get_singleton()->get_project_settings_dir().plus_file("create_recent." + base_type), FileAccess::READ);

+ f = FileAccess::open(EditorSettings::get_singleton()->get_project_settings_dir().plus_file("favorites." + base_type), FileAccess::READ);

+ FileAccess *f = FileAccess::open(EditorSettings::get_singleton()->get_project_settings_dir().plus_file("create_recent." + base_type), FileAccess::WRITE);

+ FileAccess *f = FileAccess::open(EditorSettings::get_singleton()->get_project_settings_dir().plus_file("favorites." + base_type), FileAccess::WRITE);

+void DependencyEditorOwners::_list_rmb_select(int p_item, const Vector2 &p_pos) {

+

+ file_options->clear();

+ file_options->set_size(Size2(1, 1));

+ if (p_item >= 0) {

+ file_options->add_item(TTR("Open"), FILE_OPEN);

+ }

+

+ file_options->set_position(owners->get_global_position() + p_pos);

+ file_options->popup();

+}

+

+void DependencyEditorOwners::_select_file(int p_idx) {

+

+ String fpath = owners->get_item_text(p_idx);

+

+ if (ResourceLoader::get_resource_type(fpath) == "PackedScene") {

+ editor->open_request(fpath);

+ hide();

+ emit_signal("confirmed");

+ }

+}

+

+void DependencyEditorOwners::_file_option(int p_option) {

+

+ switch (p_option) {

+ case FILE_OPEN: {

+ int idx = owners->get_current();

+ if (idx < 0 || idx >= owners->get_item_count())

+ break;

+ _select_file(idx);

+ } break;

+ }

+}

+

+void DependencyEditorOwners::_bind_methods() {

+

+ ClassDB::bind_method(D_METHOD("_list_rmb_select"), &DependencyEditorOwners::_list_rmb_select);

+ ClassDB::bind_method(D_METHOD("_file_option"), &DependencyEditorOwners::_file_option);

+ ClassDB::bind_method(D_METHOD("_select_file"), &DependencyEditorOwners::_select_file);

+}

+DependencyEditorOwners::DependencyEditorOwners(EditorNode *p_editor) {

+

+ editor = p_editor;

+

+ file_options = memnew(PopupMenu);

+ add_child(file_options);

+ file_options->connect("id_pressed", this, "_file_option");

+ owners->set_select_mode(ItemList::SELECT_SINGLE);

+ owners->connect("item_rmb_selected", this, "_list_rmb_select");

+ owners->connect("item_activated", this, "_select_file");

+ owners->set_allow_rmb_select(true);

+class EditorNode;

+ PopupMenu *file_options;

+ EditorNode *editor;

+

+ static void _bind_methods();

+ void _list_rmb_select(int p_item, const Vector2 &p_pos);

+ void _select_file(int p_idx);

+ void _file_option(int p_option);

+

+private:

+ enum FileMenu {

+ FILE_OPEN

+ };

+

+ DependencyEditorOwners(EditorNode *p_editor);

+/*************************************************************************/

+/* dictionary_property_edit.cpp */

+/*************************************************************************/

+/* This file is part of: */

+/* GODOT ENGINE */

+/* http://www.godotengine.org */

+/*************************************************************************/

+/* Copyright (c) 2007-2017 Juan Linietsky, Ariel Manzur. */

+/* Copyright (c) 2014-2017 Godot Engine contributors (cf. AUTHORS.md) */

+/* */

+/* Permission is hereby granted, free of charge, to any person obtaining */

+/* a copy of this software and associated documentation files (the */

+/* "Software"), to deal in the Software without restriction, including */

+/* without limitation the rights to use, copy, modify, merge, publish, */

+/* distribute, sublicense, and/or sell copies of the Software, and to */

+/* permit persons to whom the Software is furnished to do so, subject to */

+/* the following conditions: */

+/* */

+/* The above copyright notice and this permission notice shall be */

+/* included in all copies or substantial portions of the Software. */

+/* */

+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */

+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */

+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/

+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */

+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */

+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */

+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */

+/*************************************************************************/

+#include "dictionary_property_edit.h"

+#include "editor_node.h"

+

+void DictionaryPropertyEdit::_notif_change() {

+ _change_notify();

+}

+

+void DictionaryPropertyEdit::_notif_changev(const String &p_v) {

+ _change_notify(p_v.utf8().get_data());

+}

+

+void DictionaryPropertyEdit::_set_key(const Variant &p_old_key, const Variant &p_new_key) {

+

+ // TODO: Set key of a dictionary is not allowd yet

+ return;

+}

+

+void DictionaryPropertyEdit::_set_value(const Variant &p_key, const Variant &p_value) {

+

+ Dictionary dict = get_dictionary();

+ dict[p_key] = p_value;

+ Object *o = ObjectDB::get_instance(obj);

+ if (!o)

+ return;

+

+ o->set(property, dict);

+}

+

+Variant DictionaryPropertyEdit::get_dictionary() const {

+

+ Object *o = ObjectDB::get_instance(obj);

+ if (!o)

+ return Dictionary();

+ Variant dict = o->get(property);

+ if (dict.get_type() != Variant::DICTIONARY)

+ return Dictionary();

+ return dict;

+}

+

+void DictionaryPropertyEdit::_get_property_list(List<PropertyInfo> *p_list) const {

+

+ Dictionary dict = get_dictionary();

+

+ Array keys = dict.keys();

+ keys.sort();

+

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

+ String index = itos(i);

+

+ const Variant &key = keys[i];

+ PropertyInfo pi(key.get_type(), index + ": key");

+ p_list->push_back(pi);

+

+ const Variant &value = dict[key];

+ pi = PropertyInfo(value.get_type(), index + ": value");

+ p_list->push_back(pi);

+ }

+}

+

+void DictionaryPropertyEdit::edit(Object *p_obj, const StringName &p_prop) {

+

+ property = p_prop;

+ obj = p_obj->get_instance_id();

+}

+

+Node *DictionaryPropertyEdit::get_node() {

+

+ Object *o = ObjectDB::get_instance(obj);

+ if (!o)

+ return NULL;

+

+ return cast_to<Node>(o);

+}

+

+void DictionaryPropertyEdit::_bind_methods() {

+

+ ClassDB::bind_method(D_METHOD("_set_key"), &DictionaryPropertyEdit::_set_key);

+ ClassDB::bind_method(D_METHOD("_set_value"), &DictionaryPropertyEdit::_set_value);

+ ClassDB::bind_method(D_METHOD("_notif_change"), &DictionaryPropertyEdit::_notif_change);

+ ClassDB::bind_method(D_METHOD("_notif_changev"), &DictionaryPropertyEdit::_notif_changev);

+}

+

+bool DictionaryPropertyEdit::_set(const StringName &p_name, const Variant &p_value) {

+

+ Dictionary dict = get_dictionary();

+ Array keys = dict.keys();

+ keys.sort();

+

+ String pn = p_name;

+ int slash = pn.find(": ");

+ if (slash != -1 && pn.length() > slash) {

+ String type = pn.substr(slash + 2, pn.length());

+ int index = pn.substr(0, slash).to_int();

+ if (type == "key" && index < keys.size()) {

+

+ const Variant &key = keys[index];

+ UndoRedo *ur = EditorNode::get_singleton()->get_undo_redo();

+

+ ur->create_action(TTR("Change Dictionary Key"));

+ ur->add_do_method(this, "_set_key", key, p_value);

+ ur->add_undo_method(this, "_set_key", p_value, key);

+ ur->add_do_method(this, "_notif_changev", p_name);

+ ur->add_undo_method(this, "_notif_changev", p_name);

+ ur->commit_action();

+

+ return true;

+ } else if (type == "value" && index < keys.size()) {

+ const Variant &key = keys[index];

+ if (dict.has(key)) {

+

+ Variant value = dict[key];

+ UndoRedo *ur = EditorNode::get_singleton()->get_undo_redo();

+

+ ur->create_action(TTR("Change Dictionary Value"));

+ ur->add_do_method(this, "_set_value", key, p_value);

+ ur->add_undo_method(this, "_set_value", key, value);

+ ur->add_do_method(this, "_notif_changev", p_name);

+ ur->add_undo_method(this, "_notif_changev", p_name);

+ ur->commit_action();

+

+ return true;

+ }

+ }

+ }

+

+ return false;

+}

+

+bool DictionaryPropertyEdit::_get(const StringName &p_name, Variant &r_ret) const {

+

+ Dictionary dict = get_dictionary();

+ Array keys = dict.keys();

+ keys.sort();

+

+ String pn = p_name;

+ int slash = pn.find(": ");

+

+ if (slash != -1 && pn.length() > slash) {

+

+ String type = pn.substr(slash + 2, pn.length());

+ int index = pn.substr(0, slash).to_int();

+

+ if (type == "key" && index < keys.size()) {

+ r_ret = keys[index];

+ return true;

+ } else if (type == "value" && index < keys.size()) {

+ const Variant &key = keys[index];

+ if (dict.has(key)) {

+ r_ret = dict[key];

+ return true;

+ }

+ }

+ }

+

+ return false;

+}

+

+DictionaryPropertyEdit::DictionaryPropertyEdit() {

+ obj = 0;

+}

+/*************************************************************************/

+/* dictionary_property_edit.h */

+/*************************************************************************/

+/* This file is part of: */

+/* GODOT ENGINE */

+/* http://www.godotengine.org */

+/*************************************************************************/

+/* Copyright (c) 2007-2017 Juan Linietsky, Ariel Manzur. */

+/* Copyright (c) 2014-2017 Godot Engine contributors (cf. AUTHORS.md) */

+/* */

+/* Permission is hereby granted, free of charge, to any person obtaining */

+/* a copy of this software and associated documentation files (the */

+/* "Software"), to deal in the Software without restriction, including */

+/* without limitation the rights to use, copy, modify, merge, publish, */

+/* distribute, sublicense, and/or sell copies of the Software, and to */

+/* permit persons to whom the Software is furnished to do so, subject to */

+/* the following conditions: */

+/* */

+/* The above copyright notice and this permission notice shall be */

+/* included in all copies or substantial portions of the Software. */

+/* */

+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */

+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */

+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/

+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */

+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */

+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */

+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */

+/*************************************************************************/

+#ifndef DICTIONARY_PROPERTY_EDIT_H

+#define DICTIONARY_PROPERTY_EDIT_H

+

+#include "scene/main/node.h"

+

+class DictionaryPropertyEdit : public Reference {

+ GDCLASS(DictionaryPropertyEdit, Reference);

+

+ ObjectID obj;

+ StringName property;

+

+ void _notif_change();

+ void _notif_changev(const String &p_v);

+ void _set_key(const Variant &p_old_key, const Variant &p_new_key);

+ void _set_value(const Variant &p_key, const Variant &p_value);

+

+ Variant get_dictionary() const;

+

+protected:

+ static void _bind_methods();

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

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

+ void _get_property_list(List<PropertyInfo> *p_list) const;

+

+public:

+ void edit(Object *p_obj, const StringName &p_prop);

+

+ Node *get_node();

+

+ DictionaryPropertyEdit();

+};

+

+#endif // DICTIONARY_PROPERTY_EDIT_H

+ header += String(" version=\"") + itos(VERSION_MAJOR) + "." + itos(VERSION_MINOR) + "-" + VERSION_STATUS + "\"";

+ _write_string(f, 0, String("<doc version=\"") + itos(VERSION_MAJOR) + "." + itos(VERSION_MINOR) + "-" + VERSION_STATUS + "\" name=\"Engine Types\">");

+ emit_signal("selection_changed");

+ String current_version = itos(VERSION_MAJOR) + "." + itos(VERSION_MINOR) + "-" + VERSION_STATUS + VERSION_MODULE_CONFIG;

+ String template_path = EditorSettings::get_singleton()->get_templates_dir().plus_file(current_version).plus_file(template_file_name);

+ if (FileAccess::exists(template_path)) {

+ return template_path;

+ *err += "No export template found at \"" + template_path + "\".";

+ return String();

+void EditorExportPlugin::add_shared_object(const String &p_path, const Vector<String> &tags) {

+

+ shared_objects.push_back(SharedObject(p_path, tags));

+}

+

+void EditorExportPlugin::add_ios_framework(const String &p_path) {

+ ios_frameworks.push_back(p_path);

+}

+

+Vector<String> EditorExportPlugin::get_ios_frameworks() const {

+ return ios_frameworks;

+}

+

+void EditorExportPlugin::add_ios_plist_content(const String &p_plist_content) {

+ ios_plist_content += p_plist_content + "\n";

+}

+

+String EditorExportPlugin::get_ios_plist_content() const {

+ return ios_plist_content;

+}

+

+void EditorExportPlugin::add_ios_linker_flags(const String &p_flags) {

+ if (ios_linker_flags.length() > 0) {

+ ios_linker_flags += ' ';

+ }

+ ios_linker_flags += p_flags;

+}

+

+String EditorExportPlugin::get_ios_linker_flags() const {

+ return ios_linker_flags;

+}

+void EditorExportPlugin::add_ios_bundle_file(const String &p_path) {

+ ios_bundle_files.push_back(p_path);

+}

+

+Vector<String> EditorExportPlugin::get_ios_bundle_files() const {

+ return ios_bundle_files;

+}

+

+void EditorExportPlugin::add_ios_cpp_code(const String &p_code) {

+ ios_cpp_code += p_code;

+}

+

+String EditorExportPlugin::get_ios_cpp_code() const {

+ return ios_cpp_code;

+void EditorExportPlugin::_export_begin_script(const PoolVector<String> &p_features, bool p_debug, const String &p_path, int p_flags) {

+ get_script_instance()->call("_export_begin", p_features, p_debug, p_path, p_flags);

+void EditorExportPlugin::_export_begin(const Set<String> &p_features, bool p_debug, const String &p_path, int p_flags) {

+ ClassDB::bind_method(D_METHOD("add_shared_object", "path", "tags"), &EditorExportPlugin::add_shared_object);

+ ClassDB::bind_method(D_METHOD("add_ios_framework", "path"), &EditorExportPlugin::add_ios_framework);

+ ClassDB::bind_method(D_METHOD("add_ios_plist_content", "plist_content"), &EditorExportPlugin::add_ios_plist_content);

+ ClassDB::bind_method(D_METHOD("add_ios_linker_flags", "flags"), &EditorExportPlugin::add_ios_linker_flags);

+ ClassDB::bind_method(D_METHOD("add_ios_bundle_file", "path"), &EditorExportPlugin::add_ios_bundle_file);

+ ClassDB::bind_method(D_METHOD("add_ios_cpp_code", "code"), &EditorExportPlugin::add_ios_cpp_code);

+ BIND_VMETHOD(MethodInfo("_export_begin", PropertyInfo(Variant::POOL_STRING_ARRAY, "features"), PropertyInfo(Variant::BOOL, "is_debug"), PropertyInfo(Variant::STRING, "path"), PropertyInfo(Variant::INT, "flags")));

+EditorExportPlatform::FeatureContainers EditorExportPlatform::get_feature_containers(const Ref<EditorExportPreset> &p_preset) {

+ platform->get_platform_features(&feature_list);

+

+ FeatureContainers result;

+ result.features.insert(E->get());

+ result.features_pv.push_back(E->get());

+ return result;

+}

+EditorExportPlatform::ExportNotifier::ExportNotifier(EditorExportPlatform &p_platform, const Ref<EditorExportPreset> &p_preset, bool p_debug, const String &p_path, int p_flags) {

+ FeatureContainers features = p_platform.get_feature_containers(p_preset);

+ //initial export plugin callback

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

+ if (export_plugins[i]->get_script_instance()) { //script based

+ export_plugins[i]->_export_begin_script(features.features_pv, p_debug, p_path, p_flags);

+ } else {

+ export_plugins[i]->_export_begin(features.features, p_debug, p_path, p_flags);

+ }

+ }

+}

+

+EditorExportPlatform::ExportNotifier::~ExportNotifier() {

+ Vector<Ref<EditorExportPlugin> > export_plugins = EditorExport::get_singleton()->get_export_plugins();

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

+ export_plugins[i]->_export_end();

+ }

+}

+Error EditorExportPlatform::export_project_files(const Ref<EditorExportPreset> &p_preset, EditorExportSaveFunction p_func, void *p_udata, EditorExportSaveSharedObject p_so_func) {

+ Vector<Ref<EditorExportPlugin> > export_plugins = EditorExport::get_singleton()->get_export_plugins();

+ FeatureContainers feature_containers = get_feature_containers(p_preset);

+ Set<String> &features = feature_containers.features;

+ PoolVector<String> &features_pv = feature_containers.features_pv;

+

+ String engine_cfb = EditorSettings::get_singleton()->get_cache_dir().plus_file("tmp" + config_file);

+Error EditorExportPlatform::_add_shared_object(void *p_userdata, const SharedObject &p_so) {

+ PackData *pack_data = (PackData *)p_userdata;

+ if (pack_data->so_files) {

+ pack_data->so_files->push_back(p_so);

+ }

+

+ return OK;

+}

+

+Error EditorExportPlatform::save_pack(const Ref<EditorExportPreset> &p_preset, const String &p_path, Vector<SharedObject> *p_so_files) {

+ String tmppath = EditorSettings::get_singleton()->get_cache_dir().plus_file("packtmp");

+ pd.so_files = p_so_files;

+ Error err = export_project_files(p_preset, _save_pack_file, &pd, _add_shared_object);

+ ExportNotifier notifier(*this, p_preset, p_debug, p_path, p_flags);

+struct SharedObject {

+ String path;

+ Vector<String> tags;

+

+ SharedObject(const String &p_path, const Vector<String> &p_tags)

+ : path(p_path), tags(p_tags) {

+ }

+

+ SharedObject() {}

+};

+

+ typedef Error (*EditorExportSaveSharedObject)(void *p_userdata, const SharedObject &p_so);

+ Vector<SharedObject> *so_files;

+ struct FeatureContainers {

+ Set<String> features;

+ PoolVector<String> features_pv;

+ };

+

+ static Error _add_shared_object(void *p_userdata, const SharedObject &p_so);

+

+ struct ExportNotifier {

+ ExportNotifier(EditorExportPlatform &p_platform, const Ref<EditorExportPreset> &p_preset, bool p_debug, const String &p_path, int p_flags);

+ ~ExportNotifier();

+ };

+

+ FeatureContainers get_feature_containers(const Ref<EditorExportPreset> &p_preset);

+

+ Error save_pack(const Ref<EditorExportPreset> &p_preset, const String &p_path, Vector<SharedObject> *p_so_files = NULL);

+ Vector<SharedObject> shared_objects;

+ Vector<String> ios_frameworks;

+ String ios_plist_content;

+ String ios_linker_flags;

+ Vector<String> ios_bundle_files;

+ String ios_cpp_code;

+

+ _FORCE_INLINE_ void _export_end() {

+ ios_frameworks.clear();

+ ios_bundle_files.clear();

+ ios_plist_content = "";

+ ios_linker_flags = "";

+ ios_cpp_code = "";

+ }

+

+ void _export_begin_script(const PoolVector<String> &p_features, bool p_debug, const String &p_path, int p_flags);

+ void add_shared_object(const String &p_path, const Vector<String> &tags);

+

+ void add_ios_framework(const String &p_path);

+ void add_ios_plist_content(const String &p_plist_content);

+ void add_ios_linker_flags(const String &p_flags);

+ void add_ios_bundle_file(const String &p_path);

+ void add_ios_cpp_code(const String &p_code);

+

+ virtual void _export_begin(const Set<String> &p_features, bool p_debug, const String &p_path, int p_flags);

+ Vector<String> get_ios_frameworks() const;

+ String get_ios_plist_content() const;

+ String get_ios_linker_flags() const;

+ Vector<String> get_ios_bundle_files() const;

+ String get_ios_cpp_code() const;

+

+ if (item == ".")

+ continue;

+

+ item_list->add_item(dir_name);

+ String fscache = EditorSettings::get_singleton()->get_project_settings_dir().plus_file("filesystem_cache3");

+ String update_cache = EditorSettings::get_singleton()->get_project_settings_dir().plus_file("filesystem_update3");

+ String fscache = EditorSettings::get_singleton()->get_project_settings_dir().plus_file("filesystem_cache3");

+ String fscache = EditorSettings::get_singleton()->get_project_settings_dir().plus_file("filesystem_update3");

+ String tag = p_select.substr(1, 6);

+ String link = p_select.substr(7, p_select.length());

+

+ String topic;

+ Map<String, int> *table = NULL;

+

+ if (tag == "method") {

+ topic = "class_method";

+ table = &this->method_line;

+ } else if (tag == "member") {

+ topic = "class_property";

+ table = &this->property_line;

+ } else if (tag == "enum ") {

+ topic = "class_enum";

+ table = &this->enum_line;

+ } else if (tag == "signal") {

+ topic = "class_signal";

+ table = &this->signal_line;

+ } else {

+ return;

+ }

+ if (link.find(".") != -1) {

+ emit_signal("go_to_help", topic + ":" + link.get_slice(".", 0) + ":" + link.get_slice(".", 1));

+ if (!table->has(link))

+ class_desc->scroll_to_line((*table)[link]);

+ class_desc->push_meta("@member" + cd.properties[i].name);

+ class_desc->push_meta("@method" + methods[i].name);

+ property_line[cd.properties[i].name] = class_desc->get_line_count() - 2;

+ } else if (tag.begins_with("method ") || tag.begins_with("member ") || tag.begins_with("signal ") || tag.begins_with("enum ")) {

+ String link_target = tag.substr(tag.find(" ") + 1, tag.length());

+ String link_tag = tag.substr(0, tag.find(" ")).rpad(6);

+ p_rt->push_meta("@" + link_tag + link_target);

+ p_rt->add_text(link_target + (tag.begins_with("method ") ? "()" : ""));

+

+ int current = editor_data.get_edited_scene();

+ if (scene_tabs->get_offset_buttons_visible()) {

+ // move add button to fixed position on the tabbar

+ if (scene_tab_add->get_parent() == scene_tabs) {

+ scene_tab_add->set_position(Point2(0, 0));

+ scene_tabs->remove_child(scene_tab_add);

+ tabbar_container->add_child(scene_tab_add);

+ tabbar_container->move_child(scene_tab_add, 1);

+ }

+ } else {

+ // move add button to after last tab

+ if (scene_tab_add->get_parent() == tabbar_container) {

+ tabbar_container->remove_child(scene_tab_add);

+ scene_tabs->add_child(scene_tab_add);

+ }

+ Rect2 last_tab = Rect2();

+ if (scene_tabs->get_tab_count() != 0)

+ last_tab = scene_tabs->get_tab_rect(scene_tabs->get_tab_count() - 1);

+ scene_tab_add->set_position(Point2(last_tab.get_position().x + last_tab.get_size().x + 3, last_tab.get_position().y));

+ }

+ String title = appname.empty() ? String(VERSION_FULL_NAME) : String(VERSION_NAME + String(" - ") + appname);

+ Ref<Theme> theme = create_editor_theme(theme_base->get_theme());

+ scene_tab_add->set_icon(gui_base->get_icon("Add", "EditorIcons"));

+

+ if (p_what == Control::NOTIFICATION_RESIZED) {

+ _update_scene_tabs();

+ }

+ if (!preset->is_runnable() && (export_defer.path.ends_with(".pck") || export_defer.path.ends_with(".zip"))) {

+ if (export_defer.path.ends_with(".zip")) {

+ platform->save_zip(preset, export_defer.path);

+ } else if (export_defer.path.ends_with(".pck")) {

+ platform->save_pack(preset, export_defer.path);

+ }

+ } else {

+ platform->export_project(preset, export_defer.debug, export_defer.path, /*p_flags*/ 0);

+ }

+ String path = EditorSettings::get_singleton()->get_project_settings_dir().plus_file(p_file.get_file() + "-editstate-" + p_file.md5_text() + ".cfg");

+ String path = EditorSettings::get_singleton()->get_project_settings_dir().plus_file(p_file.get_file() + "-editstate-" + p_file.md5_text() + ".cfg");

+ // consider a square region

+ int vp_size = MIN(img->get_width(), img->get_height());

+ int x = (img->get_width() - vp_size) / 2;

+ int y = (img->get_height() - vp_size) / 2;

+ img->convert(Image::FORMAT_RGB8);

+

+ if (vp_size < preview_size) {

+ // just square it.

+ img->crop_from_point(x, y, vp_size, vp_size);

+ int ratio = vp_size / preview_size;

+ int size = preview_size * (ratio / 2);

+

+ x = (img->get_width() - size) / 2;

+ y = (img->get_height() - size) / 2;

+ img->crop_from_point(x, y, size, size);

+ // We could get better pictures with better filters

+ img->resize(preview_size, preview_size, Image::INTERPOLATE_CUBIC);

+ String temp_path = EditorSettings::get_singleton()->get_cache_dir();

+ _run(false, p_file);

+ Error err = config->load(EditorSettings::get_singleton()->get_editor_layouts_config());

+ config->save(EditorSettings::get_singleton()->get_editor_layouts_config());

+ Error err = config->load(EditorSettings::get_singleton()->get_editor_layouts_config());

+ config->save(EditorSettings::get_singleton()->get_editor_layouts_config());

+ } else if (obj->is_class("ScriptEditorDebuggerInspectedObject")) {

+ text = obj->call("get_title");

+ bool capitalize = bool(EDITOR_DEF("interface/editor/capitalize_properties", true));

+ if (current_obj->is_class("ScriptEditorDebuggerInspectedObject")) {

+ editable_warning = TTR("This is a remote object so changes to it will not be kept.\nPlease read the documentation relevant to debugging to better understand this workflow.");

+ capitalize = false;

+ }

+

+ if (property_editor->is_capitalize_paths_enabled() != capitalize) {

+ property_editor->set_enable_capitalize_paths(capitalize);

+ }

+

+ _update_scene_tabs();

+ ClassDB::register_class<EditorScenePostImport>();

+ config->save(EditorSettings::get_singleton()->get_project_settings_dir().plus_file("editor_layout.cfg"));

+ Error err = config->load(EditorSettings::get_singleton()->get_project_settings_dir().plus_file("editor_layout.cfg"));

+ Error err = config->load(EditorSettings::get_singleton()->get_editor_layouts_config());

+ Error err = config->load(EditorSettings::get_singleton()->get_editor_layouts_config());

+ _update_scene_tabs();

+ String to_path = ProjectSettings::get_singleton()->globalize_path(get_filesystem_dock()->get_current_path());

+ DirAccessRef dir = DirAccess::create(DirAccess::ACCESS_FILESYSTEM);

+

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

+

+ String from = p_files[i];

+ if (!ResourceFormatImporter::get_singleton()->can_be_imported(from)) {

+ continue;

+ }

+ String to = to_path.plus_file(from.get_file());

+ dir->copy(from, to);

+ EditorFileSystem::get_singleton()->scan_changes();

+

+ Label *dock_label = memnew(Label);

+ dock_label->set_text(TTR("Dock Position"));

+ dock_label->set_h_size_flags(Control::SIZE_EXPAND_FILL);

+ dock_hb->add_child(dock_label);

+

+ scene_tabs->connect("resized", this, "_update_scene_tabs");

+ tabbar_container = memnew(HBoxContainer);

+ scene_tab_add = memnew(ToolButton);

+ tabbar_container->add_child(scene_tab_add);

+ tabbar_container->add_child(distraction_free);

+ scene_tab_add->set_tooltip(TTR("Add a new scene."));

+ scene_tab_add->set_icon(gui_base->get_icon("Add", "EditorIcons"));

+ scene_tab_add->add_color_override("icon_color_normal", Color(0.6f, 0.6f, 0.6f, 0.8f));

+ scene_tab_add->connect("pressed", this, "_menu_option", make_binds(FILE_NEW_SCENE));

+

+

+ HBoxContainer *tabbar_container;

+ ToolButton *scene_tab_add;

+ } else if (obj->is_class("ScriptEditorDebuggerInspectedObject"))

+ name = obj->call("get_title");

+ else if (Object::cast_to<Node>(obj))

+ else if (Object::cast_to<Resource>(obj) && Object::cast_to<Resource>(obj)->get_name() != "")

+ else

+ String temp_path = EditorSettings::get_singleton()->get_cache_dir();

+ props[p_name].has_default_value = true;

+ return props[p_setting].has_default_value;

+ hints["filesystem/directories/default_project_export_path"] = PropertyInfo(Variant::STRING, "filesystem/directories/default_project_export_path", PROPERTY_HINT_GLOBAL_DIR);

+ _initial_set("text_editor/line_numbers/code_folding", true);

+ _initial_set("editors/2d/simple_spacebar_panning", false);

+ String data_path;

+ String data_dir;

+ String cache_path;

+ String cache_dir;

+

+

+ // editor is self contained, all in same folder

+ data_path = exe_path;

+ data_dir = data_path.plus_file("editor_data");

+ config_dir = data_dir;

+ cache_path = exe_path;

+ cache_dir = data_dir.plus_file("cache");

+ // Typically XDG_DATA_HOME or %APPDATA%

+ data_path = OS::get_singleton()->get_data_path();

+ data_dir = data_path.plus_file(OS::get_singleton()->get_godot_dir_name());

+ // Can be different from data_path e.g. on Linux or macOS

+ config_path = OS::get_singleton()->get_config_path();

+ config_dir = config_path.plus_file(OS::get_singleton()->get_godot_dir_name());

+ // Can be different from above paths, otherwise a subfolder of data_dir

+ cache_path = OS::get_singleton()->get_cache_path();

+ if (cache_path == data_path) {

+ cache_dir = data_dir.plus_file("cache");

+ } else {

+ cache_dir = cache_path.plus_file(OS::get_singleton()->get_godot_dir_name());

+ }

+

+ if (data_path != "" && config_path != "" && cache_path != "") {

+

+ // Validate/create data dir and subdirectories

+ if (dir->change_dir(data_path) != OK) {

+ ERR_PRINT("Cannot find path for data directory!");

+ if (dir->change_dir(data_dir) != OK) {

+ dir->make_dir(data_dir);

+ if (dir->change_dir(data_dir) != OK) {

+ ERR_PRINT("Cannot create data directory!");

+ // Validate/create cache dir

+

+ if (dir->change_dir(cache_path) != OK) {

+ ERR_PRINT("Cannot find path for cache directory!");

+ memdelete(dir);

+ goto fail;

+ }

+

+ if (dir->change_dir(cache_dir) != OK) {

+ dir->make_dir(cache_dir);

+ if (dir->change_dir(cache_dir) != OK) {

+ ERR_PRINT("Cannot create cache directory!");

+ memdelete(dir);

+ goto fail;

+ }

+ }

+

+ // Validate/create config dir and subdirectories

+

+ if (dir->change_dir(config_path) != OK) {

+ ERR_PRINT("Cannot find path for config directory!");

+ memdelete(dir);

+ goto fail;

+ }

+

+ if (dir->change_dir(config_dir) != OK) {

+ dir->make_dir(config_dir);

+ if (dir->change_dir(config_dir) != OK) {

+ ERR_PRINT("Cannot create config directory!");

+ memdelete(dir);

+ goto fail;

+ }

+ }

+

+ _create_script_templates(dir->get_current_dir().plus_file("script_templates"));

+ if (dir->change_dir("projects") != OK) {

+ dir->make_dir("projects");

+ // Validate/create project-specific config dir