From 322c6934831186fe2c238581415ffb7fabcdd616 Mon Sep 17 00:00:00 2001 From: Relintai Date: Thu, 12 Jan 2023 20:39:50 +0100 Subject: [PATCH] More cleanups. --- README.md | 2 +- about/complying_with_licenses.md | 14 ++-- about/docs_changelog.md | 4 +- about/faq.md | 72 ++++++++-------- about/introduction.md | 24 +++--- about/list_of_features.md | 82 +++++++++---------- about/release_policy.md | 4 +- about/troubleshooting.md | 16 ++-- .../contributing/bisecting_regressions.md | 16 ++-- .../contributing/bug_triage_guidelines.md | 12 +-- community/contributing/building_the_manual.md | 16 ++-- .../class_reference_writing_guidelines.md | 22 ++--- .../contributing/code_style_guidelines.md | 30 +++---- .../contributing_to_the_documentation.md | 22 ++--- .../contributing/cpp_usage_guidelines.md | 2 +- .../contributing/docs_writing_guidelines.md | 6 +- .../contributing/documentation_guidelines.md | 18 ++-- .../editor_and_docs_localization.md | 38 ++++----- community/contributing/index.md | 4 +- community/contributing/pr_workflow.md | 30 +++---- .../contributing/testing_pull_requests.md | 14 ++-- .../updating_the_class_reference.md | 16 ++-- community/contributing/ways_to_contribute.md | 22 ++--- community/tutorials.md | 72 ++++++++-------- .../compiling/compiling_for_android.md | 16 ++-- development/compiling/compiling_for_ios.md | 4 +- development/compiling/compiling_for_osx.md | 18 ++-- development/compiling/compiling_for_uwp.md | 4 +- development/compiling/compiling_for_web.md | 12 +-- .../compiling/compiling_for_windows.md | 18 ++-- development/compiling/compiling_for_x11.md | 8 +- development/compiling/compiling_with_mono.md | 24 +++--- .../compiling_with_script_encryption_key.md | 4 +- .../cross-compiling_for_ios_on_linux.md | 14 ++-- development/compiling/getting_source.md | 12 +-- .../introduction_to_the_buildsystem.md | 14 ++-- development/compiling/optimizing_for_size.md | 2 +- .../cpp/binding_to_external_libraries.md | 2 +- .../cpp/common_engine_methods_and_macros.md | 4 +- .../cpp/configuring_an_ide/android_studio.md | 8 +- development/cpp/configuring_an_ide/clion.md | 10 +-- .../cpp/configuring_an_ide/code_blocks.md | 4 +- development/cpp/configuring_an_ide/index.md | 4 +- .../cpp/configuring_an_ide/kdevelop.md | 4 +- .../cpp/configuring_an_ide/qt_creator.md | 8 +- .../cpp/configuring_an_ide/visual_studio.md | 8 +- .../configuring_an_ide/visual_studio_code.md | 12 +-- development/cpp/configuring_an_ide/xcode.md | 4 +- development/cpp/core_types.md | 24 +++--- development/cpp/custom_audiostreams.md | 12 +-- development/cpp/custom_godot_servers.md | 18 ++-- development/cpp/custom_modules_in_cpp.md | 14 ++-- .../cpp/custom_resource_format_loaders.md | 14 ++-- development/cpp/inheritance_class_tree.md | 2 +- development/cpp/object_class.md | 12 +-- development/cpp/using_cpp_profilers.md | 8 +- development/cpp/variant_class.md | 6 +- development/editor/creating_icons.md | 12 +-- .../introduction_to_editor_development.md | 22 ++--- development/file_formats/tscn.md | 2 +- .../first_2d_game/01.project_setup.md | 2 +- .../first_2d_game/02.player_scene.md | 6 +- .../first_2d_game/06.heads_up_display.md | 2 +- getting_started/first_2d_game/index.md | 6 +- .../first_3d_game/01.game_setup.md | 2 +- .../first_3d_game/02.player_input.md | 2 +- .../first_3d_game/06.jump_and_squash.md | 10 +-- .../first_3d_game/08.score_and_replay.md | 4 +- .../first_3d_game/going_further.md | 8 +- getting_started/first_3d_game/index.md | 4 +- .../introduction/first_look_at_the_editor.md | 2 +- .../introduction/godot_design_philosophy.md | 8 +- .../introduction/introduction_to_godot.md | 10 +-- .../introduction/learning_new_features.md | 24 +++--- getting_started/step_by_step/index.md | 2 +- getting_started/step_by_step/instancing.md | 4 +- .../step_by_step/scripting_first_script.md | 6 +- .../step_by_step/scripting_languages.md | 32 ++++---- getting_started/step_by_step/signals.md | 4 +- index.md | 20 ++--- tutorials/2d/2d_lights_and_shadows.md | 18 ++-- tutorials/2d/2d_movement.md | 4 +- tutorials/2d/2d_sprite_animation.md | 6 +- tutorials/2d/2d_transforms.md | 2 +- tutorials/2d/custom_drawing_in_2d.md | 6 +- tutorials/2d/using_tilemaps.md | 2 +- tutorials/3d/3d_rendering_limitations.md | 6 +- tutorials/3d/3d_text.md | 4 +- tutorials/3d/baked_lightmaps.md | 2 +- tutorials/3d/csg_tools.md | 8 +- tutorials/3d/introduction_to_3d.md | 2 +- .../portals/advanced_room_and_portal_usage.md | 10 +-- .../3d/portals/editing_rooms_and_portals.md | 14 ++-- .../first_steps_with_rooms_and_portals.md | 10 +-- .../introduction_to_rooms_and_portals.md | 4 +- .../3d/portals/rooms_and_portals_example.md | 14 ++-- .../using_objects_in_rooms_and_portals.md | 6 +- tutorials/3d/procedural_geometry/arraymesh.md | 4 +- tutorials/3d/procedural_geometry/index.md | 10 +-- .../3d/procedural_geometry/meshdatatool.md | 4 +- tutorials/3d/spatial_material.md | 2 +- tutorials/3d/using_gridmaps.md | 4 +- tutorials/3d/using_transforms.md | 4 +- tutorials/animation/2d_skeletons.md | 4 +- tutorials/animation/animation_tree.md | 2 +- tutorials/animation/cutout_animation.md | 18 ++-- tutorials/animation/playing_videos.md | 10 +-- .../assets_pipeline/escn_exporter/mesh.md | 2 +- tutorials/assets_pipeline/import_process.md | 4 +- .../importing_audio_samples.md | 2 +- tutorials/assets_pipeline/importing_images.md | 6 +- tutorials/assets_pipeline/importing_scenes.md | 14 ++-- .../assets_pipeline/importing_translations.md | 8 +- tutorials/audio/audio_buses.md | 6 +- tutorials/audio/recording_with_microphone.md | 2 +- tutorials/audio/sync_with_audio.md | 10 +-- .../autoloads_versus_internal_nodes.md | 4 +- tutorials/best_practices/data_preferences.md | 12 +-- tutorials/best_practices/godot_interfaces.md | 2 +- .../introduction_best_practices.md | 4 +- tutorials/best_practices/logic_preferences.md | 2 +- tutorials/best_practices/node_alternatives.md | 2 +- .../best_practices/scene_organization.md | 18 ++-- .../best_practices/scenes_versus_scripts.md | 6 +- .../best_practices/version_control_systems.md | 4 +- .../best_practices/what_are_godot_classes.md | 2 +- tutorials/editor/command_line_tutorial.md | 50 +++++------ tutorials/editor/external_editor.md | 4 +- tutorials/editor/index.md | 2 +- tutorials/editor/using_the_web_editor.md | 12 +-- tutorials/export/android_custom_build.md | 6 +- .../changing_application_icon_for_windows.md | 16 ++-- tutorials/export/exporting_basics.md | 4 +- tutorials/export/exporting_for_android.md | 22 ++--- .../export/exporting_for_dedicated_servers.md | 10 +-- tutorials/export/exporting_for_macos.md | 20 ++--- tutorials/export/exporting_for_uwp.md | 6 +- tutorials/export/exporting_for_web.md | 62 +++++++------- tutorials/export/exporting_for_windows.md | 2 +- tutorials/export/exporting_pcks.md | 2 +- tutorials/export/exporting_projects.md | 8 +- tutorials/export/feature_tags.md | 4 +- tutorials/export/one-click_deploy.md | 4 +- tutorials/i18n/internationalizing_games.md | 8 +- tutorials/i18n/localization_using_gettext.md | 12 +-- .../inputs/controllers_gamepads_joysticks.md | 16 ++-- tutorials/inputs/input_examples.md | 8 +- tutorials/io/background_loading.md | 4 +- tutorials/io/binary_serialization_api.md | 52 ++++++------ tutorials/io/data_paths.md | 10 +-- tutorials/io/saving_games.md | 10 +-- tutorials/math/beziers_and_curves.md | 6 +- tutorials/math/interpolation.md | 2 +- tutorials/math/random_number_generation.md | 16 ++-- tutorials/math/vectors_advanced.md | 2 +- .../navigation/real_time_navigation_3d.md | 16 ++-- .../networking/high_level_multiplayer.md | 8 +- tutorials/networking/http_client_class.md | 2 +- tutorials/networking/http_request_class.md | 2 +- tutorials/networking/ssl_certificates.md | 4 +- tutorials/networking/webrtc.md | 6 +- tutorials/networking/websocket.md | 4 +- tutorials/performance/batching.md | 8 +- tutorials/performance/cpu_optimization.md | 26 +++--- tutorials/performance/general_optimization.md | 6 +- tutorials/performance/gpu_optimization.md | 4 +- .../performance/optimizing_3d_performance.md | 6 +- .../performance/threads/thread_safe_apis.md | 2 +- .../threads/using_multiple_threads.md | 14 ++-- tutorials/performance/using_multimesh.md | 8 +- tutorials/performance/using_servers.md | 4 +- .../animating_thousands_of_fish.md | 6 +- .../controlling_thousands_of_fish.md | 2 +- .../advanced_physics_interpolation.md | 22 ++--- .../physics_interpolation_introduction.md | 4 +- ...physics_interpolation_quick_start_guide.md | 6 +- .../using_physics_interpolation.md | 10 +-- tutorials/physics/kinematic_character_2d.md | 2 +- tutorials/physics/physics_introduction.md | 4 +- tutorials/physics/ragdoll_system.md | 2 +- tutorials/physics/soft_body.md | 2 +- tutorials/physics/using_area_2d.md | 2 +- tutorials/physics/using_kinematic_body_2d.md | 2 +- .../android/android_in_app_purchases.md | 10 +-- tutorials/platform/android/android_plugin.md | 28 +++---- tutorials/platform/consoles.md | 14 ++-- tutorials/platform/customizing_html5_shell.md | 22 ++--- tutorials/platform/html5_shell_classref.md | 34 ++++---- tutorials/platform/ios/ios_plugin.md | 10 +-- tutorials/platform/ios/plugins_for_ios.md | 6 +- .../platform/mobile_rendering_limitations.md | 2 +- tutorials/plugins/editor/import_plugins.md | 14 ++-- .../plugins/editor/installing_plugins.md | 2 +- tutorials/plugins/editor/making_plugins.md | 10 +-- tutorials/plugins/editor/spatial_gizmos.md | 14 ++-- .../plugins/editor/visual_shader_plugins.md | 2 +- .../plugins/running_code_in_the_editor.md | 4 +- tutorials/rendering/jitter_stutter.md | 2 +- tutorials/rendering/multiple_resolutions.md | 12 +-- tutorials/rendering/viewports.md | 12 +-- .../scripting/cross_language_scripting.md | 2 +- tutorials/scripting/debug/debugger_panel.md | 4 +- .../debug/overview_of_debugging_tools.md | 2 +- tutorials/scripting/evaluating_expressions.md | 2 +- .../scripting/gdscript/gdscript_basics.md | 38 ++++----- .../scripting/gdscript/gdscript_exports.md | 2 +- .../scripting/gdscript/gdscript_styleguide.md | 12 +-- tutorials/scripting/gdscript/static_typing.md | 8 +- .../scripting/gdscript/warning_system.md | 2 +- tutorials/scripting/groups.md | 2 +- .../scripting/idle_and_physics_processing.md | 2 +- tutorials/scripting/index.md | 2 +- .../scripting/nodes_and_scene_instances.md | 4 +- tutorials/scripting/overridable_functions.md | 8 +- tutorials/scripting/resources.md | 10 +-- tutorials/scripting/singletons_autoload.md | 6 +- tutorials/shaders/advanced_postprocessing.md | 6 +- .../converting_glsl_to_godot_shaders.md | 18 ++-- tutorials/shaders/custom_postprocessing.md | 8 +- tutorials/shaders/introduction_to_shaders.md | 12 +-- .../shader_reference/canvas_item_shader.md | 2 +- .../shader_reference/shading_language.md | 10 +-- .../shader_reference/spatial_shader.md | 4 +- tutorials/shaders/shaders_style_guide.md | 6 +- .../shaders/using_viewport_as_texture.md | 2 +- tutorials/shaders/your_first_shader/index.md | 4 +- .../your_first_shader/your_first_2d_shader.md | 24 +++--- .../your_first_shader/your_first_3d_shader.md | 24 +++--- .../your_second_3d_shader.md | 10 +-- tutorials/ui/bbcode_in_richtextlabel.md | 2 +- tutorials/ui/control_node_gallery.md | 2 +- tutorials/ui/gui_containers.md | 2 +- tutorials/ui/gui_navigation.md | 2 +- tutorials/ui/gui_skinning.md | 10 +-- tutorials/ui/gui_theme_type_variations.md | 4 +- 235 files changed, 1195 insertions(+), 1195 deletions(-) diff --git a/README.md b/README.md index 2eb67af..9113da0 100644 --- a/README.md +++ b/README.md @@ -54,7 +54,7 @@ To add images, please put them in an `img/` folder next to the .rst file with a Similarly, you can include attachments (like assets as support material for a tutorial) by placing them into a `files/` folder next to the .rst file, and using this inline markup: ```rst -:download:`myfilename.zip ` +:download:`myfilename.zip `_. +Godot is created and distributed under the `MIT License ( https://opensource.org/licenses/MIT )`_. It doesn't have a sole owner either, as every contributor that submits code to the project does it under this same license and keeps ownership of the contribution. @@ -97,7 +97,7 @@ Third-party licenses -------------------- Godot itself contains software written by -`third parties `_. +`third parties ( https://github.com/godotengine/godot/blob/master/COPYRIGHT.txt )`_. Most of it does not require license inclusion, but some do. Make sure to do it if these are compiled in your Godot export template. If you're using the official export templates, all libraries are enabled. This @@ -108,7 +108,7 @@ Here's a list of libraries requiring attribution: FreeType ^^^^^^^^ -Godot uses `FreeType `_ to render fonts. Its license +Godot uses `FreeType ( https://www.freetype.org/ )`_ to render fonts. Its license requires attribution, so the following text must be included together with the Godot license: @@ -124,7 +124,7 @@ Godot license: ENet ^^^^ -Godot includes the `ENet `_ library to handle +Godot includes the `ENet ( http://enet.bespin.org/ )`_ library to handle high-level multiplayer. ENet has similar licensing terms as Godot: @@ -139,7 +139,7 @@ high-level multiplayer. ENet has similar licensing terms as Godot: mbed TLS ^^^^^^^^ -If the project is exported with Godot 3.1 or later, it includes `mbed TLS `_. +If the project is exported with Godot 3.1 or later, it includes `mbed TLS ( https://tls.mbed.org )`_. The Apache license needs to be complied to by including the following text: Copyright The Mbed TLS Contributors @@ -156,12 +156,12 @@ The Apache license needs to be complied to by including the following text: See the License for the specific language governing permissions and limitations under the License. -Keep in mind that Godot 2.x and 3.0 use `OpenSSL `_ 1.x +Keep in mind that Godot 2.x and 3.0 use `OpenSSL ( https://www.openssl.org )`_ 1.x instead. This old OpenSSL version used the OpenSSL license, not the Apache 2 license as the latest version of OpenSSL currently uses (as of April 2022). .. note:: If you exported your project using a - `custom build with specific modules disabled `, + `custom build with specific modules disabled `. Below is a list of new tutorials +to the `class reference ` + - `Procedural geometry `_ available under the `OSI-approved `_ MIT license. This means it is free as in "free speech" as well as in "free beer." +Godot is `Free and Open-Source Software ( https://en.wikipedia.org/wiki/Free_and_open-source_software )`_ available under the `OSI-approved ( https://opensource.org/licenses/MIT )`_ MIT license. This means it is free as in "free speech" as well as in "free beer." In short: @@ -17,18 +17,18 @@ In short: * You are free to modify, distribute, redistribute, and remix Godot to your heart's content, for any reason, both non-commercially and commercially. All the contents of this accompanying documentation are published under -the permissive Creative Commons Attribution 3.0 (`CC-BY 3.0 `_) license, with attribution +the permissive Creative Commons Attribution 3.0 (`CC-BY 3.0 ( https://creativecommons.org/licenses/by/3.0/ )`_) license, with attribution to "Juan Linietsky, Ariel Manzur and the Godot Engine community." Logos and icons are generally under the same Creative Commons license. Note that some third-party libraries included with Godot's source code may have different licenses. -For full details, look at the `COPYRIGHT.txt `_ as well -as the `LICENSE.txt `_ and `LOGO_LICENSE.txt `_ files +For full details, look at the `COPYRIGHT.txt ( https://github.com/godotengine/godot/blob/master/COPYRIGHT.txt )`_ as well +as the `LICENSE.txt ( https://github.com/godotengine/godot/blob/master/LICENSE.txt )`_ and `LOGO_LICENSE.txt ( https://github.com/godotengine/godot/blob/master/LOGO_LICENSE.md )`_ files in the Godot repository. -Also, see `the license page on the Godot website `_. +Also, see `the license page on the Godot website ( https://godotengine.org/license )`_. Which platforms are supported by Godot? --------------------------------------- @@ -38,7 +38,7 @@ Which platforms are supported by Godot? * Windows * macOS * X11 (Linux, \*BSD) -* `Web ` +* `Web ` -and `compiling Godot yourself `. +For more on this, see the sections on `exporting ` section. +`scripting `_ is a +discussions on `open issues ( https://github.com/godotengine/godot/issues )`_ is a great way to start your troubleshooting. As for new languages, support is possible via third parties using the GDNative / NativeScript / PluginScript facilities. (See the question about plugins below.) Work is currently underway, for example, on unofficial bindings for Godot -to `Python `_ and `Nim `_. +to `Python ( https://github.com/touilleMan/godot-python )`_ and `Nim ( https://github.com/pragmagic/godot-nim )`_. .. _doc_faq_what_is_gdscript: @@ -99,7 +99,7 @@ up to maximize Godot's potential in the least amount of code, affording both nov and expert developers alike to capitalize on Godot's strengths as fast as possible. If you've ever written anything in a language like Python before then you'll feel right at home. For examples, history, and a complete overview of the power GDScript -offers you, check out the `GDScript scripting guide `. +offers you, check out the `GDScript scripting guide ` +In the early days, the engine used the `Lua ( https://www.lua.org )` scripting language. Lua is fast, but creating bindings to an object oriented system (by using fallbacks) was complex and slow and took an enormous amount of code. After some experiments with -`Python `, it also proved difficult to embed. +`Python ( https://www.python.org )`, it also proved difficult to embed. The main reasons for creating a custom scripting language for Godot were: @@ -157,8 +157,8 @@ GDScript was designed to curtail the issues above, and more. What type of 3D model formats does Godot support? ------------------------------------------------- -Godot supports Collada via the `OpenCollada `_ exporter (Maya, 3DSMax). -If you are using Blender, take a look at our own `Better Collada Exporter `_. +Godot supports Collada via the `OpenCollada ( https://github.com/KhronosGroup/OpenCOLLADA/wiki/OpenCOLLADA-Tools )`_ exporter (Maya, 3DSMax). +If you are using Blender, take a look at our own `Better Collada Exporter ( https://godotengine.org/download )`_. As of Godot 3.0, glTF is supported. @@ -191,9 +191,9 @@ How do I install the Godot editor on my system (for desktop integration)? Since you don't need to actually install Godot on your system to run it, this means desktop integration is not performed automatically. There are two ways to overcome this. You can install Godot from -`Steam ` (all platforms), -`Scoop ` (Windows), `Homebrew ` (macOS) -or `Flathub ` (Linux). +`Steam ( https://store.steampowered.com/app/404790/Godot_Engine/ )` (all platforms), +`Scoop ( https://scoop.sh/ )` (Windows), `Homebrew ( https://brew.sh/ )` (macOS) +or `Flathub ( https://flathub.org/apps/details/org.godotengine.Godot )` (Linux). This will automatically perform the required steps for desktop integration. Alternatively, you can manually perform the steps that an installer would do for you: @@ -225,14 +225,14 @@ Linux This is typically `/usr/local/bin/godot` or `/usr/bin/godot`. Doing this requires administrator privileges, but this also allows you to - `run the Godot editor from a terminal ` by entering `godot`. + `run the Godot editor from a terminal ` +- Save `this .desktop file ( https://raw.githubusercontent.com/godotengine/godot/3.x/misc/dist/linux/org.godotengine.Godot.desktop )` to `$HOME/.local/share/applications/`. If you have administrator privileges, you can also save the `.desktop` file to `/usr/local/share/applications` to make the shortcut available for all users. @@ -309,7 +309,7 @@ functionality in Godot. This is why we are aiming to move some core functionality to officially supported add-ons in future versions of Godot. In terms of binary size, this also has the advantage of making you pay only for what you actually use in your project. (In the meantime, you can -`compile custom export templates with unused features disabled ` +`compile custom export templates with unused features disabled ` +4. For user interfaces, use the `anchoring ` +for additional languages, take a look at `EditorPlugins `_ -* `GDNative is here! `_ +* `A look at the GDNative architecture ( https://godotengine.org/article/look-gdnative-architecture )`_ +* `GDNative is here! ( https://godotengine.org/article/dlscript-here )`_ You can also take a look at the GDScript implementation, the Godot modules, -as well as the `unofficial Python support `_ for Godot. +as well as the `unofficial Python support ( https://github.com/touilleMan/godot-python )`_ for Godot. This would be a good starting point to see how another third-party library integrates with Godot. @@ -384,8 +384,8 @@ I would like to contribute! How can I get started? Awesome! As an open-source project, Godot thrives off of the innovation and ambition of developers like you. -The first place to get started is in the `issues `_. -Find an issue that resonates with you, then proceed to the `How to Contribute `_ +The first place to get started is in the `issues ( https://github.com/godotengine/godot/issues )`_. +Find an issue that resonates with you, then proceed to the `How to Contribute ( https://github.com/godotengine/godot/blob/master/CONTRIBUTING.md#contributing-pull-requests )`_ guide to learn how to fork, modify, and submit a Pull Request (PR) with your changes. I have a great idea for Godot. How can I share it? @@ -396,8 +396,8 @@ result in massive core changes, some sort of mimicry of what another game engine does, or alternative workflows that you'd like built into the editor. These are great, and we are thankful to have such motivated people want to contribute, but Godot's focus is and always will be the -core functionality as outlined in the `Roadmap `_, -`squashing bugs and addressing issues `_, +core functionality as outlined in the `Roadmap ( https://github.com/godotengine/godot-roadmap/blob/master/ROADMAP.md )`_, +`squashing bugs and addressing issues ( https://github.com/godotengine/godot/issues )`_, and conversations between Godot community members. Most developers in the Godot community will be more interested to learn @@ -439,8 +439,8 @@ in the Project Settings to decrease CPU and GPU usage. That said, we wouldn't recommend using Godot to create a *mobile* application since low-processor mode isn't supported on mobile platforms yet. -Check out `Material Maker ` and -`Pixelorama ` for examples of +Check out `Material Maker ( https://github.com/RodZill4/material-maker )` and +`Pixelorama ( https://github.com/Orama-Interactive/Pixelorama )` for examples of open source applications made with Godot. .. _doc_faq_use_godot_as_library: @@ -474,9 +474,9 @@ have to deal with the LGPL licensing caveats that come with GTK or Qt. Lastly, this means Godot is "eating its own dog food" since the editor itself is one of the most complex users of Godot's UI system. -This custom UI toolkit `can't be used as a library `, +This custom UI toolkit `can't be used as a library `. +`use Godot to create non-game applications by using the editor `_. +See the corresponding page on the `Godot website ( https://godotengine.org/contact )`_. diff --git a/about/introduction.md b/about/introduction.md index b0b547e..453b839 100644 --- a/about/introduction.md +++ b/about/introduction.md @@ -20,12 +20,12 @@ where to look if you need info on a specific feature. Before you start ---------------- -The `Tutorials and resources ` page lists +The `Tutorials and resources `, +you can find help on the various `Community channels `_ not-for-profit. + Freedom Conservancy ( https://sfconservancy.org )`_ not-for-profit. For a more in-depth view of the engine, you are encouraged to read this documentation further, especially the `Step by step -` tutorial. +`_ markup +`reStructuredText ( http://www.sphinx-doc.org/en/stable/rest.html )`_ markup language and then compiled into a static website/offline document using the -open source `Sphinx `_ and `ReadTheDocs -`_ tools. +open source `Sphinx ( http://www.sphinx-doc.org )`_ and `ReadTheDocs +( https://readthedocs.org/ )`_ tools. .. note:: You can contribute to Godot's documentation by opening issue tickets or sending patches via pull requests on its GitHub - `source repository `_, or + `source repository ( https://github.com/godotengine/godot-docs )`_, or translating it into your language on `Hosted Weblate - `_. + ( https://hosted.weblate.org/projects/godot-engine/godot-docs/ )`_. All the contents are under the permissive Creative Commons Attribution 3.0 -(`CC-BY 3.0 `_) license, with +(`CC-BY 3.0 ( https://creativecommons.org/licenses/by/3.0/ )`_) license, with attribution to "Juan Linietsky, Ariel Manzur and the Godot Engine community". Organization of the documentation @@ -86,7 +86,7 @@ relatively intuitive: - The `sec-learn` section is the *raison d'être* of this documentation, as it contains all the necessary information on using the engine to make games. It starts with the `Step by step - ` tutorial which should be the entry point for all + `_. +various `Godot demo projects ( https://github.com/godotengine/godot-demo-projects )`_. Have fun reading and making games with Godot Engine! diff --git a/about/list_of_features.md b/about/list_of_features.md index 555d9fd..afb328f 100644 --- a/about/list_of_features.md +++ b/about/list_of_features.md @@ -8,7 +8,7 @@ This page aims to list all features currently supported by Godot. .. note:: This page lists features supported by the current stable version of - Godot (3.5). `More features ` + Godot (3.5). `More features ( https://docs.godotengine.org/en/latest/about/list_of_features.html )` are available in the latest development version (4.0). Features @@ -33,8 +33,8 @@ Platforms - Android 4.4 and later. - iOS 10.0 and later. -- `Consoles `. -- `Headless Linux and macOS servers `. +- `Consoles ` such as +- Support for `external script editors `. +- GDScript `debugger ` to extend editor functionality. -- `Create your own plugins ` using GDScript to add new + `asset library ` +- `Download projects from the asset library `. +- Occlusion culling with `rooms and portals `. -- `Constructive solid geometry ` (intended for prototyping). +- Tools for `procedural geometry generation `. +- Text-based shaders using a `shader language inspired by GLSL `. +- Support for `cross-language scripting ` +`GDScript: ` with - `optional static typing `. +- `High-level interpreted language ` to perform asynchronous actions +- `Use threads ` +`C#: ` +`VisualScript: `. +- `Graph-based visual scripting language ` + `Godot 4.0 will remove VisualScript from core entirely. ( https://godotengine.org/article/godot-4-will-discontinue-visual-scripting )` As a result, creating new projects using visual scripting in Godot is not recommended. Future Godot 4.x releases may have VisualScript reimplemented as an extension. While Godot 3.x will keep VisualScript supported, we recommend - `trying out GDScript ` instead, + `trying out GDScript ` and effects +- Support for re-routable `audio buses `. +- Support for `custom import plugins ` + - `ESCN ( https://github.com/godotengine/godot-blender-exporter )` (direct export from Blender). - FBX (experimental, static meshes only). - Collada (.dae). - Wavefront OBJ (static scenes only, can be loaded directly as a mesh). -- 3D meshes use `Mikktspace ` to generate tangents +- 3D meshes use `Mikktspace ( http://www.mikktspace.com/ )` to generate tangents on import, which ensures consistency with other 3D applications such as Blender. Input @@ -492,8 +492,8 @@ Internationalization ^^^^^^^^^^^^^^^^^^^^ - Full support for Unicode including emoji. -- Store localization strings using `CSV ` - or `gettext `. +- Store localization strings using `CSV ` can be - downloaded for Linux and `compiled for macOS `. +- `Headless/server binaries `. + `command line argument `. +- RichTextLabel for `text formatted using BBCode ` or binary formats. +- Scenes and resources can be saved in `text-based ` that can be read +- `Export additional PCK files` which allows bypassing +- `Low-level access to servers ` for automation. +- `Command line interface ` + - `Shell completion scripts ( https://github.com/godotengine/godot/tree/master/misc/dist/shell )` are available for Bash, zsh and fish. -- Support for `C++ modules ` statically linked +- Support for `C++ modules ` using GCC, + - Can be `compiled `. + - Open developement process with `contributions welcome ` + The `Godot proposals repository ( https://github.com/godotengine/godot-proposals )` lists features that have been requested by the community and may be implemented in future Godot releases. diff --git a/about/release_policy.md b/about/release_policy.md index 574d229..36585e7 100644 --- a/about/release_policy.md +++ b/about/release_policy.md @@ -11,7 +11,7 @@ community at a given time. Godot versioning ---------------- -Godot loosely follows `Semantic Versioning ` with a +Godot loosely follows `Semantic Versioning ( https://semver.org/ )` with a `major.minor.patch` versioning system, albeit with an interpretation of each term adapted to the complexity of a game engine: @@ -146,4 +146,4 @@ the latest bug fixes for their production needs. As for the upcoming Godot 4.0, as of August 2022, we are aiming for a *beta* release in Q3 2022, and possibly a stable release by Q4 2022 (but experience has shown time and time again that such estimates tend to be overly optimistic). -`Follow the Godot blog ` for the latest updates. +`Follow the Godot blog ( https://godotengine.org/news )` for the latest updates. diff --git a/about/troubleshooting.md b/about/troubleshooting.md index f19e854..6712aa4 100644 --- a/about/troubleshooting.md +++ b/about/troubleshooting.md @@ -13,7 +13,7 @@ This page lists common issues encountered when using Godot and possible solution Everything I do in the editor or project manager appears delayed by one frame. ------------------------------------------------------------------------------ -This is a `known bug ` on +This is a `known bug ( https://github.com/godotengine/godot/issues/23069 )` on Intel graphics drivers on Windows. Updating to the latest graphics driver version *provided by Intel* should fix the issue. @@ -24,7 +24,7 @@ outdated. The grid disappears and meshes turn black when I rotate the 3D camera in the editor. ------------------------------------------------------------------------------------ -This is a `known bug ` on +This is a `known bug ( https://github.com/godotengine/godot/issues/30330 )` on Intel graphics drivers on Windows. The only workaround, for now, is to switch to the GLES2 renderer. You can switch @@ -36,7 +36,7 @@ Optimus, you can use the dedicated graphics card to run Godot. The editor or project takes a very long time to start. ------------------------------------------------------ -This is a `known bug ` on +This is a `known bug ( https://github.com/godotengine/godot/issues/20566 )` on Windows when you have specific USB peripherals connected. In particular, Corsair's iCUE software seems to cause the bug. Try updating your USB peripherals' drivers to their latest version. If the bug persists, you need to @@ -46,7 +46,7 @@ connect the peripheral again. Editor tooltips in the Inspector and Node docks blink when they're displayed. ----------------------------------------------------------------------------- -This is a `known issue ` +This is a `known issue ( https://github.com/godotengine/godot/issues/32990 )` caused by the third-party Stardock Fences application on Windows. The only known workaround is to disable Stardock Fences while using Godot. @@ -81,15 +81,15 @@ done to improve performance, especially on integrated graphics, where rendering To resolve this, open **Project > Project Settings** and enable **Display > Window > Dpi > Allow Hidpi**. On top of that, make sure your project is -configured to support `multiple resolutions `. +configured to support `multiple resolutions `. To +This is a `known bug ( https://github.com/godotengine/godot/issues/13017 )`. To resolve this, open **Project > Project Settings** and enable **Display > Window > Dpi > Allow Hidpi**. On top of that, make sure your project is configured to -support `multiple resolutions `. +support `multiple resolutions ` issues. If you reference a resource +`, you may +`Godot repository on GitHub ( https://github.com/godotengine/godot )`, you may be asked by a contributor to *bisect* the issue. Bisecting makes it possible for contributors to fix bugs faster, as they can know in advance which commit caused the regression. Your effort will be widely appreciated :) @@ -15,9 +15,9 @@ The guide below explains how to find a regression by bisecting. What is bisecting? ------------------ -Godot developers use the `Git ` version control system. +Godot developers use the `Git ( https://git-scm.com/ )` version control system. In the context of Git, bisecting is the process of performing a manual -`binary search ` +`binary search ( https://en.wikipedia.org/wiki/Binary_search_algorithm )` to determine when a regression appeared. While it's typically used for bugs, it can also be used to find other kinds of unexpected changes such as performance regressions. @@ -29,7 +29,7 @@ Before using Git's `bisect` command, we strongly recommend trying to reproduce the bug with an older (or newer) official release. This greatly reduces the range of commits that potentially need to be built from source and tested. You can find binaries of official releases, as well as alphas, betas, -and release candidates `here `. +and release candidates `here ( https://downloads.tuxfamily.org/godotengine/ )`. For example, if you've reported a bug against Godot 3.2, you should first try to reproduce the bug in Godot 3.1 (not a patch release, see below for the reason). @@ -59,7 +59,7 @@ reproduce the bug. Before bisecting a regression, you need to set up a build environment to compile Godot from source. To do so, read the - `Compiling ` page for your target platform. + `Compiling `, go to the folder that +mirror ( https://downloads.tuxfamily.org/godotengine/ )`, go to the folder that contains the pre-release you downloaded and look for the `README.txt` file. The commit hash is written inside that file. @@ -88,7 +88,7 @@ following commit hashes depending on the version: To refer to the latest state of the master branch, you can use `master` instead of a commit hash. -`Get Godot's source code using Git `. Once this +`Get Godot's source code using Git `. + `here ( https://git-scm.com/docs/git-bisect )`. diff --git a/community/contributing/bug_triage_guidelines.md b/community/contributing/bug_triage_guidelines.md index 6f2869f..ce66d7b 100644 --- a/community/contributing/bug_triage_guidelines.md +++ b/community/contributing/bug_triage_guidelines.md @@ -5,7 +5,7 @@ Bug triage guidelines This page describes the typical workflow of the bug triage team aka bugsquad when handling issues and pull requests on Godot's -`GitHub repository `. +`GitHub repository ( https://github.com/godotengine/godot )`. It is bound to evolve together with the bugsquad, so do not hesitate to propose modifications to the following guidelines. @@ -61,15 +61,15 @@ The following labels are currently defined in the Godot repository: - *Documentation*: issue related to the documentation. Mainly to request enhancements in the API documentation. Issues related to the ReadTheDocs documentation should be filed on the - `godot-docs `_ repository. + `godot-docs ( https://github.com/godotengine/godot-docs )`_ repository. - *Enhancement*: describes a proposed enhancement to an existing functionality. - *Feature proposal*: describes a wish for a new feature to be implemented. Note that the main Godot repository no longer accepts feature requests. Please use - `godot-proposals ` instead. + `godot-proposals ( https://github.com/godotengine/godot-proposals )` instead. - *For PR meeting*: the issue needs to be discussed in a pull request meeting. - These meetings are public and are held on the `Godot Contributors Chat `_. + These meetings are public and are held on the `Godot Contributors Chat ( https://chat.godotengine.org/ )`_. - *Good first issue*: the issue is *assumed* to be an easy one to fix, which makes it a great fit for new contributors who need to become familiar with the code base. @@ -149,7 +149,7 @@ Android and Linux exclusively, select those two platforms). Documentation labels ~~~~~~~~~~~~~~~~~~~~ -In the `documentation repository `, we +In the `documentation repository ( https://github.com/godotengine/godot-docs )`, we use the following labels: - *Bug*: Incorrect information in an existing page. Not to be used for @@ -177,7 +177,7 @@ use the following labels: Milestones ~~~~~~~~~~ -`Milestones `_ correspond to +`Milestones ( https://github.com/godotengine/godot/milestones )`_ correspond to planned future versions of Godot for which there is an existing roadmap. Issues that fit in the said roadmap should be filed under the corresponding milestone; if they don't correspond to any current roadmap, they should be left without diff --git a/community/contributing/building_the_manual.md b/community/contributing/building_the_manual.md index 5d5672a..c9cb0b5 100644 --- a/community/contributing/building_the_manual.md +++ b/community/contributing/building_the_manual.md @@ -9,20 +9,20 @@ documentation as a PDF, EPUB, or LaTeX file, for example. To get started, you need to: -1. Clone the `godot-docs repository `. -2. Install `Sphinx ` +1. Clone the `godot-docs repository ( https://github.com/godotengine/godot-docs/ )`. +2. Install `Sphinx ( https://www.sphinx-doc.org/ )` 3. To build the docs as HTML files, install the `readthedocs.org theme - `. + ( https://github.com/snide/sphinx_rtd_theme )`. 4. Install the Sphinx extensions defined in the `godot-docs repository - ` `requirements.txt` file. + ( https://github.com/godotengine/godot-docs/ )` `requirements.txt` file. -We recommend using `pip `, Python’s package manager to +We recommend using `pip ( https://pip.pypa.io )`, Python’s package manager to install all these tools. It comes pre-installed with `Python -`. Ensure that you install and use Python 3. Here are +( https://www.python.org/ )`. Ensure that you install and use Python 3. Here are the commands to clone the repository and then install all requirements. .. note:: You may need to write `python3 -m pip` (Unix) or `py -m pip` (Windows) instead of `pip3`. - If both approaches fail, `check that you have pip3 installed `. + If both approaches fail, `check that you have pip3 installed ( https://pip.pypa.io/en/stable/installation/ )`. .. code:: sh @@ -72,7 +72,7 @@ from the final HTML documentation but will keep the rest intact. .. note:: If you delete the `classes/` folder, do not use `git add .` when working on a pull request or the whole `classes/` folder will be removed when you commit. See `#3157 - ` for more + ( https://github.com/godotengine/godot-docs/issues/3157 )` for more detail. Alternatively, you can build the documentation by running the sphinx-build diff --git a/community/contributing/class_reference_writing_guidelines.md b/community/contributing/class_reference_writing_guidelines.md index d46cf33..9f78f2e 100644 --- a/community/contributing/class_reference_writing_guidelines.md +++ b/community/contributing/class_reference_writing_guidelines.md @@ -70,17 +70,17 @@ member variables, constants, and signals in separate XML nodes. For each, you want to learn how they work in Godot's source code. Then, fill their documentation by completing or improving the text in these tags: -- `` -- `` -- `` -- `` (in its `` tag; return types and arguments don't take separate +- `` -- `` (in its `` tag; arguments don't take separate documentation strings) -- `` +- `` to keep your descriptions short and easy to read. +`. +guide `_ to speed up your +translation tool ( https://github.com/HaSa1002/codetranslator )`_ to speed up your workflow. .. code-block:: none @@ -243,4 +243,4 @@ pull of your changes. Another writer will take care of it. You can still look at the methods' implementation in Godot's source code on GitHub. If you have doubts, feel free to ask on the `Q&A website -` and `Godot Contributors Chat `_. +( https://godotengine.org/qa/ )` and `Godot Contributors Chat ( https://chat.godotengine.org/ )`_. diff --git a/community/contributing/code_style_guidelines.md b/community/contributing/code_style_guidelines.md index e29e6f4..02a4e65 100644 --- a/community/contributing/code_style_guidelines.md +++ b/community/contributing/code_style_guidelines.md @@ -14,7 +14,7 @@ C++ and Objective-C ------------------- There are no written guidelines, but the code style agreed upon by the -developers is enforced via the `clang-format ` +developers is enforced via the `clang-format ( http://clang.llvm.org/docs/ClangFormat.html )` code beautifier, which takes care for you of all our conventions. To name a few: @@ -25,7 +25,7 @@ To name a few: - See further down regarding header includes The rules used by clang-format are outlined in the -`.clang-format ` +`.clang-format ( https://github.com/godotengine/godot/blob/master/.clang-format )` file of the Godot repository. As long as you ensure that your style matches the surrounding code and that you @@ -68,10 +68,10 @@ Here's how to install clang-format: - Linux: It will usually be available out-of-the-box with the clang toolchain packaged by your distribution. If your distro version is not the required one, you can download a pre-compiled version from the - `LLVM website `, or if you are on - a Debian derivative, use the `upstream repos `. + `LLVM website ( http://releases.llvm.org/download.html )`, or if you are on + a Debian derivative, use the `upstream repos ( http://apt.llvm.org/ )`. - macOS and Windows: You can download precompiled binaries from the - `LLVM website `. You may need to add + `LLVM website ( http://releases.llvm.org/download.html )`. You may need to add the path to the binary's folder to your system's `PATH` environment variable to be able to call `clang-format` out of the box. @@ -117,12 +117,12 @@ clang-format automatically, for example each time you save a file. Here is a non-exhaustive list of beautifier plugins for some IDEs: -- Qt Creator: `Beautifier plugin ` -- Visual Studio Code: `Clang-Format ` -- Visual Studio: `ClangFormat ` -- vim: `vim-clang-format ` +- Qt Creator: `Beautifier plugin ( http://doc.qt.io/qtcreator/creator-beautifier.html )` +- Visual Studio Code: `Clang-Format ( https://marketplace.visualstudio.com/items?itemName=xaver.clang-format )` +- Visual Studio: `ClangFormat ( https://marketplace.visualstudio.com/items?itemName=LLVMExtensions.ClangFormat )` +- vim: `vim-clang-format ( https://github.com/rhysd/vim-clang-format )` - CLion: Starting from version `2019.1`, no plugin is required. Instead, enable - `ClangFormat ` + `ClangFormat ( https://www.jetbrains.com/help/clion/clangformat-as-alternative-formatter.html#clion-support )` (Pull requests welcome to extend this list with tested plugins.) @@ -149,7 +149,7 @@ ones, the following rules should be followed: separation. - Finally, third-party headers (either from `thirdparty` or from the system's include paths) come next and should be included with the < and > symbols, e.g. - `#include `. The block of third-party headers should also be followed + `#include `. -Blacken your Python changes using `Black `. +For those, we follow the `Black style guide ( https://github.com/psf/black#the-black-code-style )`. +Blacken your Python changes using `Black ( https://pypi.org/project/black/ )`. Using black locally ~~~~~~~~~~~~~~~~~~~ @@ -308,7 +308,7 @@ Editor integration Many IDEs or code editors have beautifier plugins that can be configured to run black automatically, for example each time you save a file. For details you can -check `Black editor integration `. +check `Black editor integration ( https://github.com/psf/black#editor-integration )`. Comment style guide ------------------- @@ -344,7 +344,7 @@ Don't repeat what the code says in a comment. Explain the *why* rather than *how You can use Javadoc-style comments above function or macro definitions. It's recommended to use Javadoc-style comments *only* for methods which are not exposed to scripting. This is because exposed methods should be documented in -the `class reference XML ` +the `class reference XML `_. Modifying those pages in a pull +( https://github.com/godotengine/godot-docs )`_. Modifying those pages in a pull request triggers a rebuild of the online documentation upon merging. .. seealso:: For details on Git usage and the pull request workflow, please @@ -25,8 +25,8 @@ request triggers a rebuild of the online documentation upon merging. the docs repository. .. warning:: The class reference's source files are in the `Godot engine - repository `_. We generate - the `Godot API ` section of this documentation + repository ( https://github.com/godotengine/godot )`_. We generate + the `Godot API `. +reference ( https://github.com/godotengine/godot/tree/master/doc/classes )`. See `doc_updating_the_class_reference` for details. .. seealso:: To build the manual and test changes on your computer, see @@ -104,7 +104,7 @@ Adding new pages Before adding a new page, please ensure that it fits in the documentation: 1. Look for `existing issues - `_ or open a new one to see + ( https://github.com/godotengine/godot-docs/issues )`_ or open a new one to see if the page is necessary. 2. Ensure there isn't a page that already covers the topic. 3. Read our `doc_content_guidelines`. @@ -145,17 +145,17 @@ first letter capitalized. Sphinx and reStructuredText syntax ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -Check Sphinx’s `reST Primer ` -and the `official reference ` for +Check Sphinx’s `reST Primer ( https://www.sphinx-doc.org/en/stable/rest.html )` +and the `official reference ( http://docutils.sourceforge.net/rst.html )` for details on the syntax. Sphinx uses specific reST comments to do specific operations, like defining the table of contents (`.. toctree::`) or cross-referencing pages. Check the `official Sphinx documentation -` for more details. To learn +( https://www.sphinx-doc.org/en/stable/index.html )` for more details. To learn how to use Sphinx directives like `.. note::` or `.. seealso::`, check out the `Sphinx directives documentation -`. +( https://www.sphinx-doc.org/en/master/usage/restructuredtext/directives.html )`. Adding images and attachments ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ @@ -173,7 +173,7 @@ using this inline markup: .. code:: rst - :download:`myfilename.zip ` + :download:`myfilename.zip `_, with +( https://tldrlegal.com/license/creative-commons-attribution-(cc) )`_, with attribution to "Juan Linietsky, Ariel Manzur and the Godot community". By contributing to the documentation on the GitHub repository, you agree that diff --git a/community/contributing/cpp_usage_guidelines.md b/community/contributing/cpp_usage_guidelines.md index 847d8fe..e91a387 100644 --- a/community/contributing/cpp_usage_guidelines.md +++ b/community/contributing/cpp_usage_guidelines.md @@ -48,7 +48,7 @@ purpose, such as improving code readability or performance. Standard Template Library ^^^^^^^^^^^^^^^^^^^^^^^^^ -We don't allow using the `STL ` +We don't allow using the `STL ( https://en.wikipedia.org/wiki/Standard_Template_Library )` as Godot provides its own data types (among other things). See `doc_faq_why_not_stl` for more information. diff --git a/community/contributing/docs_writing_guidelines.md b/community/contributing/docs_writing_guidelines.md index f757c8b..81524dd 100644 --- a/community/contributing/docs_writing_guidelines.md +++ b/community/contributing/docs_writing_guidelines.md @@ -34,7 +34,7 @@ There are 3 rules to describe classes: .. seealso:: - See the `content guidelines ` for information + See the `content guidelines ` for this purpose. For +compressor included in `Squoosh ( https://squoosh.app/ )` for this purpose. For heavier images, consider using a lossy compressor like `pngquant -`_. With it, almost no image quality is lost during +( https://pngquant.org/ )`_. With it, almost no image quality is lost during compression. .. note:: diff --git a/community/contributing/documentation_guidelines.md b/community/contributing/documentation_guidelines.md index 61dddc2..e4f1453 100644 --- a/community/contributing/documentation_guidelines.md +++ b/community/contributing/documentation_guidelines.md @@ -6,15 +6,15 @@ Documentation guidelines This page describes the rules to follow if you want to contribute to Godot Engine by writing or reviewing documentation, or by translating existing documentation. Also, have a look at README of the -`godot-docs GitHub repository `_ -and the `docs front page `_ +`godot-docs GitHub repository ( https://github.com/godotengine/godot-docs )`_ +and the `docs front page ( https://docs.godotengine.org )`_ on what steps to follow and how to contact the docs team. How to contribute ----------------- Creating or modifying documentation pages is mainly done via the -`godot-docs GitHub repository `_. +`godot-docs GitHub repository ( https://github.com/godotengine/godot-docs )`_. The HTML (or PDF and EPUB) documentation is generated from the .rst files (reStructuredText markup language) in that repository. Modifying those pages in a pull request and getting it merged will trigger a rebuild of the online @@ -26,8 +26,8 @@ documentation. also valid for the docs repository. .. warning:: The class reference's source files are in the `Godot engine repository - `_. We generate the `Godot API - ` section of this documentation from them. If you want to update the + ( https://github.com/godotengine/godot )`_. We generate the `Godot API + `_, +If you're reading documentation on `docs.godotengine.org ( https://docs.godotengine.org )`_, you'll see an **Edit on GitHub** hyperlink at the top right of the page. Once you've created a GitHub account, you can propose changes to a page you're reading as follows: @@ -118,7 +118,7 @@ letter. Translating existing pages -------------------------- -You can help to translate the official Godot documentation on our `Hosted Weblate `_. +You can help to translate the official Godot documentation on our `Hosted Weblate ( https://hosted.weblate.org/engage/godot-engine/ )`_. ![](https://hosted.weblate.org/widgets/godot-engine/-/godot-docs/287x66-white.png) :alt: Translation state @@ -128,14 +128,14 @@ You can help to translate the official Godot documentation on our `Hosted Weblat :height: 66 There also is the official -`Godot i18n repository `_ +`Godot i18n repository ( https://github.com/godotengine/godot-docs-l10n )`_ where you can see when the data was last synchronized. License ------- This documentation and every page it contains is published under the terms of -the `Creative Commons Attribution 3.0 license (CC-BY-3.0) `_, with attribution to "Juan Linietsky, Ariel Manzur and the Godot community". +the `Creative Commons Attribution 3.0 license (CC-BY-3.0) ( https://tldrlegal.com/license/creative-commons-attribution-(cc) )`_, with attribution to "Juan Linietsky, Ariel Manzur and the Godot community". By contributing to the documentation on the GitHub repository, you agree that your changes are distributed under this license. diff --git a/community/contributing/editor_and_docs_localization.md b/community/contributing/editor_and_docs_localization.md index 453e048..8622147 100644 --- a/community/contributing/editor_and_docs_localization.md +++ b/community/contributing/editor_and_docs_localization.md @@ -12,15 +12,15 @@ translation effort of the community. These resources include: -1. The `Godot editor's interface ` +1. The `Godot editor's interface ( https://hosted.weblate.org/projects/godot-engine/godot/ )` (ca. 15,000 words). -2. The `online documentation ` +2. The `online documentation ( https://hosted.weblate.org/projects/godot-engine/godot-docs/ )` (editor manual and tutorials, ca. 300,000 words). -3. The `class reference `, +3. The `class reference ( https://hosted.weblate.org/projects/godot-engine/godot-class-reference/ )`, available both online and in the editor (ca. 200,000 words). To manage translations, we use the GNU gettext file format (`PO` files), and -the open source `Weblate ` web-based localization +the open source `Weblate ( https://weblate.org )` web-based localization platform, which allows easy collaboration of many contributors to complete the translation for the various components, and keep them up to date. Click the bold links above to access each resource on Weblate. @@ -45,11 +45,11 @@ Weblate, and thus direct pull requests to the Git repositories are not accepted. Translations are synced manually between Weblate and the Godot repositories by maintainers. -You should therefore `register on Weblate ` +You should therefore `register on Weblate ( https://hosted.weblate.org/accounts/register/ )` to contribute to Godot's translations. Once signed in, browse to the Godot resource which you want to contribute to (in -this page we will use the `editor translation ` +this page we will use the `editor translation ( https://hosted.weblate.org/projects/godot-engine/godot/ )` as an example) to find the list of all languages: ![](img/l10n_01_language_list.png) @@ -57,7 +57,7 @@ as an example) to find the list of all languages: .. seealso:: Feel free to consult Weblate's own documentation on the `translation - workflow ` for + workflow ( https://docs.weblate.org/en/latest/user/translating.html )` for more details. Adding a new language @@ -262,7 +262,7 @@ external links, etc. Here are some examples:: # syntax and should be preserved. Looking for the documentation of the current **development** branch? - `Have a look here `_. + `Have a look here ( https://docs.godotengine.org/en/latest )`_. # "|supported|" is an inline reference to an image and should stay unchanged. # "master" uses the markup for inline code, and will be styled as such. @@ -281,7 +281,7 @@ external links, etc. Here are some examples:: # Or it can be used with an optional custom title, which should thus be translated: - See `how to contribute `. + See `how to contribute ` + See Sphinx's `reStructured Text primer ( https://www.sphinx-doc.org/en/master/usage/restructuredtext/basics.html )` for a quick overview of the markup language you may find in source strings. You may encounter especially the inline markup (bold, italics, inline code) and the internal and external hyperlink markup. @@ -328,7 +328,7 @@ breaks if they are not part of the original translation. .. seealso:: See our documentation for class reference writers for the `list of - BBCode-like tags ` which are used + BBCode-like tags ` or -`Lokalize `. +preferred PO editing application, such as `Poedit ( https://poedit.net/ )` or +`Lokalize ( https://userbase.kde.org/Lokalize )`. To download the PO file locally, browse to the translation overview for your language, and select the first item in the "Files" menu: @@ -357,15 +357,15 @@ upload mode. version. If you want to test changes locally (especially for the editor translation), you -can use the downloaded PO file and `compile Godot from source `. +can use the downloaded PO file and `compile Godot from source .po` (e.g. `eo.po` for Esperanto) and place it in the `editor/translations/` folder -(`GitHub `). +(`GitHub ( https://github.com/godotengine/godot/tree/master/editor/translations )`). You can also test class reference changes the same way by renaming the PO file similarly and placing it in the `doc/translations/` folder -(`GitHub `). +(`GitHub ( https://github.com/godotengine/godot/tree/master/doc/translations )`). Localizing documentation images ------------------------------- @@ -375,7 +375,7 @@ Godot editor, custom-made graphs, of any other kind of visual content. Some of it includes text and might thus be relevant to localize in your language. This part is not handled via Weblate, but directly on the `godot-docs-l10n -`_ Git repository where the +( https://github.com/godotengine/godot-docs-l10n )`_ Git repository where the documentation translations are synced from Weblate. .. note:: @@ -409,8 +409,8 @@ added before the extension, e.g. `project_manager_first_open.png)` would become Finally, on godot-docs-l10n_, recreate the same folder structure as for the original image in the `images` subfolder -(`GitHub `_), +(`GitHub ( https://github.com/godotengine/godot-docs-l10n/tree/master/images )`_), and place your translated image there. In our example, the end result should be `images/getting_started/step_by_step/img/project_manager_first_open.fr.png)`. -Repeat this for other images and `make a Pull Request `. +Repeat this for other images and `make a Pull Request `. + ( https://github.com/godotengine/godot-proposals/ )`. Getting started --------------- @@ -82,7 +82,7 @@ Class reference guides The pages below focus on the class reference. As the reference is included in the Godot editor, its source files are part of -the `godot repository `_. We use XML files +the `godot repository ( https://github.com/godotengine/godot )`_. We use XML files to write it, so the process to contribute to the class reference differs from writing the online manual. diff --git a/community/contributing/pr_workflow.md b/community/contributing/pr_workflow.md index 4d8bf77..2b11e9b 100644 --- a/community/contributing/pr_workflow.md +++ b/community/contributing/pr_workflow.md @@ -25,12 +25,12 @@ organization of Godot's Git repository. Git source repository --------------------- -The `repository on GitHub `_ is a -`Git `_ code repository together with an embedded +The `repository on GitHub ( https://github.com/godotengine/godot )`_ is a +`Git ( https://git-scm.com )`_ code repository together with an embedded issue tracker and PR system. .. note:: If you are contributing to the documentation, its repository can - be found `here `_. + be found `here ( https://github.com/godotengine/godot-docs )`_. The Git version control system is the tool used to keep track of successive edits to the source code - to contribute efficiently to Godot, learning the @@ -45,8 +45,8 @@ which quickly leads to PRs with an unreadable Git history (especially after peer .. seealso:: The first sections of Git's "Book" are a good introduction to the tool's philosophy and the various commands you need to master in your daily workflow. You can read them online on the - `Git SCM `_ website. - You can also try out `GitHub's interactive guide `. + `Git SCM ( https://git-scm.com/book/en/v2 )`_ website. + You can also try out `GitHub's interactive guide ( https://try.github.io/ )`. The branches on the Git repository are organized as follows: @@ -70,7 +70,7 @@ The branches on the Git repository are organized as follows: Forking and cloning ------------------- -The first step is to *fork* the `godotengine/godot `_ +The first step is to *fork* the `godotengine/godot ( https://github.com/godotengine/godot )`_ repository on GitHub. To do so, you will need to have a GitHub account and to be logged in. In the top right corner of the repository's GitHub page, you should see the "Fork" button as shown below: @@ -84,7 +84,7 @@ Godot repo, with your GitHub username as namespace: You can then *clone* your fork, i.e. create a local copy of the online repository (in Git speak, the *origin remote*). If you haven't already, -download Git from `its website `_ if you're using Windows or +download Git from `its website ( https://git-scm.com )`_ if you're using Windows or macOS, or install it through your package manager if you're using Linux. .. note:: If you are on Windows, open Git Bash to type commands. macOS and Linux users @@ -236,11 +236,11 @@ You will then be back to the original state of your branch before calling If you have already created a merge commit without using `rebase`, or have made any other changes that have resulted in undesired history, the best option is to use an *interactive rebase* on the upstream branch. See the `dedicated -section ` for instructions. +section ` or - `git reset --hard /` (e.g. `git reset --hard upstream/master`). + you can do so with `git reset --hard /` will undo the unstaged changes to the given +- `git checkout -- ` will *stage* the changes on the listed files. +- `git add ` will *unstage* changes to the listed files. +- `git reset HEAD `_ and ask for support :) +`Godot Contributors Chat ( https://chat.godotengine.org/ )`_ and ask for support :) Use an explicit title for the PR and put the necessary details in the comment area. You can drag and drop screenshots, GIFs or zipped projects if relevant, @@ -470,7 +470,7 @@ upstream `master` branch, which you can do with: with this little by little). This will open a text editor (`vi` by default, see -`Git docs `_ +`Git docs ( https://git-scm.com/book/en/v2/Customizing-Git-Git-Configuration#_core_editor )`_ to configure your favorite one) with something which may look like this: .. code-block:: text diff --git a/community/contributing/testing_pull_requests.md b/community/contributing/testing_pull_requests.md index 04f1ae7..88dd12d 100644 --- a/community/contributing/testing_pull_requests.md +++ b/community/contributing/testing_pull_requests.md @@ -7,7 +7,7 @@ Many people are developing new features or fixing bugs on GitHub. To help with engine development, you may be asked to test those pull requests with a Godot build that includes code from the pull request in question. -Thanks to GitHub Actions, all `pull requests ` +Thanks to GitHub Actions, all `pull requests ( https://github.com/godotengine/godot/pulls )` have continuous builds available. These builds let you try out pull requests without having to compile anything from source. @@ -23,7 +23,7 @@ depending on whether you have a GitHub account or not. Due to a GitHub Actions limitation, builds are only available for 90 days after the pull request was last updated. If you still wish to try a pull request locally, you can - `compile the pull request branch from source ` + `compile the pull request branch from source ` permanently. + Windows SmartScreen or `disable macOS Gatekeeper ( https://disable-gatekeeper.github.io/ )` permanently. If you don't have a GitHub account ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ If you don't have a GitHub account and can't sign up for one, -you can use the third-party `nightly.link ` service +you can use the third-party `nightly.link ( https://nightly.link )` service to generate a universal download link. - Open the pull request page. Click the *fork*'s branch name near the top of the page: @@ -66,7 +66,7 @@ to generate a universal download link. Click the workflow file for the platform you wish to download artifacts for. *After* clicking on the file (which opens the file view), copy the page URL from your browser's address bar. -- Open the `nightly.link ` website and paste the URL you just copied +- Open the `nightly.link ( https://nightly.link )` website and paste the URL you just copied into the text field located below the heading **Paste a GitHub link, get a nightly.link!**. After pasting the URL, click **Get links** on the right. If the the format of the URL you pasted is correct, you should be presented @@ -80,7 +80,7 @@ to generate a universal download link. Note that Windows and macOS binaries are not code signed. This means you may have to bypass a security warning before you can run the executable. If you frequently test pull request builds, it may be better to disable - Windows SmartScreen or `disable macOS Gatekeeper ` permanently. + Windows SmartScreen or `disable macOS Gatekeeper ( https://disable-gatekeeper.github.io/ )` permanently. .. _doc_testing_pull_requests_compile: @@ -100,5 +100,5 @@ by Godot's GitHub Actions setup. ![](img/testing_pull_requests_fork_zip.png) -- Extract the ZIP archive and follow the `compiling ` instructions +- Extract the ZIP archive and follow the `compiling ` +The class reference is available online in the `classes `_ +the `godot-docs repository ( https://github.com/godotengine/godot-docs/ )`_ or comment on an existing issue. Doing so lets others know you're already taking care of a given class. .. seealso:: - You can find the writing guidelines for the class reference `here `. + You can find the writing guidelines for the class reference `here `_. + ( https://www.youtube.com/watch?v=5jeHXxeX-JY )`_. .. seealso:: Not sure which class to contribute to? Take a look at the class reference's - completion status `here `_. + completion status `here ( https://godotengine.github.io/doc-status/ )`_. You can find the source files for the class reference in Godot's GitHub repository: `doc/classes/ -`_. +( https://github.com/godotengine/godot/tree/master/doc/classes )`_. .. note:: For some modules in the engine's source code, you'll find the XML files in the `modules//doc_classes/` directory instead. .. warning:: Always edit the API reference through these source XML files. Do not edit the generated `.rst` files `in the online documentation - `, hosted in the `godot-docs - `_ repository. + `_ + some money to the project, check `our website ( https://godotengine.org/donate )`_ for details. Contributing code @@ -55,11 +55,11 @@ Contributing code The possibility to study, use, modify and redistribute modifications of the engine's source code are the fundamental rights that -Godot's `MIT `_ license grants you, -making it `free and open source software `_. +Godot's `MIT ( https://tldrlegal.com/license/mit-license )`_ license grants you, +making it `free and open source software ( https://en.wikipedia.org/wiki/Free_and_open-source_software )`_. As such, everyone is entitled to modify -`Godot's source code `_, and send those +`Godot's source code ( https://github.com/godotengine/godot )`_, and send those modifications back to the upstream project in the form of a patch (a text file describing the changes in a ready-to-apply manner) or - in the modern workflow that we use - via a so-called "pull request" (PR), i.e. a proposal to directly @@ -85,7 +85,7 @@ enforce some rules for code contributions, for example regarding the style to use in the C++ code (indentation, brackets, etc.) or the Git and PR workflow. A good place to start is by searching for issues tagged as -`good first issue `_ +`good first issue ( https://github.com/godotengine/godot/issues?q=is%3Aissue+is%3Aopen+label%3A%22good+first+issue%22 )`_ on GitHub. .. seealso:: Technical details about the PR workflow are outlined in a @@ -104,9 +104,9 @@ way more contributions than people validating them. To make sure that your time and efforts aren't wasted, it is recommended to vet the idea first before implementing it and putting it for a review as a PR. To that end, Godot -has a `proposal system `_. Its +has a `proposal system ( https://github.com/godotengine/godot-proposals )`_. Its usage is encouraged to plan changes and discuss them with the community. Implementation -details can also be discussed with other contributors on the `Godot Contributors Chat `_. +details can also be discussed with other contributors on the `Godot Contributors Chat ( https://chat.godotengine.org/ )`_. .. note:: Proposals are only required when working on an enhancement or a new feature. Bug reports are sufficient for fixing issues. @@ -125,7 +125,7 @@ Testing development versions To help with the testing, you have several possibilities: - Compile the engine from source yourself, following the instructions of the - `Compiling ` page for your platform. + `Compiling `_ +Godot uses `GitHub's issue tracker ( https://github.com/godotengine/godot/issues )`_ for bug reports and enhancement suggestions. You will need a GitHub account to be able to open a new issue there, and click on the **New issue** button. @@ -197,7 +197,7 @@ There are two separate resources referred to as "documentation" in Godot: - **The class reference.** This is the documentation for the complete Godot API as exposed to GDScript and the other scripting languages. It can be consulted offline, directly in Godot's code editor, or online at `Godot API - `. To contribute to the class reference, you have to edit the + `_ GitHub repository. + `godot-docs ( https://github.com/godotengine/godot-docs )`_ GitHub repository. See `doc_contributing_to_the_documentation` for more details. Contributing translations diff --git a/community/tutorials.md b/community/tutorials.md index c82b6d3..a3e3b19 100644 --- a/community/tutorials.md +++ b/community/tutorials.md @@ -3,65 +3,65 @@ Tutorials and resources ======================= -This is a list of third-party tutorials and resources created by the Godot community. For resources, remember that there is the official `Godot Asset Library `_ full of official and community resources too! Also, have a look at this `huge list over at Reddit `_. +This is a list of third-party tutorials and resources created by the Godot community. For resources, remember that there is the official `Godot Asset Library ( https://godotengine.org/asset-library/asset )`_ full of official and community resources too! Also, have a look at this `huge list over at Reddit ( https://www.reddit.com/r/godot/comments/an0iq5/godot_tutorials_list_of_video_and_written/ )`_. -Think there is something missing here? Feel free to submit a `Pull Request `_ as always. +Think there is something missing here? Feel free to submit a `Pull Request ( https://github.com/godotengine/godot-docs/blob/master/community/tutorials.rst )`_ as always. Where to start -------------- -The Godot video tutorials by `GDQuest `_, `Game from Scratch `_ and `KidsCanCode `_ are well-regarded in the community and often recommended as a gentle introduction to beginners. +The Godot video tutorials by `GDQuest ( https://www.youtube.com/channel/UCxboW7x0jZqFdvMdCFKTMsQ/playlists )`_, `Game from Scratch ( https://www.youtube.com/watch?v=iDEcP8Mc-7s&list=PLS9MbmO_ssyDk79j9ewONxV88fD5e_o5d )`_ and `KidsCanCode ( https://www.youtube.com/channel/UCNaPQ5uLX5iIEHUCLmfAgKg/playlists )`_ are well-regarded in the community and often recommended as a gentle introduction to beginners. -If you're interested in Visual Scripting, `Emilio's tutorials `_ may be worth a look. +If you're interested in Visual Scripting, `Emilio's tutorials ( https://www.youtube.com/channel/UC9DR22-qohBDtZ74R3FxOZg )`_ may be worth a look. -If you're interested in a complete introduction to programming using Godot and GDScript, the unofficial `Godot Tutorials `_ YouTube channel is a good place to start. +If you're interested in a complete introduction to programming using Godot and GDScript, the unofficial `Godot Tutorials ( https://www.youtube.com/channel/UCnr9ojBEQGgwbcKsZC-2rIg )`_ YouTube channel is a good place to start. -GDQuest's *Learn GDScript From Zero* is a free and open source interactive tutorial for absolute beginners to learn to program with Godot's GDScript language. It is available as a `desktop application `_ or `in the browser `_. +GDQuest's *Learn GDScript From Zero* is a free and open source interactive tutorial for absolute beginners to learn to program with Godot's GDScript language. It is available as a `desktop application ( https://gdquest.itch.io/learn-godot-gdscript )`_ or `in the browser ( https://gdquest.github.io/learn-gdscript )`_. Some tutorials mentioned below provide more advanced tutorials, e.g. on 3D or shaders. Video tutorials --------------- -- `Godot Tutorials `_ (2D, GDScript, Programming Basics). -- `Emilio `_ (2D, GDScript and VisualScript). -- `FinePointCGI `_ (2D, 3D, GDScript and C#). -- `GDQuest `_ (2D and 3D, GDScript, VisualScript and C#). -- `Game Development Center `_ (2D, networked multiplayer, GDScript). -- `Game Endeavor `_ (2D, GDScript). -- `Game from Scratch `_ (2D and 3D, GDScript and C#). -- `HeartBeast `_ (2D, GDScript). -- `KidsCanCode ` (2D and 3D, GDScript and VisualScript). -- `Mister Taft Creates `_ (2D, GDScript). -- `Miziziziz `_ (2D and 3D, GDScript). -- `P1X / Krzysztof Jankowski `_ (3D). -- `Pigdev `_ (2D, GDScript). -- `Steincodes ` (2D, GDScript and VisualScript). -- `TheBuffED `_ (2D, GDScript). -- `Code with Tom `_ (2D and 3D, GDScript). -- `BornCG `_ (2D and 3D, GDScript). -- `Gonkee `_ (2D and 3D, GDScript, Shaders). -- `TheGuideKnight `_ (2D, GDScript). -- `GDScript Dude `_ (GDScript). -- `Garbaj `_ (3D, GDScript). -- `Kasper Frandsen `_ (3D, Shaders). +- `Godot Tutorials ( https://www.youtube.com/channel/UCnr9ojBEQGgwbcKsZC-2rIg )`_ (2D, GDScript, Programming Basics). +- `Emilio ( https://www.youtube.com/channel/UC9DR22-qohBDtZ74R3FxOZg )`_ (2D, GDScript and VisualScript). +- `FinePointCGI ( https://www.youtube.com/channel/UCSojAWUnEUTUcdA9iJ6bryQ )`_ (2D, 3D, GDScript and C#). +- `GDQuest ( https://www.youtube.com/channel/UCxboW7x0jZqFdvMdCFKTMsQ/playlists )`_ (2D and 3D, GDScript, VisualScript and C#). +- `Game Development Center ( https://www.youtube.com/c/GameDevelopmentCenter )`_ (2D, networked multiplayer, GDScript). +- `Game Endeavor ( https://www.youtube.com/channel/UCLweX1UtQjRjj7rs_0XQ2Eg/videos )`_ (2D, GDScript). +- `Game from Scratch ( https://www.youtube.com/watch?v=iDEcP8Mc-7s&list=PLS9MbmO_ssyDk79j9ewONxV88fD5e_o5d )`_ (2D and 3D, GDScript and C#). +- `HeartBeast ( https://www.youtube.com/watch?v=wETY5_9kFtA&list=PL9FzW-m48fn2jlBu_0DRh7PvAt-GULEmd )`_ (2D, GDScript). +- `KidsCanCode ( https://www.youtube.com/channel/UCNaPQ5uLX5iIEHUCLmfAgKg/playlists )` (2D and 3D, GDScript and VisualScript). +- `Mister Taft Creates ( https://www.youtube.com/playlist?list=PL4vbr3u7UKWqwQlvwvgNcgDL1p_3hcNn2 )`_ (2D, GDScript). +- `Miziziziz ( https://www.youtube.com/playlist?list=PLmugv6_kd0qN6AyjG245_Pdak4MXKUx88 )`_ (2D and 3D, GDScript). +- `P1X / Krzysztof Jankowski ( https://www.youtube.com/playlist?list=PLvDk7UKhld4xGPovdB4IFtAHYMYjx_-3K )`_ (3D). +- `Pigdev ( https://www.youtube.com/playlist?list=PLPMN4vCRFdordS3E-3zi0Hdh7pAsbWQ6a )`_ (2D, GDScript). +- `Steincodes ( https://www.youtube.com/c/steincodes/playlists )` (2D, GDScript and VisualScript). +- `TheBuffED ( https://www.youtube.com/watch?v=ygGaN1EOQEA&list=PLvN5Z3tTxXEDfQkt4Frg6ALirespSwZd7 )`_ (2D, GDScript). +- `Code with Tom ( https://www.youtube.com/playlist?list=PLiUQR4U_J9ec0k91iHPme_qtfS1nrWF3W )`_ (2D and 3D, GDScript). +- `BornCG ( https://www.youtube.com/playlist?list=PLda3VoSoc_TSBBOBYwcmlamF1UrjVtccZ )`_ (2D and 3D, GDScript). +- `Gonkee ( https://www.youtube.com/channel/UCJqCPFHdbc6443G3Sz6VYDw )`_ (2D and 3D, GDScript, Shaders). +- `TheGuideKnight ( https://www.youtube.com/playlist?list=PLYcTJBw32KtX2fvOdtO_fS3Nd6sxM71tn )`_ (2D, GDScript). +- `GDScript Dude ( https://www.youtube.com/channel/UCQs0i6vKISElM6mh7OzLouQ )`_ (GDScript). +- `Garbaj ( https://www.youtube.com/c/Garbaj/ )`_ (3D, GDScript). +- `Kasper Frandsen ( https://www.youtube.com/c/KasperFrandsen/ )`_ (3D, Shaders). Text tutorials -------------- -- `FinepointCGI website by Mitch ` -- `GDScript website by Andrew Wilkes ` -- `Godot Recipes by KidsCanCode ` -- `Steincodes ` +- `FinepointCGI website by Mitch ( http://finepointcgi.io/ )` +- `GDScript website by Andrew Wilkes ( https://gdscript.com )` +- `Godot Recipes by KidsCanCode ( http://godotrecipes.com/ )` +- `Steincodes ( https://steincodes.tumblr.com )` Devlogs ------- -- `Andrea Catania (Physics & AI) `_ -- `Bastiaan Olij (AR & VR) `_ +- `Andrea Catania (Physics & AI) ( https://www.youtube.com/channel/UCm4RuvYtgpgFDTCgaEUT5uQ/videos )`_ +- `Bastiaan Olij (AR & VR) ( https://www.youtube.com/channel/UCrbLJYzJjDf2p-vJC011lYw/videos )`_ Resources --------- -- `awesome-godot: A curated list of free/libre plugins, scripts and add-ons `_ -- `Zeef Godot Engine: A curated directory of resources by Andre Schmitz `_ +- `awesome-godot: A curated list of free/libre plugins, scripts and add-ons ( https://github.com/godotengine/awesome-godot )`_ +- `Zeef Godot Engine: A curated directory of resources by Andre Schmitz ( https://godot-engine.zeef.com/andre.antonio.schmitz )`_ diff --git a/development/compiling/compiling_for_android.md b/development/compiling/compiling_for_android.md index df33e73..5ad521f 100644 --- a/development/compiling/compiling_for_android.md +++ b/development/compiling/compiling_for_android.md @@ -25,9 +25,9 @@ Requirements For compiling under Windows, Linux or macOS, the following is required: -- `Python 3.5+ `_. -- `SCons 3.0+ `_ build system. -- `Android SDK `_ +- `Python 3.5+ ( https://www.python.org/downloads/ )`_. +- `SCons 3.0+ ( https://scons.org/pages/download.html )`_ build system. +- `Android SDK ( https://developer.android.com/studio/#command-tools )`_ (command-line tools are sufficient). - Required SDK components will be automatically installed. @@ -37,7 +37,7 @@ For compiling under Windows, Linux or macOS, the following is required: - Gradle (will be downloaded and installed automatically if missing). - JDK 11 (either OpenJDK or Oracle JDK). - - You can download a build from `ojdkbuild `_. + - You can download a build from `ojdkbuild ( https://github.com/ojdkbuild/ojdkbuild )`_. .. seealso:: To get the Godot source code for compiling, see `doc_getting_source`. @@ -181,7 +181,7 @@ with their respective names. The templates folder can be located in: - Linux: `$HOME/.local/share/godot/templates//` - macOS: `$HOME/Library/Application Support/Godot/templates//` -`` is of the form `major.minor[.patch].status` using values from +`` +See `Setting up the buildsystem `_: +If it still fails, open a command line and run `logcat ( https://developer.android.com/studio/command-line/logcat )`_: :: @@ -239,7 +239,7 @@ one of the following reasons: - Make sure to use export templates that match your editor version; if you use a new Godot version, you *have* to update the templates too. - `libgodot_android.so` is not in `libs//` - where `` is the device's architecture. + where ``_ or - `MacPorts `_, you should be able +- SCons 3.0+ (you can install it via `Homebrew ( https://brew.sh/ )`_ or + `MacPorts ( https://www.macports.org/ )`_, you should be able to run `scons` in a terminal when installed). - Xcode 10.0 (or later) with the iOS (10.0) SDK and the command line tools. diff --git a/development/compiling/compiling_for_osx.md b/development/compiling/compiling_for_osx.md index 62f904e..41a38ca 100644 --- a/development/compiling/compiling_for_osx.md +++ b/development/compiling/compiling_for_osx.md @@ -14,13 +14,13 @@ Requirements For compiling under macOS, the following is required: -- `Python 3.5+ `_. -- `SCons 3.0+ `_ build system. -- `Xcode `_ +- `Python 3.5+ ( https://www.python.org )`_. +- `SCons 3.0+ ( https://www.scons.org )`_ build system. +- `Xcode ( https://apps.apple.com/us/app/xcode/id497799835 )`_ (or the more lightweight Command Line Tools for Xcode). -- *Optional* - `yasm `_ (for WebM SIMD optimizations). +- *Optional* - `yasm ( https://yasm.tortall.net/ )`_ (for WebM SIMD optimizations). -.. note:: If you have `Homebrew `_ installed, you can easily +.. note:: If you have `Homebrew ( https://brew.sh/ )`_ installed, you can easily install SCons and yasm using the following command:: brew install scons yasm @@ -28,7 +28,7 @@ For compiling under macOS, the following is required: Installing Homebrew will also fetch the Command Line Tools for Xcode automatically if you don't have them already. - Similarly, if you have `MacPorts `_ + Similarly, if you have `MacPorts ( https://www.macports.org/ )`_ installed, you can easily install SCons and yasm using the following command:: @@ -85,7 +85,7 @@ projects in an automated manner, use:: scons platform=server tools=yes target=release_debug --jobs=$(sysctl -n hw.logicalcpu) To compile a debug *server* build which can be used with -`remote debugging tools `, use:: +`remote debugging tools ` to be able to use macOS +`OSXCross ( https://github.com/tpoechtrager/osxcross )` to be able to use macOS as a target. First, follow the instructions to install it: -Clone the `OSXCross repository ` +Clone the `OSXCross repository ( https://github.com/tpoechtrager/osxcross )` somewhere on your machine (or download a ZIP file and extract it somewhere), e.g.:: diff --git a/development/compiling/compiling_for_uwp.md b/development/compiling/compiling_for_uwp.md index 533ec5a..1dffbb9 100644 --- a/development/compiling/compiling_for_uwp.md +++ b/development/compiling/compiling_for_uwp.md @@ -16,7 +16,7 @@ Requirements - Visual Studio 2017 or later. See `doc_compiling_for_windows` about the caveats of installing it and the various prompts. - Windows 10 SDK (can be selected in Visual Studio installation). -- `ANGLE source `. Use the +- `ANGLE source ( https://github.com/Microsoft/angle )`. Use the `ms_master` (default) branch. Keep it in a path without spaces to avoid problems. @@ -25,7 +25,7 @@ Requirements As a temporary workaround however, it is still possible to download an older state of the source code via commit - `c61d048 `. + `c61d048 ( https://github.com/microsoft/angle/tree/c61d0488abd9663e0d4d2450db7345baa2c0dfb6 )`. This page will eventually be updated in the future to reflect the new build instructions. diff --git a/development/compiling/compiling_for_web.md b/development/compiling/compiling_for_web.md index 2b40713..cfa630e 100644 --- a/development/compiling/compiling_for_web.md +++ b/development/compiling/compiling_for_web.md @@ -14,9 +14,9 @@ Requirements To compile export templates for the Web, the following is required: -- `Emscripten 1.39.9+ `. -- `Python 3.5+ `. -- `SCons 3.0+ ` build system. +- `Emscripten 1.39.9+ ( https://emscripten.org )`. +- `Python 3.5+ ( https://www.python.org/ )`. +- `SCons 3.0+ ( https://www.scons.org )` build system. .. seealso:: To get the Godot source code for compiling, see `doc_getting_source`. @@ -38,7 +38,7 @@ either `release` for a release build or `release_debug` for a debug build:: scons platform=javascript tools=no target=release scons platform=javascript tools=no target=release_debug -By default, the `JavaScript singleton ` will be built +By default, the `JavaScript singleton ` for more info. +`export page ` for the web +Refer to the `export page `_, +- `Visual Studio Community ( https://www.visualstudio.com/vs/community/ )`_, version 2017 or later. VS 2019 is recommended. **Make sure to read "Installing Visual Studio caveats" below or you will have to run/download the installer again.** -- `MinGW-w64 ` with GCC can be used as an alternative to +- `MinGW-w64 ( http://mingw-w64.org/ )` with GCC can be used as an alternative to Visual Studio. Be sure to install/configure it to use the `posix` thread model. -- `Python 3.5+ `_. +- `Python 3.5+ ( https://www.python.org/downloads/windows/ )`_. **Make sure to enable the option to add Python to the `PATH` in the installer.** -- `SCons `_ build system. Using the latest release is +- `SCons ( https://www.scons.org/ )`_ build system. Using the latest release is recommended, especially for proper support of recent Visual Studio releases. -.. note:: If you have `Scoop `_ installed, you can easily +.. note:: If you have `Scoop ( https://scoop.sh/ )`_ installed, you can easily install MinGW and other dependencies using the following command:: scoop install gcc python scons make -.. note:: If you have `MSYS2 `_ installed, you can easily +.. note:: If you have `MSYS2 ( https://www.msys2.org/ )`_ installed, you can easily install MinGW and other dependencies using the following command:: pacman -S mingw-w64-x86_64-python3-pip mingw-w64-x86_64-gcc \ @@ -191,7 +191,7 @@ Cross-compiling for Windows from other operating systems -------------------------------------------------------- If you are a Linux or macOS user, you need to install -`MinGW-w64 `, which typically comes in 32-bit +`MinGW-w64 ( https://mingw-w64.org/doku.php )`, which typically comes in 32-bit and 64-bit variants. The package names may differ based on your distribution, here are some known ones: @@ -243,7 +243,7 @@ Troubleshooting ~~~~~~~~~~~~~~~ Cross-compiling from some Ubuntu versions may lead to -`this bug `_, +`this bug ( https://github.com/godotengine/godot/issues/9258 )`_, due to a default configuration lacking support for POSIX threading. You can change that configuration following those instructions, @@ -273,7 +273,7 @@ with the following flags:: C:\godot> scons platform=windows tools=no target=release bits=64 If you plan on replacing the standard export templates, copy these to the -following location, replacing `` with the version identifier +following location, replacing `\ diff --git a/development/compiling/compiling_for_x11.md b/development/compiling/compiling_for_x11.md index 752743c..adee2f2 100644 --- a/development/compiling/compiling_for_x11.md +++ b/development/compiling/compiling_for_x11.md @@ -150,7 +150,7 @@ projects in an automated manner, use:: scons -j8 platform=server tools=yes target=release_debug To compile a debug *server* build which can be used with -`remote debugging tools `, use:: +`remote debugging tools ` to run SCons. Pyston is a JIT-enabled +You can use `Pyston ( https://www.pyston.org/ )` to run SCons. Pyston is a JIT-enabled implementation of the Python language (which SCons is written in). It is currently only compatible with Linux. Pyston can speed up incremental builds significantly, often by a factor between 1.5× and 2×. Pyston can be combined with Clang and LLD to get even faster builds. -- Download the `latest portable Pyston release `. +- Download the `latest portable Pyston release ( https://github.com/pyston/pyston/releases/latest )`. - Extract the portable `.tar.gz` to a set location, such as `$HOME/.local/opt/pyston/` (create folders as needed). - Use `cd` to reach the extracted Pyston folder from a terminal, then run `./pyston -m pip install scons` to install SCons within Pyston. @@ -254,7 +254,7 @@ to get even faster builds. ln -s ~/.local/opt/pyston/bin/scons ~/.local/bin/pyston-scons -- Instead of running `scons `, run `pyston-scons ` +- Instead of running `scons ` refers to the tools binary you compiled above with the Mono +`.tools..mono`, e.g. `bin/godot.x11.tools.64.mono` @@ -117,7 +117,7 @@ the following files in the `bin` directory: for the editor and for export templates. This directory is important for proper functioning and must be distributed together with Godot. More details about this directory in - `Data directory`. + `Data directory..`, e.g. `data.mono.x11.32.release_debug` or +`data.mono...`, where -`` is the application name as specified in the project setting +the game executable but the name will be changed to `data_`_. +We recommend using these `build scripts ( https://github.com/godotengine/godot-mono-builds )`_. They simplify this process but also include some patches needed for proper functioning with Godot. See the README on the link above for instructions on how to use the scripts. @@ -248,7 +248,7 @@ to the Gradle project. Once you've built Mono, you can proceed to build Godot with the instructions described in this page and the -`Compiling for Android` page. +`Compiling for Android` page. +`Compiling for iOS` page. +`Compiling for the Web/bcl/`, -where `` is the same name passed to the SCons `platform` option, +Godot looks for the BCL folder at `/bcl//bcl/windows`, `/bcl/javascript`. Alternatively, Godot will look for them in the following locations: @@ -352,7 +352,7 @@ Godot will look for the cross-compiler executable in the AOT compilers folder. The location of this folder is `/Tools/aot-compilers/`. In order to build the cross-compilers we recommend using these -`build scripts `_. +`build scripts ( https://github.com/godotengine/godot-mono-builds )`_. After building them, copy the executable to the Godot AOT compilers directory. The executable name is `-mono-sgen`, e.g.: `aarch64-apple-darwin-mono-sgen`. diff --git a/development/compiling/compiling_with_script_encryption_key.md b/development/compiling/compiling_with_script_encryption_key.md index fedd4aa..278998b 100644 --- a/development/compiling/compiling_with_script_encryption_key.md +++ b/development/compiling/compiling_with_script_encryption_key.md @@ -24,10 +24,10 @@ Step by step ------------ 1. Generate a 256-bit AES key in hexadecimal format. You can use the aes-256-cbc variant from - `this service `_. + `this service ( https://asecuritysite.com/encryption/keygen )`_. Alternatively, you can generate it yourself using - `OpenSSL ` command-line tools: + `OpenSSL ( https://www.openssl.org/ )` command-line tools: :: diff --git a/development/compiling/cross-compiling_for_ios_on_linux.md b/development/compiling/cross-compiling_for_ios_on_linux.md index 397c90b..7203a52 100644 --- a/development/compiling/cross-compiling_for_ios_on_linux.md +++ b/development/compiling/cross-compiling_for_ios_on_linux.md @@ -15,9 +15,9 @@ While it is possible to compile for iOS on a Linux environment, Apple is very restrictive about the tools to be used (especially hardware-wise), allowing pretty much only their products to be used for development. So this is **not official**. However, a `statement from Apple in 2010 -` +( http://www.apple.com/pr/library/2010/09/09Statement-by-Apple-on-App-Store-Review-Guidelines.html )` says they relaxed some of the `App Store review guidelines -` +( https://developer.apple.com/app-store/review/guidelines/ )` to allow any tool to be used, as long as the resulting binary does not download any code, which means it should be OK to use the procedure described here and cross-compiling the binary. @@ -25,21 +25,21 @@ described here and cross-compiling the binary. Requirements ------------ -- `XCode with the iOS SDK ` +- `XCode with the iOS SDK ( https://developer.apple.com/xcode/download )` (a dmg image) -- `Clang >= 3.5 ` for your development +- `Clang >= 3.5 ( http://clang.llvm.org )` for your development machine installed and in the `PATH`. It has to be version >= 3.5 to target `arm64` architecture. -- `Fuse ` for mounting and umounting +- `Fuse ( https://github.com/libfuse/libfuse )` for mounting and umounting the dmg image. -- `darling-dmg `, which +- `darling-dmg ( https://github.com/darlinghq/darling-dmg )`, which needs to be built from source. The procedure for that is explained below. - For building darling-dmg, you'll need the development packages of the following libraries: fuse, icu, openssl, zlib, bzip2. -- `cctools-port ` +- `cctools-port ( https://github.com/tpoechtrager/cctools-port )` for the needed build tools. The procedure for building is quite peculiar and is described below. diff --git a/development/compiling/getting_source.md b/development/compiling/getting_source.md index 1206fc6..ab7e2bd 100644 --- a/development/compiling/getting_source.md +++ b/development/compiling/getting_source.md @@ -7,18 +7,18 @@ Getting the source Downloading the Godot source code --------------------------------- -Before `getting into the SCons build system ` +Before `getting into the SCons build system ` +The source code is available on `GitHub ( https://github.com/godotengine/godot )` and while you can manually download it via the website, in general you want to do it via the `git` version control system. If you are compiling in order to make contributions or pull requests, you should -follow the instructions from the `Pull Request workflow `. +follow the instructions from the `Pull Request workflow ` available on various websites. +`tutorials ( https://git-scm.com/book )` available on various websites. In general, you need to install `git` and/or one of the various GUI clients. @@ -34,7 +34,7 @@ the following in a terminal: # You can add the --depth 1 argument to omit the commit history. # Faster, but not all Git operations (like blame) will work. -For any stable release, visit the `release page ` +For any stable release, visit the `release page ( https://github.com/godotengine/godot/releases )` and click on the link for the release you want. You can then download and extract the source from the download link on the page. @@ -50,4 +50,4 @@ after the `--branch` (or just `-b`) argument:: There are also generally branches besides `master` for each major version. After downloading the Godot source code, -you can `continue to compiling Godot `. +you can `continue to compiling Godot ` to build. We love it, we are +Godot uses `SCons ( https://www.scons.org/ )` to build. We love it, we are not changing it for anything else. We are not even sure other build systems are up to the task of building Godot. We constantly get requests to move the build system to CMake, or Visual Studio, but this is not @@ -81,7 +81,7 @@ To build for a platform (for example, x11), run with the `platform=` (or scons platform=x11 This will start the build process, which will take a while. If you want -SCons to build faster, use the `-j ` parameter to specify how many +SCons to build faster, use the `-j `, or +can be either downloaded from `godotengine.org ( https://godotengine.org/ )`, or you can build them yourself). Aside from that, there are a few standard options that can be set in all @@ -215,7 +215,7 @@ Cleaning generated files ------------------------ Sometimes, you may encounter an error due to generated files being present. You -can remove them by using `scons --clean `, where `` is the +can remove them by using `scons --clean ` + `Godot build options generator ( https://godot-build-options-generator.github.io/ )` to generate a `custom.py` file containing SCons options. You can then save this file and place it at the root of your Godot source directory. @@ -312,7 +312,7 @@ Export templates ---------------- Official export templates are downloaded from the Godot Engine site: -`godotengine.org `. However, you might want +`godotengine.org ( https://godotengine.org/ )`. However, you might want to build them yourself (in case you want newer ones, you are using custom modules, or simply don't trust your own shadow). @@ -349,7 +349,7 @@ directory to avoid conflicts. For instance, if you are building export templates for Godot 3.1.1, `version.txt` should contain `3.1.1.stable` on the first line (and nothing else). This version identifier is based on the `major`, `minor`, `patch` (if present) and `status` lines of the -`version.py file in the Godot Git repository `. +`version.py file in the Godot Git repository ( https://github.com/godotengine/godot/blob/master/version.py )`. If you are developing for multiple platforms, macOS is definitely the most convenient host platform for cross-compilation, since you can cross-compile for diff --git a/development/compiling/optimizing_for_size.md b/development/compiling/optimizing_for_size.md index 4c66e0d..7d603d7 100644 --- a/development/compiling/optimizing_for_size.md +++ b/development/compiling/optimizing_for_size.md @@ -39,7 +39,7 @@ On Windows, `strip.exe` is included in most MinGW toolchain setups. This will reduce the size of compiled binaries by a factor between 5× and 10×. The downside is that crash backtraces will no longer provide accurate information (which is useful for troubleshooting the cause of a crash). -`C++ profilers ` will also no longer be able to display +`C++ profilers `_, +Let's look at an example using `Festival ( http://www.cstr.ed.ac.uk/projects/festival/ )`_, a speech synthesis (text-to-speech) library written in C++. To bind to an external library, set up a module directory similar to the Summator example: diff --git a/development/cpp/common_engine_methods_and_macros.md b/development/cpp/common_engine_methods_and_macros.md index 2c504a9..01e2138 100644 --- a/development/cpp/common_engine_methods_and_macros.md +++ b/development/cpp/common_engine_methods_and_macros.md @@ -237,10 +237,10 @@ Godot features many error macros to make error reporting more convenient. .. seealso:: - See `core/error_macros.h ` + See `core/error_macros.h ( https://github.com/godotengine/godot/blob/3.x/core/error_macros.h )` in Godot's codebase for more information about each error macro. Some functions return an error code (materialized by a return type of `Error`). This value can be returned directly from an error macro. See the list of available error codes in - `core/error_list.h `. + `core/error_list.h ( https://github.com/godotengine/godot/blob/3.x/core/error_list.h )`. diff --git a/development/cpp/configuring_an_ide/android_studio.md b/development/cpp/configuring_an_ide/android_studio.md index 9e6c722..360b434 100644 --- a/development/cpp/configuring_an_ide/android_studio.md +++ b/development/cpp/configuring_an_ide/android_studio.md @@ -3,8 +3,8 @@ Android Studio ============== -`Android Studio `_ is a free -`JetBrains `_ IDE for Android development. +`Android Studio ( https://developer.android.com/studio )`_ is a free +`JetBrains ( https://www.jetbrains.com/ )`_ IDE for Android development. It has a feature-rich editor which supports Java and C/C++. It can be used to work on Godot's core engine as well as the Android platform codebase. @@ -22,7 +22,7 @@ Importing the project - Navigate to `/platform/android/java` and select the `settings.gradle` file. - Android Studio will import and index the project. -- To build the project, follow the `compiling instructions `. +- To build the project, follow the `compiling instructions `. +`Godot's community channels ( https://godotengine.org/community )`. diff --git a/development/cpp/configuring_an_ide/clion.md b/development/cpp/configuring_an_ide/clion.md index 43a4ae5..6073c9c 100644 --- a/development/cpp/configuring_an_ide/clion.md +++ b/development/cpp/configuring_an_ide/clion.md @@ -3,15 +3,15 @@ CLion ===== -`CLion `_ is a commercial -`JetBrains `_ IDE for C++. +`CLion ( https://www.jetbrains.com/clion/ )`_ is a commercial +`JetBrains ( https://www.jetbrains.com/ )`_ IDE for C++. Importing the project --------------------- CLion requires a `CMakeLists.txt` file as a project file, which is problematic for Godot because it uses the SCons buildsystem instead of CMake. However, -there is a `CMakeLists.txt` configuration for `Android Studio ` +there is a `CMakeLists.txt` configuration for `Android Studio `. +`Godot's community channels ( https://godotengine.org/community )`. Debugging the project --------------------- Since CLion does not support SCons, you won't be able to compile, launch, and debug Godot from CLion in one step. -You will first need to `compile godot yourself ` and run the binary without CLion. You will then be able to debug Godot by using the `Attach to process ` feature. +You will first need to `compile godot yourself ( https://docs.godotengine.org/en/stable/development/compiling/index.html )` and run the binary without CLion. You will then be able to debug Godot by using the `Attach to process ( https://www.jetbrains.com/help/clion/attaching-to-local-process.html )` feature. - Run the compilation in debug mode by entering `scons`. diff --git a/development/cpp/configuring_an_ide/code_blocks.md b/development/cpp/configuring_an_ide/code_blocks.md index 21bce7a..50dbd1c 100644 --- a/development/cpp/configuring_an_ide/code_blocks.md +++ b/development/cpp/configuring_an_ide/code_blocks.md @@ -3,7 +3,7 @@ Code::Blocks ============ -`Code::Blocks `_ is a free, open source, cross platform IDE. +`Code::Blocks ( https://codeblocks.org/ )`_ is a free, open source, cross platform IDE. Creating a new project ---------------------- @@ -126,4 +126,4 @@ Under **General Settings**, on the **Editor Settings** tab, under **Tab Options* :figclass: figure-w480 :align: center -That's it. You're ready to start contributing to Godot using the Code::Blocks IDE. Remember to save the project file and the **Workspace**. If you run into any issues, ask for help in one of `Godot's community channels `. +That's it. You're ready to start contributing to Godot using the Code::Blocks IDE. Remember to save the project file and the **Workspace**. If you run into any issues, ask for help in one of `Godot's community channels ( https://godotengine.org/community )`. diff --git a/development/cpp/configuring_an_ide/index.md b/development/cpp/configuring_an_ide/index.md index aa2158a..81d7aae 100644 --- a/development/cpp/configuring_an_ide/index.md +++ b/development/cpp/configuring_an_ide/index.md @@ -1,8 +1,8 @@ Configuring an IDE ================== -We assume that you have already `cloned `_ -and `compiled ` Godot. +We assume that you have already `cloned ( https://github.com/godotengine/godot )`_ +and `compiled `_ is a free, open source IDE for all desktop platforms. +`KDevelop ( https://www.kdevelop.org )`_ is a free, open source IDE for all desktop platforms. Importing the project --------------------- @@ -84,4 +84,4 @@ Debugging the project :align: center If you run into any issues, ask for help in one of -`Godot's community channels `. +`Godot's community channels ( https://godotengine.org/community )`. diff --git a/development/cpp/configuring_an_ide/qt_creator.md b/development/cpp/configuring_an_ide/qt_creator.md index 2bc176b..5e58ee8 100644 --- a/development/cpp/configuring_an_ide/qt_creator.md +++ b/development/cpp/configuring_an_ide/qt_creator.md @@ -3,7 +3,7 @@ Qt Creator ========== -`Qt Creator `_ is a free, open source IDE for all desktop platforms. +`Qt Creator ( https://doc.qt.io/qtcreator/index.html )`_ is a free, open source IDE for all desktop platforms. Importing the project --------------------- @@ -85,12 +85,12 @@ Debugging the project :align: center To learn more about command line arguments, refer to the -`command line tutorial `. +`command line tutorial ` +Developers must follow the project's `code style Options > C++**. @@ -108,4 +108,4 @@ Click on **Edit** to change the current settings, then click on :align: center If you run into any issues, ask for help in one of -`Godot's community channels `. +`Godot's community channels ( https://godotengine.org/community )`. diff --git a/development/cpp/configuring_an_ide/visual_studio.md b/development/cpp/configuring_an_ide/visual_studio.md index 5695f5b..9fff915 100644 --- a/development/cpp/configuring_an_ide/visual_studio.md +++ b/development/cpp/configuring_an_ide/visual_studio.md @@ -3,8 +3,8 @@ Visual Studio ============= -`Visual Studio Community ` is a Windows-only IDE -by `Microsoft `_ that's free for non-commercial use. +`Visual Studio Community ( https://visualstudio.microsoft.com )` is a Windows-only IDE +by `Microsoft ( https://microsoft.com )`_ that's free for non-commercial use. It has many useful features, such as memory view, performance view, source control and more. @@ -53,7 +53,7 @@ project manager opens a project, the initial process is terminated and the debug :align: center To learn more about command line arguments, refer to the -`command line tutorial `. +`command line tutorial Attach to Process...** menu. @@ -65,4 +65,4 @@ start debugging. :align: center If you run into any issues, ask for help in one of -`Godot's community channels `. +`Godot's community channels ( https://godotengine.org/community )`. diff --git a/development/cpp/configuring_an_ide/visual_studio_code.md b/development/cpp/configuring_an_ide/visual_studio_code.md index a6d95de..8872fd2 100644 --- a/development/cpp/configuring_an_ide/visual_studio_code.md +++ b/development/cpp/configuring_an_ide/visual_studio_code.md @@ -3,15 +3,15 @@ Visual Studio Code ================== -`Visual Studio Code `_ is a free cross-platform code editor -by `Microsoft `_ (not to be confused with `doc_configuring_an_ide_vs`). +`Visual Studio Code ( https://code.visualstudio.com )`_ is a free cross-platform code editor +by `Microsoft ( https://microsoft.com )`_ (not to be confused with `doc_configuring_an_ide_vs`). Importing the project --------------------- - Make sure the C/C++ extension is installed. You can find instructions in - the `official documentation `_. - Alternatively, `clangd `_ + the `official documentation ( https://code.visualstudio.com/docs/languages/cpp )`_. + Alternatively, `clangd ( https://open-vsx.org/extension/llvm-vs-code-extensions/vscode-clangd )`_ can be used instead. - When using the clangd extension, run `scons compiledb=yes`. - From the Visual Studio Code's main screen open the Godot root folder with @@ -169,7 +169,7 @@ js Windows .. note:: Due to sporadic performance issues, it is recommended to use LLDB over GDB on Unix-based systems. - Make sure that the `CodeLLDB extension `_ + Make sure that the `CodeLLDB extension ( https://marketplace.visualstudio.com/items?itemName=vadimcn.vscode-lldb )`_ is installed. If you encounter issues with lldb, you may consider using gdb (see the X11_gdb configuration). @@ -180,4 +180,4 @@ The name under `program` depends on your build configuration, e.g. `godot.x11.tools.64` for 64-bit X11 platform with `tools` enabled. If you run into any issues, ask for help in one of -`Godot's community channels `. +`Godot's community channels ( https://godotengine.org/community )`. diff --git a/development/cpp/configuring_an_ide/xcode.md b/development/cpp/configuring_an_ide/xcode.md index 56904cb..aadb9e2 100644 --- a/development/cpp/configuring_an_ide/xcode.md +++ b/development/cpp/configuring_an_ide/xcode.md @@ -3,7 +3,7 @@ Xcode ===== -`Xcode `_ is a free macOS-only IDE. You can +`Xcode ( https://developer.apple.com/xcode )`_ is a free macOS-only IDE. You can download it from the Mac App Store. Importing the project @@ -107,4 +107,4 @@ To check that everything is working, put a breakpoint in `platform/osx/godot_mai run the project. If you run into any issues, ask for help in one of -`Godot's community channels `. +`Godot's community channels ( https://godotengine.org/community )`. diff --git a/development/cpp/core_types.md b/development/cpp/core_types.md index 296e2d8..55d4fdc 100644 --- a/development/cpp/core_types.md +++ b/development/cpp/core_types.md @@ -34,7 +34,7 @@ directly to wchar_t. References: ~~~~~~~~~~~ -- `core/typedefs.h ` +- `core/typedefs.h ( https://github.com/godotengine/godot/blob/3.x/core/typedefs.h )` Memory model ------------ @@ -131,8 +131,8 @@ large amount of accesses. References: ~~~~~~~~~~~ -- `core/os/memory.h ` -- `core/pool_vector.h ` +- `core/os/memory.h ( https://github.com/godotengine/godot/blob/3.x/core/os/memory.h )` +- `core/pool_vector.h ( https://github.com/godotengine/godot/blob/3.x/core/pool_vector.cpp )` Containers ---------- @@ -165,10 +165,10 @@ The Vector<> class also has a few nice features: References: ~~~~~~~~~~~ -- `core/vector.h ` -- `core/list.h ` -- `core/set.h ` -- `core/map.h ` +- `core/vector.h ( https://github.com/godotengine/godot/blob/3.x/core/vector.h )` +- `core/list.h ( https://github.com/godotengine/godot/blob/3.x/core/list.h )` +- `core/set.h ( https://github.com/godotengine/godot/blob/3.x/core/set.h )` +- `core/map.h ( https://github.com/godotengine/godot/blob/3.x/core/map.h )` String ------ @@ -181,7 +181,7 @@ conversion and visualization. References: ~~~~~~~~~~~ -- `core/ustring.h ` +- `core/ustring.h ( https://github.com/godotengine/godot/blob/3.x/core/ustring.h )` StringName ---------- @@ -197,7 +197,7 @@ is fast. References: ~~~~~~~~~~~ -- `core/string_name.h ` +- `core/string_name.h ( https://github.com/godotengine/godot/blob/3.x/core/string_name.h )` Math types ---------- @@ -208,7 +208,7 @@ directory. References: ~~~~~~~~~~~ -- `core/math ` +- `core/math ( https://github.com/godotengine/godot/tree/3.x/core/math )` NodePath -------- @@ -219,7 +219,7 @@ referencing them fast. References: ~~~~~~~~~~~ -- `core/node_path.h ` +- `core/node_path.h ( https://github.com/godotengine/godot/blob/3.x/core/node_path.h )` RID --- @@ -232,4 +232,4 @@ referenced data. References: ~~~~~~~~~~~ -- `core/rid.h ` +- `core/rid.h ( https://github.com/godotengine/godot/blob/3.x/core/rid.h )` diff --git a/development/cpp/custom_audiostreams.md b/development/cpp/custom_audiostreams.md index efda73a..e47e8c2 100644 --- a/development/cpp/custom_audiostreams.md +++ b/development/cpp/custom_audiostreams.md @@ -22,8 +22,8 @@ This guide assumes the reader knows how to create C++ modules. If not, refer to References: ~~~~~~~~~~~ -- `servers/audio/audio_stream.h ` -- `scene/audio/audioplayer.cpp ` +- `servers/audio/audio_stream.h ( https://github.com/godotengine/godot/blob/master/servers/audio/audio_stream.h )` +- `scene/audio/audioplayer.cpp ( https://github.com/godotengine/godot/blob/master/scene/audio/audio_player.cpp )` What for? --------- @@ -116,7 +116,7 @@ Therefore, playback state must be self-contained in AudioStreamPlayback. References: ~~~~~~~~~~~ -- `servers/audio/audio_stream.h ` +- `servers/audio/audio_stream.h ( https://github.com/godotengine/godot/blob/master/servers/audio/audio_stream.h )` Create an AudioStreamPlayback @@ -346,6 +346,6 @@ query AudioFrames and `get_stream_sampling_rate` to query current mix rate. References: ~~~~~~~~~~~ -- `core/math/audio_frame.h ` -- `servers/audio/audio_stream.h ` -- `scene/audio/audioplayer.cpp ` +- `core/math/audio_frame.h ( https://github.com/godotengine/godot/blob/master/core/math/audio_frame.h )` +- `servers/audio/audio_stream.h ( https://github.com/godotengine/godot/blob/master/servers/audio/audio_stream.h )` +- `scene/audio/audioplayer.cpp ( https://github.com/godotengine/godot/blob/master/scene/audio/audio_player.cpp )` diff --git a/development/cpp/custom_godot_servers.md b/development/cpp/custom_godot_servers.md index e84a4a3..e2ce774 100644 --- a/development/cpp/custom_godot_servers.md +++ b/development/cpp/custom_godot_servers.md @@ -18,9 +18,9 @@ data types. If not, refer to `doc_custom_modules_in_c++`. References ~~~~~~~~~~~ -- `Why does Godot use servers and RIDs? ` -- `Singleton pattern ` -- `Mediator pattern ` +- `Why does Godot use servers and RIDs? ( https://godotengine.org/article/why-does-godot-use-servers-and-rids )` +- `Singleton pattern ( https://en.wikipedia.org/wiki/Singleton_pattern )` +- `Mediator pattern ( https://en.wikipedia.org/wiki/Mediator_pattern )` What for? --------- @@ -274,7 +274,7 @@ Custom managed resource data ---------------------------- Godot servers implement a mediator pattern. All data types inherit `RID_Data`. -`RID_Owner` owns the object when `make_rid` is called. During debug mode only, +`RID_Owner` -- `core/rid.h ` +- `RID` +- `servers/register_server_types.cpp ( https://github.com/godotengine/godot/blob/master/servers/register_server_types.cpp )` Bind methods ~~~~~~~~~~~~ @@ -474,7 +474,7 @@ to execute the desired behavior. The queue will be flushed whenever either References: ~~~~~~~~~~~ -- `core/message_queue.cpp ` +- `core/message_queue.cpp ( https://github.com/godotengine/godot/blob/3.x/core/message_queue.cpp )` Summing it up ------------- @@ -505,5 +505,5 @@ Here is the GDScript sample code: Notes ~~~~~ -- The actual `Hilbert Hotel ` is impossible. +- The actual `Hilbert Hotel ( https://en.wikipedia.org/wiki/Hilbert%27s_paradox_of_the_Grand_Hotel )` is impossible. - Connecting signal example code is pretty hacky. diff --git a/development/cpp/custom_modules_in_cpp.md b/development/cpp/custom_modules_in_cpp.md index 80971f2..c2539e8 100644 --- a/development/cpp/custom_modules_in_cpp.md +++ b/development/cpp/custom_modules_in_cpp.md @@ -35,7 +35,7 @@ Creating a new module --------------------- Before creating a module, make sure to `download the source code of Godot -and compile it `. +and compile it ` pages + template. See the `Compiling `. + `Introduction to the buildsystem - Custom modules build option ` instead. + `GDNative `, -which will dump the engine API reference to the given `` in XML format. +We can do this via running Godot's doctool i.e. `godot --doctool `, +Note that if you don't have write access rights to your supplied `` -- `core/io/resource_loader.cpp `_ +- `ResourceLoader`_ +- `core/io/image_loader.h ( https://github.com/godotengine/godot/blob/master/core/io/image_loader.h )`_ Creating a ResourceFormatLoader @@ -302,9 +302,9 @@ calls into `std::istream`. References ~~~~~~~~~~ -- `istream `_ -- `streambuf `_ -- `core/io/fileaccess.h `_ +- `istream ( http://www.cplusplus.com/reference/istream/istream/ )`_ +- `streambuf ( http://www.cplusplus.com/reference/streambuf/streambuf/?kw=streambuf )`_ +- `core/io/fileaccess.h ( https://github.com/godotengine/godot/blob/master/core/os/file_access.h )`_ Registering the new file format ------------------------------- @@ -355,7 +355,7 @@ when `load` is called. References ~~~~~~~~~~ -- `core/io/resource_loader.cpp `_ +- `core/io/resource_loader.cpp ( https://github.com/godotengine/godot/blob/master/core/io/resource_loader.cpp )`_ Loading it on GDScript ---------------------- diff --git a/development/cpp/inheritance_class_tree.md b/development/cpp/inheritance_class_tree.md index cb90416..5915d21 100644 --- a/development/cpp/inheritance_class_tree.md +++ b/development/cpp/inheritance_class_tree.md @@ -26,4 +26,4 @@ Spatial ![](img/Spatial.png) -Source files: :download:`tree.zip `. +Source files: :download:`tree.zip ` +- `core/object.h ( https://github.com/godotengine/godot/blob/3.x/core/object.h )` Registering an Object --------------------- @@ -93,7 +93,7 @@ string passing the name can be passed for brevity. References: ~~~~~~~~~~~ -- `core/class_db.h ` +- `core/class_db.h ( https://github.com/godotengine/godot/blob/3.x/core/class_db.h )` Constants --------- @@ -265,7 +265,7 @@ templates point to it. References: ~~~~~~~~~~~ -- `core/reference.h ` +- `core/reference.h ( https://github.com/godotengine/godot/blob/3.x/core/reference.h )` Resources: ---------- @@ -281,7 +281,7 @@ Resources without a path are fine too. References: ~~~~~~~~~~~ -- `core/resource.h ` +- `core/resource.h ( https://github.com/godotengine/godot/blob/3.x/core/resource.h )` Resource loading ---------------- @@ -302,7 +302,7 @@ the same time. References: ~~~~~~~~~~~ -- `core/io/resource_loader.h ` +- `core/io/resource_loader.h ( https://github.com/godotengine/godot/blob/3.x/core/io/resource_loader.h )` Resource saving --------------- @@ -321,4 +321,4 @@ be bundled with the saved resource and assigned sub-IDs, like References: ~~~~~~~~~~~ -- `core/io/resource_saver.h ` +- `core/io/resource_saver.h ( https://github.com/godotengine/godot/blob/3.x/core/io/resource_saver.h )` diff --git a/development/cpp/using_cpp_profilers.md b/development/cpp/using_cpp_profilers.md index 7cafeb6..5fd34d3 100644 --- a/development/cpp/using_cpp_profilers.md +++ b/development/cpp/using_cpp_profilers.md @@ -15,9 +15,9 @@ To this end, profilers are useful tools. Recommended profilers --------------------- -- `VerySleepy ` (Windows only) -- `HotSpot ` (Linux only) -- `Xcode Instruments ` (macOS only) +- `VerySleepy ( http://www.codersnotes.com/sleepy/ )` (Windows only) +- `HotSpot ( https://github.com/KDAB/hotspot )` (Linux only) +- `Xcode Instruments ( https://developer.apple.com/xcode/ )` (macOS only) These profilers may not be the most powerful or flexible options, but their standalone operation and limited feature set tends to make them easier to use. @@ -53,7 +53,7 @@ If you're looking into optimizing Godot's startup/shutdown performance, you can tell the profiler to use the `--quit` command line option on the Godot binary. This will exit Godot just after it finished starting. The `--quit` option works with `--editor`, `--project-manager` or -`--path ` (which runs a project directly). +`--path ` +- `core/variant.h ( https://github.com/godotengine/godot/blob/3.x/core/variant.h )` Containers: Dictionary and Array -------------------------------- @@ -56,5 +56,5 @@ Copy-on-write (COW) mode support for containers was dropped with Godot 3.0. References: ~~~~~~~~~~~ -- `core/dictionary.h ` -- `core/array.h ` +- `core/dictionary.h ( https://github.com/godotengine/godot/blob/3.x/core/dictionary.h )` +- `core/array.h ( https://github.com/godotengine/godot/blob/3.x/core/array.h )` diff --git a/development/editor/creating_icons.md b/development/editor/creating_icons.md index 6dfdf6f..2391cca 100644 --- a/development/editor/creating_icons.md +++ b/development/editor/creating_icons.md @@ -12,7 +12,7 @@ Creating icons ~~~~~~~~~~~~~~ To create new icons, you first need a vector graphics editor installed. -For instance, you can use the open source `Inkscape `_ editor. +For instance, you can use the open source `Inkscape ( https://inkscape.org/ )`_ editor. Clone the `godot` repository containing all the editor icons: @@ -38,7 +38,7 @@ Color conversion for light editor themes If the user has configured their editor to use a light theme, Godot will convert the icon's colors based on a -`set of predefined color mappings `. +`set of predefined color mappings ( https://github.com/godotengine/godot/blob/b9f2e57d6240346f1833fd0390de195c956299e7/editor/editor_themes.cpp#L122-L184 )`. This is to ensure the icon always displays with a sufficient contrast rate. Try to restrict your icon's color palette to colors found in the list above. Otherwise, your icon may become difficult to read on a light background. @@ -50,9 +50,9 @@ Because the editor renders SVGs once at load time, they need to be small in size so they can be efficiently parsed. Editor icons must be first optimized before being added to the engine, to do so: -1. Install `svgcleaner ` +1. Install `svgcleaner ( https://github.com/RazrFalcon/svgcleaner )` by downloading a binary from its - `Releases tab ` + `Releases tab ( https://github.com/RazrFalcon/svgcleaner/releases/latest )` and placing it into a location in your `PATH` environment variable. 2. Run the command below, replacing `svg_source.svg` with the path to your @@ -86,7 +86,7 @@ make a separate pull request for your icons to be available within the editor as they can be self-contained. For specific instructions on how to create module icons, refer to -`Creating custom module icons`. +`Creating custom module icons` +- `editor/icons ( https://github.com/godotengine/godot/tree/master/editor/icons )` diff --git a/development/editor/introduction_to_editor_development.md b/development/editor/introduction_to_editor_development.md index accd87a..04ac438 100644 --- a/development/editor/introduction_to_editor_development.md +++ b/development/editor/introduction_to_editor_development.md @@ -22,7 +22,7 @@ Technical choices ----------------- The Godot editor is drawn using Godot's renderer and -`UI system `. It does *not* rely on a toolkit +`UI system ` folder +`editor/ ( https://github.com/godotengine/godot/tree/master/editor )` folder of the Godot source repository. Some editor functionality is also implemented via -`modules `. Some of these are only enabled in +`modules ` folder +`modules/ ( https://github.com/godotengine/godot/tree/master/modules )` folder in the Godot source repository. Some important files in the editor are: -- `editor/editor_node.cpp `: +- `editor/editor_node.cpp ( https://github.com/godotengine/godot/blob/3.x/editor/editor_node.cpp )`: Main editor initialization file. Effectively the "main scene" of the editor. -- `editor/project_manager.cpp `: +- `editor/project_manager.cpp ( https://github.com/godotengine/godot/blob/3.x/editor/project_manager.cpp )`: Main project manager initialization file. Effectively the "main scene" of the project manager. -- `editor/plugins/canvas_item_editor_plugin.cpp `: +- `editor/plugins/canvas_item_editor_plugin.cpp ( https://github.com/godotengine/godot/blob/3.x/editor/plugins/canvas_item_editor_plugin.cpp )`: The 2D editor viewport and related functionality (toolbar at the top, editing modes, overlaid helpers/panels, …). -- `editor/plugins/spatial_editor_plugin.cpp `: +- `editor/plugins/spatial_editor_plugin.cpp ( https://github.com/godotengine/godot/blob/3.x/editor/plugins/spatial_editor_plugin.cpp )`: The 3D editor viewport and related functionality (toolbar at the top, editing modes, overlaid panels, …). -- `editor/spatial_editor_gizmos.cpp `: +- `editor/spatial_editor_gizmos.cpp ( https://github.com/godotengine/godot/blob/3.x/editor/spatial_editor_gizmos.cpp )`: Where the 3D editor gizmos are defined and drawn. This file doesn't have a 2D counterpart as 2D gizmos are drawn by the nodes themselves. @@ -77,12 +77,12 @@ from `servers/` and `core/`, it cannot depend on includes from `editor/`. Currently, there are some dependencies to `editor/` includes in `scene/` files, but -`they are in the process of being removed `. +`they are in the process of being removed ( https://github.com/godotengine/godot/issues/29730 )`. Development tips ---------------- To iterate quickly on the editor, we recommend to set up a test project and -`open it from the command line ` after compiling +`open it from the command line `_ +`resource_format_text.cpp ( https://github.com/godotengine/godot/blob/master/scene/resources/resource_format_text.cpp )`_ in the `ResourceFormatLoaderText` class. File structure diff --git a/getting_started/first_2d_game/01.project_setup.md b/getting_started/first_2d_game/01.project_setup.md index d9d1200..808c131 100644 --- a/getting_started/first_2d_game/01.project_setup.md +++ b/getting_started/first_2d_game/01.project_setup.md @@ -12,7 +12,7 @@ Launch Godot and create a new project. GDScript ``` - Download :download:`dodge_assets.zip `. + Download :download:`dodge_assets.zip ` node to the scene. +` node as a child. The `AnimatedSprite` will handle the +` resource, which is a list of the animations it can + "New SpriteFrames". Click again to open the "SpriteFrames" panel: diff --git a/getting_started/first_2d_game/06.heads_up_display.md b/getting_started/first_2d_game/06.heads_up_display.md index 5e82f41..b6e597f 100644 --- a/getting_started/first_2d_game/06.heads_up_display.md +++ b/getting_started/first_2d_game/06.heads_up_display.md @@ -22,7 +22,7 @@ The HUD needs to display the following information: The basic node for UI elements is `Control`. To create our UI, we'll use two types of `Control` nodes: `Label -` and `Button`. +`. +`Getting Started `. +( https://github.com/godotengine/godot-demo-projects )`. We prepared some game assets you'll need to download so we can jump straight to the code. You can download them by clicking the link below. -:download:`dodge_assets.zip `. +:download:`dodge_assets.zip `. +( https://github.com/GDQuest/godot-3d-dodge-the-creeps/releases/tag/1.0.0 )`. Once you downloaded it, extract the .zip archive on your computer. Open the Godot project manager and click the *Import* button. diff --git a/getting_started/first_3d_game/02.player_input.md b/getting_started/first_3d_game/02.player_input.md index 18a4f8d..506d01a 100644 --- a/getting_started/first_3d_game/02.player_input.md +++ b/getting_started/first_3d_game/02.player_input.md @@ -45,7 +45,7 @@ This should instantiate the model as a child of *Pivot*. You can rename it to The `.glb` files contain 3D scene data based on the open-source GLTF 2.0 specification. They're a modern and powerful alternative to a proprietary format like FBX, which Godot also supports. To produce these files, we designed the - model in `Blender 3D ` and exported it to GLTF. + model in `Blender 3D ( https://www.blender.org/ )` and exported it to GLTF. As with all kinds of physics nodes, we need a collision shape for our character to collide with the environment. Select the *Player* node again and add a diff --git a/getting_started/first_3d_game/06.jump_and_squash.md b/getting_started/first_3d_game/06.jump_and_squash.md index c039baf..39682d7 100644 --- a/getting_started/first_3d_game/06.jump_and_squash.md +++ b/getting_started/first_3d_game/06.jump_and_squash.md @@ -8,7 +8,7 @@ lesson, we'll make the player die when a monster hits them on the ground. First, we have to change a few settings related to physics interactions. Enter the world of `physics layers -`. +` tagging feature. +` class and are related to +the `KinematicBody` object that holds +`KinematicCollision`. + The method `is_in_group()` is available on every `Node 0.1`. The collision normal is a 3D vector diff --git a/getting_started/first_3d_game/08.score_and_replay.md b/getting_started/first_3d_game/08.score_and_replay.md index 077311c..5daea02 100644 --- a/getting_started/first_3d_game/08.score_and_replay.md +++ b/getting_started/first_3d_game/08.score_and_replay.md @@ -262,14 +262,14 @@ gdscript GDScript ``` The function `get_tree()` gives us access to the global `SceneTree -` object, which allows us to reload and restart the current +`. +another feature in Godot: `autoloads `_. +`( https://github.com/GDQuest/godot-3d-dodge-the-creeps )`_. Exploring the manual -------------------- @@ -29,11 +29,11 @@ information about 2D, 3D, physics, rendering and performance, and much more. Here are the sections we recommend you to explore next: -1. Read the `Scripting section ` to learn essential programming features you’ll use +1. Read the `Scripting section ` and `Physics ` sections will teach you more about 3D game creation in the +2. The `3D ` is another important one for any game project. +3. `Inputs `. +( https://github.com/GDQuest/godot-3d-dodge-the-creeps/ )`. .. note:: @@ -42,7 +42,7 @@ source code here: `Squash the Creep source code We prepared some game assets so we can jump straight to the code. You can download them here: `Squash the Creeps assets -`. +( https://github.com/GDQuest/godot-3d-dodge-the-creeps/releases/tag/1.1.0 )`. We will first work on a basic prototype for the player's movement. We will then add the monsters that we'll spawn randomly around the screen. After that, we'll diff --git a/getting_started/introduction/first_look_at_the_editor.md b/getting_started/introduction/first_look_at_the_editor.md index a4d86d1..6850d07 100644 --- a/getting_started/introduction/first_look_at_the_editor.md +++ b/getting_started/introduction/first_look_at_the_editor.md @@ -13,7 +13,7 @@ This page will give you a brief overview of Godot's interface. We're going to look at the different main screens and docks to help you situate yourself. .. seealso:: For a comprehensive breakdown of the editor's interface and how to - use it, see the `Editor manual `. + use it, see the `Editor manual `_ +`Godot explained in 5 minutes ( https://www.youtube.com/watch?v=KjX5llYZ5eQ )`_ if you're looking for an overview of the engine's features. Object-oriented design and composition @@ -77,7 +77,7 @@ the ability to hot-reload locally and on remote devices, etc. The goal is to offer a full package to create games and a continuous user experience. You can still work with external programs as long as there is an import plugin for it. Or you can create one, like the `Tiled -Map Importer `. +Map Importer ( https://github.com/vnen/godot-tiled-importer )`. That is also partly why Godot offers its own programming languages GDScript and VisualScript, along with C#. They're designed for the needs @@ -111,12 +111,12 @@ manage states and transitions visually.* .. warning:: - `Godot 4.0 will remove VisualScript from core entirely. ` + `Godot 4.0 will remove VisualScript from core entirely. ( https://godotengine.org/article/godot-4-will-discontinue-visual-scripting )` As a result, creating new projects using visual scripting in Godot is not recommended. Future Godot 4.x releases may have VisualScript reimplemented as an extension. While Godot 3.x will keep VisualScript supported, we recommend - `trying out GDScript ` instead, + `trying out GDScript `, a +You can code your games using `GDScript `, which is popular in the games industry. +`C# `. +`VisualScript ` technology, you can also write +With the `GDNative `. + Search or press ![](img/manual_class_reference_search.png) -To browse it online, head to the manual's `Class Reference ` +To browse it online, head to the manual's `Class Reference `_ GitHub repository + ( https://github.com/godotengine/godot-docs/issues )`_ GitHub repository to report it. You can Ctrl-click any underlined text like the name of a class, property, @@ -67,14 +67,14 @@ beyond the scope of Godot's documentation. If you're new to programming, we recommend two excellent free resources to get you started: 1. Harvard university offers a free courseware to learn to program, `CS50 - `_. It will teach you programming + ( https://cs50.harvard.edu/x/ )`_. It will teach you programming fundamentals, how code works, and how to think like a programmer. These skills are essential to become a game developer and learn any game engine efficiently. You can see this course as an investment that will save you time and trouble when you learn to create games. 2. If you prefer books, check out the free ebook `Automate The Boring Stuff With - Python `_ by Al Sweigart. + Python ( https://automatetheboringstuff.com/ )`_ by Al Sweigart. Learning with the community --------------------------- @@ -82,10 +82,10 @@ Learning with the community Godot has a growing community of users. If you're stuck on a problem or need help to better understand how to achieve something, you can ask other users for help on one of the many `active -communities `_. +communities ( https://godotengine.org/community )`_. The best place to ask for questions and find already answered ones is the -official `Questions & Answers `_ site. These +official `Questions & Answers ( https://godotengine.org/qa/ )`_ site. These responses show up in search engine results and get saved, allowing other users to benefit from discussions on the platform. Once you asked a question there, you can share its link on other social platforms. Before asking a question, be @@ -109,7 +109,7 @@ information: 3. If there is code involved, **share a code sample**. Other users won't be able to help you fix a problem without seeing your code. Share the code as text directly. To do so, you can copy and paste a short code snippet in a chat - box, or use a website like `Pastebin `_ to share long + box, or use a website like `Pastebin ( https://pastebin.com/ )`_ to share long files. 4. **Share a screenshot** of your *Scene* dock along with your written code. Most of @@ -123,15 +123,15 @@ information: should have a built-in tool to take screenshots with the :kbd:`PrtSc` (Print Screen) key. - Alternatively, you can use a program like `ShareX `_ - on Windows or `FlameShot `_ on Linux. + Alternatively, you can use a program like `ShareX ( https://getsharex.com/ )`_ + on Windows or `FlameShot ( https://flameshot.org/ )`_ on Linux. 5. Sharing a video of your running game can also be really **useful to troubleshoot your game**. You can use programs like `OBS Studio - `_ and `Screen to GIF - `_ to capture your screen. + ( https://obsproject.com/ )`_ and `Screen to GIF + ( https://www.screentogif.com/ )`_ to capture your screen. - You can then use a service like `streamable `_ or a + You can then use a service like `streamable ( https://streamable.com/ )`_ or a cloud provider to upload and share your videos for free. 6. If you're not using the stable version of Godot, please mention the version diff --git a/getting_started/step_by_step/index.md b/getting_started/step_by_step/index.md index 760e857..1beae56 100644 --- a/getting_started/step_by_step/index.md +++ b/getting_started/step_by_step/index.md @@ -2,7 +2,7 @@ Step by step ============ This series builds upon the `Introduction to Godot -` and will get you started with the editor and the +` node as its root named Ball, which allows the ball to fall +`. +:download:`instancing.zip `, we assume you have programming foundations. +`. + the `GDScript reference` page. +.. seealso:: To learn more about C#, head to the `C# basics `, +`community-supported languages ` + `Godot 4.0 will remove VisualScript from core entirely. ( https://godotengine.org/article/godot-4-will-discontinue-visual-scripting )` As a result, creating new projects using visual scripting in Godot is not recommended. Future Godot 4.x releases may have VisualScript reimplemented as an extension. While Godot 3.x will keep VisualScript supported, we recommend - `trying out GDScript ` instead, + `trying out GDScript `_ or Visual Studio. While C# support is +`VSCode ( https://code.visualstudio.com/ )`_ or Visual Studio. While C# support is now mature, you will find fewer learning resources for it compared to GDScript. That's why we recommend C# mainly to users who already have experience with the language. @@ -68,9 +68,9 @@ Let's look at each language's features, as well as its pros and cons. GDScript ~~~~~~~~ -`GDScript` is an -`object-oriented `_ and -`imperative `_ +`GDScript`_, as + ( https://en.wikipedia.org/wiki/Garbage_collection_(computer_science) )`_, as this feature eventually gets in the way when creating games. The engine counts references and manages the memory for you in most cases by default, but you can also control memory if you need to. -- `Gradual typing `_. Variables +- `Gradual typing ( https://en.wikipedia.org/wiki/Gradual_typing )`_. Variables have dynamic types by default, but you also can use type hints for strong type checks. @@ -111,7 +111,7 @@ languages, including Squirrel, Lua, and Python. ~~~~~~~~~ As Microsoft's `C# -`_ is a favorite +( https://en.wikipedia.org/wiki/C_Sharp_(programming_language) )`_ is a favorite amongst game developers, we officially support it. C# is a mature and flexible language with tons of libraries written for it. We could add support for it thanks to a generous donation from Microsoft. @@ -123,9 +123,9 @@ should be aware of its garbage collector. .. note:: You must use the Mono edition of the Godot editor to script in C#. You can download it on the Godot website's `download - `_ page. + ( https://godotengine.org/download/ )`_ page. -Since Godot uses the `Mono `_ .NET runtime, in theory, +Since Godot uses the `Mono ( https://mono-project.com )`_ .NET runtime, in theory, you can use any third-party .NET library or framework in Godot, as well as any Common Language Infrastructure-compliant programming language, such as F#, Boo, or ClojureCLR. However, C# is the only officially supported .NET option. @@ -141,15 +141,15 @@ VisualScript .. warning:: - `Godot 4.0 will remove VisualScript from core entirely. ` + `Godot 4.0 will remove VisualScript from core entirely. ( https://godotengine.org/article/godot-4-will-discontinue-visual-scripting )` As a result, creating new projects using visual scripting in Godot is not recommended. Future Godot 4.x releases may have VisualScript reimplemented as an extension. While Godot 3.x will keep VisualScript supported, we recommend - `trying out GDScript ` instead, + `trying out GDScript ` is a graph-based visual +`Visual Scripting`. + `Getting started with VisualScript `_ and keeps your +( https://en.wikipedia.org/wiki/Coupling_(computer_programming) )`_ and keeps your code flexible. For example, you might have a life bar on the screen that represents the @@ -142,7 +142,7 @@ node's motion. Our Sprite moves thanks to code in the `_process()` function. Godot provides a method to toggle processing on and off: `Node.set_process() -`. Another method of the Node class, +`_. + `Have a look here ( https://docs.godotengine.org/en/latest )`_. You can also browse the documentation for the current stable - `3.4 `_ branch. + `3.4 ( https://docs.godotengine.org/en/3.4 )`_ branch. .. only:: i18n .. note:: This documentation is translated from the `original English one - `_ by community members - on `Weblate `_. + ( https://docs.godotengine.org/en/latest )`_ by community members + on `Weblate ( https://hosted.weblate.org/projects/godot-engine/godot-docs )`_. Depending on the translation effort's completion level, you may find paragraphs or whole pages which are still in English. You can @@ -28,17 +28,17 @@ Godot Docs – *3.5* branch the "latest" (development) branch, but should be suitable to learn how to use stable Godot releases nevertheless. -Welcome to the official documentation of `Godot Engine `, +Welcome to the official documentation of `Godot Engine ( https://godotengine.org )`, the free and open source community-driven 2D and 3D game engine! If you are new to this documentation, we recommend that you read the -`introduction page ` to get an overview of what this +`introduction page ` +You can also `download an HTML copy ( https://nightly.link/godotengine/godot-docs/workflows/build_offline_docs/master/godot-docs-html-stable.zip )` for offline reading (updated every Monday). Extract the ZIP archive then open the top-level `index.html` in a web browser. @@ -50,12 +50,12 @@ the top-level `index.html` in a web browser. by letting us know! Submit an issue or pull request on the `GitHub repository - `_, + ( https://github.com/godotengine/godot-docs/issues )`_, help us `translate the documentation - `_ into your + ( https://hosted.weblate.org/engage/godot-engine/ )`_ into your language, or talk to us on the `#documentation` channel on the `Godot Contributors Chat - `_! + ( https://chat.godotengine.org/ )`_! .. centered:: |weblate_widget| diff --git a/tutorials/2d/2d_lights_and_shadows.md b/tutorials/2d/2d_lights_and_shadows.md index 6a81bbd..63835e8 100644 --- a/tutorials/2d/2d_lights_and_shadows.md +++ b/tutorials/2d/2d_lights_and_shadows.md @@ -7,13 +7,13 @@ Introduction ------------ This tutorial explains how the 2D lighting works in the -`lights and shadows `_ demo project. +`lights and shadows ( https://github.com/godotengine/godot-demo-projects/tree/master/2d/lights_and_shadows )`_ demo project. It begins with a brief description of the resources used in the final demo and then describes how to make a scene like the demo step by step. ![](img/light_shadow_main.png) -All the resources for this tutorial can be found in the `official demo repository `_ +All the resources for this tutorial can be found in the `official demo repository ( https://github.com/godotengine/godot-demo-projects )`_ on GitHub. I suggest you download it before starting. Alternatively, it can be downloaded from the Project Manager. Launch Godot and in the top bar select "Templates" and search for "2D Lights and Shadows Demo". @@ -25,19 +25,19 @@ For this demo we use four textures: two for the lights, one for the shadow caste and one for the background. I've included links to them all here if you want to download them separately from the demo. -The first is the background image (`background.png) `_) +The first is the background image (`background.png) ( https://raw.githubusercontent.com/godotengine/godot-demo-projects/master/2d/lights_and_shadows/background.png) )`_) used in the demo. You do not necessarily need a background, but we use one for the demo. -The second is a plain black image (`caster.png) `_) +The second is a plain black image (`caster.png) ( https://raw.githubusercontent.com/godotengine/godot-demo-projects/master/2d/lights_and_shadows/caster.png) )`_) to use as our shadow caster object. For a top down game this could be a wall or any other object that casts a shadow. -Next is the light itself (`light.png) `_). +Next is the light itself (`light.png) ( https://raw.githubusercontent.com/godotengine/godot-demo-projects/master/2d/lights_and_shadows/light.png) )`_). If you click the link you will notice how large it is. The image you use for a light should cover the area you want your light to cover. This image is 1024x1024 pixels, so you should use it to cover 1024x1024 pixels in your game. -Lastly, we have the spotlight image (`spot.png) `_). +Lastly, we have the spotlight image (`spot.png) ( https://raw.githubusercontent.com/godotengine/godot-demo-projects/master/2d/lights_and_shadows/spot.png) )`_). The demo uses a blob to show where the light is and the larger light image to show the effect of the light upon the rest of the scene. @@ -51,7 +51,7 @@ The demo uses four different nodes: * `Light2D` * `LightOccluder2D` -`CanvasModulate` is used to darken the scene. +`CanvasModulate`_ and nothing else. The child `LightOccluder2D` is where all the magic happens. In a +set to the `caster image ( https://raw.githubusercontent.com/godotengine/godot-demo-projects/master/2d/lights_and_shadows/caster.png) )`_ and nothing else. The child `LightOccluder2D` is where all the magic happens. In a game the `Sprite` could be more than a black box; it could be an image of whatever object is casting the shadow: a wall, a magical chest, or anything else. @@ -194,7 +194,7 @@ section set `Enable` to `on`. This turns on shadows with hard edges like in the ![](img/light_shadow_filter0_pcf0.png) To give the shadows that nice, soft edge look we set the variables `filter`, `filter smooth`, and -`gradient length`. Godot supports `Percentage Closer Filtering `_ +`gradient length`. Godot supports `Percentage Closer Filtering ( https://developer.nvidia.com/gpugems/GPUGems/gpugems_ch11.html )`_ (PCF), which takes multiple samples of the shadow map around a pixel and blurs them to create a smooth shadow effect. The higher the number of samples the smoother the shadow will look, but the slower it will run. That is why Godot provides 3-13 samples by default and allows you to choose. diff --git a/tutorials/2d/2d_movement.md b/tutorials/2d/2d_movement.md index 33fb510..ed32b83 100644 --- a/tutorials/2d/2d_movement.md +++ b/tutorials/2d/2d_movement.md @@ -23,7 +23,7 @@ children: `Sprite` and `CollisionShape2D`. You can use the Godot icon ("icon.png for the Sprite's texture or use any other 2D image you have. Open `Project -> Project Settings` and select the "Input Map" tab. Add the following -input actions (see `InputEvent ` for details): +input actions (see `InputEvent ` +:download:`2D_movement_demo.zip ` +:download:`run_animation.zip ` for more + `Physics Introduction ` for more + `Physics Introduction ` node can be used. +` +Godot offers method parameters in `draw_line`. +`draw_polygon` +`Antialiased Line2D add-on ( https://github.com/godot-extended-libraries/godot-antialiased-line2d )` (which also supports antialiased Polygon2D drawing). Note that this add-on relies on high-level nodes, rather than low-level `_draw()` functions. diff --git a/tutorials/2d/using_tilemaps.md b/tutorials/2d/using_tilemaps.md index a6d9bce..344ef9e 100644 --- a/tutorials/2d/using_tilemaps.md +++ b/tutorials/2d/using_tilemaps.md @@ -21,7 +21,7 @@ Project setup ------------- This demo will use the following tiles taken from Kenney's "Abstract Platformer" -art pack. You can find the complete set `here `_ +art pack. You can find the complete set `here ( https://kenney.nl/assets/abstract-platformer )`_ but for this demo we'll stick to this small set. ![](img/tilesheet.png) diff --git a/tutorials/3d/3d_rendering_limitations.md b/tutorials/3d/3d_rendering_limitations.md index 512c718..686460e 100644 --- a/tutorials/3d/3d_rendering_limitations.md +++ b/tutorials/3d/3d_rendering_limitations.md @@ -21,7 +21,7 @@ Texture size limits On desktops and laptops, textures larger than 8192×8192 may not be supported on older devices. You can check your target GPU's limitations on -`GPUinfo.org `. +`GPUinfo.org ( https://www.gpuinfo.org/ )`. Mobile GPUs are typically limited to 4096×4096 textures. Also, some mobile GPUs don't support repeating non-power-of-two-sized textures. Therefore, if you want @@ -46,13 +46,13 @@ There are two main ways to alleviate banding: It also requires HDR to be enabled in the Project Settings (which is the default). - Alternatively, bake some noise into your textures. This is mainly effective in 2D, e.g. for vignetting effects. In 3D, you can also use a - `custom debanding shader ` + `custom debanding shader ( https://github.com/fractilegames/godot-gles2-debanding-material )` to be applied on your *materials*. This technique works even if your project is rendered in LDR, which means it will work when using the GLES2 renderer. .. seealso:: - See `Banding in Games: A Noisy Rant ` + See `Banding in Games: A Noisy Rant ( http://loopit.dk/banding_in_games.pdf )` for more details about banding and ways to combat it. Depth buffer precision diff --git a/tutorials/3d/3d_text.md b/tutorials/3d/3d_text.md index d6fe933..4e957e3 100644 --- a/tutorials/3d/3d_text.md +++ b/tutorials/3d/3d_text.md @@ -12,7 +12,7 @@ methods to do this. The Label3D node and the text mesh for a MeshInstance node. This page does **not** cover how to display a GUI scene in a 3D -environment. For information on how to do that see `this ` +environment. For information on how to do that see `this ( https://github.com/godotengine/godot-demo-projects/tree/master/viewport/2d_in_3d )` demo project. Label3D @@ -30,7 +30,7 @@ up and shaded by light sources if the shaded flag is enabled, but it will not cast a shadow, even with cast shadow turned on under the nodes GeometryInstance3D settings. This is because the node is a quad mesh (one glyph per quad) with transparent textures and has the same limitations -as Sprite3D. See `this page ` +as Sprite3D. See `this page `'s Propagation property. +- **Propagation:** Similar to `GIProbe ` + you may want to use `Qodot ( https://github.com/Shfty/qodot-plugin )` instead. It lets you design levels using - `TrenchBroom ` and import + `TrenchBroom ( https://kristianduske.com/trenchbroom/ )` and import them in Godot. ![](img/csg.gif) @@ -204,7 +204,7 @@ another CSGCylinder and adjust the dimensions to use it as a pole. ![](img/csg_lamp_pole_stand.png) We will use a CSGPolygon for the lampshade. Use the **Spin** mode for the -CSGPolygon and draw a `trapezoid `_ +CSGPolygon and draw a `trapezoid ( https://en.wikipedia.org/wiki/Trapezoid )`_ while in **Front View** (numeric keypad 1); this shape will extrude around the origin and form the lampshade. @@ -257,7 +257,7 @@ usage to organic surfaces like terrain. Still, when prototyping, it can be used to quickly apply textures to CSG-based levels. .. note:: If you need some textures for prototyping, Kenney made a - `set of CC0-licensed prototype textures `. + `set of CC0-licensed prototype textures ( https://kenney.nl/assets/prototype-textures )`. There are two ways to apply a material to a CSG node: diff --git a/tutorials/3d/introduction_to_3d.md b/tutorials/3d/introduction_to_3d.md index 7c55351..5eb2e18 100644 --- a/tutorials/3d/introduction_to_3d.md +++ b/tutorials/3d/introduction_to_3d.md @@ -125,7 +125,7 @@ similar to other tools in the Editor Settings: Coordinate system ----------------- -Godot uses the `metric ` +Godot uses the `metric ( https://en.wikipedia.org/wiki/Metric_system )` system for everything in 3D, with 1 unit being equal to 1 meter. Physics and other areas are tuned for this scale. Therefore, attempting to use a different scale is usually a bad idea (unless you know what you are doing). diff --git a/tutorials/3d/portals/advanced_room_and_portal_usage.md b/tutorials/3d/portals/advanced_room_and_portal_usage.md index 40ebb78..9b997e2 100644 --- a/tutorials/3d/portals/advanced_room_and_portal_usage.md +++ b/tutorials/3d/portals/advanced_room_and_portal_usage.md @@ -17,7 +17,7 @@ This works because if a monster is in an area that is completely out of view for How does a monster know whether it is within the gameplay area? ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -This problem is solved because the portal system contains a subsystem called the **Gameplay Monitor** that can be turned on and off from the `RoomManager`. When switched on, any roaming objects that move inside or outside the gameplay area (whether by moving themselves, or the camera moving) will receive callbacks to let them know of this change. +This problem is solved because the portal system contains a subsystem called the **Gameplay Monitor** that can be turned on and off from the `RoomManager` node, and its slightly easier to use variation, the `VisibilityEnabler` node. VisibilityEnabler can be used to switch off animation and sleep physics when an object is outside the view frustum. You do this by simply placing a VisibilityEnabler node in your subscene (for e.g. a monster). It will do the rest. Consult the `VisibilityEnabler` documentation for full details. +The engine's solution to this problem is the `VisibilityNotifier` is a special node which allows you to deal with a group of rooms at once, instead of having write code for them individually. This is especially useful in conjunction with gameplay callbacks. The most important use for RoomGroups is to delineate between "inside" and "outside" areas. +A `RoomGroup` to represent the sun. When the outside RoomGroup receives an `enter gameplay` callback, you can turn the light on, and you can turn it off when the RoomGroup exits gameplay. With the light off, performance will increase as there is no need to render it indoors. +For instance, when outside you may wish to use a `DirectionalLight`_ +*Scene is 'Diorama Eco scene' by Odo, with slight changes for illustration purposes.* `CC Attribution ( https://creativecommons.org/licenses/by/4.0/ )`_ Internal room scenes ^^^^^^^^^^^^^^^^^^^^ diff --git a/tutorials/3d/portals/editing_rooms_and_portals.md b/tutorials/3d/portals/editing_rooms_and_portals.md index ac8f159..a3b1bf4 100644 --- a/tutorials/3d/portals/editing_rooms_and_portals.md +++ b/tutorials/3d/portals/editing_rooms_and_portals.md @@ -8,9 +8,9 @@ Putting all the ideas together, here is an example scene tree: ![](img/example_scenetree.png) -- We have used a `RoomGroup` to denote an outside area. -- The `MeshInstance`\ s inside the `Room`\ s are either `STATIC` or `DYNAMIC`. -- We have created a `Spatial` (I decided to call it 'Freeform', but you could use any name) under which to place `STATIC` and `DYNAMIC` objects that will be autoplaced in rooms +- We have used a `RoomGroup`. -- `-roomgroup` becomes a `RoomGroup`. -- `-portal` becomes a `Portal`. +- `-room` becomes a `Room` node, the snapping to the portal plane is enforced, and the vertices are specified (and editable) as 2D coordinates in the inspector, rather than 3D points. +Portal meshes have some restrictions to work properly. They must be convex, and the polygon points should be in the same plane. The accuracy to the plane does not have to be exact, as Godot will automatically average the direction of the portal plane. Once converted to a `Portal`. The RoomManager is responsible for the runtime maintenance of the system, especially converting the objects in your rooms into a *room graph* which is used at runtime to perform occlusion culling and other tasks. +Anytime you want to use the portal system, you need to include a special node in your scene tree, called the `RoomManager`\ s are a way of spatially partitioning your level into areas that make sense in terms of level design. Rooms often quite literally *are* rooms (like in a building). Ultimately though, as far as the engine is concerned, a room represents a **non-overlapping** convex volume in which you typically place most of your objects that fall within that area. +`Room`. You do not have to worry about these to start with. +There is one exception, however, for `internal rooms` is a node type that can be added to the scene tree like any other. You can place objects within the room by making them children and grand-children of the Room node. +A `Room`\ s are special convex polygons that you position over the openings between rooms in order to allow the system to see between them. You can create a portal node directly in the editor. The default portal has 4 points and behaves much like a `plane` `MeshInstance`. You can add or remove points using the inspector. A portal requires at least 3 points to work - this is because it needs to form a polygon rather than a point or line. +`Portal` s (*aka cells*), and `Portal` s. Portals are openings between the rooms that the `Camera` (and lights) can see through. +The rooms and portals system is an optional component of Godot that allows you to partition your 3D game levels into a series of `Room`. They do not warp space, they simply represent a window that the camera (or lights) can see through. +.. note:: Godot portals should not be confused with those in the `game of the same name ( https://en.wikipedia.org/wiki/Portal_(video_game) )`. They do not warp space, they simply represent a window that the camera (or lights) can see through. Minimizing manual labour ^^^^^^^^^^^^^^^^^^^^^^^^ diff --git a/tutorials/3d/portals/rooms_and_portals_example.md b/tutorials/3d/portals/rooms_and_portals_example.md index 2238beb..afe677c 100644 --- a/tutorials/3d/portals/rooms_and_portals_example.md +++ b/tutorials/3d/portals/rooms_and_portals_example.md @@ -2,7 +2,7 @@ Rooms and Portals example ========================= Download this tutorial project: -`Simple Portals Example `_ +`Simple Portals Example ( https://github.com/lawnjelly/godot-demo-projects/tree/portals_simple_demo/3d/portals/room_and_portals_simple_example )`_ . Introduction @@ -16,13 +16,13 @@ Step 1 ![](tutorial_simple/img/tutorial_simple_1.png) - Create a new project. -- Add a `Spatial` as the scene root (on the screenshot, it's called "Root"). -- Next add a `RoomManager` node. We will need this later to process the room system. +- Add a `Spatial` node as a child of the roomlist. +- Add a new `Room` for the floor. Create a box by adding a CubeMesh resource to the MeshInstance. Scale and position it to form a floor. +- Create a `MeshInstance` in the kitchen. +- Create a new `Portal` so it will be autoplaced in one of the rooms. +- Let's also create an `OmniLight`\ s) are treated in the same way by the engine. The portal renderer is slightly different, in that it makes a distinction between the different roles objects will have in your game. It makes this distinction to define the `Room`\ s, and to render and process everything in the most efficient way. +Normally, when you use Godot, all objects that you can see (`VisualInstance`, where you can set a `PortalMode`. This determines how objects will behave in the portal system. +If you look in the inspector, every VisualInstance in Godot is derived from a `CullInstance`\ s. DirectionalLights have no source room as they affect *everywhere*. They should therefore not be placed in a room. As DirectionalLights can be expensive, it is a good idea to turn them off when inside, see the later `doc_rooms_and_portals_roomgroups` section for details on how to do this. +In general lights are handled like any other visual instance. They can be placed in rooms, and they will sprawl to affect neighbouring rooms, following the dimensions and direction of the light. The exception to this is `DirectionalLight` for the options available. +lines, points, etc. See `Mesh.PrimitiveType `. +See also `Mesh.ArrayType ` for more information. +See `Mesh.ArrayType `. +For more information about the ArrayMesh, please see the `ArrayMesh tutorial `. +For more information about the MeshDataTool, please see the `MeshDataTool tutorial `. +For more information about the SurfaceTool, please see the `SurfaceTool tutorial `. +For more information about ImmediateGeometry, please see the `ImmediateGeometry tutorial ` for an example of mesh generation. +In the examples below, assume an ArrayMesh called `mesh` has already been created. See `ArrayMesh tutorial ` for how to generate the base mesh. +See `ArrayMesh tutorial `. + `here ( http://wiki.polycount.com/wiki/Normal_Map_Technical_Details )`. Rim ~~~ diff --git a/tutorials/3d/using_gridmaps.md b/tutorials/3d/using_gridmaps.md index 4a31c21..7c44371 100644 --- a/tutorials/3d/using_gridmaps.md +++ b/tutorials/3d/using_gridmaps.md @@ -7,7 +7,7 @@ Introduction ------------ `Gridmaps` are a tool for creating 3D -game levels, similar to the way `TileMap ` +game levels, similar to the way `TileMap `. +:download:`gridmap_demo.zip `_ for a detailed explanation of this problem. +* Gimbal lock is at play (first and last rotated axis align, so a degree of freedom is lost). See `Wikipedia's page on Gimbal Lock ( https://en.wikipedia.org/wiki/Gimbal_lock )`_ for a detailed explanation of this problem. Say no to Euler angles ====================== @@ -298,4 +298,4 @@ Transforms are your friend For most beginners, getting used to working with transforms can take some time. However, once you get used to them, you will appreciate their simplicity and power. -Don't hesitate to ask for help on this topic in any of Godot's `online communities `_ and, once you become confident enough, please help others! +Don't hesitate to ask for help on this topic in any of Godot's `online communities ( https://godotengine.org/community )`_ and, once you become confident enough, please help others! diff --git a/tutorials/animation/2d_skeletons.md b/tutorials/animation/2d_skeletons.md index 08141d6..5817950 100644 --- a/tutorials/animation/2d_skeletons.md +++ b/tutorials/animation/2d_skeletons.md @@ -36,13 +36,13 @@ Setup animating within Godot. For this tutorial, we will be using a single image to construct our character. -Download it from :download:`gBot_pieces.png) ` or save the +Download it from :download:`gBot_pieces.png) ` to have a good reference +:download:`gBot_complete.png) `_, for reference: +This is how it's done in the `Third Person Shooter demo ( https://github.com/godotengine/tps-demo )`_, for reference: ![](img/animtree1.png) diff --git a/tutorials/animation/cutout_animation.md b/tutorials/animation/cutout_animation.md index 2b3e230..f42fd83 100644 --- a/tutorials/animation/cutout_animation.md +++ b/tutorials/animation/cutout_animation.md @@ -6,8 +6,8 @@ Cutout animation What is it? ~~~~~~~~~~~ -Traditionally, `cutout animation ` -is a type of `stop motion animation ` +Traditionally, `cutout animation ( https://en.wikipedia.org/wiki/Cutout_animation )` +is a type of `stop motion animation ( https://en.wikipedia.org/wiki/Stop_motion )` in which pieces of paper (or other thin material) are cut into special shapes and arranged in two-dimensional representations of characters and objects. Characters' bodies are usually made out of several pieces. The pieces are @@ -16,12 +16,12 @@ and rotates the parts in small increments between each shot to create the illusion of movement when the images are played back quickly in sequence. Simulations of cutout animation can now be created using software as seen in -`South Park ` and `Jake and the Never -Land Pirates `. +`South Park ( https://en.wikipedia.org/wiki/South_Park )` and `Jake and the Never +Land Pirates ( https://en.wikipedia.org/wiki/Jake_and_the_Never_Land_Pirates )`. In video games, this technique has also become popular. Examples of -this are `Paper Mario ` or -`Rayman Origins ` . +this are `Paper Mario ( https://en.wikipedia.org/wiki/Super_Paper_Mario )` or +`Rayman Origins ( https://en.wikipedia.org/wiki/Rayman_Origins )` . Cutout animation in Godot ~~~~~~~~~~~~~~~~~~~~~~~~~ @@ -54,12 +54,12 @@ Making of GBot ~~~~~~~~~~~~~~ For this tutorial, we will use as demo content the pieces of the -`GBot ` +`GBot ( https://www.youtube.com/watch?v=S13FrWuBMx4&list=UUckpus81gNin1aV8WSffRKw )` character, created by Andreas Esau. ![](img/tuto_cutout_walk.gif) -Get your assets: :download:`gbot_resources.zip `. +Get your assets: :download:`gbot_resources.zip `. +This process is described in a `separate tutorial Unshaded** to improve rendering performance. See `doc_viewports` and the -`GUI in 3D demo ` +`GUI in 3D demo ( https://github.com/godotengine/godot-demo-projects/tree/master/viewport/gui_in_3d )` for more information on setting this up. Video decoding conditions and recommended resolutions @@ -142,7 +142,7 @@ There are several limitations with the current implementation of video playback - Seeking a video to a certain point is not supported. - Changing playback speed is not supported. VideoPlayer also won't follow - `Engine.time_scale`. + `Engine.time_scale` -(GUI) and `FFmpeg ` (CLI) are popular open source tools +`HandBrake ( https://handbrake.fr/ )` +(GUI) and `FFmpeg ( https://ffmpeg.org/ )` (CLI) are popular open source tools for this purpose. FFmpeg has a steeper learning curve, but it's more powerful. Here are example FFmpeg commands to convert a MP4 video to Ogg Theora. Since @@ -206,7 +206,7 @@ video quality, increasing audio quality doesn't increase the output file size nearly as much. Therefore, if you want the cleanest audio possible, you can increase this to `9` to get *perceptually lossless* audio. This is especially valuable if your input file already uses lossy audio compression. See -`this page ` +`this page ( https://wiki.hydrogenaud.io/index.php?title=Recommended_Ogg_Vorbis#Recommended_Encoder_Settings )` for a table listing Ogg Vorbis audio quality presets and their respective variable bitrates. diff --git a/tutorials/assets_pipeline/escn_exporter/mesh.md b/tutorials/assets_pipeline/escn_exporter/mesh.md index 8d65329..88bf947 100644 --- a/tutorials/assets_pipeline/escn_exporter/mesh.md +++ b/tutorials/assets_pipeline/escn_exporter/mesh.md @@ -19,5 +19,5 @@ it takes a relatively long time. incorrect shape keys exported, try to disable :code:`Apply Modifiers` and do the exporting again. Besides, it is worthwhile to report the incompatible modifier to the `issue list - `, + ( https://github.com/godotengine/godot-blender-exporter/issues )`, which helps to develop the exporter to have a more precise check of modifiers. diff --git a/tutorials/assets_pipeline/import_process.md b/tutorials/assets_pipeline/import_process.md index f6183a0..525abf2 100644 --- a/tutorials/assets_pipeline/import_process.md +++ b/tutorials/assets_pipeline/import_process.md @@ -18,12 +18,12 @@ Godot will automatically import these files internally and keep the imported resources hidden in a `res://.import` folder. This means that when trying to access imported assets through code you -need to use the `Resource Loader` as it will +need to use the `Resource Loader` cannot access +However, the `Resource Loader` with built-in effects. +Godot has an `extensive bus system ` + - SVGs are rasterized using `NanoSVG ( https://github.com/memononen/nanosvg )` when importing them. Support is limited; complex vectors may not render correctly. For complex vectors, rendering them to PNGs using Inkscape is often a better solution. - This can be automated thanks to its `command-line interface `. + This can be automated thanks to its `command-line interface ( https://wiki.inkscape.org/wiki/index.php/Using_the_Command_Line#Export_files )`. - WebP (`.webp`) - WebP files support transparency and can be compressed lossily or losslessly. The precision is limited to 8 bits per channel. @@ -129,7 +129,7 @@ Note that RGTC compression affects the resulting normal map image. You will have More information about normal maps (including a coordinate order table for popular engines) can be found - `here `. + `here ( http://wiki.polycount.com/wiki/Normal_Map_Technical_Details )`. Flags ----- diff --git a/tutorials/assets_pipeline/importing_scenes.md b/tutorials/assets_pipeline/importing_scenes.md index cd4e916..1ff9b56 100644 --- a/tutorials/assets_pipeline/importing_scenes.md +++ b/tutorials/assets_pipeline/importing_scenes.md @@ -31,7 +31,7 @@ Exporting DAE files from Maya and 3DS Max Autodesk added built-in COLLADA support to Maya and 3DS Max, but it's broken by default and should not be used. The best way to export this format is by using the -`OpenCollada ` +`OpenCollada ( https://github.com/KhronosGroup/OpenCOLLADA/wiki/OpenCOLLADA-Tools )` plugins. They work well, although they are not always up-to date with the latest version of the software. @@ -75,7 +75,7 @@ Exporting DAE files from Blender Blender has built-in COLLADA support, but it does not work properly for the needs of game engines and should not be used as is. -Godot provides a `Blender plugin `_ +Godot provides a `Blender plugin ( https://github.com/godotengine/collada-exporter )`_ that will correctly export COLLADA scenes for use in Godot. It does not work in Blender 2.8 or newer, but there are plans to update it in the future. @@ -83,12 +83,12 @@ Exporting ESCN files from Blender ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ The most powerful one, called `godot-blender-exporter -`. +( https://github.com/godotengine/godot-blender-exporter )`. It uses a .escn file, which is kind of another name for a .tscn file (Godot scene file); it keeps as much information as possible from a Blender scene. However, it is considered experimental. -The ESCN exporter has a detailed `document ` describing +The ESCN exporter has a detailed `document `, -`ArmorPaint (open source) `, and `Material Maker (open source) `. +textures, they can work in Godot. This includes the `Substance suite ( https://www.substance3d.com/ )`, +`ArmorPaint (open source) ( https://armorpaint.org/ )`, and `Material Maker (open source) ( https://github.com/RodZill4/material-maker )`. .. note:: For more information on Godot's materials, see `doc_spatial_material`. @@ -266,7 +266,7 @@ Ensure Tangents If textures with normal mapping are to be used, meshes need to have tangent arrays. This option ensures that these are generated if not present in the source scene. -Godot uses `Mikktspace ` for this, +Godot uses `Mikktspace ( http://www.mikktspace.com/ )` for this, but it's always better to have them generated in the exporter. Storage diff --git a/tutorials/assets_pipeline/importing_translations.md b/tutorials/assets_pipeline/importing_translations.md index 8c1a60e..fa24362 100644 --- a/tutorials/assets_pipeline/importing_translations.md +++ b/tutorials/assets_pipeline/importing_translations.md @@ -40,16 +40,16 @@ To complete the picture and allow efficient support for translations, Godot has a special importer that can read CSV files. Most spreadsheet editors can export to this format, so the only requirement is that the files have a special arrangement. The CSV files **must** be saved with UTF-8 encoding -without a `byte order mark `. +without a `byte order mark ( https://en.wikipedia.org/wiki/Byte_order_mark )`. .. warning:: By default, Microsoft Excel will always save CSV files with ANSI encoding rather than UTF-8. There is no built-in way to do this, but there are workarounds as described - `here `. + `here ( https://stackoverflow.com/questions/4221176/excel-to-csv-with-utf8-encoding )`. - We recommend using `LibreOffice ` or Google Sheets instead. + We recommend using `LibreOffice ( https://www.libreoffice.org/ )` or Google Sheets instead. CSV files must be formatted as follows: @@ -64,7 +64,7 @@ CSV files must be formatted as follows: +--------+----------+----------+----------+ The "lang" tags must represent a language, which must be one of the `valid -locales ` supported by the engine. The "KEY" tags must be +locales ` is likely a better choice + a `limiter `), or to apply +(see `Reverb buses `. +demo project using this can be found `here ( https://github.com/godotengine/godot-demo-projects/tree/master/audio/spectrum )`. StereoEnhance ~~~~~~~~~~~~~ diff --git a/tutorials/audio/recording_with_microphone.md b/tutorials/audio/recording_with_microphone.md index 571c90a..9781a04 100644 --- a/tutorials/audio/recording_with_microphone.md +++ b/tutorials/audio/recording_with_microphone.md @@ -8,7 +8,7 @@ iOS. A simple demo is included in the official demo projects and will be used as support for this tutorial: -``_. +`( https://github.com/godotengine/godot-demo-projects/tree/master/audio/mic_record )`_. You will need to enable audio input in the project settings, or you'll just get empty audio files. diff --git a/tutorials/audio/sync_with_audio.md b/tutorials/audio/sync_with_audio.md index 1ec6835..a8b9fbd 100644 --- a/tutorials/audio/sync_with_audio.md +++ b/tutorials/audio/sync_with_audio.md @@ -26,11 +26,11 @@ The problem, in the end, is not this slight delay but synchronizing graphics and Using the system clock to sync ------------------------------ -As mentioned before, If you call `AudioStreamPlayer.play()`, sound will not begin immediately, but when the audio thread processes the next chunk. +As mentioned before, If you call `AudioStreamPlayer.play()`. +This delay can't be avoided but it can be estimated by calling `AudioServer.get_time_to_next_mix()`. +The output latency (what happens after the mix) can also be estimated by calling `AudioServer.get_output_latency()` to obtain the current position for the song sounds ideal, but it's not that useful as-is. This value will increment in chunks (every time the audio callback mixed a block of sound), so many calls can return the same value. Added to this, the value will be out of sync with the speakers too because of the previously mentioned reasons. +Using `AudioStreamPlayer.get_playback_position()`. +To compensate for the "chunked" output, there is a function that can help: `AudioServer.get_time_since_last_mix()`. But if we call the `AudioStreamPlayer` while it is +` keyword in GDScript. +`_. + `Big O Notation ( https://rob-bell.net/2009/06/a-beginners-guide-to-big-o-notation/ )`_. Long-story short, it describes the worst-case scenario of runtime length. In laymen's terms: @@ -40,12 +40,12 @@ Array vs. Dictionary vs. Object ------------------------------- Godot stores all variables in the scripting API in the -`Variant `_ +`Variant ( https://docs.godotengine.org/en/latest/development/cpp/variant_class.html )`_ class. Variants can store Variant-compatible data structures such as `Array` as well as `Object` s. -Godot implements Array as a `Vector`. The engine stores the Array +Godot implements Array as a `Vector`. + a `Vector`. The engine +Godot implements Dictionary as an `OrderedHashMap`. +`here ` docs. + `data preferences `_ principle and - `encapsulation `_. + ( https://en.wikipedia.org/wiki/Single_responsibility_principle )`_ principle and + `encapsulation ( https://en.wikipedia.org/wiki/Encapsulation_(computer_programming) )`_. diff --git a/tutorials/best_practices/logic_preferences.md b/tutorials/best_practices/logic_preferences.md index 9e3b9f7..619201a 100644 --- a/tutorials/best_practices/logic_preferences.md +++ b/tutorials/best_practices/logic_preferences.md @@ -140,5 +140,5 @@ As such, the best options would be... into a plugin. For an example of the various ways one can swap scenes around at runtime, -please see the `"Change scenes manually" ` +please see the `"Change scenes manually" ` + `already been said `_ +`loose coupling ( https://en.wikipedia.org/wiki/Loose_coupling )`_ to other parts of the codebase. This keeps the size of objects small (for maintainability) and improves their reusability. @@ -41,7 +41,7 @@ themselves. If a scene must interact with an external context, experienced developers recommend the use of -`Dependency Injection `_. +`Dependency Injection ( https://en.wikipedia.org/wiki/Dependency_injection )`_. This technique involves having a high-level API provide the dependencies of the low-level API. Why do this? Because classes which rely on their external environment can inadvertently trigger bugs and unexpected behavior. @@ -183,10 +183,10 @@ adversely effecting other classes. Scripts and scenes, as extensions of engine classes, should abide by *all* OOP principles. Examples include... -- `SOLID `_ -- `DRY `_ -- `KISS `_ -- `YAGNI `_ +- `SOLID ( https://en.wikipedia.org/wiki/SOLID )`_ +- `DRY ( https://en.wikipedia.org/wiki/Don%27t_repeat_yourself )`_ +- `KISS ( https://en.wikipedia.org/wiki/KISS_principle )`_ +- `YAGNI ( https://en.wikipedia.org/wiki/You_aren%27t_gonna_need_it )`_ Choosing a node tree structure ------------------------------ @@ -218,7 +218,7 @@ the various menus and widgets the project needs. - Control "GUI" (gui.gd) When changing levels, one can then swap out the children of the "World" node. -`Changing scenes manually ` gives users full +`Changing scenes manually `. +... then one should create an `autoload 'singleton' node ` +`Autoloads versus regular nodes ` +- `Custom Types ` +- `Script Classes `, the base type that scenes inherit from, defines resources +`. Documentation on how to use the Git +`here ( https://github.com/godotengine/godot-git-plugin/releases )`. Documentation on how to use the Git plugin can be found -`here `. +`here ( https://github.com/godotengine/godot-git-plugin/wiki )`. Files to exclude from VCS ------------------------- diff --git a/tutorials/best_practices/what_are_godot_classes.md b/tutorials/best_practices/what_are_godot_classes.md index 75bb972..81f4a58 100644 --- a/tutorials/best_practices/what_are_godot_classes.md +++ b/tutorials/best_practices/what_are_godot_classes.md @@ -23,7 +23,7 @@ These scripts are not technically classes. Instead, they are resources that tell sequence of initializations to perform on one of the engine's built-in classes. Godot's internal classes have methods that register a class's data with a `ClassDB -`. This database provides runtime access to class information. `ClassDB` contains +` must be enabled). | +| `-e`, `--editor` | Start the editor instead of running the scene (`tools ` must be enabled). | +| `-p`, `--project-manager` | Start the project manager, even if a project is auto-detected (`tools `, `--language ` | Use a specific locale ( being a two-letter code). See `doc_locales` for more details. | +| `-l being a two-letter code). See `doc_locales` for more details. | +------------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------+ -| `--path ` | Path to a project ( must contain a 'project.godot' file). | +| `--path must contain a 'project.godot' file). | +------------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------+ | `-u`, `--upwards` | Scan folders upwards for 'project.godot' file. | +------------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------+ -| `--main-pack ` | Path to a pack (.pck) file to load. | +| `--main-pack ` | Render thread mode ('unsafe', 'safe', 'separate'). See `Thread Model` for more details. | +| `--render-thread ` | Remote filesystem (`[:]` address). | +| `--remote-fs
[:]` address). | +------------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------+ -| `--audio-driver ` | Audio driver. Use `--help` first to display the list of available drivers. | +| `--audio-driver ` | Video driver. Use `--help` first to display the list of available drivers. | +| `--video-driver x` | Request window resolution. | +| `--resolution x,` | Request window position. | +| `--position ,` | Remote debug (`:` address). | +| `--remote-debug
:` | Simulate high CPU load (delay each frame by milliseconds). | +| `--frame-delay milliseconds). | +------------------------------+---------------------------------------------------------------------------------------------+ -| `--time-scale ` | Force time scale (higher values are faster, 1.0 is normal speed). | +| `--time-scale ` | Force a fixed number of frames per second. This setting disables real-time synchronization. | +| `--fixed-fps `, `--script